1.4.0.3
Gameface
cohtml Namespace Reference

Contains almost all Coherent namespaces, classes and functions. More...

Namespaces

 CursorTypes
 
 EventAction
 Holds the possible actions when deciding if to handle an input event.
 
 ImagesListExtract
 Enum containing the options we want when getting the list of loaded images.
 
 InputEventPhase
 
 MemTags
 
 TextInput
 
 TextInputControlType
 
 VMemFlags
 
 VMemProtection
 

Classes

class  AdjustPointer
 
class  ArgumentsBinder
 Class for communicating between EventHandler and the scripting. More...
 
struct  ArrayInfo
 Represents a array of a type exposed to the scripting. More...
 
class  ArrayReaderFactory
 
class  ArrayReaderFactory< T * >
 
struct  AssertFail
 
class  Binder
 Provides binding between C++ and the UI. More...
 
struct  BitmapFontDescription
 Struct representing bitmap font data. More...
 
struct  BoolConstant
 
class  ByRefHolder
 
struct  CachedResourcesWatermarks
 Watermarks used for the image cache management. More...
 
struct  ClassType
 
struct  ClassType< Property Class::*>
 
struct  ClassType< Property(Class::*)() const >
 
struct  ClassType< Property(Class::*)()>
 
struct  CoherentToBoolean
 
struct  CoherentToBoolean< bool >
 
struct  CoherentToBoolean< double >
 
struct  CoherentToBoolean< float >
 
struct  CoherentToBoolean< int >
 
struct  CoherentToBoolean< unsigned >
 
struct  CoherentToColor
 
struct  CoherentToColor< const int & >
 
struct  CoherentToColor< const renoir::Color & >
 
struct  CoherentToColor< const unsigned & >
 
struct  CoherentToNumber
 
struct  CoherentToNumber< double >
 
struct  CoherentToNumber< float >
 
struct  CoherentToNumber< int >
 
struct  CoherentToNumber< unsigned >
 
struct  CoherentToString
 
struct  CoherentToString< bool >
 
struct  CoherentToString< char * >
 
struct  CoherentToString< const char * >
 
struct  CoherentToString< double >
 
struct  CoherentToString< float >
 
struct  CoherentToString< int >
 
struct  CoherentToString< long >
 
struct  CoherentToString< long long >
 
struct  CoherentToString< short >
 
struct  CoherentToString< std::basic_string< char, CharTraits, Allocator > >
 
struct  CoherentToString< unsigned >
 
struct  CoherentToString< unsigned long >
 
struct  CoherentToString< unsigned long long >
 
struct  CoherentToString< unsigned short >
 
struct  CoherentToTransformMatrix2D
 
struct  CoherentToTransformMatrix2D< const float[6]>
 
struct  CoherentTypeInfo
 
class  ConcreteProperty
 
class  ConcretePropertyReadOnly
 
struct  DebugDump
 Debugging class used for dumping the whole structure of the page DOM. More...
 
struct  DisableDefaultBinding
 
struct  EnableIf
 
struct  EnableIf< true, T >
 
class  EventHandler
 
struct  EventModifiersState
 The state of the key modifiers when an event happens. More...
 
struct  EventMouseModifiersState
 The state of the mouse modifiers when an event happens. More...
 
class  FieldProperty
 
class  FieldProperty< PropertyType(Class::*)>
 
class  FieldProperty< PropertyType(Class::*)[ArraySize]>
 
struct  FrameCapture
 Debugging class holding debug frame captured data and size. Passed to FrameCaptureCallback on View::BeginCaptureDebugFrame and View::CaptureSingleDebugFrame methods. More...
 
struct  FunctorArity
 
class  FunctorTraits
 Provides information about function objects. More...
 
struct  FunctorTraits< ResultType(*)()>
 
struct  FunctorTraits< ResultType(*)(Arg0Type)>
 
struct  FunctorTraits< ResultType(*)(Arg0Type, Arg1Type)>
 
struct  FunctorTraits< ResultType(*)(Arg0Type, Arg1Type, Arg2Type)>
 
struct  FunctorTraits< ResultType(*)(Arg0Type, Arg1Type, Arg2Type, Arg3Type)>
 
struct  FunctorTraits< ResultType(*)(Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type)>
 
struct  FunctorTraits< ResultType(Arg0Type)>
 
struct  FunctorTraits< ResultType(Arg0Type, Arg1Type)>
 
struct  FunctorTraits< ResultType(Arg0Type, Arg1Type, Arg2Type)>
 
struct  FunctorTraits< ResultType(Arg0Type, Arg1Type, Arg2Type, Arg3Type)>
 
struct  FunctorTraits< ResultType(Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type)>
 
struct  FunctorTraits< ResultType(ClassType::*)() const >
 
struct  FunctorTraits< ResultType(ClassType::*)()>
 
struct  FunctorTraits< ResultType(ClassType::*)(Arg0Type) const >
 
struct  FunctorTraits< ResultType(ClassType::*)(Arg0Type)>
 
struct  FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type) const >
 
struct  FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type)>
 
struct  FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type, Arg2Type) const >
 
struct  FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type, Arg2Type)>
 
struct  FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type, Arg2Type, Arg3Type) const >
 
struct  FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type, Arg2Type, Arg3Type)>
 
struct  FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type) const >
 
struct  FunctorTraits< ResultType(ClassType::*)(Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type)>
 
struct  FunctorTraits< std::function< R(A0)> >
 
struct  FunctorTraits< std::function< R(A0, A1)> >
 
struct  FunctorTraits< std::function< R(A0, A1, A2)> >
 
struct  FunctorTraits< std::function< R(A0, A1, A2, A3)> >
 
struct  FunctorTraits< std::function< R(A0, A1, A2, A3, A4)> >
 
struct  GamepadPoseState
 Represents the pose of a motion tracking controller. More...
 
struct  GamepadState
 Represents the entire state of a single gamepad. More...
 
struct  GamepadStateExtended
 Extended representation of the gamepad state, including information for controllers that support motion tracking. More...
 
struct  GestureEventData
 A gesture event. More...
 
struct  GetArrayValue
 
struct  GetArrayValue< T & >
 
struct  GetArrayValue< Type[]>
 
struct  GetMapValue
 
struct  GetMapValue< T & >
 
struct  GetObjectInfo
 
struct  GetObjectInfo< Type &, ET_UserType >
 
struct  GetPairValue
 
struct  GetPairValue< T & >
 
struct  GetValue
 
struct  GetValue< Property Class::* >
 
struct  GetValue< Property(Class::*)() const >
 
struct  GetValue< Property(Class::*)()>
 
class  IAllocator
 Allocator interface used by Cohtml for all memory allocations. The user has to provide an object that imlements this interface. Memory allocations in Cohtml are tagged, so the user knows the relative distribution of memory among subsystems. More...
 
class  IAsyncResourceHandler
 Class that will handle all asynchronous resource requests. More...
 
class  IAsyncResourceRequest
 Encapsulates an asynchronous resource request. More...
 
class  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. More...
 
class  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. More...
 
class  IDataStorageHandler
 Class that will handle data storage requests. More...
 
class  IDataStorageRequest
 Encapsulates a data storage request. More...
 
class  IDataStorageResponse
 Response that the application should use when the data storage has been read. More...
 
class  IEventHandler
 
class  IFileSystemReader
 Class that allows Cohtml to interface with the local file system. It allows enumerating folders and opening streams to local resources. More...
 
class  IInputProxy
 Represents an INPUT or TEXTAREA element in the View. More...
 
class  ILocalizationManager
 Takes care of translating text between different locales. More...
 
struct  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. More...
 
class  INodeProxy
 Represents a DOM element in the View - i.e. a DIV, the BODY etc. More...
 
struct  IsCString
 
struct  IsCString< const T * >
 
struct  IsDefaultBindEnabled
 
struct  IsExposedByRef
 
struct  IsExposedByRef< bool >
 
struct  IsExposedByRef< char * >
 
struct  IsExposedByRef< const bool >
 
struct  IsExposedByRef< const char * >
 
struct  IsExposedByRef< const double >
 
struct  IsExposedByRef< const float >
 
struct  IsExposedByRef< const signed char >
 
struct  IsExposedByRef< const signed int >
 
struct  IsExposedByRef< const signed long >
 
struct  IsExposedByRef< const signed long long >
 
struct  IsExposedByRef< const unsigned char >
 
struct  IsExposedByRef< const unsigned int >
 
struct  IsExposedByRef< const unsigned long >
 
struct  IsExposedByRef< const unsigned long long >
 
struct  IsExposedByRef< const wchar_t * >
 
struct  IsExposedByRef< double >
 
struct  IsExposedByRef< float >
 
struct  IsExposedByRef< signed char >
 
struct  IsExposedByRef< signed int >
 
struct  IsExposedByRef< signed long >
 
struct  IsExposedByRef< signed long long >
 
struct  IsExposedByRef< T & >
 
struct  IsExposedByRef< unsigned char >
 
struct  IsExposedByRef< unsigned int >
 
struct  IsExposedByRef< unsigned long >
 
struct  IsExposedByRef< unsigned long long >
 
struct  IsExposedByRef< wchar_t * >
 
struct  IsMap
 
struct  IsMap< std::map< Key, Value, Comparator, Allocator > >
 
struct  IsMap< std::unordered_map< Key, Value, Hash, Pred, Allocator > >
 
struct  IsPair
 
struct  IsPair< std::pair< T1, T2 > >
 
struct  IsSame
 
struct  IsSame< T, T >
 
struct  IsVector
 
struct  IsVector< std::vector< T, A > >
 
struct  IsVoid
 
struct  IsVoid< void >
 
class  ISyncStreamReader
 Class for synchronously reading local resources. More...
 
class  ITextInputHandler
 Notifies of changes to input elements. More...
 
class  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. More...
 
class  IViewListener
 Interface that allows to listen for various events in the View. More...
 
struct  KeyEventData
 A keyboard event. More...
 
class  Library
 This class encapsulates the global Cohtml library. More...
 
struct  LibraryParams
 
struct  LibraryParamsWithExternalRenderingLibrary
 Initialization parameters of the Cohtml library. More...
 
struct  MapInfo
 Represents a map of a type exposed to the scripting. More...
 
struct  MouseEventData
 
struct  ObjectInfo
 Represents a object of a type exposed to the scripting. More...
 
struct  Overload_CoherentBind_For_Your_Type
 
struct  PairInfo
 Represents a pair of a type exposed to the scripting. More...
 
struct  PlatformSpecificParams
 Platform-specific initialization parameters of the Cohtml library. More...
 
struct  PointerTrait
 
struct  PointerTrait< const T & >
 
struct  PointerTrait< const T * >
 
struct  PointerTrait< const T >
 
struct  PointerTrait< std::shared_ptr< const T > >
 
struct  PointerTrait< std::shared_ptr< T > >
 
struct  PointerTrait< std::unique_ptr< const T > >
 
struct  PointerTrait< std::unique_ptr< T > >
 
struct  PointerTrait< T & >
 
struct  PointerTrait< T * >
 
class  Property
 Represents a property of a type exposed to the scripting. More...
 
struct  PropertyType
 
struct  PropertyType< ReturnType(Class::*)(const Property &)>
 
struct  PropertyType< ReturnType(Class::*)(const T(&)[N]) >
 
struct  PropertyType< ReturnType(Class::*)(Property)>
 
struct  PropertyType< ReturnType(Class::*)(T(&)[N]) >
 
struct  RemoveConst
 
struct  RemoveConst< const T & >
 
struct  RemoveConst< const T >
 
struct  RemoveConstRef
 
struct  RemoveConstRef< const T & >
 
struct  RemoveConstRef< const T >
 
struct  RemoveConstRef< T & >
 
struct  RemoveRef
 
struct  RemoveRef< const T & >
 
struct  RemoveRef< T & >
 
struct  ReturnsByRef
 
struct  ReturnsByRef< T &(C::*)() const >
 
struct  ReturnsByRef< T &(C::*)()>
 
struct  ReturnsByRef< T(C::*)() const >
 
struct  ReturnsByRef< T(C::*)()>
 
struct  ReturnsByRef< T(C::*)>
 
struct  ScreenInfo
 Holds the information about current screen. More...
 
class  System
 A System owns multiple Views. These Views share resources among them. It is usually enough to have just one System per application run. More...
 
class  SystemCacheStats
 Statistics of the current state of the internal caches of the system NB: Remember to Release the object when done with it to avoid memory leaks. More...
 
class  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.) More...
 
struct  SystemRendererSettings
 System renderer settings. More...
 
struct  SystemRendererSettingsWithExternalRenderingLibrary
 System renderer settings when an using external rendering library. More...
 
struct  SystemSettings
 Settings for a System. More...
 
class  ThisHolder
 
class  ThisHolder< TrueType >
 
struct  TouchEventData
 A touch event. More...
 
class  TypeDescription
 Helper class for describing types. More...
 
class  TypedProperty
 
struct  TypeToElementType
 
struct  TypeToElementType< bool >
 
struct  TypeToElementType< char >
 
struct  TypeToElementType< const std::unordered_map< Key, Value, Hash, Pred, Allocator > & >
 
struct  TypeToElementType< const std::unordered_map< Key, Value, Hash, Pred, Allocator > >
 
struct  TypeToElementType< const Type >
 
struct  TypeToElementType< double >
 
struct  TypeToElementType< float >
 
struct  TypeToElementType< int >
 
struct  TypeToElementType< renoir::Color >
 
struct  TypeToElementType< signed char >
 
struct  TypeToElementType< signed long >
 
struct  TypeToElementType< signed long long >
 
struct  TypeToElementType< signed short >
 
struct  TypeToElementType< std::basic_string< char, CharTraits, Allocator > >
 
struct  TypeToElementType< std::map< Key, Value, Comparator, Allocator > >
 
struct  TypeToElementType< std::pair< T1, T2 > >
 
struct  TypeToElementType< std::unordered_map< Key, Value, Hash, Pred, Allocator > & >
 
struct  TypeToElementType< std::unordered_map< Key, Value, Hash, Pred, Allocator > >
 
struct  TypeToElementType< std::vector< T, A > >
 
struct  TypeToElementType< Type & >
 
struct  TypeToElementType< Type(&)[Size]>
 
struct  TypeToElementType< unsigned >
 
struct  TypeToElementType< unsigned char >
 
struct  TypeToElementType< unsigned long >
 
struct  TypeToElementType< unsigned long long >
 
struct  TypeToElementType< unsigned short >
 
struct  TypeToElementTypeWrapper
 
struct  TypeToElementTypeWrapper< Type, true >
 
struct  UnwrapPointer
 
struct  UnwrapPointer< const T & >
 
struct  UnwrapPointer< const T >
 
struct  UnwrapPointer< T & >
 
struct  UnwrapPointerType
 
struct  UnwrapPointerType< T, true >
 
class  VectorReaderFactory
 
class  VectorReaderFactory< std::vector< T, A > >
 
class  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. More...
 
class  ViewRenderer
 The ViewRenderer is in charge of drawing a View in a user-supplied texture. More...
 
struct  ViewRendererSettings
 
struct  ViewSettings
 Settings used when initializing a View. More...
 

Typedefs

typedef double TimePoint
 
typedef int TaskFamilyId
 
typedef void(* OnWorkAvailableFunc) (void *userData, WorkType type, TaskFamilyId family)
 Called when a new task is available and should be executed later on. More...
 
typedef void * BoundEventHandle
 
typedef void(* OnRenderingTasksAvailableFunc) (void *userData, unsigned viewId, unsigned frameId, RenderingTasksAvailableType type)
 
typedef double(* OnMonotonicallyIncreasingTimeRequestFunc) (void *userdata, unsigned viewId)
 
typedef void(* FrameCaptureCallback) (void *userData, FrameCapture *capture)
 Function signature of callback used in View::BeginCaptureDebugFrame and View::CaptureSingleDebugFrame. More...
 
typedef void(* Reader) (Binder *, void *, size_t)
 
typedef void *(* MapElementGetter) (void *userData, const char *name)
 
typedef size_t(* LengthGetter) (void *userData)
 
typedef void *(* ElementGetter) (void *userData, size_t index)
 
typedef BoolConstant< true > TrueType
 
typedef BoolConstant< false > FalseType
 
typedef void *(* NativeReader) (void *, size_t)
 
typedef size_t(* VectorLengthFunc) (void *)
 

Enumerations

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. More...
 
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. More...
 
enum  HTMLTag : unsigned char {
  HTMLTag::HTML, HTMLTag::HEAD, HTMLTag::TITLE, HTMLTag::BASE,
  HTMLTag::LINK, HTMLTag::META, HTMLTag::STYLE, HTMLTag::SCRIPT,
  HTMLTag::NOSCRIPT, HTMLTag::TEMPLATE, HTMLTag::BODY, HTMLTag::ARTICLE,
  HTMLTag::SECTION, HTMLTag::NAV, HTMLTag::ASIDE, HTMLTag::H1,
  HTMLTag::H2, HTMLTag::H3, HTMLTag::H4, HTMLTag::H5,
  HTMLTag::H6, HTMLTag::HGROUP, HTMLTag::HEADER, HTMLTag::FOOTER,
  HTMLTag::ADDRESS, HTMLTag::P, HTMLTag::HR, HTMLTag::PRE,
  HTMLTag::BLOCKQUOTE, HTMLTag::OL, HTMLTag::UL, HTMLTag::LI,
  HTMLTag::DL, HTMLTag::DT, HTMLTag::DD, HTMLTag::FIGURE,
  HTMLTag::FIGCAPTION, HTMLTag::MAIN, HTMLTag::DIV, HTMLTag::A,
  HTMLTag::EM, HTMLTag::STRONG, HTMLTag::SMALL, HTMLTag::S,
  HTMLTag::CITE, HTMLTag::Q, HTMLTag::DFN, HTMLTag::ABBR,
  HTMLTag::DATA, HTMLTag::TIME, HTMLTag::CODE, HTMLTag::VAR,
  HTMLTag::SAMP, HTMLTag::KBD, HTMLTag::SUB, HTMLTag::SUP,
  HTMLTag::I, HTMLTag::B, HTMLTag::U, HTMLTag::MARK,
  HTMLTag::RUBY, HTMLTag::RT, HTMLTag::RP, HTMLTag::BDI,
  HTMLTag::BDO, HTMLTag::SPAN, HTMLTag::BR, HTMLTag::WBR,
  HTMLTag::INS, HTMLTag::DEL, HTMLTag::IMAGE, HTMLTag::IMG,
  HTMLTag::IFRAME, HTMLTag::EMBED, HTMLTag::OBJECT, HTMLTag::PARAM,
  HTMLTag::VIDEO, HTMLTag::AUDIO, HTMLTag::SOURCE, HTMLTag::TRACK,
  HTMLTag::CANVAS, HTMLTag::MAP, HTMLTag::AREA, HTMLTag::MATH,
  HTMLTag::MI, HTMLTag::MO, HTMLTag::MN, HTMLTag::MS,
  HTMLTag::MTEXT, HTMLTag::MGLYPH, HTMLTag::MALIGNMARK, HTMLTag::ANNOTATION_XML,
  HTMLTag::SVG, HTMLTag::FOREIGNOBJECT, HTMLTag::DESC, HTMLTag::TABLE,
  HTMLTag::CAPTION, HTMLTag::COLGROUP, HTMLTag::COL, HTMLTag::TBODY,
  HTMLTag::THEAD, HTMLTag::TFOOT, HTMLTag::TR, HTMLTag::TD,
  HTMLTag::TH, HTMLTag::FORM, HTMLTag::FIELDSET, HTMLTag::LEGEND,
  HTMLTag::LABEL, HTMLTag::INPUT, HTMLTag::BUTTON, HTMLTag::SELECT,
  HTMLTag::DATALIST, HTMLTag::OPTGROUP, HTMLTag::OPTION, HTMLTag::TEXTAREA,
  HTMLTag::KEYGEN, HTMLTag::OUTPUT, HTMLTag::PROGRESS, HTMLTag::METER,
  HTMLTag::DETAILS, HTMLTag::SUMMARY, HTMLTag::MENU, HTMLTag::MENUITEM,
  HTMLTag::APPLET, HTMLTag::ACRONYM, HTMLTag::BGSOUND, HTMLTag::DIR,
  HTMLTag::FRAME, HTMLTag::FRAMESET, HTMLTag::NOFRAMES, HTMLTag::ISINDEX,
  HTMLTag::LISTING, HTMLTag::XMP, HTMLTag::NEXTID, HTMLTag::NOEMBED,
  HTMLTag::PLAINTEXT, HTMLTag::RB, HTMLTag::STRIKE, HTMLTag::BASEFONT,
  HTMLTag::BIG, HTMLTag::BLINK, HTMLTag::CENTER, HTMLTag::FONT,
  HTMLTag::MARQUEE, HTMLTag::MULTICOL, HTMLTag::NOBR, HTMLTag::SPACER,
  HTMLTag::TT, HTMLTag::RTC, HTMLTag::UNKNOWN, HTMLTag::ALL,
  HTMLTag::CUSTOM, HTMLTag::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_ScratchLayerTextures = 1 << 3 }
 
enum  ValueType {
  VT_Null, VT_Boolean, VT_Number, VT_String,
  VT_Object, VT_Array, VT_Count
}
 The primitive types coming from JS. More...
 
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
}
 

Functions

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 externaly initialized rendering library. More...
 
void DestroyAdaptedRenderingAllocatorAndLogger (IAllocator *allocator, renoir::IAllocator *renderingAllocator, renoir::Logging::ILogHandler *renderingLogger)
 Deallocates the adapters created from AdaptRenderingAllocatorAndLoggerFromCohtml. More...
 
template<typename T >
void CoherentCreateModelBindPointer (Binder *binder, T *model)
 
template<typename ArrayType >
void CoherentArrayElementReader (Binder *binder, void *data, size_t position)
 
template<typename ArrayType >
void CoherentArrayElementBinder (Binder *binder, void *arr, size_t index)
 
template<typename ArrayType , size_t ArraySize>
void CoherentBindInternal (Binder *binder, ArrayType(&array)[ArraySize])
 
template<typename ArrayType , size_t ArraySize>
void CoherentBindInternal (Binder *binder, const ArrayType(&array)[ArraySize])
 
template<typename ArrayType , size_t ArraySize>
void 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 >
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 MapType , typename T >
EnableIf<!cohtml::PointerTrait< T >::Value, void * >::Type CoherentMapNativeElementReader (void *data, char const *name)
 
template<typename MapType , typename T >
EnableIf< cohtml::PointerTrait< T >::Value, void * >::Type CoherentMapNativeElementReader (void *data, char const *name)
 
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 >
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 T1 , typename T2 >
void CoherentBindInternal (Binder *binder, std::pair< T1, T2 > &value)
 
template<typename T1 , typename T2 >
void CoherentBindInternal (Binder *binder, const std::pair< T1, T2 > &value)
 
template<typename T1 , typename T2 >
void CoherentReadInternal (Binder *binder, std::pair< T1, T2 > &value)
 
template<typename T >
EnableIf<!IsPair< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetPairValueInvoke (Binder *binder, void *object, PairInfo *pairInfo, const TypedProperty< T &> *prop)
 
template<typename T1 , typename T2 >
bool GetPairValueInvoke (Binder *binder, PairInfo *pairInfo, std::pair< T1, T2 > *pPair)
 
template<typename T >
EnableIf< IsPair< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetPairValueInvoke (Binder *binder, void *object, PairInfo *arrayInfo, const TypedProperty< T &> *prop)
 
template<typename T >
EnableIf< IsCString< T >::Value, void >::Type CoherentTypeInfoCallCoherentBindInternal (Binder *binder)
 
template<typename T >
EnableIf<!IsCString< T >::Value, void >::Type CoherentTypeInfoCallCoherentBindInternal (Binder *binder)
 
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)
 
 CSTRING_TYPETRAIT (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 >
void CoherentVectorElementReader (Binder *binder, void *data, size_t position)
 
template<typename VectorType >
void * CoherentVectorNativeElementReader (void *data, size_t position)
 
template<typename VectorType >
size_t CoherentVectorLength (void *data)
 
template<typename VectorType , typename T >
EnableIf<!cohtml::PointerTrait< T >::Value, void >::Type CoherentVectorElementReader (Binder *binder, void *data, size_t position)
 
template<typename VectorType , typename T >
EnableIf< cohtml::PointerTrait< T >::Value, void >::Type CoherentVectorElementReader (Binder *binder, void *data, size_t position)
 
template<typename VectorType , typename T >
EnableIf<!cohtml::PointerTrait< T >::Value, void * >::Type CoherentVectorNativeElementReader (void *data, size_t position)
 
template<typename VectorType , typename T >
EnableIf< cohtml::PointerTrait< T >::Value, void * >::Type CoherentVectorNativeElementReader (void *data, size_t position)
 
template<typename VectorType >
void CoherentVectorElementBinder (Binder *binder, void *arr, 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)
 
Event handlers

Creating event handlers from C++ functors

template<typename Functor >
IEventHandlerMakeHandler (Functor functor)
 Create event handler from generic C++ functor. More...
 
template<typename Method >
IEventHandlerMakeHandler (void *object, Method method)
 Create event handler from C++ method. More...
 

Detailed Description

Contains almost all Coherent namespaces, classes and functions.

Typedef Documentation

◆ BoundEventHandle

typedef void * cohtml::BoundEventHandle

◆ ElementGetter

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

◆ FalseType

◆ FrameCaptureCallback

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

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

Parameters
userDataThe user data passed to View::BeginCaptureDebugFrame and View::CaptureSingleDebugFrame calls
captureObject containing pointer to the data and the size. Must call Release() when finished using it.

◆ LengthGetter

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

◆ MapElementGetter

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

◆ NativeReader

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

◆ OnMonotonicallyIncreasingTimeRequestFunc

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

◆ OnRenderingTasksAvailableFunc

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

◆ OnWorkAvailableFunc

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

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

◆ Reader

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

◆ TaskFamilyId

typedef int cohtml::TaskFamilyId

◆ TimePoint

typedef double cohtml::TimePoint

◆ TrueType

◆ VectorLengthFunc

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

Enumeration Type Documentation

◆ ElementType

Enumerator
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 

◆ GamepadHand

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.

Enumerator
GH_None 

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.

◆ HTMLTag

enum cohtml::HTMLTag : unsigned char
strong
Enumerator
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 
HR 
PRE 
BLOCKQUOTE 
OL 
UL 
LI 
DL 
DT 
DD 
FIGURE 
FIGCAPTION 
MAIN 
DIV 
EM 
STRONG 
SMALL 
CITE 
DFN 
ABBR 
DATA 
TIME 
CODE 
VAR 
SAMP 
KBD 
SUB 
SUP 
MARK 
RUBY 
RT 
RP 
BDI 
BDO 
SPAN 
BR 
WBR 
INS 
DEL 
IMAGE 
IMG 
IFRAME 
EMBED 
OBJECT 
PARAM 
VIDEO 
AUDIO 
SOURCE 
TRACK 
CANVAS 
MAP 
AREA 
MATH 
MI 
MO 
MN 
MS 
MTEXT 
MGLYPH 
MALIGNMARK 
ANNOTATION_XML 
SVG 
FOREIGNOBJECT 
DESC 
TABLE 
CAPTION 
COLGROUP 
COL 
TBODY 
THEAD 
TFOOT 
TR 
TD 
TH 
FORM 
FIELDSET 
LEGEND 
LABEL 
INPUT 
BUTTON 
SELECT 
DATALIST 
OPTGROUP 
OPTION 
TEXTAREA 
KEYGEN 
OUTPUT 
PROGRESS 
METER 
DETAILS 
SUMMARY 
MENU 
MENUITEM 
APPLET 
ACRONYM 
BGSOUND 
DIR 
FRAME 
FRAMESET 
NOFRAMES 
ISINDEX 
LISTING 
XMP 
NEXTID 
NOEMBED 
PLAINTEXT 
RB 
STRIKE 
BASEFONT 
BIG 
BLINK 
CENTER 
FONT 
MARQUEE 
MULTICOL 
NOBR 
SPACER 
TT 
RTC 
UNKNOWN 
ALL 
CUSTOM 
COUNT 

◆ InterceptRequestStatus

Enumerator
Allow 
Restrict 

◆ InternalCaches

Enumerator
ICACHE_Shadows 

Access the cache for shadow textures (e.g. box-shadow, text-shadow) This cache has only size in number of contained objects.

ICACHE_Paths 

Access the cache for complex shapes This cache has only size in number of contained objects.

ICACHE_Textures 

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_ScratchLayerTextures 

Access the cache for temporary internal textures The size of the texture is only in bytes.

◆ RenderingTasksAvailableType

Enumerator
RTA_ViewReadyForRendering 
RTA_RenderingSubSystemTask 

◆ ValueType

The primitive types coming from JS.

Enumerator
VT_Null 
VT_Boolean 
VT_Number 
VT_String 
VT_Object 
VT_Array 
VT_Count 

◆ WorkExecutionMode

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

Enumerator
WEM_UntilQueueEmpty 
WEM_UntilQuit 

Execute until all outstanding tasks have complete.

Execute until cohtml is un-initialized. Use this only if you have a dedicated thread you'll use only for the specified cohtml work.

◆ WorkType

Enumerator
WT_Resources 
WT_Layout 

Function Documentation

◆ AdaptRenderingAllocatorAndLoggerFromCohtml()

void cohtml::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 externaly initialized rendering library.

◆ ByRef()

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

◆ CoherentArrayElementBinder()

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

◆ CoherentArrayElementReader()

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

◆ CoherentBindInternal() [1/40]

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

◆ CoherentBindInternal() [2/40]

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

◆ CoherentBindInternal() [3/40]

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

◆ CoherentBindInternal() [4/40]

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

◆ CoherentBindInternal() [5/40]

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

◆ CoherentBindInternal() [6/40]

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

◆ CoherentBindInternal() [7/40]

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

◆ CoherentBindInternal() [8/40]

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

◆ CoherentBindInternal() [9/40]

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

◆ CoherentBindInternal() [10/40]

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

◆ CoherentBindInternal() [11/40]

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

◆ CoherentBindInternal() [12/40]

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

◆ CoherentBindInternal() [13/40]

template<typename ArrayType , size_t ArraySize>
void cohtml::CoherentBindInternal ( Binder binder,
ArrayType(&)  array[ArraySize] 
)

◆ CoherentBindInternal() [14/40]

template<typename ArrayType , size_t ArraySize>
void cohtml::CoherentBindInternal ( Binder binder,
const ArrayType(&)  array[ArraySize] 
)

◆ CoherentBindInternal() [15/40]

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

◆ CoherentBindInternal() [16/40]

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

◆ CoherentBindInternal() [17/40]

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

◆ CoherentBindInternal() [18/40]

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

◆ CoherentBindInternal() [19/40]

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

◆ CoherentBindInternal() [20/40]

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

◆ CoherentBindInternal() [21/40]

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

◆ CoherentBindInternal() [22/40]

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

◆ CoherentBindInternal() [23/40]

void cohtml::CoherentBindInternal ( Binder binder,
bool  value 
)
inline

◆ CoherentBindInternal() [24/40]

void cohtml::CoherentBindInternal ( Binder binder,
signed short  value 
)
inline

◆ CoherentBindInternal() [25/40]

void cohtml::CoherentBindInternal ( Binder binder,
unsigned short  value 
)
inline

◆ CoherentBindInternal() [26/40]

void cohtml::CoherentBindInternal ( Binder binder,
signed int  value 
)
inline

◆ CoherentBindInternal() [27/40]

void cohtml::CoherentBindInternal ( Binder binder,
unsigned int  value 
)
inline

◆ CoherentBindInternal() [28/40]

void cohtml::CoherentBindInternal ( Binder binder,
signed long long  value 
)
inline

◆ CoherentBindInternal() [29/40]

void cohtml::CoherentBindInternal ( Binder binder,
unsigned long long  value 
)
inline

◆ CoherentBindInternal() [30/40]

void cohtml::CoherentBindInternal ( Binder binder,
signed long  value 
)
inline

◆ CoherentBindInternal() [31/40]

void cohtml::CoherentBindInternal ( Binder binder,
unsigned long  value 
)
inline

◆ CoherentBindInternal() [32/40]

void cohtml::CoherentBindInternal ( Binder binder,
char  value 
)
inline

◆ CoherentBindInternal() [33/40]

void cohtml::CoherentBindInternal ( Binder binder,
signed char  value 
)
inline

◆ CoherentBindInternal() [34/40]

void cohtml::CoherentBindInternal ( Binder binder,
unsigned char  value 
)
inline

◆ CoherentBindInternal() [35/40]

void cohtml::CoherentBindInternal ( Binder binder,
float  value 
)
inline

◆ CoherentBindInternal() [36/40]

void cohtml::CoherentBindInternal ( Binder binder,
double  value 
)
inline

◆ CoherentBindInternal() [37/40]

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

◆ CoherentBindInternal() [38/40]

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

◆ CoherentBindInternal() [39/40]

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

◆ CoherentBindInternal() [40/40]

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

◆ CoherentBindInternalPointer() [1/3]

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

◆ CoherentBindInternalPointer() [2/3]

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

◆ CoherentBindInternalPointer() [3/3]

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

◆ CoherentBindInternalPointerHelper() [1/2]

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

◆ CoherentBindInternalPointerHelper() [2/2]

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

◆ CoherentCreateModelBindPointer()

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

◆ CoherentMapNativeElementReader() [1/2]

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

◆ CoherentMapNativeElementReader() [2/2]

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

◆ CoherentReadInternal() [1/22]

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

◆ CoherentReadInternal() [2/22]

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

◆ CoherentReadInternal() [3/22]

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

◆ CoherentReadInternal() [4/22]

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

◆ CoherentReadInternal() [5/22]

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

◆ CoherentReadInternal() [6/22]

template<typename ArrayType , size_t ArraySize>
void cohtml::CoherentReadInternal ( Binder binder,
ArrayType(&)  array[ArraySize] 
)

◆ CoherentReadInternal() [7/22]

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

◆ CoherentReadInternal() [8/22]

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

◆ CoherentReadInternal() [9/22]

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

◆ CoherentReadInternal() [10/22]

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

◆ CoherentReadInternal() [11/22]

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

◆ CoherentReadInternal() [12/22]

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

◆ CoherentReadInternal() [13/22]

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

◆ CoherentReadInternal() [14/22]

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

◆ CoherentReadInternal() [15/22]

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

◆ CoherentReadInternal() [16/22]

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

◆ CoherentReadInternal() [17/22]

void cohtml::CoherentReadInternal ( Binder binder,
bool &  value 
)
inline

◆ CoherentReadInternal() [18/22]

void cohtml::CoherentReadInternal ( Binder binder,
char &  value 
)
inline

◆ CoherentReadInternal() [19/22]

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

◆ CoherentReadInternal() [20/22]

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

◆ CoherentReadInternal() [21/22]

void cohtml::CoherentReadInternal ( Binder binder,
float &  value 
)
inline

◆ CoherentReadInternal() [22/22]

void cohtml::CoherentReadInternal ( Binder binder,
double &  value 
)
inline

◆ CoherentReadInternalUserType() [1/3]

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

◆ CoherentReadInternalUserType() [2/3]

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

◆ CoherentReadInternalUserType() [3/3]

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

◆ CoherentTypeInfoCallCoherentBindInternal() [1/2]

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

◆ CoherentTypeInfoCallCoherentBindInternal() [2/2]

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

◆ CoherentVectorElementBinder()

template<typename VectorType >
void cohtml::CoherentVectorElementBinder ( Binder binder,
void *  arr,
size_t  index 
)

◆ CoherentVectorElementReader() [1/3]

template<typename VectorType >
void cohtml::CoherentVectorElementReader ( Binder binder,
void *  data,
size_t  position 
)

◆ CoherentVectorElementReader() [2/3]

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

◆ CoherentVectorElementReader() [3/3]

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

◆ CoherentVectorLength()

template<typename VectorType >
size_t cohtml::CoherentVectorLength ( void *  data)

◆ CoherentVectorNativeElementReader() [1/3]

template<typename VectorType >
void* cohtml::CoherentVectorNativeElementReader ( void *  data,
size_t  position 
)

◆ CoherentVectorNativeElementReader() [2/3]

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

◆ CoherentVectorNativeElementReader() [3/3]

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

◆ CSTRING_TYPETRAIT() [1/4]

cohtml::CSTRING_TYPETRAIT ( char  )

◆ CSTRING_TYPETRAIT() [2/4]

cohtml::CSTRING_TYPETRAIT ( wchar_t  )

◆ CSTRING_TYPETRAIT() [3/4]

cohtml::CSTRING_TYPETRAIT ( char16_t  )

◆ CSTRING_TYPETRAIT() [4/4]

cohtml::CSTRING_TYPETRAIT ( char32_t  )

◆ DestroyAdaptedRenderingAllocatorAndLogger()

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

Deallocates the adapters created from AdaptRenderingAllocatorAndLoggerFromCohtml.

◆ GetArrayValueInvoke() [1/3]

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

◆ GetArrayValueInvoke() [2/3]

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

◆ GetArrayValueInvoke() [3/3]

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

◆ GetMapValueInvoke() [1/4]

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

◆ GetMapValueInvoke() [2/4]

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

◆ GetMapValueInvoke() [3/4]

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

◆ GetMapValueInvoke() [4/4]

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

◆ GetObjectInfoInvoke() [1/2]

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

◆ GetObjectInfoInvoke() [2/2]

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

◆ GetPairValueInvoke() [1/3]

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

◆ GetPairValueInvoke() [2/3]

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

◆ GetPairValueInvoke() [3/3]

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

◆ MakeHandler() [1/2]

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

Create event handler from generic C++ functor.

Parameters
functorgeneric C++ functor, i.e. pointer to static function or object with operator()
Returns
IEventHandler that wraps the functor

◆ MakeHandler() [2/2]

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

Create event handler from C++ method.

Parameters
objectpointer to the instance with which the method will be invoked
methodthe C++ method to be invoked
Returns
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.

◆ MakeProperty() [1/2]

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

◆ MakeProperty() [2/2]

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

◆ MakePropertyReadOnly()

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