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
class	cohtml::AdjustPointer
class	cohtml::ArgumentsBinder Class for communicating between EventHandler and the scripting.
struct	cohtml::ArrayInfo Represents a array of a type exposed to the scripting.
class	cohtml::ArrayReaderFactory
class	*cohtml::ArrayReaderFactory< T , Size >**
struct	cohtml::AssertFail
class	cohtml::Binder Provides binding between C++ and the UI.
struct	cohtml::BoolConstant
class	cohtml::ByRefHolder
struct	cohtml::CachedResourcesWatermarks Watermarks used for the image cache management.
struct	cohtml::ClassType
struct	*cohtml::ClassType< Property Class::>**
struct	*cohtml::ClassType< Property(Class::)() const >**
struct	*cohtml::ClassType< Property(Class::)()>**
struct	cohtml::CoherentToBoolean
struct	cohtml::CoherentToBoolean< bool >
struct	cohtml::CoherentToBoolean< double >
struct	cohtml::CoherentToBoolean< float >
struct	cohtml::CoherentToBoolean< int >
struct	cohtml::CoherentToBoolean< signed long >
struct	cohtml::CoherentToBoolean< signed long long >
struct	cohtml::CoherentToBoolean< signed short >
struct	cohtml::CoherentToBoolean< unsigned >
struct	cohtml::CoherentToBoolean< unsigned long >
struct	cohtml::CoherentToBoolean< unsigned long long >
struct	cohtml::CoherentToBoolean< unsigned short >
struct	cohtml::CoherentToColor
struct	cohtml::CoherentToColor< const int & >
struct	cohtml::CoherentToColor< const renoir::Color & >
struct	cohtml::CoherentToColor< const unsigned & >
struct	cohtml::CoherentToNumber
struct	cohtml::CoherentToNumber< double >
struct	cohtml::CoherentToNumber< float >
struct	cohtml::CoherentToNumber< int >
struct	cohtml::CoherentToNumber< signed long >
struct	cohtml::CoherentToNumber< signed long long >
struct	cohtml::CoherentToNumber< signed short >
struct	cohtml::CoherentToNumber< unsigned >
struct	cohtml::CoherentToNumber< unsigned long >
struct	cohtml::CoherentToNumber< unsigned long long >
struct	cohtml::CoherentToNumber< unsigned short >
struct	cohtml::CoherentToString
struct	cohtml::CoherentToString< bool >
struct	*cohtml::CoherentToString< char >**
struct	cohtml::CoherentToString< char[N]>
struct	*cohtml::CoherentToString< const char >**
struct	cohtml::CoherentToString< const char[N]>
struct	cohtml::CoherentToString< double >
struct	cohtml::CoherentToString< float >
struct	cohtml::CoherentToString< int >
struct	cohtml::CoherentToString< long >
struct	cohtml::CoherentToString< long long >
struct	cohtml::CoherentToString< short >
struct	cohtml::CoherentToString< std::basic_string< char, CharTraits, Allocator > >
struct	cohtml::CoherentToString< unsigned >
struct	cohtml::CoherentToString< unsigned long >
struct	cohtml::CoherentToString< unsigned long long >
struct	cohtml::CoherentToString< unsigned short >
struct	cohtml::CoherentToTransformMatrix2D
struct	cohtml::CoherentToTransformMatrix2D< const char(&)[N]>
struct	*cohtml::CoherentToTransformMatrix2D< const float & >**
struct	cohtml::CoherentToTransformMatrix2D< const float(&)[6]>
struct	*cohtml::CoherentToTransformMatrix2D< float & >**
struct	cohtml::CoherentToTransformMatrix2D< float(&)[6]>
struct	cohtml::CoherentTypeInfo
class	cohtml::ConcreteProperty
class	cohtml::ConcretePropertyReadOnly
class	cohtml::DataBuffer A reference counted data buffer.
struct	cohtml::DebugDump Debugging class used for dumping the whole structure of the page DOM.
struct	cohtml::DisableDefaultBinding
struct	cohtml::EnableIf
struct	cohtml::EnableIf< true, T >
class	cohtml::EventHandler
struct	cohtml::EventModifiersState The state of the key modifiers when an event happens.
struct	cohtml::EventMouseModifiersState The state of the mouse modifiers when an event happens.
class	cohtml::FieldProperty
class	*cohtml::FieldProperty< PropertyType(Class::)>**
class	*cohtml::FieldProperty< PropertyType(Class::)[ArraySize]>**
struct	cohtml::FontDescription Struct used for identifying fonts.
struct	cohtml::FrameCapture Debugging class holding debug frame captured data and size. Passed to FrameCaptureCallback on View::BeginCaptureDebugFrame and View::CaptureSingleDebugFrame methods.
struct	cohtml::FunctorArity
struct	cohtml::FunctorTraits
struct	cohtml::FunctorTraits< ResultType()>
struct	*cohtml::FunctorTraits< ResultType()()>**
struct	*cohtml::FunctorTraits< ResultType()(Arg0Type)>**
struct	*cohtml::FunctorTraits< ResultType()(Arg0Type, Arg1Type)>**
struct	*cohtml::FunctorTraits< ResultType()(Arg0Type, Arg1Type, Arg2Type)>**
struct	*cohtml::FunctorTraits< ResultType()(Arg0Type, Arg1Type, Arg2Type, Arg3Type)>**
struct	*cohtml::FunctorTraits< ResultType()(Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type)>**
struct	cohtml::FunctorTraits< ResultType(Arg0Type)>
struct	cohtml::FunctorTraits< ResultType(Arg0Type, Arg1Type)>
struct	cohtml::FunctorTraits< ResultType(Arg0Type, Arg1Type, Arg2Type)>
struct	cohtml::FunctorTraits< ResultType(Arg0Type, Arg1Type, Arg2Type, Arg3Type)>
struct	cohtml::FunctorTraits< ResultType(Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type)>
struct	*cohtml::FunctorTraits< ResultType(ClassType::)() const >**
struct	*cohtml::FunctorTraits< ResultType(ClassType::)()>**
struct	*cohtml::FunctorTraits< ResultType(ClassType::)(Arg0Type) const >**
struct	*cohtml::FunctorTraits< ResultType(ClassType::)(Arg0Type)>**
struct	*cohtml::FunctorTraits< ResultType(ClassType::)(Arg0Type, Arg1Type) const >**
struct	*cohtml::FunctorTraits< ResultType(ClassType::)(Arg0Type, Arg1Type)>**
struct	*cohtml::FunctorTraits< ResultType(ClassType::)(Arg0Type, Arg1Type, Arg2Type) const >**
struct	*cohtml::FunctorTraits< ResultType(ClassType::)(Arg0Type, Arg1Type, Arg2Type)>**
struct	*cohtml::FunctorTraits< ResultType(ClassType::)(Arg0Type, Arg1Type, Arg2Type, Arg3Type) const >**
struct	*cohtml::FunctorTraits< ResultType(ClassType::)(Arg0Type, Arg1Type, Arg2Type, Arg3Type)>**
struct	*cohtml::FunctorTraits< ResultType(ClassType::)(Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type) const >**
struct	*cohtml::FunctorTraits< ResultType(ClassType::)(Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type)>**
struct	cohtml::FunctorTraits< std::function< R()> >
struct	cohtml::FunctorTraits< std::function< R(A0)> >
struct	cohtml::FunctorTraits< std::function< R(A0, A1)> >
struct	cohtml::FunctorTraits< std::function< R(A0, A1, A2)> >
struct	cohtml::FunctorTraits< std::function< R(A0, A1, A2, A3)> >
struct	cohtml::FunctorTraits< std::function< R(A0, A1, A2, A3, A4)> >
struct	cohtml::GamepadPoseState Represents the pose of a motion tracking controller.
struct	cohtml::GamepadState Represents the entire state of a single gamepad.
struct	cohtml::GamepadStateExtended Extended representation of the gamepad state, including information for controllers that support motion tracking.
struct	cohtml::GestureEventData A gesture event.
struct	cohtml::GetArrayValue
struct	cohtml::GetArrayValue< T & >
struct	cohtml::GetArrayValue< Type[]>
struct	cohtml::GetMapValue
struct	cohtml::GetMapValue< T & >
struct	cohtml::GetObjectInfo
struct	cohtml::GetObjectInfo< Type &, ET_UserType >
struct	cohtml::GetPairValue
struct	cohtml::GetPairValue< T & >
struct	cohtml::GetValue
struct	*cohtml::GetValue< Property Class:: >**
struct	*cohtml::GetValue< Property(Class::)() const >**
struct	*cohtml::GetValue< Property(Class::)()>**
struct	cohtml::GPUMemoryInfo
class	cohtml::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.
class	cohtml::IAsyncResourceHandler Class that will handle all asynchronous resource requests.
class	cohtml::IAsyncResourceRequest Encapsulates an asynchronous resource request.
class	cohtml::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.
class	cohtml::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.
class	cohtml::IClientSideSocket The IClientSideSocket represents platform/client specific part of the web sockets.
class	cohtml::IDataStorageHandler Class that will handle data storage requests.
class	cohtml::IDataStorageRequest Encapsulates a data storage request.
class	cohtml::IDataStorageResponse Response that the application should use when the data storage has been read.
class	cohtml::IEventHandler
class	cohtml::IFileSystemReader Class that allows Cohtml to interface with the local file system. It allows enumerating folders and opening streams to local resources.
class	cohtml::IFileSystemWriter Class that allows Cohtml to interface with the local file system. It allows opening a file for writing and writing information to it.
class	cohtml::IInputProxy Represents an INPUT or TEXTAREA element in the View.
class	cohtml::IInternationalizationManager Takes care of culture specific text operations.
class	cohtml::ILocalizationManager Takes care of translating text between different locales.
struct	cohtml::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.
class	cohtml::INodeProxy Represents a DOM element in the View - i.e. a DIV, the BODY etc.
class	cohtml::IProfileMarkersTracer
struct	cohtml::IsChar
struct	cohtml::IsConst
struct	cohtml::IsConst< const T >
struct	cohtml::IsCString
struct	*cohtml::IsCString< const T >**
struct	cohtml::IsDefaultBindEnabled
struct	cohtml::IsExposedByRef
struct	cohtml::IsExposedByRef< bool >
struct	*cohtml::IsExposedByRef< char >**
struct	cohtml::IsExposedByRef< const bool >
struct	*cohtml::IsExposedByRef< const char >**
struct	cohtml::IsExposedByRef< const double >
struct	cohtml::IsExposedByRef< const float >
struct	cohtml::IsExposedByRef< const signed char >
struct	cohtml::IsExposedByRef< const signed int >
struct	cohtml::IsExposedByRef< const signed long >
struct	cohtml::IsExposedByRef< const signed long long >
struct	cohtml::IsExposedByRef< const unsigned char >
struct	cohtml::IsExposedByRef< const unsigned int >
struct	cohtml::IsExposedByRef< const unsigned long >
struct	cohtml::IsExposedByRef< const unsigned long long >
struct	*cohtml::IsExposedByRef< const wchar_t >**
struct	cohtml::IsExposedByRef< double >
struct	cohtml::IsExposedByRef< float >
struct	cohtml::IsExposedByRef< signed char >
struct	cohtml::IsExposedByRef< signed int >
struct	cohtml::IsExposedByRef< signed long >
struct	cohtml::IsExposedByRef< signed long long >
struct	cohtml::IsExposedByRef< T & >
struct	cohtml::IsExposedByRef< unsigned char >
struct	cohtml::IsExposedByRef< unsigned int >
struct	cohtml::IsExposedByRef< unsigned long >
struct	cohtml::IsExposedByRef< unsigned long long >
struct	*cohtml::IsExposedByRef< wchar_t >**
struct	cohtml::IsMap
struct	cohtml::IsMap< std::map< Key, Value, Comparator, Allocator > >
struct	cohtml::IsMap< std::unordered_map< Key, Value, Hash, Pred, Allocator > >
class	cohtml::ISocketListener The ISocketListener represents cohtml::View side of the web sockets.
struct	cohtml::IsPair
struct	cohtml::IsPair< std::pair< T1, T2 > >
struct	cohtml::IsSame
struct	cohtml::IsSame< T, T >
struct	cohtml::IsValidModelType
struct	cohtml::IsValidModelType< std::basic_string< Char, CharTraits, Allocator > >
struct	cohtml::IsValidModelType< std::map< Key, Value, Comparator, Allocator > >
struct	cohtml::IsValidModelType< std::pair< T1, T2 > >
struct	cohtml::IsValidModelType< std::unordered_map< Key, Value, Hash, Pred, Allocator > >
struct	cohtml::IsValidModelType< std::vector< T, A > >
struct	cohtml::IsVector
struct	cohtml::IsVector< std::vector< T, A > >
struct	cohtml::IsVoid
struct	cohtml::IsVoid< void >
class	cohtml::ISyncStreamReader Class for synchronously reading local resources.
class	cohtml::ISyncStreamWriter Class for synchronously writing local resources.
class	cohtml::ITextInputHandler Notifies of changes to input elements.
class	cohtml::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`.
class	cohtml::ITimeZoneProvider
class	cohtml::IViewListener Interface that allows to listen for various events in the View.
class	cohtml::IVirtualAllocator Virtual memory allocator interface used by Cohtml for scripting memory allocations.
struct	cohtml::KeyEventData A keyboard event.
class	cohtml::Library This class encapsulates the global Cohtml library.
struct	cohtml::LibraryParams
struct	cohtml::LibraryParamsWithExternalRenderingLibrary Initialization parameters of the Cohtml library.
struct	cohtml::MapInfo Represents a map of a type exposed to the scripting.
struct	cohtml::MemberPointerTraits
struct	*cohtml::MemberPointerTraits< T C:: >**
struct	cohtml::MouseEventData
struct	cohtml::ObjectInfo Represents a object of a type exposed to the scripting.
struct	cohtml::Overload_CoherentBind_For_Your_Type
struct	cohtml::PageCapture Object pointing a raw data coming from a full page capture (see View::SetupPageCapture and View::DoPageCapture).
struct	cohtml::PairInfo Represents a pair of a type exposed to the scripting.
struct	cohtml::PlatformSpecificParams Platform-specific initialization parameters of the Cohtml library.
struct	cohtml::PointerTrait
struct	cohtml::PointerTrait< const T & >
struct	*cohtml::PointerTrait< const T >**
struct	cohtml::PointerTrait< const T >
struct	cohtml::PointerTrait< std::shared_ptr< const T > >
struct	cohtml::PointerTrait< std::shared_ptr< T > >
struct	cohtml::PointerTrait< std::unique_ptr< const T > >
struct	cohtml::PointerTrait< std::unique_ptr< T > >
struct	cohtml::PointerTrait< T & >
struct	*cohtml::PointerTrait< T >**
struct	cohtml::PreciseHandle
class	cohtml::Property Represents a property of a type exposed to the scripting.
struct	cohtml::PropertyType
struct	*cohtml::PropertyType< ReturnType(Class::)(const Property &)>**
struct	*cohtml::PropertyType< ReturnType(Class::)(const T(&)[N]) >**
struct	*cohtml::PropertyType< ReturnType(Class::)(Property)>**
struct	*cohtml::PropertyType< ReturnType(Class::)(T(&)[N]) >**
struct	cohtml::RemoveConst
struct	cohtml::RemoveConst< const T & >
struct	cohtml::RemoveConst< const T >
struct	cohtml::RemoveConstRef
struct	cohtml::RemoveConstRef< const T & >
struct	cohtml::RemoveConstRef< const T >
struct	cohtml::RemoveConstRef< T & >
struct	cohtml::RemoveRef
struct	cohtml::RemoveRef< const T & >
struct	cohtml::RemoveRef< T & >
struct	cohtml::ReturnsByRef
struct	*cohtml::ReturnsByRef< T &(C::)() const >**
struct	*cohtml::ReturnsByRef< T &(C::)()>**
struct	*cohtml::ReturnsByRef< T(C::)() const >**
struct	*cohtml::ReturnsByRef< T(C::)()>**
struct	*cohtml::ReturnsByRef< T(C::)>**
struct	cohtml::ScreenInfo Holds the information about current screen.
class	cohtml::ScriptCompiler
class	cohtml::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.
class	cohtml::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.
class	cohtml::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.)
struct	cohtml::SystemRendererSettings System renderer settings.
struct	cohtml::SystemRendererSettingsWithExternalRenderingLibrary System renderer settings when an using external rendering library.
struct	cohtml::SystemSettings Settings for a System.
class	cohtml::ThisHolder
class	cohtml::ThisHolder< TrueType >
struct	cohtml::TouchEventData A touch event.
class	cohtml::TypeDescription Helper class for describing types.
class	cohtml::TypedProperty
struct	cohtml::TypeToElementType
struct	cohtml::TypeToElementType< bool >
struct	cohtml::TypeToElementType< char >
struct	cohtml::TypeToElementType< const std::unordered_map< Key, Value, Hash, Pred, Allocator > & >
struct	cohtml::TypeToElementType< const std::unordered_map< Key, Value, Hash, Pred, Allocator > >
struct	cohtml::TypeToElementType< const Type >
struct	cohtml::TypeToElementType< double >
struct	cohtml::TypeToElementType< float >
struct	cohtml::TypeToElementType< int >
struct	cohtml::TypeToElementType< renoir::Color >
struct	cohtml::TypeToElementType< signed char >
struct	cohtml::TypeToElementType< signed long >
struct	cohtml::TypeToElementType< signed long long >
struct	cohtml::TypeToElementType< signed short >
struct	cohtml::TypeToElementType< std::basic_string< char, CharTraits, Allocator > >
struct	cohtml::TypeToElementType< std::map< Key, Value, Comparator, Allocator > >
struct	cohtml::TypeToElementType< std::pair< T1, T2 > >
struct	cohtml::TypeToElementType< std::unordered_map< Key, Value, Hash, Pred, Allocator > & >
struct	cohtml::TypeToElementType< std::unordered_map< Key, Value, Hash, Pred, Allocator > >
struct	cohtml::TypeToElementType< std::vector< T, A > >
struct	cohtml::TypeToElementType< Type & >
struct	cohtml::TypeToElementType< Type(&)[Size]>
struct	cohtml::TypeToElementType< unsigned >
struct	cohtml::TypeToElementType< unsigned char >
struct	cohtml::TypeToElementType< unsigned long >
struct	cohtml::TypeToElementType< unsigned long long >
struct	cohtml::TypeToElementType< unsigned short >
struct	cohtml::TypeToElementTypeWrapper
struct	cohtml::TypeToElementTypeWrapper< Type, true >
struct	cohtml::UnwrapPointer
struct	cohtml::UnwrapPointer< const T & >
struct	cohtml::UnwrapPointer< const T >
struct	cohtml::UnwrapPointer< T & >
struct	cohtml::UnwrapPointerType
struct	cohtml::UnwrapPointerType< T, true >
struct	cohtml::UserFontDescription Struct representing user font data. Baseline is 0.
struct	cohtml::UserGPUMemoryInfo
class	cohtml::VectorReaderFactory
class	cohtml::VectorReaderFactory< std::vector< T, A > >
class	cohtml::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.
class	cohtml::ViewRenderer The ViewRenderer is in charge of drawing a View in a user-supplied texture.
struct	cohtml::ViewRendererSettings
struct	cohtml::ViewSettings Settings used when initializing a View.

Types

	Name
enum	WorkType { WT_Resources, WT_Layout}
enum	WorkExecutionMode { 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.
enum	GamepadHand { 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 char	HTMLTag { 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, SLOT, UNKNOWN, ALL, CUSTOM, SVGCircle, SVGDefs, SVGEllipse, SVGG, SVGLine, SVGLinearGradient, SVGPath, SVGPolygon, SVGPolyline, SVGRadialGradient, SVGRect, SVGSolidColor, SVGStop, SVGText, SVGUse, SVGClipPath, SVGMask, SVGImage, COUNT}
enum	RenderingTasksAvailableType { RTA_ViewReadyForRendering, RTA_RenderingSubSystemTask}
enum	InterceptRequestStatus { Allow, Restrict}
enum	InternalCaches { 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, ICACHE_DepthStencilTextures = 1 « 9}
enum	CaptureMode { 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 { VT_Null, VT_Undefined, VT_Boolean, VT_Number, VT_String, VT_Object, VT_Array, VT_Count} The primitive types coming from JS.
enum	ElementType { 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 double	TimePoint
typedef int	TaskFamilyId
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 *, size_t)	ArrayElementGetter
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.
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.
void	DestroyAdaptedRenderingAllocatorAndLogger(IAllocator * allocator, renoir::IAllocator * renderingAllocator, renoir::Logging::ILogHandler * renderingLogger) Deallocates the adapters created from AdaptRenderingAllocatorAndLoggerFromCohtml.
bool	IsTagSelfClosing(HTMLTag tag)
bool	CanTagContainHTML(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 T > EnableIf< PointerTrait< T >::Value, void * >::Type	CoherentArrayElementGetterImpl(T & object)
template <typename T > EnableIf<!PointerTrait< T >::Value &&!IsCString< T >::Value, void * >::Type	CoherentArrayElementGetterImpl(T & object)
template <typename T > EnableIf<!PointerTrait< T >::Value &&IsCString< T >::Value, void * >::Type	CoherentArrayElementGetterImpl(T & object)
template <typename ArrayType > void *	CoherentArrayElementGetter(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])
void	CoherentBindInternal(Binder * binder, bool value)
void	CoherentBindInternal(Binder * binder, signed short value)
void	CoherentBindInternal(Binder * binder, unsigned short value)
void	CoherentBindInternal(Binder * binder, signed int value)
void	CoherentBindInternal(Binder * binder, unsigned int value)
void	CoherentBindInternal(Binder * binder, signed long long value)
void	CoherentBindInternal(Binder * binder, unsigned long long value)
void	CoherentBindInternal(Binder * binder, signed long value)
void	CoherentBindInternal(Binder * binder, unsigned long value)
void	CoherentBindInternal(Binder * binder, char value)
void	CoherentBindInternal(Binder * binder, signed char value)
void	CoherentBindInternal(Binder * binder, unsigned char value)
void	CoherentBindInternal(Binder * binder, float value)
void	CoherentBindInternal(Binder * binder, double value)
void	CoherentBindInternal(Binder * binder, const char * value)
void	CoherentBindInternal(Binder * binder, const wchar_t * value)
void	CoherentBindInternal(Binder * binder, const char16_t * value)
void	CoherentBindInternal(Binder * binder, const char32_t * value)
void	CoherentReadInternal(Binder * binder, signed short & value)
void	CoherentReadInternal(Binder * binder, unsigned short & value)
void	CoherentReadInternal(Binder * binder, signed int & value)
void	CoherentReadInternal(Binder * binder, unsigned int & value)
void	CoherentReadInternal(Binder * binder, signed long long & value)
void	CoherentReadInternal(Binder * binder, unsigned long long & value)
void	CoherentReadInternal(Binder * binder, signed long & value)
void	CoherentReadInternal(Binder * binder, unsigned long & value)
void	CoherentReadInternal(Binder * binder, bool & value)
void	CoherentReadInternal(Binder * binder, char & value)
void	CoherentReadInternal(Binder * binder, signed char & value)
void	CoherentReadInternal(Binder * binder, unsigned char & value)
void	CoherentReadInternal(Binder * binder, float & value)
void	CoherentReadInternal(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 ,typename A > void	CoherentBindKeyValueProperty(Binder * binder, T && key, A && value)
template <typename T ,typename A > void	CoherentBindKeyValueProperty(Binder * binder, T && keyProperty, void * key, A && valueProperty, void * value)
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)
void	CoherentBindInternal(Binder * binder, renoir::Color & value)
void	CoherentBindInternal(Binder * binder, const renoir::Color & value)
void	CoherentReadInternal(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 ArrayType ,size_t ArraySize> EnableIf<(!IsChar< ArrayType >::Value
template <typename ArrayType ,size_t ArraySize> EnableIf<(!IsChar< ArrayType >::Value
template <typename ValueType > bool	ExtractRawArray(Binder * , const ValueType & , ArrayInfo * )
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 > EnableIf< PointerTrait< T >::Value, void * >::Type	CoherentVectorElementGetterImpl(T & object)
template <typename T > EnableIf<!PointerTrait< T >::Value &&!IsCString< T >::Value, void * >::Type	CoherentVectorElementGetterImpl(T & object)
template <typename T > EnableIf<!PointerTrait< T >::Value &&IsCString< T >::Value, void * >::Type	CoherentVectorElementGetterImpl(T & object)
template <typename VectorType > void *	CoherentVectorElementGetter(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

Enumerator	Value	Description
WT_Resources
WT_Layout

enum WorkExecutionMode

Enumerator	Value	Description
WEM_UntilQueueEmpty
WEM_UntilQuit		Execute 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

Enumerator	Value	Description
GH_None	0	Gamepad either does not support distinguishing hands, or cannot be determined.
GH_Left		Gamepad is bound to the left hand.
GH_Right		Gamepad 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

Enumerator	Value	Description
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
SLOT
UNKNOWN
ALL
CUSTOM
SVGCircle
SVGDefs
SVGEllipse
SVGG
SVGLine
SVGLinearGradient
SVGPath
SVGPolygon
SVGPolyline
SVGRadialGradient
SVGRect
SVGSolidColor
SVGStop
SVGText
SVGUse
SVGClipPath
SVGMask
SVGImage
COUNT

enum RenderingTasksAvailableType

Enumerator	Value	Description
RTA_ViewReadyForRendering
RTA_RenderingSubSystemTask

enum InterceptRequestStatus

Enumerator	Value	Description
Allow
Restrict

enum InternalCaches

Enumerator	Value	Description
ICACHE_Shadows	1 « 0	Access the cache for shadow textures (e.g. box-shadow, text-shadow) This cache has only size in number of contained objects.
ICACHE_Paths	1 « 1	Access the cache for complex shapes This cache has only size in number of contained objects.
ICACHE_Textures	1 « 2	Access the cache for client textures (such as image elements) This cache has both size in number of contained objects and size in bytes.
ICACHE_ScratchLayers	1 « 3	Access the cache for temporary internal textures that can contain packed data from multiple surfaces. The reported size is the amount of bytes allocated.
ICACHE_ScratchTextures	1 « 4	Access the cache for temporary internal textures that are dedicated for single surfaces only. The reported size is the amount of bytes allocated.
ICACHE_GfxCommandBuffers	1 « 5	Access 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_GfxCommandProcessors	1 « 6	Access 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_SVGSurfaces	1 « 7	Access 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_BackdropFilterSurfaces	1 « 8	Access the texture cache for surfaces used during backdrop filter rendeirng. This cache flag can be used to clear those textures and force their recreation.
ICACHE_DepthStencilTextures	1 « 9	Access the cache for internal depth stencil textures. The reported size is the amount of bytes allocated.

enum CaptureMode

Enumerator	Value	Description
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

Enumerator	Value	Description
VT_Null
VT_Undefined
VT_Boolean
VT_Number
VT_String
VT_Object
VT_Array
VT_Count

The primitive types coming from JS.

enum ElementType

Enumerator	Value	Description
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:

userData The user data passed to View::BeginCaptureDebugFrame and View::CaptureSingleDebugFrame calls
capture Object containing pointer to the data and the size. Must call Release() when finished using it.

typedef Reader

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

typedef ArrayLengthGetter

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

typedef ArrayElementGetter

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

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 CoherentArrayElementGetterImpl

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

function CoherentArrayElementGetterImpl

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

function CoherentArrayElementGetterImpl

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

function CoherentArrayElementGetter

template <typename ArrayType >
void * CoherentArrayElementGetter(
    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 CoherentBindKeyValueProperty

template <typename T ,
typename A >
void CoherentBindKeyValueProperty(
    Binder * binder,
    T && key,
    A && value
)

function CoherentBindKeyValueProperty

template <typename T ,
typename A >
void CoherentBindKeyValueProperty(
    Binder * binder,
    T && keyProperty,
    void * key,
    A && valueProperty,
    void * value
)

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 ExtractRawArray

template <typename ArrayType ,
size_t ArraySize>
inline EnableIf<(!IsChar< ArrayType >::Value||IsSame< ArrayType, unsigned char >::Value) &&(TypeToElementType< ArrayType >::value !=ElementType::ET_UserType), bool >::Type ExtractRawArray(
    Binder * binder,
    ArrayType(&) userData[ArraySize],
    ArrayInfo * arrayInfo
)

Helper function for converting a Property into an array when the property is a C-style array.

Parameters:

binder - the binder to use
userData - object that might be a C-style array or not
arrayInfo - information about array type - callbacks, properties, methods

Return: true - if the conversion was successful

function ExtractRawArray

template <typename ArrayType ,
size_t ArraySize>
inline EnableIf<(!IsChar< ArrayType >::Value||IsSame< ArrayType, unsigned char >::Value) &&(TypeToElementType< ArrayType >::value==ElementType::ET_UserType), bool >::Type ExtractRawArray(
    Binder * binder,
    ArrayType(&) userData[ArraySize],
    ArrayInfo * arrayInfo
)

function ExtractRawArray

template <typename ValueType >
inline bool ExtractRawArray(
    Binder * ,
    const ValueType & ,
    ArrayInfo * 
)

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 CoherentVectorElementGetterImpl

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

function CoherentVectorElementGetterImpl

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

function CoherentVectorElementGetterImpl

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

function CoherentVectorElementGetter

template <typename VectorType >
void * CoherentVectorElementGetter(
    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
)

cohtml

Namespaces #

Classes #

Types #

Functions #

Types Documentation #

enum WorkType #

enum WorkExecutionMode #

enum GamepadHand #

enum HTMLTag #

enum RenderingTasksAvailableType #

enum InterceptRequestStatus #

enum InternalCaches #

enum CaptureMode #

enum ValueType #

enum ElementType #

typedef TimePoint #

typedef TaskFamilyId #

typedef OnWorkAvailableFunc #

typedef OnUserImageDroppedFunc #

typedef BoundEventHandle #

typedef OnRenderingTasksAvailableFunc #

typedef OnMonotonicallyIncreasingTimeRequestFunc #

typedef FrameCaptureCallback #

typedef Reader #

typedef ArrayLengthGetter #

typedef ArrayElementGetter #

typedef MapElementGetter #

typedef LengthGetter #

typedef ElementGetter #

typedef TrueType #

typedef FalseType #

typedef NativeReader #

typedef VectorLengthFunc #

Functions Documentation #

function MakeHandler #

function MakeHandler #

function AdaptRenderingAllocatorAndLoggerFromCohtml #

function DestroyAdaptedRenderingAllocatorAndLogger #

function IsTagSelfClosing #

function CanTagContainHTML #

function CoherentCreateModelBindPointer #

function CoherentArrayLength #

function CoherentArrayElementReader #

function CoherentArrayElementBinder #

function CoherentArrayElementGetterImpl #

function CoherentArrayElementGetterImpl #

function CoherentArrayElementGetterImpl #

function CoherentArrayElementGetter #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentReadInternal #

function CoherentReadInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentBindInternal #

function CoherentReadInternal #

function CoherentReadInternal #

function CoherentReadInternal #

function CoherentReadInternal #

function CoherentReadInternal #

function CoherentReadInternal #

function CoherentReadInternal #

function CoherentReadInternal #

function CoherentReadInternal #

Namespaces

Classes

Types

Functions

Types Documentation

enum WorkType

enum WorkExecutionMode

enum GamepadHand

enum HTMLTag

enum RenderingTasksAvailableType

enum InterceptRequestStatus

enum InternalCaches

enum CaptureMode

enum ValueType

enum ElementType

typedef TimePoint

typedef TaskFamilyId

typedef OnWorkAvailableFunc

typedef OnUserImageDroppedFunc

typedef BoundEventHandle

typedef OnRenderingTasksAvailableFunc

typedef OnMonotonicallyIncreasingTimeRequestFunc

typedef FrameCaptureCallback

typedef Reader

typedef ArrayLengthGetter

typedef ArrayElementGetter

typedef MapElementGetter

typedef LengthGetter

typedef ElementGetter

typedef TrueType

typedef FalseType

typedef NativeReader

typedef VectorLengthFunc

Functions Documentation

function MakeHandler

function MakeHandler

function AdaptRenderingAllocatorAndLoggerFromCohtml

function DestroyAdaptedRenderingAllocatorAndLogger

function IsTagSelfClosing

function CanTagContainHTML

function CoherentCreateModelBindPointer

function CoherentArrayLength

function CoherentArrayElementReader

function CoherentArrayElementBinder

function CoherentArrayElementGetterImpl

function CoherentArrayElementGetterImpl

function CoherentArrayElementGetterImpl

function CoherentArrayElementGetter

function CoherentBindInternal

function CoherentBindInternal

function CoherentReadInternal

function CoherentReadInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentBindInternal

function CoherentReadInternal

function CoherentReadInternal

function CoherentReadInternal

function CoherentReadInternal

function CoherentReadInternal

function CoherentReadInternal

function CoherentReadInternal

function CoherentReadInternal

function CoherentReadInternal

function CoherentReadInternal