cohtml

Utility macros for enabling bitwise flag operations on enum class types. These macros define the standard bitwise operators (|, &, ^, ~ and their assignment variants) so enum values can be combined and tested as flags. More…

Namespaces

Name
cohtml::cohtml
cohtml::CursorTypes
cohtml::EnumFlags
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::InspectorContextSetting
cohtml::Logging
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 an 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< std::variant< Args… > >
struct	cohtml::CoherentToBoolean< T * >
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::CoherentToColor< int >
struct	cohtml::CoherentToColor< renoir::Color >
struct	cohtml::CoherentToColor< std::variant< Args… > >
struct	cohtml::CoherentToColor< T * >
struct	cohtml::CoherentToColor< unsigned >
struct	cohtml::CoherentToNumber
struct	cohtml::CoherentToNumber< double, Number >
struct	cohtml::CoherentToNumber< float, Number >
struct	cohtml::CoherentToNumber< int, Number >
struct	cohtml::CoherentToNumber< signed long long, Number >
struct	cohtml::CoherentToNumber< signed long, Number >
struct	cohtml::CoherentToNumber< signed short, Number >
struct	cohtml::CoherentToNumber< std::variant< Args… >, Number >
struct	cohtml::CoherentToNumber< T *, N >
struct	cohtml::CoherentToNumber< unsigned long long, Number >
struct	cohtml::CoherentToNumber< unsigned long, Number >
struct	cohtml::CoherentToNumber< unsigned short, Number >
struct	cohtml::CoherentToNumber< unsigned, Number >
struct	cohtml::CoherentToString
struct	cohtml::CoherentToString< bool, void >
struct	cohtml::CoherentToString< char *, void >
struct	cohtml::CoherentToString< char, void >
struct	cohtml::CoherentToString< char16_t *, void >
struct	cohtml::CoherentToString< char32_t *, void >
struct	cohtml::CoherentToString< char[N], void >
struct	cohtml::CoherentToString< const char *, void >
struct	cohtml::CoherentToString< const char16_t *, void >
struct	cohtml::CoherentToString< const char32_t *, void >
struct	cohtml::CoherentToString< const char[N], void >
struct	cohtml::CoherentToString< const wchar_t *, void >
struct	cohtml::CoherentToString< double, void >
struct	cohtml::CoherentToString< float, void >
struct	cohtml::CoherentToString< int, void >
struct	cohtml::CoherentToString< long long, void >
struct	cohtml::CoherentToString< long, void >
struct	cohtml::CoherentToString< short, void >
struct	cohtml::CoherentToString< std::basic_string< Char, CharTraits, Allocator > >
struct	cohtml::CoherentToString< std::variant< Args… >, void >
struct	cohtml::CoherentToString< T *, void >
struct	cohtml::CoherentToString< T, typename EnableIf< IsEnum< T >::Value >::Type >
struct	cohtml::CoherentToString< unsigned char, void >
struct	cohtml::CoherentToString< unsigned long long, void >
struct	cohtml::CoherentToString< unsigned long, void >
struct	cohtml::CoherentToString< unsigned short, void >
struct	cohtml::CoherentToString< unsigned, void >
struct	cohtml::CoherentToString< wchar_t *, void >
struct	cohtml::CoherentToTransformMatrix2D
struct	cohtml::CoherentToTransformMatrix2D< const char(&)[N]>
struct	cohtml::CoherentToTransformMatrix2D< const char[N]>
struct	cohtml::CoherentToTransformMatrix2D< const float * >
struct	cohtml::CoherentToTransformMatrix2D< const float *& >
struct	cohtml::CoherentToTransformMatrix2D< const float(&)[6]>
struct	cohtml::CoherentToTransformMatrix2D< const float[6]>
struct	cohtml::CoherentToTransformMatrix2D< float * >
struct	cohtml::CoherentToTransformMatrix2D< float *& >
struct	cohtml::CoherentToTransformMatrix2D< float(&)[6]>
struct	cohtml::CoherentToTransformMatrix2D< std::variant< Args… > >
struct	cohtml::CoherentToTransformMatrix2D< T * >
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< const std::variant< Args… > *&, ET_PolymorphUserType >
struct	cohtml::GetObjectInfo< std::variant< Args… > &, ET_PolymorphUserType >
struct	cohtml::GetObjectInfo< std::variant< Args… > *&, ET_PolymorphUserType >
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 a 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::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 Interface for handling method calls and UI event callbacks.
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::IsEnum
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 property 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 an 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 types 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. This interface type-erases access to a native property so the SDK can interact with it without knowing its concrete C++ type.
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 class unsigned int	CompatibilityFlags { None = 0, VCF_SynchronousStyleSolving = 1 << 0, VCF_DisableAspectRatio = 1 << 1, VCF_StripWhitespaceNodes = 1 << 2, VCF_RevertRematchingBehavior_Partial = 1 << 3, VCF_RevertRematchingBehavior_All = 1 << 4, VCF_DisableFlexBasisUnits = 1 << 5, VCF_IncludeStyleValueInMutationObserver = 1 << 6, LCF_DoNotSnapToIntegerCoordsBeforeTransform = 1 << 7, LCF_DisableFontDataPreloading = 1 << 8, LCF_DisableCSSSharing = 1 << 9, VCF_AutoDetectColorSpaceFromRenderTarget = 1 << 10} Compatibility flags that can be used to enable legacy behaviors. Split into 2 groups, depending on what API the flag should be passed to:
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 { ENTRY, COUNT}
enum	RenderingTasksAvailableType { RTA_ViewReadyForRendering, RTA_RenderingSubSystemTask}
enum class	LayoutAlgorithm { CompatibilityMode, WebStandardMode}
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, ICACHE_GPUResourcesPool = 1 << 10}
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	RegisterModelStatus { RMS_Success, RMS_ModelDataAlreadyRegistered, RMS_ModelNameAlreadyRegistered, RMS_InvalidModel, RMS_DocumentNotCreated} Status of a call to CreateModel() and RegisterModel()
enum	UpdateModelStatus { UMS_Success, UMS_ModelNotRegistered, UMS_DocumentNotCreated} Status of a call to UpdateWholeModel(), UnregisterModel()
enum	SynchronizeModelsStatus { SMS_Success, SMS_DocumentNotCreated, SMS_DocumentDestruction, SMS_SynchronizationInProgress} Status of a call to SynchronizeModels()
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} Represents the underlying data category of a property, array element, map value, or pair member exposed to the scripting system.
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 void(*)(Binder *, void *, size_t)	ArrayElementBinder
typedef BoolConstant< true >	TrueType
typedef BoolConstant< false >	FalseType
template <typename T > using typename RemoveConstRef< T >::Type	RemoveConstRef_t
template <typename T > using typename UnwrapPointerType< typename RemoveConstRef< T >::Type, PointerTrait< T >::Value >::Type	DecayedType
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.
	COHTML_DEFINE_ENUM_FLAG_OPERATORS(CompatibilityFlags )
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)
bool	CanSVGTagContainText(HTMLTag tag)
bool	CanTagBeSVG(HTMLTag tag)
template <typename T > void COHERENT_STDCALL	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])
const char *	ValueTypeToString(ValueType type)
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 T > bool	GetMapValueInvoke(Binder * binder, MapInfo * mapInfo, T notMap)
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 T > bool	GetPairValueInvoke(Binder * binder, PairInfo * pairInfo, T value)
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)
template <typename T > DecayedType< T > *	DecayToMutablePtrUnchecked(T & value) Removes const and reference qualifiers from T and converts the input to a mutable pointer.
	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… Args> void	CoherentBindInternal(cohtml::Binder * binder, std::variant< Args… > & value)
template <typename… Args> void	CoherentBindInternal(cohtml::Binder * binder, std::variant< Args… > * value)
template <typename… Args> void	CoherentBindInternal(cohtml::Binder * binder, const std::variant< Args… > & value)
template <typename… Args> void	CoherentBindInternal(cohtml::Binder * binder, const std::variant< Args… > * value)
template <typename… Args> void	CoherentReadInternal(cohtml::Binder * binder, std::variant< Args… > & value)
template <typename… Args> void	CoherentReadInternal(cohtml::Binder * binder, const std::variant< Args… > & value)
template <typename… Args> bool	GetObjectInfoInvoke(Binder * binder, ObjectInfo * objInfo, std::variant< Args… > & value)
template <typename… Args> bool	GetArrayValueInvoke(Binder * binder, void * object, ArrayInfo * arrayinfo, const TypedProperty< std::variant< Args… > &> * prop)
template <typename… Args> bool	GetArrayValueInvoke(Binder * binder, void * object, ArrayInfo * arrayinfo, const TypedProperty< std::variant< Args… > *&> * prop)
template <typename… Args> bool	GetArrayValueInvoke(Binder * binder, void * object, ArrayInfo * arrayinfo, const TypedProperty< const std::variant< Args… > *&> * prop)
template <typename… Args> bool	GetPairValueInvoke(Binder * binder, void * object, PairInfo * pairInfo, const TypedProperty< std::variant< Args… > &> * prop)
template <typename… Args> bool	GetPairValueInvoke(Binder * binder, void * object, PairInfo * pairInfo, const TypedProperty< std::variant< Args… > *&> * prop)
template <typename… Args> bool	GetPairValueInvoke(Binder * binder, void * object, PairInfo * pairInfo, const TypedProperty< const std::variant< Args… > *&> * prop)
template <typename… Args> bool	GetMapValueInvoke(Binder * binder, void * object, MapInfo * mapInfo, const TypedProperty< std::variant< Args… > &> * prop)
template <typename… Args> bool	GetMapValueInvoke(Binder * binder, void * object, MapInfo * mapInfo, const TypedProperty< std::variant< Args… > *&> * prop)
template <typename… Args> bool	GetMapValueInvoke(Binder * binder, void * object, MapInfo * mapInfo, const TypedProperty< const std::variant< Args… > *&> * prop)
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 > bool	GetArrayValueInvoke(Binder * binder, ArrayInfo * arrayInfo, T value)
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)

Detailed Description

Utility macros for enabling bitwise flag operations on enum class types. These macros define the standard bitwise operators (|, &, ^, ~ and their assignment variants) so enum values can be combined and tested as flags.

When binding a std::variant property, changing the active alternative at runtime to a different complex type after the property has been bound to JavaScript is unsupported and results in undefined behavior. (e.g. model.data bound as MyUserType, then reassigned). The underlying JavaScript object is not recreated when the active type changes.

Contains almost all Coherent namespaces, classes and functions.

Types Documentation

enum CompatibilityFlags

Enumerator	Value	Description
None	0
VCF_SynchronousStyleSolving	1 << 0	Enables the legacy synchronous style solving behavior for each view, where style changes are applied immediately on the UI thread as part of View::Advance() instead of being deferred into its own task to be executed on a different thread. Avoid using this as it may cause performance regressions!
VCF_DisableAspectRatio	1 << 1	Disables the aspect ratio correction for images, which can be used to work around some driver bugs that cause incorrect aspect ratio when rendering to render targets with non-default resolutions.
VCF_StripWhitespaceNodes	1 << 2	Enables the stripping of whitespace-only text nodes from the DOM, which can be used to work around some layout issues in existing UIs caused by the presence of such nodes. Stripping is disabled by default because some front-end frameworks (such as Svelte and SolidJS) rely on whitespace nodes and break when they are removed.
VCF_RevertRematchingBehavior_Partial	1 << 3	Reverts some of the optimizations related to rematching of CSS selectors, which can be used to work around some layout issues in existing UIs that were caused by the previous rematching behavior.
VCF_RevertRematchingBehavior_All	1 << 4	Reverts all of the optimizations related to rematching of CSS selectors, which can be used to work around some layout issues in existing UIs that were caused by the previous rematching behavior.
VCF_DisableFlexBasisUnits	1 << 5	Enables the use of legacy flex-basis units in the layout algorithm. The default behavior of flex-basis is more standard-compliant, but this can cause layout issues in existing UIs that rely on the old behavior.
VCF_IncludeStyleValueInMutationObserver	1 << 6	Enables the inclusion of style values in the MutationObserver records, which can be used to work around some issues in existing UIs that are not compatible with the new behavior of not including such values.
LCF_DoNotSnapToIntegerCoordsBeforeTransform	1 << 7	Disables the snapping of element coordinates to integer values before applying transforms, which can be used to work around some rendering issues in existing UIs that were caused by the new default behavior of snapping such coordinates. Snapping is enabled by default because not snapping can cause rendering issues in some cases.
LCF_DisableFontDataPreloading	1 << 8	Disables font data preloading, which can improve compatibility with some custom file system implementations that don’t support multiple concurrent stream readers for the same resource.
LCF_DisableCSSSharing	1 << 9	Enables the use of legacy behavior for handling of CSS stylesheets for shadow trees and views, where stylesheets are never shared and each shadow tree or view has its own copy at all times.
VCF_AutoDetectColorSpaceFromRenderTarget	1 << 10	Enables legacy behavior where Cohtml automatically determines the color space, either sRGB (gamma-encoded) or Linear, in which to render each view, based on the render target format passed via “ViewRenderer::SetRenderTarget()”. If not enabled, Cohtml defaults to rendering all views in sRGB color space, irrespective of the render target format.

Compatibility flags that can be used to enable legacy behaviors. Split into 2 groups, depending on what API the flag should be passed to:

• VCF - View compatibility flags, should be passed via the ViewSettings.
• LCF - Library compatibility flags, should be passed via the LibraryParams. All flags can be combined. View and Library compatibility flags are independent: flags intended for one are silently ignored by the other.

enum WorkType

Enumerator	Value	Description
WT_Resources
WT_Layout

enum WorkExecutionMode

Enumerator	Value	Description
WEM_UntilQueueEmpty		Execute until all outstanding tasks have complete.
WEM_UntilQuit		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
ENTRY
COUNT

enum RenderingTasksAvailableType

Enumerator	Value	Description
RTA_ViewReadyForRendering
RTA_RenderingSubSystemTask

enum LayoutAlgorithm

Enumerator	Value	Description
CompatibilityMode		Yoga in compatibility mode This keeps some preexisting bugs with the layout algorithm and previous default styles with the goal to not break existing UIs that were made with the previous layout behavior in mind.
WebStandardMode		Yoga in web compliant mode This includes all fixes. Also changes some default styles to their defaults in the web namely flex-shrink and border-box Also in this mode the default position - static now operates as static instead of relative.

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	No longer used. See ‘ICACHE_GPUResourcesPool’.
ICACHE_ScratchLayers	1 << 3	No longer used. See ‘ICACHE_GPUResourcesPool’.
ICACHE_ScratchTextures	1 << 4	No longer used. See ‘ICACHE_GPUResourcesPool’.
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 rendering. This cache flag can be used to clear those textures and force their recreation.
ICACHE_DepthStencilTextures	1 << 9	No longer used. See ‘ICACHE_GPUResourcesPool’.
ICACHE_GPUResourcesPool	1 << 10	Cache used for GPU resources like internal intermediate render target textures, vertex buffers, index buffers, and constant buffers used during rendering.

enum CaptureMode

Enumerator	Value	Description
CM_PreserveAll		Do not alter the serialization of the pixel data.
CM_PreserveAlpha		Obfuscate only the color channels of the images but preserve the alpha channel.
CM_ObfuscateAll		Obfuscate the color channels as well as the alpha channel of the images.

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 RegisterModelStatus

Enumerator	Value	Description
RMS_Success		The operation was successful.
RMS_ModelDataAlreadyRegistered		The specified model object is already registered (with the same or another name)
RMS_ModelNameAlreadyRegistered		The specified model name is already registered.
RMS_InvalidModel		The specified model object is nullptr, not bound successfully or odd aligned.
RMS_DocumentNotCreated		The Document is not yet created.

Status of a call to CreateModel() and RegisterModel()

enum UpdateModelStatus

Enumerator	Value	Description
UMS_Success		The operation was successful.
UMS_ModelNotRegistered		The specified model is not registered.
UMS_DocumentNotCreated		The Document is not yet created.

Status of a call to UpdateWholeModel(), UnregisterModel()

enum SynchronizeModelsStatus

Enumerator	Value	Description
SMS_Success		The operation was successful.
SMS_DocumentNotCreated		The Document is not yet created.
SMS_DocumentDestruction		The Document is being destroyed.
SMS_SynchronizationInProgress		There is an ongoing synchronization.

Status of a call to SynchronizeModels()

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		Boolean value (bool).
ET_Int8		8-bit signed integer.
ET_UInt8		8-bit unsigned integer.
ET_Int16		16-bit signed integer.
ET_UInt16		16-bit unsigned integer.
ET_Int32		32-bit signed integer.
ET_UInt32		32-bit unsigned integer.
ET_Int64		64-bit signed integer.
ET_UInt64		64-bit unsigned integer.
ET_Float		32-bit floating-point number.
ET_Double		64-bit floating-point number.
ET_String		String value. May be stored as a C-string, std::string, or any custom string type. Not directly cast by the SDK; retrieved exclusively via ToString().
ET_Color		Color value.
ET_Array		Sequential container. Described by ArrayInfo.
ET_Map		Associative container. Described by MapInfo.
ET_Pair		Pair or 2-tuple. Described by PairInfo.
ET_UserType		User-defined type. Described by TypeInfo.
ET_PolymorphUserType		Dynamically-typed value, such as std::variant.

Represents the underlying data category of a property, array element, map value, or pair member exposed to the scripting system.

Primitive types (ET_Boolean through ET_Double) represent concrete C++ values. For all primitive types except ET_String, the SDK may cast pointers returned by *Info callbacks directly to the corresponding native type.

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 ArrayElementBinder

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

typedef TrueType

typedef BoolConstant<true> cohtml::TrueType;

typedef FalseType

typedef BoolConstant<false> cohtml::FalseType;

using RemoveConstRef_t

template <typename T >
using cohtml::RemoveConstRef_t = typedef typename RemoveConstRef<T>::Type;

using DecayedType

template <typename T >
using cohtml::DecayedType = typedef typename UnwrapPointerType< typename RemoveConstRef<T>::Type, PointerTrait<T>::Value >::Type;

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 COHTML_DEFINE_ENUM_FLAG_OPERATORS

COHTML_DEFINE_ENUM_FLAG_OPERATORS(
    CompatibilityFlags
)

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 CanSVGTagContainText

inline bool CanSVGTagContainText(
    HTMLTag tag
)

function CanTagBeSVG

inline bool CanTagBeSVG(
    HTMLTag tag
)

function CoherentCreateModelBindPointer

template <typename T >
void COHERENT_STDCALL 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 ValueTypeToString

inline const char * ValueTypeToString(
    ValueType type
)

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 GetMapValueInvoke

template <typename T >
inline bool GetMapValueInvoke(
    Binder * binder,
    MapInfo * mapInfo,
    T notMap
)

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 T >
inline bool GetPairValueInvoke(
    Binder * binder,
    PairInfo * pairInfo,
    T value
)

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 DecayToMutablePtrUnchecked

template <typename T >
DecayedType< T > * DecayToMutablePtrUnchecked(
    T & value
)

Removes const and reference qualifiers from T and converts the input to a mutable pointer.

• If T is a value type, returns &value
• If T is a pointer type, unwraps it and returns a mutable pointer valueThe value or pointer to decay

Mutable pointer to the decayed underlying type

Constness is discarded via blind cast and assumed to be safe by contract.

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 CoherentBindInternal

template <typename... Args>
void CoherentBindInternal(
    cohtml::Binder * binder,
    std::variant< Args... > & value
)

function CoherentBindInternal

template <typename... Args>
void CoherentBindInternal(
    cohtml::Binder * binder,
    std::variant< Args... > * value
)

function CoherentBindInternal

template <typename... Args>
void CoherentBindInternal(
    cohtml::Binder * binder,
    const std::variant< Args... > & value
)

function CoherentBindInternal

template <typename... Args>
void CoherentBindInternal(
    cohtml::Binder * binder,
    const std::variant< Args... > * value
)

function CoherentReadInternal

template <typename... Args>
void CoherentReadInternal(
    cohtml::Binder * binder,
    std::variant< Args... > & value
)

function CoherentReadInternal

template <typename... Args>
void CoherentReadInternal(
    cohtml::Binder * binder,
    const std::variant< Args... > & value
)

function GetObjectInfoInvoke

template <typename... Args>
bool GetObjectInfoInvoke(
    Binder * binder,
    ObjectInfo * objInfo,
    std::variant< Args... > & value
)

function GetArrayValueInvoke

template <typename... Args>
bool GetArrayValueInvoke(
    Binder * binder,
    void * object,
    ArrayInfo * arrayinfo,
    const TypedProperty< std::variant< Args... > &> * prop
)

function GetArrayValueInvoke

template <typename... Args>
bool GetArrayValueInvoke(
    Binder * binder,
    void * object,
    ArrayInfo * arrayinfo,
    const TypedProperty< std::variant< Args... > *&> * prop
)

function GetArrayValueInvoke

template <typename... Args>
bool GetArrayValueInvoke(
    Binder * binder,
    void * object,
    ArrayInfo * arrayinfo,
    const TypedProperty< const std::variant< Args... > *&> * prop
)

function GetPairValueInvoke

template <typename... Args>
bool GetPairValueInvoke(
    Binder * binder,
    void * object,
    PairInfo * pairInfo,
    const TypedProperty< std::variant< Args... > &> * prop
)

function GetPairValueInvoke

template <typename... Args>
bool GetPairValueInvoke(
    Binder * binder,
    void * object,
    PairInfo * pairInfo,
    const TypedProperty< std::variant< Args... > *&> * prop
)

function GetPairValueInvoke

template <typename... Args>
bool GetPairValueInvoke(
    Binder * binder,
    void * object,
    PairInfo * pairInfo,
    const TypedProperty< const std::variant< Args... > *&> * prop
)

function GetMapValueInvoke

template <typename... Args>
bool GetMapValueInvoke(
    Binder * binder,
    void * object,
    MapInfo * mapInfo,
    const TypedProperty< std::variant< Args... > &> * prop
)

function GetMapValueInvoke

template <typename... Args>
bool GetMapValueInvoke(
    Binder * binder,
    void * object,
    MapInfo * mapInfo,
    const TypedProperty< std::variant< Args... > *&> * prop
)

function GetMapValueInvoke

template <typename... Args>
bool GetMapValueInvoke(
    Binder * binder,
    void * object,
    MapInfo * mapInfo,
    const TypedProperty< const std::variant< Args... > *&> * prop
)

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 >
inline bool GetArrayValueInvoke(
    Binder * binder,
    ArrayInfo * arrayInfo,
    T value
)

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
)

---