cohtml

Contains almost all Coherent namespaces, classes and functions.

Namespaces

Name
cohtml::CursorTypes
cohtml::EventAction
Holds the possible actions when deciding if to handle an input event.
cohtml::Fonts
cohtml::i18n
cohtml::ImagesListExtract
Enum containing the options we want when getting the list of loaded images.
cohtml::InputEventPhase
cohtml::InspectorNetworkTabSettings
Settings for inspector network tab.
cohtml::MemTags
cohtml::Profile
cohtml::TextInput
cohtml::TextInputControlType
cohtml::VMemFlags
cohtml::VMemProtection
cohtml::websocket

Classes

Name
classcohtml::AdjustPointer
classcohtml::ArgumentsBinder
Class for communicating between EventHandler and the scripting.
structcohtml::ArrayInfo
Represents a array of a type exposed to the scripting.
classcohtml::ArrayReaderFactory
classcohtml::ArrayReaderFactory< T *, Size >
structcohtml::AssertFail
classcohtml::Binder
Provides binding between C++ and the UI.
structcohtml::BoolConstant
classcohtml::ByRefHolder
structcohtml::CachedResourcesWatermarks
Watermarks used for the image cache management.
structcohtml::ClassType
structcohtml::ClassType< Property Class::*>
structcohtml::ClassType< Property(Class::*)() const >
structcohtml::ClassType< Property(Class::*)()>
structcohtml::CoherentToBoolean
structcohtml::CoherentToBoolean< bool >
structcohtml::CoherentToBoolean< double >
structcohtml::CoherentToBoolean< float >
structcohtml::CoherentToBoolean< int >
structcohtml::CoherentToBoolean< signed long >
structcohtml::CoherentToBoolean< signed long long >
structcohtml::CoherentToBoolean< signed short >
structcohtml::CoherentToBoolean< unsigned >
structcohtml::CoherentToBoolean< unsigned long >
structcohtml::CoherentToBoolean< unsigned long long >
structcohtml::CoherentToBoolean< unsigned short >
structcohtml::CoherentToColor
structcohtml::CoherentToColor< const int & >
structcohtml::CoherentToColor< const renoir::Color & >
structcohtml::CoherentToColor< const unsigned & >
structcohtml::CoherentToNumber
structcohtml::CoherentToNumber< double >
structcohtml::CoherentToNumber< float >
structcohtml::CoherentToNumber< int >
structcohtml::CoherentToNumber< signed long >
structcohtml::CoherentToNumber< signed long long >
structcohtml::CoherentToNumber< signed short >
structcohtml::CoherentToNumber< unsigned >
structcohtml::CoherentToNumber< unsigned long >
structcohtml::CoherentToNumber< unsigned long long >
structcohtml::CoherentToNumber< unsigned short >
structcohtml::CoherentToString
structcohtml::CoherentToString< bool >
structcohtml::CoherentToString< char * >
structcohtml::CoherentToString< char[N]>
structcohtml::CoherentToString< const char * >
structcohtml::CoherentToString< const char[N]>
structcohtml::CoherentToString< double >
structcohtml::CoherentToString< float >
structcohtml::CoherentToString< int >
structcohtml::CoherentToString< long >
structcohtml::CoherentToString< long long >
structcohtml::CoherentToString< short >
structcohtml::CoherentToString< std::basic_string< char, CharTraits, Allocator > >
structcohtml::CoherentToString< unsigned >
structcohtml::CoherentToString< unsigned long >
structcohtml::CoherentToString< unsigned long long >
structcohtml::CoherentToString< unsigned short >
structcohtml::CoherentToTransformMatrix2D
structcohtml::CoherentToTransformMatrix2D< const char(&)[N]>
structcohtml::CoherentToTransformMatrix2D< const float *& >
structcohtml::CoherentToTransformMatrix2D< const float(&)[6]>
structcohtml::CoherentToTransformMatrix2D< float *& >
structcohtml::CoherentToTransformMatrix2D< float(&)[6]>
structcohtml::CoherentTypeInfo
classcohtml::ConcreteProperty
classcohtml::ConcretePropertyReadOnly
classcohtml::DataBuffer
A reference counted data buffer.
structcohtml::DebugDump
Debugging class used for dumping the whole structure of the page DOM.
structcohtml::DisableDefaultBinding
structcohtml::EnableIf
structcohtml::EnableIf< true, T >
classcohtml::EventHandler
structcohtml::EventModifiersState
The state of the key modifiers when an event happens.
structcohtml::EventMouseModifiersState
The state of the mouse modifiers when an event happens.
classcohtml::FieldProperty
classcohtml::FieldProperty< PropertyType(Class::*)>
classcohtml::FieldProperty< PropertyType(Class::*)[ArraySize]>
structcohtml::FontDescription
Struct used for identifying fonts.
structcohtml::FrameCapture
Debugging class holding debug frame captured data and size. Passed to FrameCaptureCallback on View::BeginCaptureDebugFrame and View::CaptureSingleDebugFrame methods.
structcohtml::FunctorArity
structcohtml::FunctorTraits
structcohtml::FunctorTraits< ResultType()>
structcohtml::FunctorTraits< ResultType(*)()>
structcohtml::FunctorTraits< ResultType(*)(Arg0Type)>
structcohtml::FunctorTraits< ResultType(*)(Arg0Type, Arg1Type)>
structcohtml::FunctorTraits< ResultType(*)(Arg0Type, Arg1Type, Arg2Type)>
structcohtml::FunctorTraits< ResultType(*)(Arg0Type, Arg1Type, Arg2Type, Arg3Type)>
structcohtml::FunctorTraits< ResultType(*)(Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type)>
structcohtml::FunctorTraits< ResultType(Arg0Type)>
structcohtml::FunctorTraits< ResultType(Arg0Type, Arg1Type)>
structcohtml::FunctorTraits< ResultType(Arg0Type, Arg1Type, Arg2Type)>
structcohtml::FunctorTraits< ResultType(Arg0Type, Arg1Type, Arg2Type, Arg3Type)>
structcohtml::FunctorTraits< ResultType(Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type)>
structcohtml::FunctorTraits< ResultType(ClassType::*)() const >
structcohtml::FunctorTraits< ResultType(ClassType::*)()>
structcohtml::FunctorTraits< ResultType(ClassType::*)(Arg0Type) const >
structcohtml::FunctorTraits< ResultType(ClassType::*)(Arg0Type)>
structcohtml::FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type) const >
structcohtml::FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type)>
structcohtml::FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type, Arg2Type) const >
structcohtml::FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type, Arg2Type)>
structcohtml::FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type, Arg2Type, Arg3Type) const >
structcohtml::FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type, Arg2Type, Arg3Type)>
structcohtml::FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type) const >
structcohtml::FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type)>
structcohtml::FunctorTraits< std::function< R()> >
structcohtml::FunctorTraits< std::function< R(A0)> >
structcohtml::FunctorTraits< std::function< R(A0, A1)> >
structcohtml::FunctorTraits< std::function< R(A0, A1, A2)> >
structcohtml::FunctorTraits< std::function< R(A0, A1, A2, A3)> >
structcohtml::FunctorTraits< std::function< R(A0, A1, A2, A3, A4)> >
structcohtml::GamepadPoseState
Represents the pose of a motion tracking controller.
structcohtml::GamepadState
Represents the entire state of a single gamepad.
structcohtml::GamepadStateExtended
Extended representation of the gamepad state, including information for controllers that support motion tracking.
structcohtml::GestureEventData
A gesture event.
structcohtml::GetArrayValue
structcohtml::GetArrayValue< T & >
structcohtml::GetArrayValue< Type[]>
structcohtml::GetMapValue
structcohtml::GetMapValue< T & >
structcohtml::GetObjectInfo
structcohtml::GetObjectInfo< Type &, ET_UserType >
structcohtml::GetPairValue
structcohtml::GetPairValue< T & >
structcohtml::GetValue
structcohtml::GetValue< Property Class::* >
structcohtml::GetValue< Property(Class::*)() const >
structcohtml::GetValue< Property(Class::*)()>
structcohtml::GPUMemoryInfo
classcohtml::IAllocator
Allocator interface used by Cohtml for all memory allocations. The user has to provide an object that implements this interface. Memory allocations in Cohtml are tagged, so the user knows the relative distribution of memory among subsystems.
classcohtml::IAsyncResourceHandler
Class that will handle all asynchronous resource requests.
classcohtml::IAsyncResourceRequest
Encapsulates an asynchronous resource request.
classcohtml::IAsyncResourceResponse
Response that the application should use when the resource has been loaded You can keep a reference to this object as long as needed and call Finish afterwards.
classcohtml::IAsyncResourceStreamResponse
Response that the application should use when the resource stream has been created You can keep a reference to this object as long as needed and call Finish afterwards.
classcohtml::IClientSideSocket
The IClientSideSocket represents platform/client specific part of the web sockets.
classcohtml::IDataStorageHandler
Class that will handle data storage requests.
classcohtml::IDataStorageRequest
Encapsulates a data storage request.
classcohtml::IDataStorageResponse
Response that the application should use when the data storage has been read.
classcohtml::IEventHandler
classcohtml::IFileSystemReader
Class that allows Cohtml to interface with the local file system. It allows enumerating folders and opening streams to local resources.
classcohtml::IFileSystemWriter
Class that allows Cohtml to interface with the local file system. It allows opening a file for writing and writing information to it.
classcohtml::IInputProxy
Represents an INPUT or TEXTAREA element in the View.
classcohtml::IInternationalizationManager
Takes care of culture specific text operations.
classcohtml::ILocalizationManager
Takes care of translating text between different locales.
structcohtml::ImagesList
A list of images. Used for getting all images that are currently loaded by this View. The list can be used to build a collection of resources that must be pre-loaded via native code or JavaScript to avoid dynamic loading when the page is shown.
classcohtml::INodeProxy
Represents a DOM element in the View - i.e. a DIV, the BODY etc.
classcohtml::IProfileMarkersTracer
structcohtml::IsChar
structcohtml::IsConst
structcohtml::IsConst< const T >
structcohtml::IsCString
structcohtml::IsCString< const T * >
structcohtml::IsDefaultBindEnabled
structcohtml::IsExposedByRef
structcohtml::IsExposedByRef< bool >
structcohtml::IsExposedByRef< char * >
structcohtml::IsExposedByRef< const bool >
structcohtml::IsExposedByRef< const char * >
structcohtml::IsExposedByRef< const double >
structcohtml::IsExposedByRef< const float >
structcohtml::IsExposedByRef< const signed char >
structcohtml::IsExposedByRef< const signed int >
structcohtml::IsExposedByRef< const signed long >
structcohtml::IsExposedByRef< const signed long long >
structcohtml::IsExposedByRef< const unsigned char >
structcohtml::IsExposedByRef< const unsigned int >
structcohtml::IsExposedByRef< const unsigned long >
structcohtml::IsExposedByRef< const unsigned long long >
structcohtml::IsExposedByRef< const wchar_t * >
structcohtml::IsExposedByRef< double >
structcohtml::IsExposedByRef< float >
structcohtml::IsExposedByRef< signed char >
structcohtml::IsExposedByRef< signed int >
structcohtml::IsExposedByRef< signed long >
structcohtml::IsExposedByRef< signed long long >
structcohtml::IsExposedByRef< T & >
structcohtml::IsExposedByRef< unsigned char >
structcohtml::IsExposedByRef< unsigned int >
structcohtml::IsExposedByRef< unsigned long >
structcohtml::IsExposedByRef< unsigned long long >
structcohtml::IsExposedByRef< wchar_t * >
structcohtml::IsMap
structcohtml::IsMap< std::map< Key, Value, Comparator, Allocator > >
structcohtml::IsMap< std::unordered_map< Key, Value, Hash, Pred, Allocator > >
classcohtml::ISocketListener
The ISocketListener represents cohtml::View side of the web sockets.
structcohtml::IsPair
structcohtml::IsPair< std::pair< T1, T2 > >
structcohtml::IsSame
structcohtml::IsSame< T, T >
structcohtml::IsValidModelType
structcohtml::IsValidModelType< std::basic_string< Char, CharTraits, Allocator > >
structcohtml::IsValidModelType< std::map< Key, Value, Comparator, Allocator > >
structcohtml::IsValidModelType< std::pair< T1, T2 > >
structcohtml::IsValidModelType< std::unordered_map< Key, Value, Hash, Pred, Allocator > >
structcohtml::IsValidModelType< std::vector< T, A > >
structcohtml::IsVector
structcohtml::IsVector< std::vector< T, A > >
structcohtml::IsVoid
structcohtml::IsVoid< void >
classcohtml::ISyncStreamReader
Class for synchronously reading local resources.
classcohtml::ISyncStreamWriter
Class for synchronously writing local resources.
classcohtml::ITextInputHandler
Notifies of changes to input elements.
classcohtml::ITextTransformationManager
Implement this interface to support text transformations. The class is used when the text-transform proeperty is used. Most languages require Unicode support to implement casing and cohtml delegates this work to the embedder. OS-specific APIs in Win32, Mac OS X and cross-platform libraries like ICU can implement the required functionality. An instance must be optionally set in SystemSettings.
classcohtml::ITimeZoneProvider
classcohtml::IViewListener
Interface that allows to listen for various events in the View.
classcohtml::IVirtualAllocator
Virtual memory allocator interface used by Cohtml for scripting memory allocations.
structcohtml::KeyEventData
A keyboard event.
classcohtml::Library
This class encapsulates the global Cohtml library.
structcohtml::LibraryParams
structcohtml::LibraryParamsWithExternalRenderingLibrary
Initialization parameters of the Cohtml library.
structcohtml::MapInfo
Represents a map of a type exposed to the scripting.
structcohtml::MemberPointerTraits
structcohtml::MemberPointerTraits< T C::* >
structcohtml::MouseEventData
structcohtml::ObjectInfo
Represents a object of a type exposed to the scripting.
structcohtml::Overload_CoherentBind_For_Your_Type
structcohtml::PageCapture
Object pointing a raw data coming from a full page capture (see View::SetupPageCapture and View::DoPageCapture).
structcohtml::PairInfo
Represents a pair of a type exposed to the scripting.
structcohtml::PlatformSpecificParams
Platform-specific initialization parameters of the Cohtml library.
structcohtml::PointerTrait
structcohtml::PointerTrait< const T & >
structcohtml::PointerTrait< const T * >
structcohtml::PointerTrait< const T >
structcohtml::PointerTrait< std::shared_ptr< const T > >
structcohtml::PointerTrait< std::shared_ptr< T > >
structcohtml::PointerTrait< std::unique_ptr< const T > >
structcohtml::PointerTrait< std::unique_ptr< T > >
structcohtml::PointerTrait< T & >
structcohtml::PointerTrait< T * >
structcohtml::PreciseHandle
classcohtml::Property
Represents a property of a type exposed to the scripting.
structcohtml::PropertyType
structcohtml::PropertyType< ReturnType(Class::*)(const Property &)>
structcohtml::PropertyType< ReturnType(Class::*)(const T(&)[N]) >
structcohtml::PropertyType< ReturnType(Class::*)(Property)>
structcohtml::PropertyType< ReturnType(Class::*)(T(&)[N]) >
structcohtml::RemoveConst
structcohtml::RemoveConst< const T & >
structcohtml::RemoveConst< const T >
structcohtml::RemoveConstRef
structcohtml::RemoveConstRef< const T & >
structcohtml::RemoveConstRef< const T >
structcohtml::RemoveConstRef< T & >
structcohtml::RemoveRef
structcohtml::RemoveRef< const T & >
structcohtml::RemoveRef< T & >
structcohtml::ReturnsByRef
structcohtml::ReturnsByRef< T &(C::*)() const >
structcohtml::ReturnsByRef< T &(C::*)()>
structcohtml::ReturnsByRef< T(C::*)() const >
structcohtml::ReturnsByRef< T(C::*)()>
structcohtml::ReturnsByRef< T(C::*)>
structcohtml::ScreenInfo
Holds the information about current screen.
classcohtml::ScriptCompiler
classcohtml::System
A System owns multiple Views. These Views share resources among them. It is usually enough to have just one System per application run. All System APIs, unless explicitly stated otherwise, can be called on any thread, but should not be used on multiple threads simultaneously.
classcohtml::SystemCacheStats
Statistics of the current state of the internal caches of the system Remember to Release the object when done with it to avoid memory leaks.
classcohtml::SystemRenderer
The SystemRenderer lives on the render thread and holds all resources shared between multiple Views belonging to the same System (font atlases, texture caches etc.)
structcohtml::SystemRendererSettings
System renderer settings.
structcohtml::SystemRendererSettingsWithExternalRenderingLibrary
System renderer settings when an using external rendering library.
structcohtml::SystemSettings
Settings for a System.
classcohtml::ThisHolder
classcohtml::ThisHolder< TrueType >
structcohtml::TouchEventData
A touch event.
classcohtml::TypeDescription
Helper class for describing types.
classcohtml::TypedProperty
structcohtml::TypeToElementType
structcohtml::TypeToElementType< bool >
structcohtml::TypeToElementType< char >
structcohtml::TypeToElementType< const std::unordered_map< Key, Value, Hash, Pred, Allocator > & >
structcohtml::TypeToElementType< const std::unordered_map< Key, Value, Hash, Pred, Allocator > >
structcohtml::TypeToElementType< const Type >
structcohtml::TypeToElementType< double >
structcohtml::TypeToElementType< float >
structcohtml::TypeToElementType< int >
structcohtml::TypeToElementType< renoir::Color >
structcohtml::TypeToElementType< signed char >
structcohtml::TypeToElementType< signed long >
structcohtml::TypeToElementType< signed long long >
structcohtml::TypeToElementType< signed short >
structcohtml::TypeToElementType< std::basic_string< char, CharTraits, Allocator > >
structcohtml::TypeToElementType< std::map< Key, Value, Comparator, Allocator > >
structcohtml::TypeToElementType< std::pair< T1, T2 > >
structcohtml::TypeToElementType< std::unordered_map< Key, Value, Hash, Pred, Allocator > & >
structcohtml::TypeToElementType< std::unordered_map< Key, Value, Hash, Pred, Allocator > >
structcohtml::TypeToElementType< std::vector< T, A > >
structcohtml::TypeToElementType< Type & >
structcohtml::TypeToElementType< Type(&)[Size]>
structcohtml::TypeToElementType< unsigned >
structcohtml::TypeToElementType< unsigned char >
structcohtml::TypeToElementType< unsigned long >
structcohtml::TypeToElementType< unsigned long long >
structcohtml::TypeToElementType< unsigned short >
structcohtml::TypeToElementTypeWrapper
structcohtml::TypeToElementTypeWrapper< Type, true >
structcohtml::UnwrapPointer
structcohtml::UnwrapPointer< const T & >
structcohtml::UnwrapPointer< const T >
structcohtml::UnwrapPointer< T & >
structcohtml::UnwrapPointerType
structcohtml::UnwrapPointerType< T, true >
structcohtml::UserFontDescription
Struct representing user font data. Baseline is 0.
structcohtml::UserGPUMemoryInfo
classcohtml::VectorReaderFactory
classcohtml::VectorReaderFactory< std::vector< T, A > >
classcohtml::View
The View represents a UI page with its DOM, styles and JavaScript context. Think of the View as a whole UI or UI element. The View for instance could be the whole HUD of a game. All View APIs, unless explicitly stated otherwise, can be called on any thread, but should not be used on multiple threads simultaneously.
classcohtml::ViewRenderer
The ViewRenderer is in charge of drawing a View in a user-supplied texture.
structcohtml::ViewRendererSettings
structcohtml::ViewSettings
Settings used when initializing a View.

Types

Name
enumWorkType { WT_Resources, WT_Layout}
enumWorkExecutionMode { WEM_UntilQueueEmpty, WEM_UntilQuit}
The enumeration tells the Library how much work to execute in the invocation Please refer to the asynchronous work documentation for details.
enumGamepadHand { GH_None = 0, GH_Left, GH_Right}
Enumeration that represent binding of a gamepad to a specific hand. Used for motion tracking controllers which are used in pairs, one controller per hand.
enum class unsigned charHTMLTag { HTML, HEAD, TITLE, BASE, LINK, META, STYLE, SCRIPT, NOSCRIPT, TEMPLATE, BODY, ARTICLE, SECTION, NAV, ASIDE, H1, H2, H3, H4, H5, H6, HGROUP, HEADER, FOOTER, ADDRESS, P, HR, PRE, BLOCKQUOTE, OL, UL, LI, DL, DT, DD, FIGURE, FIGCAPTION, MAIN, DIV, A, EM, STRONG, SMALL, S, CITE, Q, DFN, ABBR, DATA, TIME, CODE, VAR, SAMP, KBD, SUB, SUP, I, B, U, MARK, RUBY, RT, RP, BDI, BDO, SPAN, BR, WBR, INS, DEL, IMAGE, IMG, IFRAME, EMBED, OBJECT, PARAM, VIDEO, AUDIO, SOURCE, TRACK, CANVAS, MAP, AREA, MATH, MI, MO, MN, MS, MTEXT, MGLYPH, MALIGNMARK, ANNOTATION_XML, SVG, FOREIGNOBJECT, DESC, TABLE, CAPTION, COLGROUP, COL, TBODY, THEAD, TFOOT, TR, TD, TH, FORM, FIELDSET, LEGEND, LABEL, INPUT, BUTTON, SELECT, DATALIST, OPTGROUP, OPTION, TEXTAREA, KEYGEN, OUTPUT, PROGRESS, METER, DETAILS, SUMMARY, MENU, MENUITEM, APPLET, ACRONYM, BGSOUND, DIR, FRAME, FRAMESET, NOFRAMES, ISINDEX, LISTING, XMP, NEXTID, NOEMBED, PLAINTEXT, RB, STRIKE, BASEFONT, BIG, BLINK, CENTER, FONT, MARQUEE, MULTICOL, NOBR, SPACER, TT, RTC, UNKNOWN, ALL, CUSTOM, SVGCircle, SVGDefs, SVGEllipse, SVGG, SVGLine, SVGLinearGradient, SVGPath, SVGPolygon, SVGPolyline, SVGRadialGradient, SVGRect, SVGSolidColor, SVGStop, SVGText, SVGUse, SVGClipPath, SVGMask, SVGImage, COUNT}
enumRenderingTasksAvailableType { RTA_ViewReadyForRendering, RTA_RenderingSubSystemTask}
enumInterceptRequestStatus { Allow, Restrict}
enumInternalCaches { ICACHE_Shadows = 1 « 0, ICACHE_Paths = 1 « 1, ICACHE_Textures = 1 « 2, ICACHE_ScratchLayers = 1 « 3, ICACHE_ScratchTextures = 1 « 4, ICACHE_GfxCommandBuffers = 1 « 5, ICACHE_GfxCommandProcessors = 1 « 6, ICACHE_SVGSurfaces = 1 « 7, ICACHE_BackdropFilterSurfaces = 1 « 8}
enumCaptureMode { CM_PreserveAll, CM_PreserveAlpha, CM_ObfuscateAll}
When serializing rendering commands, part of the image data in a document is saved as well. With these capture modes, you can force the capturer to obfuscate the pixel data and with that no images will be leaked through the serialized capture.
enumValueType { VT_Null, VT_Undefined, VT_Boolean, VT_Number, VT_String, VT_Object, VT_Array, VT_Count}
The primitive types coming from JS.
enumElementType { ET_Boolean, ET_Int8, ET_UInt8, ET_Int16, ET_UInt16, ET_Int32, ET_UInt32, ET_Int64, ET_UInt64, ET_Float, ET_Double, ET_String, ET_Color, ET_Array, ET_Map, ET_Pair, ET_UserType, ET_PolymorphUserType}
typedef doubleTimePoint
typedef intTaskFamilyId
typedef void(*)(void *userData, WorkType type, TaskFamilyId family)OnWorkAvailableFunc
Called when a new task is available and should be executed later on.
typedef void(*)(void *userData, void *texturePtr)OnUserImageDroppedFunc
typedef void *BoundEventHandle
typedef void(*)(void *userData, unsigned viewId, unsigned frameId, RenderingTasksAvailableType type)OnRenderingTasksAvailableFunc
typedef double(*)(void *userdata, unsigned viewId)OnMonotonicallyIncreasingTimeRequestFunc
typedef void(*)(void *userData, FrameCapture *capture)FrameCaptureCallback
Function signature of callback used in View::BeginCaptureDebugFrame and View::CaptureSingleDebugFrame.
typedef void(*)(Binder *, void *, size_t)Reader
typedef size_t(*)(void *)ArrayLengthGetter
typedef void ()(void *userData, const char *name)MapElementGetter
typedef size_t(*)(void *userData)LengthGetter
typedef void ()(void *userData, size_t index)ElementGetter
typedef BoolConstant< true >TrueType
typedef BoolConstant< false >FalseType
typedef void ()(void *, size_t)NativeReader
typedef size_t(*)(void *)VectorLengthFunc

Functions

Name
template <typename Functor >
IEventHandler *
MakeHandler(Functor functor)
Create event handler from generic C++ functor.
template <typename Method >
IEventHandler *
MakeHandler(void * object, Method method)
Create event handler from C++ method.
voidAdaptRenderingAllocatorAndLoggerFromCohtml(IAllocator * allocator, Logging::ILogHandler * logger, renoir::IAllocator ** outRenderingAllocator, renoir::Logging::ILogHandler ** outRenderingLogger)
Function to adapt Cohtml based IAllocator and ILogHandler to the Rendering library variants It will use the allocator instance to allocate the adapters. You can call this to use Cohtml instances when using an externally initialized rendering library.
voidDestroyAdaptedRenderingAllocatorAndLogger(IAllocator * allocator, renoir::IAllocator * renderingAllocator, renoir::Logging::ILogHandler * renderingLogger)
Deallocates the adapters created from AdaptRenderingAllocatorAndLoggerFromCohtml.
boolIsTagSelfClosing(HTMLTag tag)
boolCanTagContainHTML(HTMLTag tag)
template <typename T >
void
CoherentCreateModelBindPointer(Binder * binder, T * model)
template <typename ArrayType ,size_t Size>
size_t
CoherentArrayLength(void * arrayPtr)
template <typename ArrayType >
void
CoherentArrayElementReader(Binder * binder, void * data, size_t position)
template <typename ArrayType >
void
CoherentArrayElementBinder(Binder * binder, void * arr, size_t index)
template <typename ArrayType ,size_t ArraySize>
EnableIf<!IsChar< ArrayType >::Value
template <typename ArrayType ,size_t ArraySize>
EnableIf< IsChar< ArrayType >::Value &&!IsSame< ArrayType, unsigned char >::Value >::Type
CoherentBindInternal(Binder * binder, ArrayType array[ArraySize])
template <typename ArrayType ,size_t ArraySize>
EnableIf<!IsChar< ArrayType >::Value
template <typename ArrayType ,size_t ArraySize>
EnableIf< IsChar< ArrayType >::Value &&!IsSame< ArrayType, unsigned char >::Value >::Type
CoherentReadInternal(Binder * binder, ArrayType array[ArraySize])
voidCoherentBindInternal(Binder * binder, bool value)
voidCoherentBindInternal(Binder * binder, signed short value)
voidCoherentBindInternal(Binder * binder, unsigned short value)
voidCoherentBindInternal(Binder * binder, signed int value)
voidCoherentBindInternal(Binder * binder, unsigned int value)
voidCoherentBindInternal(Binder * binder, signed long long value)
voidCoherentBindInternal(Binder * binder, unsigned long long value)
voidCoherentBindInternal(Binder * binder, signed long value)
voidCoherentBindInternal(Binder * binder, unsigned long value)
voidCoherentBindInternal(Binder * binder, char value)
voidCoherentBindInternal(Binder * binder, signed char value)
voidCoherentBindInternal(Binder * binder, unsigned char value)
voidCoherentBindInternal(Binder * binder, float value)
voidCoherentBindInternal(Binder * binder, double value)
voidCoherentBindInternal(Binder * binder, const char * value)
voidCoherentBindInternal(Binder * binder, const wchar_t * value)
voidCoherentBindInternal(Binder * binder, const char16_t * value)
voidCoherentBindInternal(Binder * binder, const char32_t * value)
voidCoherentReadInternal(Binder * binder, signed short & value)
voidCoherentReadInternal(Binder * binder, unsigned short & value)
voidCoherentReadInternal(Binder * binder, signed int & value)
voidCoherentReadInternal(Binder * binder, unsigned int & value)
voidCoherentReadInternal(Binder * binder, signed long long & value)
voidCoherentReadInternal(Binder * binder, unsigned long long & value)
voidCoherentReadInternal(Binder * binder, signed long & value)
voidCoherentReadInternal(Binder * binder, unsigned long & value)
voidCoherentReadInternal(Binder * binder, bool & value)
voidCoherentReadInternal(Binder * binder, char & value)
voidCoherentReadInternal(Binder * binder, signed char & value)
voidCoherentReadInternal(Binder * binder, unsigned char & value)
voidCoherentReadInternal(Binder * binder, float & value)
voidCoherentReadInternal(Binder * binder, double & value)
template <typename T >
EnableIf< cohtml::TypeToElementType< T >::value==ElementType::ET_UserType, void >::Type
CoherentBindInternalPointerHelper(Binder * binder, T * object)
template <typename T >
EnableIf< cohtml::TypeToElementType< T >::value !=ElementType::ET_UserType, void >::Type
CoherentBindInternalPointerHelper(Binder * binder, T * object)
template <typename T >
EnableIf< PointerTrait< T >::Value, void >::Type
CoherentBindInternalPointer(Binder * binder, T & object)
template <typename T >
EnableIf<!PointerTrait< T >::Value &&!IsCString< T >::Value, void >::Type
CoherentBindInternalPointer(Binder * binder, T & object)
template <typename T >
EnableIf<!PointerTrait< T * >::Value &&IsCString< T * >::Value, void >::Type
CoherentBindInternalPointer(Binder * binder, T *& object)
template <typename T >
EnableIf< PointerTrait< T >::Value, void >::Type
CoherentReadInternalUserType(Binder * binder, T & object)
template <typename T >
EnableIf<!PointerTrait< T >::Value &&IsCString< T >::Value, void >::Type
CoherentReadInternalUserType(Binder * binder, T & object)
template <typename T >
EnableIf<!PointerTrait< T >::Value &&!IsCString< T >::Value, void >::Type
CoherentReadInternalUserType(Binder * binder, T & object)
template <typename T >
EnableIf< IsDefaultBindEnabled< T >::Value >::Type
CoherentBindInternal(Binder * binder, T & object)
template <typename T >
EnableIf< IsDefaultBindEnabled< T >::Value >::Type
CoherentBindInternal(Binder * binder, const T & object)
template <typename T >
EnableIf< IsDefaultBindEnabled< T >::Value >::Type
CoherentReadInternal(Binder * binder, T & object)
template <typename T >
ByRefHolder< T >
ByRef(T & ref)
template <typename T >
void
CoherentBindInternal(Binder * binder, ByRefHolder< T > & holder)
template <typename T >
void
CoherentBindInternal(Binder * binder, const ByRefHolder< T > & holder)
voidCoherentBindInternal(Binder * binder, renoir::Color & value)
voidCoherentBindInternal(Binder * binder, const renoir::Color & value)
voidCoherentReadInternal(Binder * binder, renoir::Color & value)
template <typename Key ,typename Value ,typename Comparator ,typename Allocator >
void
CoherentBindInternal(Binder * binder, std::map< Key, Value, Comparator, Allocator > & value)
template <typename Key ,typename Value ,typename Comparator ,typename Allocator >
void
CoherentBindInternal(Binder * binder, const std::map< Key, Value, Comparator, Allocator > & value)
template <typename Key ,typename Value ,typename Comparator ,typename Allocator >
void
CoherentReadInternal(Binder * binder, std::map< Key, Value, Comparator, Allocator > & value)
template <typename Key ,typename Value ,typename Comparator ,typename Allocator >
bool
GetMapValueInvoke(Binder * binder, MapInfo * mapInfo, std::map< Key, Value, Comparator, Allocator > * pMap)
template <typename T >
void
CoherentReadMapKey(Binder * binder, T & value)
template <typename T >
EnableIf<!IsMap< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type
GetMapValueInvoke(Binder * binder, void * object, MapInfo * mapInfo, const TypedProperty< T &> * prop)
template <typename T >
EnableIf< IsMap< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type
GetMapValueInvoke(Binder * binder, void * object, MapInfo * mapInfo, const TypedProperty< T &> * prop)
template <typename MapType ,typename MapKeyType ,typename MapValueType >
EnableIf<!cohtml::PointerTrait< MapValueType >::Value, void * >::Type
CoherentMapNativeElementReader(void * data, char const * name)
template <typename MapType ,typename MapKeyType ,typename MapValueType >
EnableIf< cohtml::PointerTrait< MapValueType >::Value, void * >::Type
CoherentMapNativeElementReader(void * data, char const * name)
template <typename T1 ,typename T2 >
void
CoherentBindInternal(Binder * binder, std::pair< T1, T2 > & value)
template <typename T1 ,typename T2 >
void
CoherentBindInternal(Binder * binder, const std::pair< T1, T2 > & value)
template <typename T1 ,typename T2 >
void
CoherentReadInternal(Binder * binder, std::pair< T1, T2 > & value)
template <typename T >
EnableIf<!IsPair< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type
GetPairValueInvoke(Binder * binder, void * object, PairInfo * pairInfo, const TypedProperty< T &> * prop)
template <typename T1 ,typename T2 >
bool
GetPairValueInvoke(Binder * binder, PairInfo * pairInfo, std::pair< T1, T2 > * pPair)
template <typename T >
EnableIf< IsPair< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type
GetPairValueInvoke(Binder * binder, void * object, PairInfo * arrayInfo, const TypedProperty< T &> * prop)
template <typename T >
EnableIf< IsCString< T >::Value, void >::Type
CoherentTypeInfoCallCoherentBindInternal(Binder * binder)
template <typename T >
EnableIf< IsCString< T >::Value, void >::Type
CoherentTypeInfoCallCoherentBindInternal(Binder * binder, void * model)
template <typename T >
EnableIf<!IsCString< T >::Value, void >::Type
CoherentTypeInfoCallCoherentBindInternal(Binder * binder)
template <typename T >
EnableIf<!IsCString< T >::Value, void >::Type
CoherentTypeInfoCallCoherentBindInternal(Binder * binder, void * model)
template <typename Type >
EnableIf< PointerTrait< Type >::Value, bool >::Type
GetObjectInfoInvoke(Binder * binder, void * object, ObjectInfo * objInfo, const TypedProperty< Type &> * prop)
template <typename Type >
EnableIf<!PointerTrait< Type >::Value, bool >::Type
GetObjectInfoInvoke(Binder * binder, void * object, ObjectInfo * objInfo, const TypedProperty< Type &> * prop)
template <typename P >
FieldProperty< P >
MakeProperty(const char * name, P p)
template <typename G ,typename S >
ConcreteProperty< G, S >
MakeProperty(const char * name, G g, S s)
template <typename G >
ConcretePropertyReadOnly< G >
MakePropertyReadOnly(const char * name, G g)
template <typename Char ,typename CharTraits ,typename Allocator >
void
CoherentBindInternal(Binder * binder, std::basic_string< Char, CharTraits, Allocator > & value)
template <typename Char ,typename CharTraits ,typename Allocator >
void
CoherentBindInternal(Binder * binder, const std::basic_string< Char, CharTraits, Allocator > & value)
template <typename Char ,typename CharTraits ,typename Allocator >
void
CoherentReadInternal(Binder * binder, std::basic_string< Char, CharTraits, Allocator > & value)
template <typename Char ,typename CharTraits ,typename Allocator >
void
CoherentReadMapKey(Binder * binder, std::basic_string< Char, CharTraits, Allocator > & value)
CSTRING_TYPETRAIT(char )
CSTRING_TYPETRAIT(signed char)
CSTRING_TYPETRAIT(unsigned char)
CSTRING_TYPETRAIT(wchar_t )
CSTRING_TYPETRAIT(char16_t )
CSTRING_TYPETRAIT(char32_t )
template <typename Key ,typename Value ,typename Hash ,typename Pred ,typename Allocator >
void
CoherentBindInternal(Binder * binder, std::unordered_map< Key, Value, Hash, Pred, Allocator > & value)
template <typename Key ,typename Value ,typename Hash ,typename Pred ,typename Allocator >
void
CoherentBindInternal(Binder * binder, const std::unordered_map< Key, Value, Hash, Pred, Allocator > & value)
template <typename Key ,typename Value ,typename Hash ,typename Pred ,typename Allocator >
void
CoherentReadInternal(Binder * binder, std::unordered_map< Key, Value, Hash, Pred, Allocator > & value)
template <typename Key ,typename Value ,typename Hash ,typename Pred ,typename Allocator >
bool
GetMapValueInvoke(Binder * binder, MapInfo * mapInfo, std::unordered_map< Key, Value, Hash, Pred, Allocator > * pMap)
template <typename VectorType >
size_t
CoherentVectorLength(void * vectorPtr)
template <typename VectorType ,typename T >
EnableIf<!cohtml::PointerTrait< T >::Value, void >::Type
CoherentVectorElementReader(Binder * binder, void * vectorPtr, size_t position)
template <typename VectorType ,typename T >
EnableIf< cohtml::PointerTrait< T >::Value, void >::Type
CoherentVectorElementReader(Binder * binder, void * vectorPtr, size_t position)
template <typename VectorType ,typename T >
EnableIf<!cohtml::PointerTrait< T >::Value, void * >::Type
CoherentVectorNativeElementReader(void * vectorPtr, size_t position)
template <typename VectorType ,typename T >
EnableIf< cohtml::PointerTrait< T >::Value, void * >::Type
CoherentVectorNativeElementReader(void * vectorPtr, size_t position)
template <typename VectorType >
void
CoherentVectorElementBinder(Binder * binder, void * vectorPtr, size_t index)
template <typename T ,typename A >
void
CoherentBindInternal(Binder * binder, std::vector< T, A > & value)
template <typename T ,typename A >
void
CoherentBindInternal(Binder * binder, const std::vector< T, A > & value)
template <typename A >
void
CoherentBindInternal(Binder * binder, std::vector< float, A > & value)
template <typename A >
void
CoherentBindInternal(Binder * binder, const std::vector< float, A > & value)
template <typename A >
void
CoherentBindInternal(Binder * binder, std::vector< int, A > & value)
template <typename A >
void
CoherentBindInternal(Binder * binder, const std::vector< int, A > & value)
template <typename T ,typename A >
void
CoherentReadInternal(Binder * binder, std::vector< T, A > & value)
template <typename T >
EnableIf<!IsVector< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type
GetArrayValueInvoke(Binder * binder, void * object, ArrayInfo * arrayInfo, const TypedProperty< T &> * prop)
template <typename T ,typename A >
bool
GetArrayValueInvoke(Binder * binder, ArrayInfo * arrayInfo, std::vector< T, A > * pVector)
template <typename T >
EnableIf< IsVector< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type
GetArrayValueInvoke(Binder * binder, void * object, ArrayInfo * arrayInfo, const TypedProperty< T &> * prop)

Types Documentation

enum WorkType

EnumeratorValueDescription
WT_Resources
WT_Layout

enum WorkExecutionMode

EnumeratorValueDescription
WEM_UntilQueueEmpty
WEM_UntilQuitExecute until all outstanding tasks have complete. Execute until cohtml is uninitialized. Use this only if you have a dedicated thread you’ll use only for the specified cohtml work.

The enumeration tells the Library how much work to execute in the invocation Please refer to the asynchronous work documentation for details.

enum GamepadHand

EnumeratorValueDescription
GH_None0Gamepad either does not support distinguishing hands, or cannot be determined.
GH_LeftGamepad is bound to the left hand.
GH_RightGamepad is bound to the right hand.

Enumeration that represent binding of a gamepad to a specific hand. Used for motion tracking controllers which are used in pairs, one controller per hand.

enum HTMLTag

EnumeratorValueDescription
HTML
HEAD
TITLE
BASE
LINK
META
STYLE
SCRIPT
NOSCRIPT
TEMPLATE
BODY
ARTICLE
SECTION
NAV
ASIDE
H1
H2
H3
H4
H5
H6
HGROUP
HEADER
FOOTER
ADDRESS
P
HR
PRE
BLOCKQUOTE
OL
UL
LI
DL
DT
DD
FIGURE
FIGCAPTION
MAIN
DIV
A
EM
STRONG
SMALL
S
CITE
Q
DFN
ABBR
DATA
TIME
CODE
VAR
SAMP
KBD
SUB
SUP
I
B
U
MARK
RUBY
RT
RP
BDI
BDO
SPAN
BR
WBR
INS
DEL
IMAGE
IMG
IFRAME
EMBED
OBJECT
PARAM
VIDEO
AUDIO
SOURCE
TRACK
CANVAS
MAP
AREA
MATH
MI
MO
MN
MS
MTEXT
MGLYPH
MALIGNMARK
ANNOTATION_XML
SVG
FOREIGNOBJECT
DESC
TABLE
CAPTION
COLGROUP
COL
TBODY
THEAD
TFOOT
TR
TD
TH
FORM
FIELDSET
LEGEND
LABEL
INPUT
BUTTON
SELECT
DATALIST
OPTGROUP
OPTION
TEXTAREA
KEYGEN
OUTPUT
PROGRESS
METER
DETAILS
SUMMARY
MENU
MENUITEM
APPLET
ACRONYM
BGSOUND
DIR
FRAME
FRAMESET
NOFRAMES
ISINDEX
LISTING
XMP
NEXTID
NOEMBED
PLAINTEXT
RB
STRIKE
BASEFONT
BIG
BLINK
CENTER
FONT
MARQUEE
MULTICOL
NOBR
SPACER
TT
RTC
UNKNOWN
ALL
CUSTOM
SVGCircle
SVGDefs
SVGEllipse
SVGG
SVGLine
SVGLinearGradient
SVGPath
SVGPolygon
SVGPolyline
SVGRadialGradient
SVGRect
SVGSolidColor
SVGStop
SVGText
SVGUse
SVGClipPath
SVGMask
SVGImage
COUNT

enum RenderingTasksAvailableType

EnumeratorValueDescription
RTA_ViewReadyForRendering
RTA_RenderingSubSystemTask

enum InterceptRequestStatus

EnumeratorValueDescription
Allow
Restrict

enum InternalCaches

EnumeratorValueDescription
ICACHE_Shadows1 « 0Access the cache for shadow textures (e.g. box-shadow, text-shadow) This cache has only size in number of contained objects.
ICACHE_Paths1 « 1Access the cache for complex shapes This cache has only size in number of contained objects.
ICACHE_Textures1 « 2Access the cache for client textures (such as image elements) This cache has both size in number of contained objects and size in bytes.
ICACHE_ScratchLayers1 « 3Access the cache for temporary internal textures that can contain packed data from multiple surfaces. The reported size is the amount of bytes allocated.
ICACHE_ScratchTextures1 « 4Access the cache for temporary internal textures that are dedicated for single surfaces only. The reported size is the amount of bytes allocated.
ICACHE_GfxCommandBuffers1 « 5Access the pool of command buffers, used for generating graphics commands for the graphics library. The cache has both size in number of contained objects and size in bytes.
ICACHE_GfxCommandProcessors1 « 6Access the pool of command processors, used for transforming the raw command buffers into ones usable by the graphics backend. The cache has both size in number of contained objects and size in bytes.
ICACHE_SVGSurfaces1 « 7Access the texture cache for textures where some non-inline SVGs are drawn. This cache flag can be used to clear those textures and force their recreation.
ICACHE_BackdropFilterSurfaces1 « 8Access the texture cache for surfaces used during backdrop filter rendeirng. This cache flag can be used to clear those textures and force their recreation.

enum CaptureMode

EnumeratorValueDescription
CM_PreserveAll
CM_PreserveAlpha
CM_ObfuscateAll

When serializing rendering commands, part of the image data in a document is saved as well. With these capture modes, you can force the capturer to obfuscate the pixel data and with that no images will be leaked through the serialized capture.

enum ValueType

EnumeratorValueDescription
VT_Null
VT_Undefined
VT_Boolean
VT_Number
VT_String
VT_Object
VT_Array
VT_Count

The primitive types coming from JS.

enum ElementType

EnumeratorValueDescription
ET_Boolean
ET_Int8
ET_UInt8
ET_Int16
ET_UInt16
ET_Int32
ET_UInt32
ET_Int64
ET_UInt64
ET_Float
ET_Double
ET_String
ET_Color
ET_Array
ET_Map
ET_Pair
ET_UserType
ET_PolymorphUserType

typedef TimePoint

typedef double cohtml::TimePoint;

typedef TaskFamilyId

typedef int cohtml::TaskFamilyId;

typedef OnWorkAvailableFunc

typedef void(* cohtml::OnWorkAvailableFunc) (void *userData, WorkType type, TaskFamilyId family);

Called when a new task is available and should be executed later on.

typedef OnUserImageDroppedFunc

typedef void(* cohtml::OnUserImageDroppedFunc) (void *userData, void *texturePtr);

typedef BoundEventHandle

typedef void * cohtml::BoundEventHandle;

typedef OnRenderingTasksAvailableFunc

typedef void(* cohtml::OnRenderingTasksAvailableFunc) (void *userData, unsigned viewId, unsigned frameId, RenderingTasksAvailableType type);

typedef OnMonotonicallyIncreasingTimeRequestFunc

typedef double(* cohtml::OnMonotonicallyIncreasingTimeRequestFunc) (void *userdata, unsigned viewId);

typedef FrameCaptureCallback

typedef void(* cohtml::FrameCaptureCallback) (void *userData, FrameCapture *capture);

Function signature of callback used in View::BeginCaptureDebugFrame and View::CaptureSingleDebugFrame.

Parameters:

typedef Reader

typedef void(* cohtml::Reader)(Binder *, void *, size_t);

typedef ArrayLengthGetter

typedef size_t(* cohtml::ArrayLengthGetter) (void *);

typedef MapElementGetter

typedef void*(* cohtml::MapElementGetter) (void *userData, const char *name);

typedef LengthGetter

typedef size_t(* cohtml::LengthGetter) (void *userData);

typedef ElementGetter

typedef void*(* cohtml::ElementGetter) (void *userData, size_t index);

typedef TrueType

typedef BoolConstant<true> cohtml::TrueType;

typedef FalseType

typedef BoolConstant<false> cohtml::FalseType;

typedef NativeReader

typedef void*(* cohtml::NativeReader) (void *, size_t);

typedef VectorLengthFunc

typedef size_t(* cohtml::VectorLengthFunc) (void *);

Functions Documentation

function MakeHandler

template <typename Functor >
IEventHandler * MakeHandler(
    Functor functor
)

Create event handler from generic C++ functor.

Parameters:

  • functor generic C++ functor, i.e. pointer to static function or object with operator()

Return: IEventHandler that wraps the functor

function MakeHandler

template <typename Method >
IEventHandler * MakeHandler(
    void * object,
    Method method
)

Create event handler from C++ method.

Parameters:

  • object pointer to the instance with which the method will be invoked
  • method the C++ method to be invoked

Return: IEventHandler that wraps the method

Warning: the object pointer is stored until cohtml::ViewListener::OnBindingsReleased is called. Therefore the pointer must remain valid until then.

function AdaptRenderingAllocatorAndLoggerFromCohtml

void AdaptRenderingAllocatorAndLoggerFromCohtml(
    IAllocator * allocator,
    Logging::ILogHandler * logger,
    renoir::IAllocator ** outRenderingAllocator,
    renoir::Logging::ILogHandler ** outRenderingLogger
)

Function to adapt Cohtml based IAllocator and ILogHandler to the Rendering library variants It will use the allocator instance to allocate the adapters. You can call this to use Cohtml instances when using an externally initialized rendering library.

function DestroyAdaptedRenderingAllocatorAndLogger

void DestroyAdaptedRenderingAllocatorAndLogger(
    IAllocator * allocator,
    renoir::IAllocator * renderingAllocator,
    renoir::Logging::ILogHandler * renderingLogger
)

Deallocates the adapters created from AdaptRenderingAllocatorAndLoggerFromCohtml.

function IsTagSelfClosing

inline bool IsTagSelfClosing(
    HTMLTag tag
)

function CanTagContainHTML

inline bool CanTagContainHTML(
    HTMLTag tag
)

function CoherentCreateModelBindPointer

template <typename T >
void CoherentCreateModelBindPointer(
    Binder * binder,
    T * model
)

function CoherentArrayLength

template <typename ArrayType ,
size_t Size>
size_t CoherentArrayLength(
    void * arrayPtr
)

function CoherentArrayElementReader

template <typename ArrayType >
void CoherentArrayElementReader(
    Binder * binder,
    void * data,
    size_t position
)

function CoherentArrayElementBinder

template <typename ArrayType >
void CoherentArrayElementBinder(
    Binder * binder,
    void * arr,
    size_t index
)

function CoherentBindInternal

template <typename ArrayType ,
size_t ArraySize>
inline EnableIf<!IsChar< ArrayType >::Value||IsSame< ArrayType, unsigned char >::Value >::Type CoherentBindInternal(
    Binder * binder,
    ArrayType(&) array[ArraySize]
)

function CoherentBindInternal

template <typename ArrayType ,
size_t ArraySize>
inline EnableIf< IsChar< ArrayType >::Value &&!IsSame< ArrayType, unsigned char >::Value >::Type CoherentBindInternal(
    Binder * binder,
    ArrayType array[ArraySize]
)

function CoherentReadInternal

template <typename ArrayType ,
size_t ArraySize>
inline EnableIf<!IsChar< ArrayType >::Value||IsSame< ArrayType, unsigned char >::Value >::Type CoherentReadInternal(
    Binder * binder,
    ArrayType(&) array[ArraySize]
)

function CoherentReadInternal

template <typename ArrayType ,
size_t ArraySize>
inline EnableIf< IsChar< ArrayType >::Value &&!IsSame< ArrayType, unsigned char >::Value >::Type CoherentReadInternal(
    Binder * binder,
    ArrayType array[ArraySize]
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    bool value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    signed short value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    unsigned short value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    signed int value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    unsigned int value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    signed long long value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    unsigned long long value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    signed long value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    unsigned long value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    char value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    signed char value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    unsigned char value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    float value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    double value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    const char * value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    const wchar_t * value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    const char16_t * value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    const char32_t * value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    signed short & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    unsigned short & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    signed int & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    unsigned int & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    signed long long & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    unsigned long long & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    signed long & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    unsigned long & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    bool & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    char & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    signed char & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    unsigned char & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    float & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    double & value
)

function CoherentBindInternalPointerHelper

template <typename T >
EnableIf< cohtml::TypeToElementType< T >::value==ElementType::ET_UserType, void >::Type CoherentBindInternalPointerHelper(
    Binder * binder,
    T * object
)

function CoherentBindInternalPointerHelper

template <typename T >
EnableIf< cohtml::TypeToElementType< T >::value !=ElementType::ET_UserType, void >::Type CoherentBindInternalPointerHelper(
    Binder * binder,
    T * object
)

function CoherentBindInternalPointer

template <typename T >
EnableIf< PointerTrait< T >::Value, void >::Type CoherentBindInternalPointer(
    Binder * binder,
    T & object
)

function CoherentBindInternalPointer

template <typename T >
EnableIf<!PointerTrait< T >::Value &&!IsCString< T >::Value, void >::Type CoherentBindInternalPointer(
    Binder * binder,
    T & object
)

function CoherentBindInternalPointer

template <typename T >
EnableIf<!PointerTrait< T * >::Value &&IsCString< T * >::Value, void >::Type CoherentBindInternalPointer(
    Binder * binder,
    T *& object
)

function CoherentReadInternalUserType

template <typename T >
EnableIf< PointerTrait< T >::Value, void >::Type CoherentReadInternalUserType(
    Binder * binder,
    T & object
)

function CoherentReadInternalUserType

template <typename T >
EnableIf<!PointerTrait< T >::Value &&IsCString< T >::Value, void >::Type CoherentReadInternalUserType(
    Binder * binder,
    T & object
)

function CoherentReadInternalUserType

template <typename T >
EnableIf<!PointerTrait< T >::Value &&!IsCString< T >::Value, void >::Type CoherentReadInternalUserType(
    Binder * binder,
    T & object
)

function CoherentBindInternal

template <typename T >
EnableIf< IsDefaultBindEnabled< T >::Value >::Type CoherentBindInternal(
    Binder * binder,
    T & object
)

function CoherentBindInternal

template <typename T >
EnableIf< IsDefaultBindEnabled< T >::Value >::Type CoherentBindInternal(
    Binder * binder,
    const T & object
)

function CoherentReadInternal

template <typename T >
EnableIf< IsDefaultBindEnabled< T >::Value >::Type CoherentReadInternal(
    Binder * binder,
    T & object
)

function ByRef

template <typename T >
ByRefHolder< T > ByRef(
    T & ref
)

function CoherentBindInternal

template <typename T >
void CoherentBindInternal(
    Binder * binder,
    ByRefHolder< T > & holder
)

function CoherentBindInternal

template <typename T >
void CoherentBindInternal(
    Binder * binder,
    const ByRefHolder< T > & holder
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    renoir::Color & value
)

function CoherentBindInternal

inline void CoherentBindInternal(
    Binder * binder,
    const renoir::Color & value
)

function CoherentReadInternal

inline void CoherentReadInternal(
    Binder * binder,
    renoir::Color & value
)

function CoherentBindInternal

template <typename Key ,
typename Value ,
typename Comparator ,
typename Allocator >
void CoherentBindInternal(
    Binder * binder,
    std::map< Key, Value, Comparator, Allocator > & value
)

function CoherentBindInternal

template <typename Key ,
typename Value ,
typename Comparator ,
typename Allocator >
void CoherentBindInternal(
    Binder * binder,
    const std::map< Key, Value, Comparator, Allocator > & value
)

function CoherentReadInternal

template <typename Key ,
typename Value ,
typename Comparator ,
typename Allocator >
void CoherentReadInternal(
    Binder * binder,
    std::map< Key, Value, Comparator, Allocator > & value
)

function GetMapValueInvoke

template <typename Key ,
typename Value ,
typename Comparator ,
typename Allocator >
inline bool GetMapValueInvoke(
    Binder * binder,
    MapInfo * mapInfo,
    std::map< Key, Value, Comparator, Allocator > * pMap
)

function CoherentReadMapKey

template <typename T >
void CoherentReadMapKey(
    Binder * binder,
    T & value
)

function GetMapValueInvoke

template <typename T >
inline EnableIf<!IsMap< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetMapValueInvoke(
    Binder * binder,
    void * object,
    MapInfo * mapInfo,
    const TypedProperty< T &> * prop
)

function GetMapValueInvoke

template <typename T >
EnableIf< IsMap< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetMapValueInvoke(
    Binder * binder,
    void * object,
    MapInfo * mapInfo,
    const TypedProperty< T &> * prop
)

function CoherentMapNativeElementReader

template <typename MapType ,
typename MapKeyType ,
typename MapValueType >
EnableIf<!cohtml::PointerTrait< MapValueType >::Value, void * >::Type CoherentMapNativeElementReader(
    void * data,
    char const * name
)

function CoherentMapNativeElementReader

template <typename MapType ,
typename MapKeyType ,
typename MapValueType >
EnableIf< cohtml::PointerTrait< MapValueType >::Value, void * >::Type CoherentMapNativeElementReader(
    void * data,
    char const * name
)

function CoherentBindInternal

template <typename T1 ,
typename T2 >
void CoherentBindInternal(
    Binder * binder,
    std::pair< T1, T2 > & value
)

function CoherentBindInternal

template <typename T1 ,
typename T2 >
void CoherentBindInternal(
    Binder * binder,
    const std::pair< T1, T2 > & value
)

function CoherentReadInternal

template <typename T1 ,
typename T2 >
void CoherentReadInternal(
    Binder * binder,
    std::pair< T1, T2 > & value
)

function GetPairValueInvoke

template <typename T >
inline EnableIf<!IsPair< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetPairValueInvoke(
    Binder * binder,
    void * object,
    PairInfo * pairInfo,
    const TypedProperty< T &> * prop
)

function GetPairValueInvoke

template <typename T1 ,
typename T2 >
inline bool GetPairValueInvoke(
    Binder * binder,
    PairInfo * pairInfo,
    std::pair< T1, T2 > * pPair
)

function GetPairValueInvoke

template <typename T >
EnableIf< IsPair< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetPairValueInvoke(
    Binder * binder,
    void * object,
    PairInfo * arrayInfo,
    const TypedProperty< T &> * prop
)

function CoherentTypeInfoCallCoherentBindInternal

template <typename T >
EnableIf< IsCString< T >::Value, void >::Type CoherentTypeInfoCallCoherentBindInternal(
    Binder * binder
)

function CoherentTypeInfoCallCoherentBindInternal

template <typename T >
EnableIf< IsCString< T >::Value, void >::Type CoherentTypeInfoCallCoherentBindInternal(
    Binder * binder,
    void * model
)

function CoherentTypeInfoCallCoherentBindInternal

template <typename T >
EnableIf<!IsCString< T >::Value, void >::Type CoherentTypeInfoCallCoherentBindInternal(
    Binder * binder
)

function CoherentTypeInfoCallCoherentBindInternal

template <typename T >
EnableIf<!IsCString< T >::Value, void >::Type CoherentTypeInfoCallCoherentBindInternal(
    Binder * binder,
    void * model
)

function GetObjectInfoInvoke

template <typename Type >
EnableIf< PointerTrait< Type >::Value, bool >::Type GetObjectInfoInvoke(
    Binder * binder,
    void * object,
    ObjectInfo * objInfo,
    const TypedProperty< Type &> * prop
)

function GetObjectInfoInvoke

template <typename Type >
EnableIf<!PointerTrait< Type >::Value, bool >::Type GetObjectInfoInvoke(
    Binder * binder,
    void * object,
    ObjectInfo * objInfo,
    const TypedProperty< Type &> * prop
)

function MakeProperty

template <typename P >
FieldProperty< P > MakeProperty(
    const char * name,
    P p
)

function MakeProperty

template <typename G ,
typename S >
ConcreteProperty< G, S > MakeProperty(
    const char * name,
    G g,
    S s
)

function MakePropertyReadOnly

template <typename G >
ConcretePropertyReadOnly< G > MakePropertyReadOnly(
    const char * name,
    G g
)

function CoherentBindInternal

template <typename Char ,
typename CharTraits ,
typename Allocator >
void CoherentBindInternal(
    Binder * binder,
    std::basic_string< Char, CharTraits, Allocator > & value
)

function CoherentBindInternal

template <typename Char ,
typename CharTraits ,
typename Allocator >
void CoherentBindInternal(
    Binder * binder,
    const std::basic_string< Char, CharTraits, Allocator > & value
)

function CoherentReadInternal

template <typename Char ,
typename CharTraits ,
typename Allocator >
void CoherentReadInternal(
    Binder * binder,
    std::basic_string< Char, CharTraits, Allocator > & value
)

function CoherentReadMapKey

template <typename Char ,
typename CharTraits ,
typename Allocator >
void CoherentReadMapKey(
    Binder * binder,
    std::basic_string< Char, CharTraits, Allocator > & value
)

function CSTRING_TYPETRAIT

CSTRING_TYPETRAIT(
    char 
)

function CSTRING_TYPETRAIT

CSTRING_TYPETRAIT(
    signed char
)

function CSTRING_TYPETRAIT

CSTRING_TYPETRAIT(
    unsigned char
)

function CSTRING_TYPETRAIT

CSTRING_TYPETRAIT(
    wchar_t 
)

function CSTRING_TYPETRAIT

CSTRING_TYPETRAIT(
    char16_t 
)

function CSTRING_TYPETRAIT

CSTRING_TYPETRAIT(
    char32_t 
)

function CoherentBindInternal

template <typename Key ,
typename Value ,
typename Hash ,
typename Pred ,
typename Allocator >
void CoherentBindInternal(
    Binder * binder,
    std::unordered_map< Key, Value, Hash, Pred, Allocator > & value
)

function CoherentBindInternal

template <typename Key ,
typename Value ,
typename Hash ,
typename Pred ,
typename Allocator >
void CoherentBindInternal(
    Binder * binder,
    const std::unordered_map< Key, Value, Hash, Pred, Allocator > & value
)

function CoherentReadInternal

template <typename Key ,
typename Value ,
typename Hash ,
typename Pred ,
typename Allocator >
void CoherentReadInternal(
    Binder * binder,
    std::unordered_map< Key, Value, Hash, Pred, Allocator > & value
)

function GetMapValueInvoke

template <typename Key ,
typename Value ,
typename Hash ,
typename Pred ,
typename Allocator >
inline bool GetMapValueInvoke(
    Binder * binder,
    MapInfo * mapInfo,
    std::unordered_map< Key, Value, Hash, Pred, Allocator > * pMap
)

function CoherentVectorLength

template <typename VectorType >
size_t CoherentVectorLength(
    void * vectorPtr
)

function CoherentVectorElementReader

template <typename VectorType ,
typename T >
EnableIf<!cohtml::PointerTrait< T >::Value, void >::Type CoherentVectorElementReader(
    Binder * binder,
    void * vectorPtr,
    size_t position
)

function CoherentVectorElementReader

template <typename VectorType ,
typename T >
EnableIf< cohtml::PointerTrait< T >::Value, void >::Type CoherentVectorElementReader(
    Binder * binder,
    void * vectorPtr,
    size_t position
)

function CoherentVectorNativeElementReader

template <typename VectorType ,
typename T >
EnableIf<!cohtml::PointerTrait< T >::Value, void * >::Type CoherentVectorNativeElementReader(
    void * vectorPtr,
    size_t position
)

function CoherentVectorNativeElementReader

template <typename VectorType ,
typename T >
EnableIf< cohtml::PointerTrait< T >::Value, void * >::Type CoherentVectorNativeElementReader(
    void * vectorPtr,
    size_t position
)

function CoherentVectorElementBinder

template <typename VectorType >
void CoherentVectorElementBinder(
    Binder * binder,
    void * vectorPtr,
    size_t index
)

function CoherentBindInternal

template <typename T ,
typename A >
void CoherentBindInternal(
    Binder * binder,
    std::vector< T, A > & value
)

function CoherentBindInternal

template <typename T ,
typename A >
void CoherentBindInternal(
    Binder * binder,
    const std::vector< T, A > & value
)

function CoherentBindInternal

template <typename A >
void CoherentBindInternal(
    Binder * binder,
    std::vector< float, A > & value
)

function CoherentBindInternal

template <typename A >
void CoherentBindInternal(
    Binder * binder,
    const std::vector< float, A > & value
)

function CoherentBindInternal

template <typename A >
void CoherentBindInternal(
    Binder * binder,
    std::vector< int, A > & value
)

function CoherentBindInternal

template <typename A >
void CoherentBindInternal(
    Binder * binder,
    const std::vector< int, A > & value
)

function CoherentReadInternal

template <typename T ,
typename A >
void CoherentReadInternal(
    Binder * binder,
    std::vector< T, A > & value
)

function GetArrayValueInvoke

template <typename T >
inline EnableIf<!IsVector< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetArrayValueInvoke(
    Binder * binder,
    void * object,
    ArrayInfo * arrayInfo,
    const TypedProperty< T &> * prop
)

function GetArrayValueInvoke

template <typename T ,
typename A >
inline bool GetArrayValueInvoke(
    Binder * binder,
    ArrayInfo * arrayInfo,
    std::vector< T, A > * pVector
)

function GetArrayValueInvoke

template <typename T >
EnableIf< IsVector< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetArrayValueInvoke(
    Binder * binder,
    void * object,
    ArrayInfo * arrayInfo,
    const TypedProperty< T &> * prop
)