| ►Nkanzi | Easing functions that require external dependencies for calculation |
| ►Nemscripten | |
| CDefaultEmscriptenGraphicsOutput | Class representing a default Emscripten graphics output |
| ►Ninterop | |
| CAbstractBindingRuntimeWrapper | |
| CAbstractBindingWrapper | |
| CActionDirector | |
| ►CActivityCodeBehindDirector | |
| CStatusChangeHandlerDirector | |
| CBindingProcessorWrapper | |
| CBitmapImageWrapper | |
| CCallbackBindingProcessorDirector | |
| CClassPropertyDefaultValueWrapper | |
| ►CCodeBehindDirector | |
| CCommandHandlerDirector | |
| CConditionDirector | |
| CContainerWrapper | |
| CContext | |
| CContextDirector | |
| CDataContextModifiedSubscriptionDirector | |
| CDataContextModifiedSubscriptionTokenWrapper | |
| CDataObjectListDirector | |
| CDataSourceDirector | |
| CEditorInfoWrapper | |
| CForwardingActionDirector | |
| CIteratorWrapper | |
| CListBoxItemGenerator2DDirector | |
| CListBoxItemGenerator3DDirector | |
| CMainLoopStageWrapper | |
| CMainLoopTaskTokenWrapper | |
| CMainLoopTimerTokenWrapper | |
| CMessageArgumentsWrapper | |
| CMessageSubscriptionDirector | |
| CMessageSubscriptionTokenWrapper | |
| CMessageTypeWrapper | |
| CMetaclassDirector | |
| CMetaclassReleaseVisitor | |
| CMetaclassWrapper | |
| CNativeExceptionWrapper | Used to store a native exception ptr in a foreign language |
| CNode2DDirector | |
| CNode3DDirector | |
| CNodeComponentDirector | |
| CObjectReference | |
| CObjectWrapper | |
| CPluginDirector | |
| CPluginHandlerDirector | |
| CPropertyTypeWrapper | |
| CResourceAcquireTaskDirector | |
| CResourceAcquireTaskWrapper | |
| CResourceIDWrapper | |
| CResourceLoadTaskDirector | |
| ►CResourceProtocolDirector | |
| CResult | |
| CResourceReloadProtocolDirector | |
| CStaleObjectException | Exception which is thrown when a wrapper no longer points to a valid object |
| CTaskDirector | |
| CTextureCreateInfo | Struct which contains all the parameters that are needed for texture creation |
| CTimerTaskDirector | |
| CTriggerDirector | |
| CTypedIteratorWrapper | |
| CVariantWrapper | |
| ►Nqnx | |
| CDefaultQnxEGLGraphicsOutput | Class representing a default QNX EGL graphics output |
| CDefaultQnxEGLGraphicsOutputProperties | |
| CDefaultQnxInputEventContext | Structure representing the default context for an async input event |
| CDefaultQnxPulseHandler | |
| CQnxChannelID | Class representing Qnx communication channel ID |
| CQnxConnectionID | Class representing Qnx connection ID |
| CQnxContext | Class representing a Qnx context |
| CQnxDisplay | Class representing a Qnx display |
| CQnxEGLPBufferGraphicsOutput | Class representing a QNX EGL pixel buffer graphics output |
| CQnxEGLPBufferGraphicsOutputProperties | |
| CQnxEGLWindow | Class representing a Qnx EGL window |
| CQnxEvent | Class representing a Qnx event |
| CQnxSigEvent | Class representing Qnx sig event |
| CQnxWindow | Class representing a Qnx window |
| CAbstractAnimation | Interface for abstract animations |
| CAbstractBinding | AbstractBinding is the base class for binding classes |
| CAbstractBindingRuntime | Base class for binding runtimes |
| CAbstractBindingVariableSource | Abstract interface for VariableBindingSources and VariableExpressionValueSource |
| CAbstractExpressionValueSource | Value source base for use in bindings with multiple sources |
| CAbstractExpressionValueSourceRuntime | Runtime base class for expression value sources |
| CAbstractIndexedRange | Abstract indexed range interface |
| CAbstractLogger | To implement a logger, inherit from this class |
| CAbstractMessageType | AbstractMessageType is a homogeneous message type handle to an existing message type |
| CAbstractMessageTypeDescriptor | An instance of a AbstractMessageTypeDescriptor represents a single message type in the Kanzi message system in an abstract homogeneous form |
| CAbstractNodeReference | |
| CAbstractProfiler | AbstractProfiler |
| CAbstractPropertyNotificationHandler | Abstract property notification handler |
| CAbstractPropertyType | AbstractPropertyType is a homogeneous property type handle to an existing property type |
| ►CAbstractPropertyTypeDescriptor | AbstractPropertyTypeDescriptor is used internally by the property type system to manage property types |
| CModifierEntry | |
| CModifierStorage | |
| CNotificationStorage | |
| CPropertyStorage | |
| CRawValueSourceOwner | Owner for raw value source pointers |
| CValueModifier | |
| CValueSource | |
| CValueSourceEntry | Entry pointing to value sources |
| CValueSourceOwner | Value source owner abstracts the owner pointer of a value source |
| CAbstractRange | Abstract range interface |
| CAbstractRangeIterator | Abstract range iterator interface |
| CAbstractRangeLocation | Location into a range |
| CAbstractResourceReference | |
| CAbstractValueProfiler | Abstract value profiler |
| CAction | Actions are small operations that Kanzi executes when the trigger event that contains that action occurs and the trigger conditions are met |
| CActionBase | Base abstraction class for Action classes |
| CActivity2D | An Activity is a part of application UI that is responsible for a task |
| CActivity3D | An Activity is a part of application UI that is responsible for a task |
| ►CActivityBrowserController | ActivityBrowserController is an interface class for implementing runtime data exchange between the Kanzi Studio Preview and the ActivityBrowser Kanzi Studio plugin |
| CForceTriggerMessageArguments | Message arguments for the ForceTriggerMessage |
| CNodeInfoTreeAvailableArguments | Message arguments for the NodeInfoTreeAvailableMessage |
| CActivityCodeBehind | ActivityCodeBehind is code that is associated with a particular Activity node, and has access to the properties of that Activity node |
| ►CActivityConcept | Base class for Activity classes |
| CActivityInternalMessageArguments | Class for all the internal Activity messages that do not require any message arguments |
| CActivityMessageArguments | Message arguments that hold the name of the Activity included in the message |
| CStartActivationInternalMessageArguments | Message arguments for the StartActivationInternalMessage |
| CStatusChangedInternalMessageArguments | Message arguments for internal Activity messages related to Activity status changes |
| CStatusChangedMessageArguments | Message arguments for the StatusChangedMessage |
| CActivityConceptImpl | Implementation class for ActivityConcept |
| CActivityElement | ActivityElement is the base class for all Activity and Activity Host classes |
| ►CActivityElementHistory | Encapsulates serialized data for activity elements |
| CSerializedActivityProperty | Encapsulates the serialized data for a property |
| CActivityElementImpl | ActivityElement implementation class |
| CActivityHistoryManager | ActivityHistoryManager encapsulates functionality of serialization of activities |
| ►CActivityHostConcept | Base class for Activity Host classes |
| CActivatingActivity | Class to manage storing and switching of Activity nodes |
| CActivationMessageArguments | Message arguments for ActivateActivity and DeactivateActivity messages |
| CActiveActivity | Class to manage storing and switching of Activity nodes |
| CActivityInfo | Stores information that identifies an Activity node |
| CActivityPrefabMessageArguments | Message arguments for ActivityPrefabAttachedMessage and ActivityPrefabDetachedMessage |
| CDeactivatingActivity | Class to manage storing and switching of Activity nodes |
| CRegisterActivityElementInternalMessageArguments | Message arguments for RegisterActivityElementInternal message |
| CUnregisterActivityElementInternalMessageArguments | Message arguments for UnregisterActivityElementInternal message |
| CActivityHostConceptImpl | Implementation class for ActivityHostConcept |
| CActivityHostControllerPropertyManager | Encapsulates management of activities through a controller property |
| CActivityPrefabLoader | Helper class for the Activity Host class types |
| CActivitySourceController | Encapsulates the management of data provider for Data-Driven Exclusive Activity Host |
| CActivityStatusAnimationFinishedHandler | Encapsulates dispatching of messages when an activating or a deactivating activity animation is finished |
| CActivityStatusManager | Covers the management of the StatusProperty in the State Manager that the prefab of an Activity node uses for transition animations |
| CActivitySwitchingSynchronizer | Encapsulates the synchronization of animations for activating and deactivating Activity nodes |
| CAndroidLogger | |
| CAnimationBindingProcessor | Animation binding processor executes an animation and calculates the value for use in expression bindings |
| CAnimationBindingProcessorRuntime | Holds the runtime state of an AnimationBindingProcessor |
| ►CAnimationPlayer | Use the Animation Player to play back an animation timeline that you set using the TimelineProperty property in that Animation Player |
| CCompletedMessageArguments | Message arguments for the Completed message |
| CPauseMessageArguments | Message arguments for the Pause message |
| CPlayMessageArguments | Message arguments for the Play message |
| CResumeMessageArguments | Message arguments for the Resume message |
| CStartedMessageArguments | Message arguments for the Started message |
| CStopMessageArguments | Message arguments for the Stop message |
| CStoppedMessageArguments | Message arguments for the Stopped message |
| CAnimationResource | A Resource wrapper class for animations |
| CApplication | Application class is the base class for Kanzi applications |
| ►CApplicationProperties | Configurable application properties |
| CFontEngineHasher | Class that provides the hash operator for the FontEngine enumeration |
| CImageLoadParameters | Parameters that Kanzi passes to third-party image libraries when loading image files |
| CSlog2Config | User configurable parameters for slogger2. Default values are set in the ApplicationProperties constructor |
| CAppliedStyleEntry | Applied style entry |
| CApplyAction | Base abstraction for Actions for DataTrigger, such as ForwardingApplyAction and ApplyActivationAction |
| CApplyActivationAction | An ApplyActivationAction keeps an Activity node activated for as long as the condition is met in a DataTrigger that contains this action |
| CApplyPropertyAction | An ApplyPropertyAction sets a property to the requested value for as long as the condition is met in the DataTrigger that sets off this action |
| CAutoClosingModalScope | Implements the auto-closing modal scopes |
| CAutoClosingModelessScope | Implements the auto-closing modeless focus scope |
| CBackEasingFunction | Changes the value back slightly before moving it toward the target |
| CBezierEasingFunction | Changes the value according to a Bezier curve |
| CBinaryResource | |
| CBinding | Binding is the simplest form of binding |
| CBindingBaseRuntime | Base runtime class for simple one-on-one bindings |
| CBindingExpressionOpCode | Expression binding operation |
| CBindingExpressionOpCodeParameters | Runtime Parameters for binding expression opcodes |
| CBindingHostConcept | BindingHostConcept specifies an interface for adding and removing bindings to the binding host |
| CBindingHostConceptImpl | Implementation class for BindingHostConcept |
| CBindingLoadInfo | Use the BindingLoadInfo to create the information for a binding that you need when adding the binding to an object |
| CBindingLookupContext | Lookup context for bindings |
| CBindingLookupNotificationBase | Base class for notifications on binding lookup |
| CBindingNodeLookupContext | Binding lookup context for Node |
| CBindingProcessor | Binding processor |
| CBindingProcessorRuntime | Holds the runtime state of a binding processor |
| CBindingRenderPassLookupContext | Binding lookup context for RenderPass |
| CBindingRenderValueLookupContext | Binding lookup context for render value associations |
| CBindingRuntime | Runtime for binding |
| CBindingSource | Binding source contains all the persistent data that you need to access a source value for the binding |
| CBindingSourceRuntime | Binding source runtime interface |
| CBindingTargetRuntime | Binding target runtime interface |
| CBindingToken | Helper class that manages the lifetime of the runtime binding owned by a Node or a RenderPass, by removing the owned binding on the destruction of that Node or the RenderPass |
| CBindingTriggerLookupContext | Binding lookup context for Node |
| CBindingValueSourceOwner | Owner for value source bindings |
| ►CBitmapFontFile | Font implementation for bitmap fonts |
| CBitmapGlyphData | Derived GlyphData implementation for bitmap fonts |
| CKerningPairHasher | Class providing hash operator for bitmap font kerning pairs |
| CBitmapFontLoader | FontLoader implementation for bitmap fonts |
| CBitmapImage | Image is the basic runtime primitive to load, hold, and convert image data in memory |
| CBlendModeRenderStatePropertyNotificationHandler | Custom render state property notification handler for blend mode |
| CBlendModeRenderValueBindingTargetRuntime | Custom render value binding target runtime for blend mode |
| CBlendModeValuePropertyNotificationHandler | Custom notification handler for blend mode |
| CBlitRenderPass | Use the Blit Render Pass to blit one or more textures to the screen of the current rendering context using a material |
| CBlurEffect2D | Use BlurEffect2D to apply a Gaussian blur post-processing effect to 2D nodes |
| CBlurEffectRenderer2D | Blur effect renderer class |
| CBounceEasingFunction | Changes the value as a sequence of bounces |
| CBox | Class for box volume |
| CBrush | Brush class |
| CBrushRenderer | Brush renderer class |
| CBufferObjectStream | Specifies stream to GL buffer object |
| CButton2D | Use the Button 2D node to create a 2D UI control that the user can interact with through clicking, tapping, or pressing a keyboard key |
| CButton3D | Use the Button 3D node to create a 3D UI control that the user can interact with through clicking, tapping, or pressing a keyboard key |
| ►CButtonConcept | Button nodes provide an area that receives keyboard and touch input which Kanzi translates to state events |
| CCanceledMessageArguments | |
| CClickedMessageArguments | |
| CLongPressMessageArguments | |
| CPointerEnteredMessageArguments | |
| CPointerLeftMessageArguments | |
| CPressedMessageArguments | |
| CToggledOffMessageArguments | Message arguments used by the ToggledOffMessage |
| CToggledOnMessageArguments | Message arguments used by the ToggledOnMessage |
| CToggleStateChangedMessageArguments | Message arguments used by the ToggleStateChangedMessage |
| CButtonConceptImpl | Implementation class for ButtonConcept |
| CCallbackBindingProcessor | Callback processor |
| CCallbackProcessorRuntime | Holds the runtime state of a CallbackBindingProcessor |
| CCamera | Camera node defines a view transform that is used to render the 3D scene |
| CCharacterLayout | Structure for layout of a single character for text rendering |
| CCircleEasingFunction | Changes the value using a circular function |
| CClassPropertyDefaultValue | ClassPropertyDefaultValue is a helper for installing property values as class metadata |
| CClearRenderPass | Use a Clear Render Pass to clear the color, depth, and stencil buffers of the current render context before passing the control to the descendants of this render pass |
| CClickConcept | Use the ClickConcept properties to control how nodes handle click and double-click |
| CClickConceptImpl | Implementation of base Click Concept class for derived classes |
| ►CClickManipulator | Click input manipulator recognizes the click and tap gestures from the incoming touch events |
| CClickBeginMessageArguments | Message arguments for click gesture began message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CClickCancelMessageArguments | Message arguments for click canceled message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CClickEnterMessageArguments | Message arguments for pointer entering the node area message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CClickLeaveMessageArguments | Message arguments for pointer leaving the node area message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CClickMessageArguments | Message arguments for click gesture recognized message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CClickManipulatorComponent | ClickManipulatorComponent installs a ClickManipulator to a node |
| CClock | Represents a monotonic, high resolution clock that advances steadily as the physical time moves forward |
| CCodeBehind | Code Behind is a workflow where you associate code with an instance of a node instead of a type |
| CCodeBehindRegisterGuard | RAII class for attaching code behind to an Activity or Activity Host node |
| CColorBrush | Color brush class |
| CColorBrushRenderer | Color brush renderer class |
| CColorRGBA | Color with 4 floating point components: red, green, blue and alpha (r, g, b, a) |
| CCombinerObjectSource | Combiner object source |
| CCombinerObjectSourceRuntime | Runtime for combiner object source |
| ►CCommand | Command class defines property and message types used in implementation of commands |
| CCommandMessageArguments | Represents the message arguments for command messages |
| CCompositionBrush | Texture brush class |
| CCompositionBrushRenderer | OpenGL texture brush renderer class |
| ►CCompositionManager | Composition manager |
| CRequest | Composition request class |
| CReuseParameters | Reuse and pruning parameters for unused composition targets |
| CTarget | Composition target |
| CCompositionRequirements | Composition requirements represents the required buffers for composition |
| CCompositionStack | Composition stack for managing current render context |
| ►CCompositionTargetRenderPass | Use the Composition Target Render Pass to set one to four composition targets and render all descendant render passes to the composition targets that the Composition Target Render Pass created |
| CCompositionFormatSettings | Format settings for composition target render pass |
| CCompositionSizeSettings | Size settings for Composition Target Render Pass |
| CCondition | Condition for triggers |
| CConstraintBindingProcessor | Binding processor structure for constraints |
| CConstraintBindingProcessorRuntime | Holds the runtime state of a ConstraintBindingProcessor |
| CConstraints | Contains property types of Constraints |
| CContainsPropertyFilter | Use the Contains Property Filter to collect 3D nodes that contain, or do not contain a specific property |
| CContainsPropertyFilterRuntime | Runtime for contains property node filter |
| CContentBrush | Texture brush class |
| CContentBrushRenderer | Content brush renderer class |
| CContentItemCollectionModel | Base class for exposing abstract access to collections of items of UI controls with content |
| CContentItemModel | Base class for exposing abstract access to content of UI controls with single content item model |
| CContentLayout2D | Use the Content Layout 2D node to present content in a 2D UI control as a single item |
| CContentLayout3D | Use the Content Layout 3D node to present content in a 3D UI control as a single item |
| CContentLayoutConcept | Use the Content Layout nodes to present complex content as one element in the UI |
| CContentLayoutConceptImpl | ContentLayoutConceptImpl is an abstract class for implementing the Content Layout node concept |
| CContentReference | |
| CControllerPropertySource | Abstract class whose implementation encapsulates management of controller property source for an activity host controller property |
| CCoutLogger | This logger class writes log messages to standard output |
| CCubeMapRenderPass | Use the Cubemap Render Pass to create a cubemap texture that represents the scene from some location |
| CCubicEasingFunction | Changes the value based on the cube of time using the function f(t) = t^3 |
| ►CCurveReparametrization | Kanzi uses curve reparametrization to subdivide a spline or a line into a series of samples |
| CReparametrizationSample | A sample point (phase, length) for mapping between curve parameter and curve length |
| ►CDataContext | DataContext acts as a container for data |
| CModifiedSubscription | Subscription entry |
| CDataDrivenExclusiveActivityHost2D | A type of Exclusive Activity Host node, that uses a list of Activity nodes provided by setting a list DataObject, from a DataSource, to the ActivitySourceProperty property |
| CDataDrivenExclusiveActivityHost3D | A type of Exclusive Activity Host node, that uses a list of Activity nodes provided by setting a list DataObject, from a DataSource, to the ActivitySourceProperty property |
| CDataDrivenExclusiveActivityHostConcept | Base class for the Data-Driven Exclusive Activity Host classes |
| CDataDrivenExclusiveActivityHostImpl | Implementation class for DataDrivenExclusiveActivityHostConcept and ExclusiveActivityHostConcept |
| CDataObject | DataObject is the base class for data |
| CDataObjectBool | Implementation of DataObjectTyped<bool, DataObject::Bool> |
| CDataObjectEnum | Provides functions to the host, set, and get values of the given type |
| CDataObjectEnumBase | DataObjectEnumBase is the base class for enum data |
| CDataObjectInt | Implementation of DataObjectTyped<int32_t, DataObject::Int> |
| CDataObjectList | DataObjectList is the base class for list data object |
| CDataObjectReal | Implementation of DataObjectTyped<double, DataObject::Real> |
| CDataObjectString | Implementation of DataObjectTyped<string, DataObject::String> |
| CDataObjectTyped | Template class that you can use with the standard types |
| CDataObjectTypeTraits | DataObjectTypeTraits Provides type information for how a data type should be stored, passed as a parameter, etc |
| CDataObjectTypeTraits< double > | A specialization for double, because PropertyDataTypeTraits<T> does not have double |
| CDataSource | Use data sources to separate the user interface from the application data and to remove the dependencies between a Kanzi Studio project and the application code which define the Kanzi application |
| CDataSourceBindingSource | Data source binding source |
| CDataSourceBindingSourceRuntime | Runtime for object property binding source |
| CDataSourceControllerPropertySource | Implementation of ControllerPropertySource, for controller property value provided by a data source field |
| CDataSourceExpressionValueSource | Data Source expression value source |
| CDataSourceExpressionValueSourceRuntime | Runtime for object property expression value source |
| CDataSourceListItemGenerator | |
| CDataSourceListItemGenerator2D | |
| CDataSourceListItemGenerator3D | |
| CDataTrigger | Use a DataTrigger to apply an action to either set a property value of a target node or activate an Activity node |
| CDataTriggerComponent | Base class for the DataTrigger class |
| CDataTriggerTemplate | DataTriggerTemplate is the base class for the Data Trigger templates |
| CDebugRenderRegistry | The debug render registry enables you to register custom debug render functions for Node3D nodes |
| CDefaultEGLGraphicsOutputProperties | |
| CDefaultListBoxItemContainerGenerator | |
| CDefaultListBoxItemGenerator | |
| CDefaultLogger | Use this class to access the Default Logger |
| CDefaultProfilerRegistry | The default profiler registry placeholder |
| CDispatchMessageAction | DispatchMessageAction dispatches a message of specified type to a specified target |
| CDistanceFilter | Distance filter |
| CDistanceFilterRuntime | Runtime for distance filter |
| CDockLayout2D | Use the Dock Layout 2D node to place nodes relative to each other along the sides of a Dock Layout 2D node |
| CDockLayout3D | Use the Dock Layout 3D node to place nodes relative to each other along the sides of a Dock Layout 3D node |
| CDockLayoutConcept | Dock layout concept base class |
| CDockLayoutConceptImpl | Dock layout concept implementation base class |
| CDomain | Domain binds Kanzi subsystems and objects together |
| CDomainProfilerCollection | The domain profiler collection |
| ►CDragAndDropManipulator | Drag-and-drop input manipulator recognizes the drag-and-drop gesture from incoming touch events |
| CCanceledMessageArguments | Message arguments for the drag-and-drop cancel message |
| CFinishedMessageArguments | Message arguments for drag-and-drop finished message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CMovedMessageArguments | Message arguments for drag-and-drop moved message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CStartedMessageArguments | Message arguments for drag-and-drop started message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CDrawObjectsRenderPass | Use the Draw Objects Render Pass to render only nodes in a Scene node provided by an object source you set in this render pass |
| CDrawObjectsWithMaterialRenderPass | Use the Draw Objects With Material Render Pass to render nodes provided by an object source using a material |
| CDummyBindingTargetRuntime | Runtime for dummy binding target |
| CDynamicMessageType | DynamicMessageType is a handle to an existing message type |
| CDynamicPropertyType | DynamicPropertyType is a handle to an existing property type |
| CEGLCapabilities | |
| CEGLConfig | Class representing a single EGL config |
| CEGLContext | Class representing an EGL context |
| CEGLDisplay | Class representing an EGL display connection |
| CEGLPBufferSurface | Class representing EGL PBuffer surface |
| CEGLVersion | Struct holding EGL version information |
| CEGLWindowSurface | Class representing EGL window surface |
| CElasticEasingFunction | Changes the value that resembles an oscillating spring until it comes to rest |
| CEmptyNode2D | Empty Node 2D can be used to group other 2D nodes |
| CEmptyNode3D | |
| Cenable_bitmask_operators | Enabler template for bitmask operators over an Enum class |
| CEventFilter | EventFilter class |
| CEventQueue | Implements a queue of Kanzi input events gathered by EventSource instances |
| CEventSource | EventSource class |
| CEventSourceDecorator | The EventSourceDecorator declares the interface for the EventSource decorators |
| CEventSourceProperties | Configurable event source properties |
| CExampleApplication | |
| CExclusiveActivityHost2D | An Activity Host that displays Activity nodes one at a time |
| CExclusiveActivityHost3D | An Activity Host that displays Activity nodes one at a time |
| CExclusiveActivityHostBaseImpl | Implementation of common functionality of ExclusiveActivityHost and DataDrivenExclusiveActivityHost classes |
| ►CExclusiveActivityHostConcept | This is the base class for all Exclusive Activity Host nodes |
| CActivityInExclusiveHostInfo | Stores information that identifies an Activity node under an ExclusiveActivityHost |
| CExclusiveActivityHostContent | Container for the content information for an ExclusiveActivityHost |
| CImplicitActivityChangeRequestMessageArguments | Base class for Exclusive Activity Host Concept message argument classes |
| CExclusiveActivityHostContentHandler | Helper class used to modify the ExclusiveActivityHostContent of an ExclusiveActivityHost |
| CExclusiveActivityHostImpl | Implementation class for ExclusiveActivityHost |
| CExponentialEasingFunction | Changes the value with an exponential function with power that you can configure |
| CExpressionBinding | ExpressionBinding enables you to bind from multiple sources to one target, and to modify the values before writing them to target values |
| CExpressionBindingProcessor | Expression binding processor |
| CExpressionBindingRuntime | Runtime for expression binding |
| CExpressionBindingSource | Expression binding source collects expression value sources and executes operations on the values to produce a read result |
| CExpressionBindingSourceRuntime | Runtime for expression binding source |
| CExpressionCondition | Use trigger conditions to set which conditions must be met for a Trigger to set off |
| CFile | Interface class for files |
| CFilterObjectSource | Filter object source |
| CFilterObjectSourceRuntime | Base class for filter runtime classes |
| CFixedString | String that points to a string literal |
| CFlagScopeGuard | Scope guard for boolean value |
| ►CFloatValueAccumulator | Use a FloatValueAccumulator to increase the value of a float property type or a property field over time |
| CSetAccumulatedValueBoundariesMessageArguments | Message arguments for the SetAccumulateValueBoundaries message |
| CFlowLayout2D | Flow Layout 2D arranges 2D items along a line and continues to the next line when it runs out of space |
| CFlowLayout3D | Flow Layout 3D arranges 3D items along a line and continues to the next line when it runs out of space |
| CFlowLayoutConcept | Flow layout concept base class |
| CFlowLayoutConceptImpl | Flow layout concept implementation base class |
| CFocusChainIndex | Contains the focus order and focus order offset information of a node in a focus scope |
| CFocusChainNode | The focus chain node of a focus scope consists of the node of the focus scope, its focus order, and the focus order offset |
| CFocusFence | Implements the focus fences |
| CFocusGroup | Implements the focus groups |
| ►CFocusManager | Focus Manager enables you to set and change the keyboard focus between attached nodes |
| CFocusEnteredFocusScopeMessageArguments | Message arguments used by the FocusEnteredFocusScopeMessage |
| CFocusLeftFocusScopeMessageArguments | Message arguments used by the FocusLeftFocusScopeMessage |
| CInputOutsideOverlayMessageArguments | Message arguments used by the InputOutsideOverlayMessage |
| CMoveFocusMessageArguments | Message arguments used by the focus move messages |
| COverlayBroughtToFrontMessageArguments | Message arguments used by the OverlayBroughtToFrontMessage |
| COverlayGainedFocusMessageArguments | Message arguments used by the OverlayGainedFocusMessage |
| COverlayLostFocusMessageArguments | Message arguments used by the OverlayLostFocusMessage |
| COverlaySentToBackMessageArguments | Message arguments used by the OverlaySentToBackMessage |
| CPostFocusMessageArguments | |
| CPreFocusMessageArguments | Message arguments for the pre-focus messages |
| CScopeStateChangeMessageArguments | Base message argument class for the focus scope state change message arguments |
| CFocusNavigationGesture | Declares a focus navigation gesture |
| CFocusNavigationManipulator | FocusNavigationManipulator converts key gestures into focus chain navigation actions to move the focus between focusable nodes |
| ►CFocusScope | Holds the attributes of a focus scope: |
| CFocusChain | The FocusChain contains the snapshot of the focus chain of a focus scope |
| CFocusScopeVisitor | Focus scope visitor for UI scene traversal of focus scopes |
| ►CFontEnginePlugin | FontEnginePlugin is the interface definition for font engine plugins |
| CBackendProperties | Font backend properties |
| CFontFamily | A font family resource contains font files |
| ►CFontFile | FontFile is the base class for different font file resource implementations |
| CGlyphData | GlyphData contains the metrics for an individual rendered glyph and its bitmap |
| CFontLoader | Use FontLoader to create FontFile objects from memory or a file |
| CFontManager | Use the FontManager class to: |
| CFontRuntime | Runtime font |
| CFontStyleConcept | FontStyleConcept is the base class for the nodes that draw text with different font styles |
| CFontStyleConceptImpl | Implementation class for FontStyleConcept |
| CFontStyleDefinition | FontStyleDefinition provides a collection of font characteristics |
| ►CForwardingAction | ForwardingAction is the base class for the action classes that read and send arguments, such as SetPropertyAction or DispatchMessageAction |
| CBindingEntry | Entry for bindings to install when the action is invoked |
| CBindingRuntimeEntry | Entry for binding runtimes to execute when the action is invoked |
| ►CForwardingApplyAction | ForwardingApplyAction is the base class for the ApplyAction classes that read and send an argument, such as ApplyPropertyAction |
| CBindingInfo | Stored info for a binding |
| ►CFramebuffer | Framebuffer attachment state |
| CAttachmentPoint | AttachmentPoint |
| CFrameDescription | Description of a frame, the remaining area of a quad with another quad cut out |
| CFrameTimeQueue | Helper class for calculating the frame rate |
| CFreeTypeFontEnginePlugin | FreeTypeFontEnginePlugin is the FreeType font engine plugin implementation |
| CFreeTypeFontFile | Font implementation using the Freetype rasterizer |
| CFreeTypeFontLoader | FontLoader implementation for the Freetype rasterizer |
| CFreeTypeTextShaper | TextShaper implementation using these open source libraries: |
| Cfrom_chars_result | Holds the status result of a call to from_chars |
| CFromToAnimation | Template class for from-to animations |
| CFromToAnimationBase | Template base class for from-to animations |
| CFrustumCullFilter | Frustum cull filter |
| CFrustumCullFilterRuntime | Runtime for frustum cull filter |
| ►CGatherLightsRenderPass | GatherLightsRenderPass is a class for generating light properties for rendering nodes |
| CInstantiatorNotification | Instantiator notification information installed by the gather lights render pass |
| CLightInfo | Internal information structure for storing information on lights |
| ►CLightRange | Light range is a range type for retrieving light values |
| CLightRangeLocation | Light range location implementation |
| ►CGatherNearestLightsRenderPass | GatherNearestLightsRenderPass is an implementation of light gathering |
| CLightDistanceInfo | Light distance information |
| ►CNearestLightRange | Nearest light range is an extension to light range that returns the lights in distance order to caller |
| CNearestLightRangeLocation | Light range location implementation |
| ►CGenericResourceProfilingContext | Generic resource profiling context |
| CSampler | The context sampler |
| ►CGeometry | Geometry represents 2D coordinate data that you can use to render 2D nodes and text |
| CVertex | Vertex for geometry |
| CGlBlendModeRenderValue | Custom blend mode render value implementation |
| CGlBrushRenderer | OpenGL brush renderer specifics |
| CGLBufferHandle | GLBufferHandle manages RAII ownership for GL buffer object |
| CGLFramebufferHandle | GLFramebufferHandle manages RAII ownership for GL framebuffer object |
| CGlGraphicsAdapter | Base class for handling calls to OpenGL family |
| CGlGraphicsAdapterCallGles | OpenGL API call handler which calls the implementation from dynamically loaded GLES library |
| CGlGraphicsAdapterCheckForErrors | Check for GL errors |
| CGlGraphicsAdapterLogger | Logs OpenGL API calls |
| CGlGraphicsLogScope | Scoped OpenGL log enable/disabler |
| CGLGraphicsOutput | GLGraphicsOutput class |
| CGLProgramHandle | GLProgramHandle manages RAII ownership for GL program object |
| CGLRenderbufferHandle | GLRenderbufferHandle manages RAII ownership for GL renderbuffer object |
| ►CGlRenderState | OpenGL render state |
| CRenderValueInfo | Render value information |
| CRenderValueUnion | Union containing one render value to be arranged into an array |
| CTextureRenderValue | Container for texture render value and the width/height uniforms |
| CGlRenderValue | Individual render value container |
| CGlRenderValue< TextureSharedPtr > | Specialization of GlRenderValue |
| CGlRenderValueBase | Base class for render value information |
| CGlRenderValueBinding | GlRenderValueBinding is a binding from shaders/materials into values in GlRenderState |
| CGLShaderHandle | GLShaderHandle manages RAII ownership for GL shader object |
| CGLTextureHandle | GLTextureHandle manages RAII ownership for GL texture object |
| ►CGlyphCache | Glyph cache renders different characters on a texture with the font and font size that you use in your Kanzi application |
| CTextureCoordinates | Coordinates to the position of a single glyph in a glyph cache texture |
| CGlyphCacheManager | GlyphCacheManager creates and maintains glyph caches for different font file and font size combinations |
| CGlyphRun | GlyphRun contains the memory structures that are needed to render a text string |
| CGPUBuffer | |
| CGPUResource | GPUResource is a resource that must be deployed to the GPU |
| CGraphicsOutput | GraphicsOutput class |
| CGridLayout2D | Grid Layout 2D arranges 2D items in a grid |
| CGridLayout3D | Grid Layout 3D arranges 3D items in a grid |
| ►CGridLayoutConcept | Base class for the Grid Layout nodes |
| CRowColumnDefinition | Definition for the size and position of a single row or column |
| ►CGridLayoutConceptImpl | Implementation class for GridLayoutConcept |
| CGridObjectLocationWorkspace | Information used to store the state between function calls when locating objects |
| CGridListBox2D | Use the Grid List Box 2D node to create scrollable lists of 2D items arranged in a grid |
| CGridListBox2DTraits | |
| CGridListBox3D | Use the Grid List Box 3D node to create scrollable lists of 3D items arranged in a grid |
| CGridListBox3DTraits | |
| CGridListBoxConcept | GridListBoxConcept provides the common properties and messages for the GridListBox2D and GridListBox3D nodes |
| CHudDebugEvent | The event toggles the head-up display debugging status |
| CImage2D | Image2D node |
| CImmutableIteratorRange | Iterator location range pointing to a particular location of an iterator range |
| CImmutableSplitStringRange | ImmutableSplitStringRange is an analogue to the ImmutableIteratorRange for a SplitStringRange |
| CImmutableString | Immutable string container |
| ►CIndexedPropertyAccessRange | Indexed property access range |
| CIndexedPropertyAccessRangeLocation | Location implementation for indexed property access range |
| ►CIndexedViewRange | View over another indexed range |
| CIndexedViewRangeLocation | Location class for indexed view range |
| CInputEvent | Base event class providing the core functionality of the Kanzi input events |
| CInputManager | InputManager converts the events from the given event queue into input specific messages |
| ►CInputManipulator | The base class for the Kanzi input manipulators |
| CCollection | Common functions of collections of attached InputManipulators processing a specific input event type |
| CInputMessageArguments | Message arguments for input manipulator messages |
| CKeyInputMessageArguments | Represents base message arguments for key input messages |
| CTouchInfo | Structure to hold the state of the current touch points |
| CInputMethod | The InputMethod class defines the interface of the Kanzi input methods |
| CInputMethodBackend | The InputMethodBackend defines the interface of the input method backends |
| CInputMethodListener | The InputMethodListener defines the communication interface of Kanzi input methods |
| CInputMethodManager | The InputMethodManager keeps track of the input method backends registered in Kanzi |
| ►CInstantiator3D | Use the Instantiator node to replicate the appearance of a 3D node, or a tree of 3D nodes, that the Instantiator node targets |
| CFinalTransformModifier | Container for property modifiers for instantiated nodes |
| CInstructionBindingProcessor | Instruction binding processor is the top-level class for all instruction-like binding processors |
| CInstructionBindingProcessorRuntime | Holds the runtime state of an InstructionBindingProcessor |
| CInterpolatedValue | Core component for smooth interpolation in code |
| CIntervalProfiler | The interval profiler |
| CIntervalProfilerSampleData | The interval profiler data sample |
| CIntervalProfilerSampleStatistics | |
| CIntervalProfilingSampler | The main loop task profiling sampler collects interval measurement to produce IntervalProfilerSampleData sample |
| ►CIntValueAccumulator | Use an IntValueAccumulator to increase the value of an integer property type over time |
| CSetAccumulatedValueBoundariesMessageArguments | Message argument for SetAccumulatedValueBoundaries message |
| CIrisImageHeader | |
| ►CIteratorRange | Iterator is an range that references a location in another range |
| CIteratorRangeLocation | Location implementation for iterator range |
| CItypeFontEnginePlugin | ItypeFontEnginePlugin is the IType font engine plugin implementation |
| ►CItypeFontFile | Font implementation using the iType rasterizer |
| CItypeGlyphData | Derived GlyphData implementation for iType |
| CItypeFontLoader | FontLoader implementation for Monotype's iType rasterizer |
| ►CItypeTextShaper | TextShaper implementation using Monotype's WTShaper library |
| CFontData | Runtime data for text layouting to be passed to WTShaper |
| CJavaException | Exception class that can be used to wrap a Java generated exception |
| CJavaModule | |
| CJNIError | |
| CJniLibrary | |
| CJvmModule | |
| CKanziComponentsModule | |
| ►CKeyboard | Keyboard declares the messages dispatched to the nodes when Kanzi handles a hardware key event |
| CKeyDownMessageArguments | Message arguments used by the KeyDownMessage |
| CKeyStateChangedMessageArguments | Represents base message arguments for key state change messages |
| CKeyUpMessageArguments | Message arguments used by the KeyUpMessage |
| CKeyEvent | The KeyEvent holds a pressed, released, or auto-repeated key event which occurs in the host operating system |
| ►CKeyframeAnimation | Template class for keyframe animations |
| CBezierKeyframe | Use bezier keyframes to animate property value along a bezier curve |
| CKeyframe | Keyframe defines a value for the animated property at a specific time in an animation timeline |
| CLinearKeyframe | Use linear keyframes to interpolate animated property value linearly between keyframes |
| CStepKeyframe | Use Step keyframes to keep the value of the current keyframe constant up until the following keyframe |
| CKeyGestureInfo | This class defines the elements that compose a key gesture, key values, and key modifiers |
| ►CKeyManipulator | KeyManipulator class is a key input manipulator that detects key gestures |
| CKeyCanceledMessageArguments | Message arguments used by the KeyCanceledMessage |
| CKeyPressedMessageArguments | Message arguments used by the KeyPressedMessage |
| CKeyReleasedMessageArguments | Message arguments used by the KeyReleasedMessage |
| CKeyManipulatorComponent | The KeyManipulatorComponent node component installs a KeyManipulator to the attached node, and configures the key gesture of the manipulator |
| CKeyMap | Defines the keys to map from a {LogicalKey, KeyModifier} pair to a simple LogicalKey |
| CKeyMapEventFilter | The KeyMapEventFilter provides key translation in Kanzi |
| CKeyRepeatGenerator | The KeyRepeatGenerator is an event source decorator that scans the event queue of the EventSource it extends for key-press events and generates from them key-press repetitions |
| CKzbFile | Kzb file loader |
| CKZBFileException | Exception which is thrown when error occurs during loading from KZB |
| CKzbMemoryParser | Parser for kzb files |
| CLegacyError | |
| CLegacyEventSource | LegacyEventSource class |
| CLegacyGraphicsOutput | LegacyGraphicsOutput class |
| CLegacyRenderPass | Legacy Render Pass is phased out in favor of specialized render passes that perform individual operations, which are combined in a Legacy Render Pass into a single render pass |
| CLevelOfDetail3D | Level of detail selector node is a 3D node that changes the appearance of its child nodes based on the viewing distance |
| CLibJPEGParameters | Parameters that Kanzi passes to libjpeg to use when loading jpg image files |
| CLibPNGParameters | Parameters that Kanzi passes to libpng to use when loading png image files |
| CLight | Light node is a source of light for a 3D scene |
| CLinearEasingFunction | Changes the value with constant velocity |
| ►CListBoxConcept | Properties and messages for list boxes |
| CItemHiddenMessageArguments | Message arguments for the messages about item hiding in a List Box node |
| CItemMessageArguments | Base class for item-related message arguments |
| CItemSelectedMessageArguments | Message arguments for the messages about the item selected event in a List Box node |
| CItemVisibleMessageArguments | Message arguments for the messages about the new visible item in a List Box node |
| CListBoxConceptImpl | ListBoxConceptImpl provides the common base implementation for the List Box nodes, such as GridListBox2D, GridListBox3D, and TrajectoryListBox3D |
| CListBoxGridPresenter | |
| CListBoxItemContainer | Use the List Box Item Container prefab to create common functionality and decoration for all items in a List Box |
| CListBoxItemContainer2D | List Box Item Container for 2D List Box nodes. Wrapper component for storing item object nodes |
| CListBoxItemContainer3D | List Box Item Container for 3D List Box nodes. Wrapper component for storing item object nodes |
| CListBoxItemContainerGenerator2D | |
| CListBoxItemContainerGenerator3D | |
| CListBoxItemContainerImpl | Implementation of base List Box Item Container class for List Box |
| CListBoxItemGenerator2D | |
| CListBoxItemGenerator3D | |
| ►CListBoxScrollingConcept | Messages for the List Box nodes that implement scrolling |
| CScrolledMessageArguments | Message arguments for the messages about the scrolled event in a List Box node |
| CScrollFinishedMessageArguments | Message arguments for the messages about the scroll finished event in a List Box node |
| CScrollMessageArguments | Base class for scroll-related message arguments |
| CScrollStartedMessageArguments | Message arguments for the messages about the scroll started event in a List Box node |
| CTargetChangedMessageArguments | Message arguments for the messages about the changed scroll target in a List Box node |
| CUserScrollFinishedMessageArguments | Message arguments for the messages about the user scroll finished event in a List Box node |
| CUserScrollStartedMessageArguments | Message arguments for the messages about the user scroll started event in a List Box node |
| CListBoxScrollPresenterConceptImpl | ListBoxScrollPresenterConceptImpl is the base class concept implementation for the List Box presenters that use Scroll View in their presentation |
| ►CListBoxTrajectoryPresenter | |
| CKzuTrajectoryLayoutSnapInfo | |
| ►CLongPressManipulator | Long-press input manipulator recognizes the long-press gesture from the incoming touch events |
| CLongPressCancelMessageArguments | Message arguments for long-press canceled message |
| CLongPressMessageArguments | Message arguments for long-press gesture recognized message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CLongPressManipulatorComponent | LongPressManipulatorComponent installs a LongPressManipulator to a node |
| CMainLoopProfiler | MainLoopProfiler implements profiling for tasks of MainLoopScheduler |
| CMainLoopProfilingAggregateData | MainLoopProfilingAggregateData implements profiling data aggregation for MainLoopProfiler |
| CMainLoopProfilingSampleData | MainLoopProfilingSampleData implements profiling sample data for MainLoopProfiler |
| CMainLoopProfilingSampler | MainLoopProfilingSampler implements profiling sampler for MainLoopProfiler |
| ►CMainLoopScheduler | MainLoopScheduler implements the Kanzi application main loop in form of a customizable sequence of stages, each consisting of a sequence of tasks, where a task is any callable, including functions, function objects, and lambdas |
| CTaskInfo | TaskInfo is a structure containing information related to a task |
| CManualBinding | Manual binding is a one-to-one binding that caches the value that was written to the target |
| CManualBindingRuntime | Runtime for binding |
| CManualBindingSource | Manual binding source |
| CManualBindingSourceRuntime | Runtime for manual binding source |
| CManualBindingTargetRuntime | Runtime for manual binding target |
| CMaskEffect2D | Use MaskEffect2D to apply a mask to 2D nodes |
| CMaskEffectRenderer2D | Mask effect renderer class |
| CMaterial | A material is an instance of a material type (ShaderProgram) that contains the property values for the material type properties |
| CMaterialBrush | Freeform shader brush |
| CMaterialBrushRenderer | Material brush renderer |
| CMaterialSetupRenderPass | Use the Material Setup Render Pass to set properties to a material for further render operations using that material |
| CMatrix3x3 | Matrix with 3x3 elements |
| CMatrix4x4 | Matrix with 4x4 elements |
| CMemoryParser | |
| CMemoryWriter | |
| ►CMesh | Mesh stores the geometry data for rendering Model3D nodes |
| CBone | Definition of mesh bone that is used for mesh skinning |
| CCluster | Cluster has a material, primitive type (currently always triangles), and handle for GPU memory buffer where primitive indices are stored |
| ►CCreateInfo | Use Mesh::CreateInfo to describe and create meshes |
| CCluster | Parameters for Mesh::Cluster creation |
| CMappedBuffer | Mapped buffer is a container for GPU memory that is mapped into CPU memory |
| CSkeleton | Skeleton is for animating mesh with bones |
| CMeshVertexAttribute | MeshVertexAttribute describes how mesh vertex data is stored in memory |
| ►CMessageArguments | MessageArguments is the base class for arguments passed in messages |
| CArgumentEntry | Linked list entry containing arguments type and value |
| CMessageBindingSource | Message binding source |
| CMessageBindingSourceRuntime | Runtime for message binding source |
| CMessageBindingTargetRuntime | Runtime for message binding target |
| CMessageTrigger | Message handler trigger |
| CMessageType | An instance of a MessageType represents a single message type in the Kanzi message system |
| CMetaclass | Metaclass provides type inspection mechanism for Kanzi classes |
| CMetaclassAbstractBase | |
| CMetaclassAbstractImpl | |
| CMetaclassImpl | |
| CMetaclassStaticBase | |
| CMetaclassStaticImpl | |
| CMetadataGeneratedName | This class is used to disambiguate a constructor which takes a non-literal string argument from an overload which takes a string-literal i.e. FixedString |
| CMetaMethod | MetaMethod provides method invocation mechanism for Kanzi classes |
| CMetaObject | MetaObject is the base class for classes that provide type reflection |
| CMethodArgument | Holds argument type and value information |
| CMethodArguments | Holds arguments applied on metamethod invocation |
| CModalScope | Implements the modal scopes |
| CModel3D | Node for rendering meshes in 3D space |
| CModelessScope | Implements the modeless overlay focus scopes |
| CModule | Module is a class representing a functional module with its own metadata about the types it contains |
| CModuleDeleter | Module deleter for shared_ptr |
| ►CMorph | |
| CMeshAttribute | |
| CMorphRuntime | Contains morph weights for a morph |
| CMorphWeightTimeline | Timeline for animating morph weights |
| CMorphWeightTimelinePlayback | Timeline Playback for morph timeline |
| CMoveFocusAction | Use the MoveFocusAction action to transfer focus from the currently focused item to another focusable item in the focus navigation chain |
| ►CMultiClickManipulator | Multi-click input manipulator recognizes multi-click and multi-tap gestures from incoming touch events |
| CCanceledMessageArguments | Message arguments for multi-click cancel message |
| CMultiClickMessageArguments | Message arguments for the multi-click gesture recognized message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CMultiClickManipulatorComponent | MultiClickManipulatorComponent installs a MultiClickManipulator to a node |
| CNamedIntervalProfiler | The named interval profiler |
| CNamedIntervalProfilerSampleData | The named interval profiler data sample |
| CNamedIntervalProfilerSampler | This sampler collects interval measurement to produce NamedIntervalProfilerSampleData sample |
| CNamedIntervalProfilerSampleStatistics | Named Interval profiler sample statistics |
| ►CNamedResourceProfilingContext | Named resource profiling context |
| CSampler | The context sampler |
| CNativeDeploymentTarget | Reference to a backend implementation specific memory storage type for deployment |
| CNativeWindowProperties | Properties for a window |
| CNavigationGesture | Declares a navigation gesture |
| ►CNavigationManipulator | The NavigationManipulator supports these navigation directions and default keyboard keys for them: |
| CKeyNavigationMessageArguments | |
| CNavigationManipulatorComponent | The NavigationManipulatorComponent node component installs a NavigationManipulator to a node, and configures the navigation key gestures of the manipulator |
| CNinePatchImage2D | A nine-patch image is a 3x3 grid of images |
| ►CNode | Base class for Kanzi nodes |
| CMessageSubscriptionToken | Message subscription token for nodes |
| CNodeComponentEntry | Object node component entry |
| ►CNode2D | Node2D is the base class of all 2D nodes |
| CClippingArea | Clipping information carried from parents |
| ►CNode3D | Base class for all 3D nodes |
| CRenderEntryParameters | Render entry parameters |
| ►CNodeComponent | NodeComponent is the base class for all node components |
| CNodeComponentSourceMessageArguments | Base class for message arguments that are sent by a node component |
| CNodeComponentTargetMessageArguments | Base class for message arguments that are sent to a node component |
| CNodeComponentTemplate | NodeComponentTemplate is the base class for all node component templates |
| ►CNodeCompositor2D | Composition functionality for 2D nodes |
| CCompositionState | CompositionState defines the state held by the compositor while Kanzi performs the composition, that is, between calls to beginComposition and blitComposition |
| CGeometryState | GeometryState defines the state used for rendering a quad |
| CNodeEffect2D | Use node effects to apply post-processing effects to 2D nodes |
| CNodeEffectPrefab2D | Use node effect prefabs to create node effects that define post-processing effects for 2D nodes |
| ►CNodeEffectRenderer2D | Node effect renderer class |
| ►CEffectPass | Effect pass configuration |
| CInput | Effect pass input configuration |
| ►CEffectRenderState | Render state configuration to use with an effect pass |
| CInput | Render state texture input configuration |
| CNodeEffectTemplate2D | Use NodeEffectTemplate2D to instantiate a node effect |
| CNodeList | NodeList is a container that works as input and output node listing for filtering and rendering |
| CNodeListRenderPass | Use the Node List Render Pass to filter and hold a list of nodes that you want to render using other render passes |
| CNodePropertyNotificationHandler | Node property notification handler |
| CNodeReference | Provides functionality for a reference to any attached node that you can access using a relative path |
| ►CNodeVisual2D | Data and functionality required for rendering Node2D visuals |
| CBrushState | State associated with brush rendering |
| CNullBrush | Null brush class |
| CNullGraphicsOutput | NullGraphicsOutput class |
| Cnullptr_t | Nullptr_t is the type of the null pointer literal, nullptr |
| CObject | Object is the base class for Kanzi UI classes that implement association with a Domain |
| CObjectControllerPropertySource | Implementation of the ControllerPropertySource, for ControllerProperty value provided as a property field, either on the Activity Host node or, if the Activity Host node does not have that property, its nearest ancestor that does have that property |
| CObjectFactory | |
| CObjectLoader | ObjectLoader loads objects from KZB |
| CObjectPropertyBindingSource | Object property binding source |
| CObjectPropertyBindingSourceRuntime | Runtime for ObjectPropertyBindingSource |
| CObjectPropertyExpressionValueSource | Object Property expression value source |
| CObjectPropertyExpressionValueSourceRuntime | Runtime for object property expression value source |
| CObjectPropertyListenerImpl | Object property listener implementation |
| CObjectSource | Structure for object source |
| CObjectSourceRuntime | Runtime for an object source |
| CObjectTypeFilter | Use the Object Type Filter to collect 3D nodes based on their type |
| CObjectTypeFilterRuntime | Runtime for object type filter |
| COnAttachedTrigger | On Attached Trigger |
| COnPropertyChangedTrigger | Invokes associated actions on setting of a property type, specified by SourcePropertyTypeProperty, on a source node, specified by SourceNodeProperty |
| COrientationChangedEvent | Specialized event that reports the orientation change of a window |
| COrientedBoundingBox | An oriented bounding box represents a bounding box that has been transformed by a transformation matrix |
| COutlineEffect2D | Use OutlineEffect2D to apply an outline to the content of 2D nodes |
| COutlineEffectRenderer2D | Outline effect renderer class |
| COverlayScope | Implements the base of overlay focus scopes |
| ►CPage | Use Page nodes to create the structure of an application user interface |
| CActivatedMessageArguments | Represents message arguments of Activated message |
| CDeactivatedMessageArguments | Represents message arguments of Deactivated message |
| CNavigateMessageArguments | Represents message arguments of Navigate message |
| CNavigateParentMessageArguments | Represents message arguments of NavigateParent message |
| CNavigationActivatedMessageArguments | These messages are used by the page navigation logic internally |
| CNavigationDeactivatedMessageArguments | Represents message arguments of NavigationDeactivated message |
| CRegisterToNavigationMessageArguments | Represents message arguments of RegisterToNavigation message |
| CUnregisterFromNavigationMessageArguments | Represents message arguments of UnregisterFromNavigation message |
| ►CPageHost | Use a PageHost node to group Page and PageHost nodes, and to manage navigation requests and transitions in a tree of Page nodes under a PageHost node |
| CNavigateNextMessageArguments | Represents message arguments of NavigateNext message |
| CNavigatePreviousMessageArguments | Represents message arguments of NavigatePrevious message |
| CNavigationFinishedMessageArguments | Represents message arguments of NavigationFinished message |
| CNavigationStartedMessageArguments | Represents message arguments of NavigationStarted message |
| ►CPageTransitionCollection | Transition collection is used to define transitions within a Page Host |
| CRuntime | Runtime class that is instantiated per page. Drives the internal state manager that is used to animate transitions |
| CTransition | Describes transition from one page to another |
| CTransitionAnimation | Entry in transition animation array |
| ►CPanManipulator | Pan input manipulator recognizes a pan gesture from the incoming touch events |
| CBaseMessageArguments | Base message arguments for pan gestures that contain movement information |
| CCanceledMessageArguments | Message arguments for pan cancel message |
| CEnteredMessageArguments | Message arguments for pan gesture entered node area message |
| CFinishedMessageArguments | Message arguments for pan gesture finished message |
| CLeftMessageArguments | Message arguments for pan gesture left node area message |
| CMovedMessageArguments | Message arguments for moved message sent during pan gesture |
| CStartedMessageArguments | Message arguments for pan gesture started message |
| CPanManipulatorComponent | PanManipulatorComponent installs a PanManipulator to a node |
| CParallelActivityHost2D | An Activity Host that can display multiple Activity nodes at a time |
| CParallelActivityHost3D | An Activity Host that can display multiple Activity nodes at a time |
| ►CParallelActivityHostConcept | This is the base class for Parallel Activity Host nodes |
| CActivityInParallelHostInfo | Stores information that identifies an Activity node under a ParallelActivityHost |
| CActivityInParallelHostPrefabLoader | Extends ActivityPrefabLoader with a specialized behavior for child Activity nodes of a ParallelExclusiveActivityHost |
| CParallelActivityHostContentHandler | Helper class used to modify the ParallelActivityHostContent of a ParallelActivityHost |
| CParallelActivityHostImpl | ParallelActivityHostConcept implementation class |
| CParallelTimeline | Kanzi animation system consists of animations and timelines: |
| CParallelTimelinePlayback | Playback control class for parallel timelines |
| CPatchingNotificationHandler | Patching notification handler interface |
| CPerformanceInfo | HUD class allows drawing information on top of tests |
| CPerformanceInfoProperties | Configurable performance info display properties |
| ►CPinchManipulator | Pinch input manipulator recognizes the pinch gesture from the incoming touch events |
| CCanceledMessageArguments | Message that notifies about the cancellation of the pinch gesture |
| CFinishedMessageArguments | Message arguments for pinch gesture finished message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CMovedMessageArguments | Message arguments for moved message sent during pan gesture. Inherits argument properties from InputManipulator::InputMessageArguments |
| CStartedMessageArguments | Message arguments for pinch gesture started message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CPipelineStateRenderPass | Use the Pipeline State Render Pass to set for its child render passes the depth and stencil testing, transparency, and culling |
| CPlane | The equation of a plane in 3D space is defined with a normal vector (perpendicular to that plane) and a known point on the plane |
| CPlanePlaneIntersection | Stores the intersection of two planes |
| CPlaneRayIntersection | Stores the result of an intersection between a plane and a ray |
| CPlugin | |
| CPointerEvent | The event holds a pointer event data and typically originates from a mouse or other pointing device |
| CPortal | Portal node |
| CPowerEasingFunction | Changes the value with a configurable power function using the function f(t) = t^p, where p is equal to the power parameter |
| CPrefabTemplate | A prefab template contains information that is required to create a tree of Node instances |
| CPrefabTemplateNode | A prefab template node contains information that is required to create node instances: the metaclass of the node, the (initial) property values of the node, information about the bindings and node components of the node, and the list of of child nodes |
| CPrefabView2D | Prefab view 2D node |
| CPrefabView3D | Prefab view 3D node |
| ►CPrefabViewConcept | Prefab view concept class |
| CAsynchronousLoadCompletedMessageArguments | Message arguments |
| CLoadAsynchronouslyMessageArguments | Message arguments |
| CPrefabViewConceptImpl | Base class for prefab views |
| CPreviewTimeline | Preview timeline, |
| CPreviewTimelinePlayback | Preview timeline playback controls child timeline playbacks based on preview instructions |
| CProfilerRegistry | Profiler registry |
| CProfilingCategory | Represents the runtime state of the profiling category |
| CProfilingScopeHelper | The profiling scope helper |
| CProgressiveRenderingViewport2D | Progressive rendering viewport 2D is a viewport which splits rendering its scene across multiple frames |
| ►CPropertyAccessRange | Property access range wraps the access of properties from another range |
| CPropertyAccessRangeLocation | Location implementation for property access range |
| CPropertyAnimationTimeline | The Kanzi animation system consists of animations, which define how to animate properties, and timelines, which map animations to time and to the objects that you want to animate |
| CPropertyAnimationTimelinePlayback | Playback class for PropertyAnimationTimeline |
| CPropertyDataTypeTraits | |
| CPropertyDataTypeTraits< AbstractRangeSharedPtr > | |
| CPropertyDataTypeTraits< bool > | |
| CPropertyDataTypeTraits< ColorRGBA > | |
| CPropertyDataTypeTraits< float > | |
| CPropertyDataTypeTraits< int > | |
| CPropertyDataTypeTraits< Matrix3x3 > | |
| CPropertyDataTypeTraits< Matrix4x4 > | |
| CPropertyDataTypeTraits< ResourceSharedPtr > | |
| CPropertyDataTypeTraits< SRTValue2D > | |
| CPropertyDataTypeTraits< SRTValue3D > | |
| CPropertyDataTypeTraits< string > | |
| CPropertyDataTypeTraits< Vector2 > | |
| CPropertyDataTypeTraits< Vector3 > | |
| CPropertyDataTypeTraits< Vector4 > | |
| CPropertyDataTypeTraits< void * > | |
| CPropertyDrivenAnimationPlayer | Use Property Driven Animation Player when you want to use a property type to control a keyframe animation |
| ►CPropertyFieldAnimationTimeline | Kanzi animation system consists of animations and timelines: |
| CEntry | Structure holding the property field which is to be animated, and its associated animation |
| CPropertyFieldAnimationTimelinePlayback | Playback control class for Property Field Animation timelines |
| CPropertyFieldTargetInterpolationTimelinePlayback | Playback for property target interpolation timeline for interpolating specific property field |
| CPropertyIsEqualFilter | Use the Property Is Equal Filter to collect 3D nodes that contain, or do not contain a specific property whose value matches a specific value |
| CPropertyIsEqualFilterRuntime | Runtime for contains property node filter |
| CPropertyListener | |
| CPropertyModifierBindingTargetRuntime | Base class for property modifier binding target runtimes |
| CPropertyObject | PropertyObject is the base class that supports setting and retrieving of property types |
| CPropertyObserver | Helper class for observing certain property in nodes |
| ►CPropertyTargetEasingInterpolator | Use a Property Target Easing Interpolator when you want to create a smooth transition between the current value of a property and a value that you set dynamically |
| CSetEnabledMessageArguments | Message arguments for the PropertyTargetEasingInterpolator::SetEnabledMessage message |
| CPropertyTargetEasingTimeline | Property Target Easing Timeline interpolates a property gradually from its old value to a new value using an easing curve each time a new value is set to the property |
| CPropertyTargetEasingTimelinePlayback | Playback for PropertyTargetEasingTimeline |
| CPropertyTargetInterpolationTimeline | Property target interpolation timeline is a timeline that gradually interpolates specified property from its old value to new one each time new value is set to the property |
| CPropertyTargetInterpolationTimelinePlayback | Playback for property target interpolation timeline |
| ►CPropertyTargetInterpolator | Use a Property Target Interpolator when you want to dynamically set the target value of a property and want to interpolate the current value to the target value over time |
| CCompletedMessageArguments | Message arguments for Completed message |
| CPropertyType | An instance of a PropertyType represents a single property type in the Kanzi property system |
| ►CPropertyType< Type, typename enable_if< is_enum< Type >::value >::type > | Specialization for PropertyType for enums. See PropertyType |
| CTraits | |
| ►CPropertyTypeDescriptor | PropertyTypeDescriptor is used internally by the property system to implement all operations required for property types that have the same data type |
| CTypedModifierEntry | |
| CTypedModifierStorage | |
| CTypedNotificationEntry | |
| ►CTypedNotificationStorage | |
| CCleanupFunctor | Functor for cleaning up stale notification entries |
| CTypedValueSource | |
| ►CPropertyTypeEditorInfo | Editor information for metadata |
| CAttributeDictionary | |
| CQnxLogger | |
| CQuadDescription | Use QuadDescription to create renderable quad geometry |
| CQuadraticEasingFunction | Changes the value based on the square of time using the function f(t) = t^2 |
| CQuarticEasingFunction | Changes the value based on the 4th order polynomial using the function f(t) = t^4 |
| CQuaternion | Quaternions represent rotation around an axis, defined by quaternion components x, y, z and w |
| CQuaternionLongerPath | Quaternion for interpolating rotation along longer path |
| CQuinticEasingFunction | Changes the value based on the 5th order polynomial using the function f(t) = t^5 |
| CRangeAccumulateBindingProcessor | Runs a binary operation for each value in a range in sequence |
| CRangeAccumulateBindingProcessorRuntime | Holds the runtime state of a RangeAccumulateBindingProcessor |
| CRangeBindingProcessor | Range binding processor is a binding processor for accessing properties from property objects in ranges |
| CRangeBindingProcessorRuntime | Holds the runtime state of a RangeBindingProcessor |
| ►CRangeConcept | RangeConcept represents a number range with an optional step |
| CCommonMessageArguments | |
| CValueChangedMessageArguments | |
| CValueChangeFinishedMessageArguments | |
| CValueChangeStartedMessageArguments | |
| CRangeConceptImpl | |
| CRay | Ray can be mathematically defined as a point (the origin of the ray in space) and a direction |
| CRayBoxIntersection | Stores the result of an intersection between a box and a ray |
| CReadOnlyDiskFile | Implements the File interface for files residing on a disk |
| CReadOnlyMemoryFile | (read-only) file interface to a block of memory |
| CRectangle | 2-dimensional integer rectangle |
| CReferenceCountScopeGuard | Reference count scope guard |
| CRelativeNodeResolver | Enables you to get the current node in relative path |
| ►CRenderbuffer | Renderbuffers provide the images that can be rendered to by attaching them to the framebuffer as color or depth stencil images |
| CCreateInfo | Renderbuffer creation parameters |
| CRenderEntry3D | Host container for render states for 3D rendering |
| CRenderEntryRegistry | Registry used to keep track of DrawObjectsRenderPass objects that contain render entries |
| ►CRenderer | |
| CRendererSettings | Settings structure for renderer construction |
| ►CTextureUnitInfo | Texture unit information structure |
| CBoundTextureHandle | Structure for tracking bound texture handles |
| CRenderer3D | Renderer is the core component for assigning lights, meshes, cameras, skin animations etc. to lower level rendering |
| CRendererStatisticsScope | |
| ►CRenderPass | RenderPass is the base class for Kanzi render passes |
| CCameraSettings | Camera settings structure |
| CRenderPassPrefab | Use render pass prefabs to create render pass trees that define how Kanzi renders 3D content in your project |
| CRenderPassTemplate | Use RenderPassTemplate to instantiate a single render pass |
| CRenderPassView | Use the Render Pass View to instantiate a RenderPassPrefab |
| CRenderPropertyBindingSource | Render property binding source |
| CRenderPropertyBindingSourceRuntime | Runtime for RenderPropertyBindingSource |
| CRenderPropertyExpressionValueSource | Render property expression value source |
| CRenderPropertyExpressionValueSourceRuntime | Runtime for render property expression value source |
| CRenderStatePropertyNotificationHandler | Render value updater for render state |
| CRenderValueBindingTargetRuntime | Runtime for render value binding target |
| CRenderValuePropertyNotificationHandler | Render value updater for individual render values |
| CRenderValuePropertyNotificationHandlerBase | Base class for notification handlers for render values and render state values (through handles) |
| CResource | Represents the base class for all resources |
| CResourceBindingProcessor | Resource binding processor creates a resource reference that is used to resolve a string into a resource |
| CResourceBindingProcessorRuntime | Holds the runtime state of a ResourceBindingProcessor |
| CResourceBindingSource | Resource binding source |
| CResourceBindingSourceRuntime | Runtime for object property binding source |
| CResourceDictionary | A resource dictionary is a container that maps resource IDs to resources |
| CResourceDictionarySelector | A resource dictionary selector is a type of a resource dictionary that redirects resource queries to its only nested dictionary |
| CResourceID | Resource ID |
| CResourceLoaderFactory | Factory for resource loader tasks |
| CResourceLoaderThreadContext | Resource loader thread local data |
| ►CResourceManager | Use the resource manager to access and use resources in kzb files |
| CAcquireTask | Load task for a group of resources |
| CFinishingQueue | Collection of resource loading tasks that have been already been loaded by a loader thread and are waiting to be finished by the main thread |
| CLoadTask | Use this base class to implement the load tasks that load new resources |
| CResourceProfiler | The resource profiler |
| ►CResourceProfilingAcquireContext | The profiling context of resource acquirement |
| CSampler | The context sampler |
| CResourceProfilingAttributes | Container for resource profiling attributes |
| CResourceProfilingContext | The resource profiling context |
| ►CResourceProfilingContextFactory | Resource profiling context factory |
| CAbstractSampler | Abstract resource profiling context sampler |
| ►CResourceProfilingDataSample | The resource profiling data sample |
| CFactory | The resource factory |
| ►CResourceProfilingDeployContext | The profiling context of resource deployment |
| CSampler | The context sampler |
| ►CResourceProfilingLoadContext | The profiling context of resource loading |
| CSampler | The context sampler |
| CResourceProfilingLoadTask | Resource profiling wrapper for load task |
| ►CResourceProfilingMainLoopContext | The main loop resource profiling context |
| CSampler | The context sampler |
| CResourceProfilingPtreePopulator | Resource profiling ptree populator |
| CResourceReference | |
| ►CSampler | Sampler provides the sampling parameters, such as minification and magnification filters, mipmap mode, and texture addressing mode for textures |
| CCreateInfo | |
| CScene | Scene is a 3D node that is the root node for other 3D nodes |
| CSceneGraphTimelinePlaybackContext | Helper class to resolve objects for animation timelines |
| CScopedRefCounter | Scoped reference counter, which takes an unsigned integer value as argument on construction to track |
| CScopeValue | ScopeValue template class sets a value to a variable of Type for the lifetime of the ScopeValue object, and restores the previous value of the variable when destroyed |
| ►CScreen | The screen represents the metrics of the target device and acts as the root node for the whole node tree |
| CActivateThemeMessageArguments | |
| CScrollView2D | Use the Scroll View 2D node to create an input plane to enable user input from gestures |
| CScrollView3D | Use the Scroll View 3D node to create an input plane to enable user input from gestures |
| ►CScrollViewConcept | ScrollViewConcept is the base class that provides the functionality for the ScrollView2D and ScrollView3D classes |
| CScrollDirectionMessageArguments | |
| CScrollDownMessageArguments | Message arguments used by the ScrollDownMessage |
| CScrollEdgeMessageArguments | |
| CScrolledMessageArguments | |
| CScrollEndMessageArguments | Message arguments used by the ScrollEndMessage |
| CScrollFinishedMessageArguments | |
| CScrollHomeMessageArguments | Message arguments used by the ScrollHomeMessage |
| CScrollLeftMessageArguments | Message arguments used by the ScrollLeftMessage |
| CScrollMessageArguments | |
| CScrollPageDownMessageArguments | Message arguments used by the ScrollPageDownMessage |
| CScrollPageMessageArguments | |
| CScrollPageUpMessageArguments | Message arguments used by the ScrollPageUpMessage |
| CScrollPositionMessageArguments | |
| CScrollRightMessageArguments | Message arguments used by the ScrollRightMessage |
| CScrollStartedMessageArguments | |
| CScrollTargetMessageArguments | |
| CScrollUpMessageArguments | Message arguments used by the ScrollUpMessage |
| CSetScrollMessageArguments | |
| CSetScrollTargetMessageArguments | |
| CSnapMessageArguments | |
| CSnapRequestMessageArguments | |
| CUserScrollFinishedMessageArguments | |
| CUserScrollStartedMessageArguments | |
| CZoomedMessageArguments | |
| CScrollViewConceptImpl | Implementation class for ScrollViewConcept |
| CSetPropertyAction | SetPropertyAction sets the value of a property of a target node based on: |
| ►CShaderProgram | ShaderProgram defines programmable vertex and fragment operations done by the GPU for a draw call |
| CBindingInfo | Binding info |
| CCreateInfo | Struct that contains all the parameters that Kanzi needs to create a ShaderProgram |
| CCreateInfoProgramBinary | ShaderProgram creation parameters for initialized from vendor specific GL program binary |
| CCreateInfoShaderBinary | ShaderProgram creation parameters for initialized from vendor specific GL shader binary |
| CCreateInfoShaderSources | ShaderProgram creation parameters for initialized from shader source code strings |
| CSamplerInfo | |
| CUniformProperty | |
| CShaderTextureUniform | Specifies single texture uniform entry |
| CShaderVertexAttribute | ShaderVertexAttribute describes the attributes that shader program will read when executed by graphics device |
| CShadowEffect2D | Use ShadowEffect2D to apply drop- and inner-shadow post-processing effects to 2D nodes |
| CShadowEffectRenderer2D | Shadow effect renderer class |
| CSharedImmutableString | Shared immutable string container |
| CSineEasingFunction | Changes the value with a sine formula |
| CSlider2D | Use the Slider 2D node as a building block for a 2D UI control that lets the application user change a numerical value using a visual indicator between a minimum and a maximum value |
| CSlider2DConceptImpl | |
| CSlider3D | Use the Slider 3D node as a building block for a 3D UI control that lets the application user change a numerical value using a visual indicator between a minimum and a maximum value |
| CSlider3DConceptImpl | |
| CSliderConcept | SliderConcept contains the trajectory ResourceID property |
| CSliderTrajectoryPresenter | |
| CSmootherStepEasingFunction | Changes the value quickly without instant changes in velocity |
| CSmoothStepEasingFunction | Changes the value quickly without instant changes in velocity |
| CSortByShaderObjectSource | Sort by shader object source |
| CSortByShaderObjectSourceRuntime | Runtime for sort by shader object source |
| CSortByZObjectSource | Z-sorting object source |
| CSortByZObjectSourceRuntime | Runtime for z-sort object source |
| CSortObjectSource | Sort object source |
| CSortObjectSourceRuntime | Base class for sort runtime classes |
| Cspan | |
| CSpeedMeasurer | Speed measurer estimates the rate of change from a series of measurements |
| CSplashScreen | Splash screen |
| CSpline | Spline is a piecewise polynomial curve that defines a path in a 3-dimensional space |
| ►CSplitStringRange | SplitStringRange is a range that iteratively performs a string split |
| CSplitPosition | String position |
| CSplitStringRangeLocation | Location implementation for split string range |
| CSRTValue2D | A structure that describes the scale, rotation and translation transformation in 2D space |
| CSRTValue3D | A structure that describes the scale, rotation and translation transformation in 3D space |
| CSRTValue3DLongerPath | |
| CStackLayout2D | Stack Layout 2D arranges its items on a line along the axis you specify in the DirectionProperty |
| CStackLayout3D | Stack Layout 3D arranges its items on a line along the axis you specify in the DirectionProperty |
| CStackLayoutConcept | Stack layout concept base class |
| CStackLayoutConceptImpl | Stack layout concept implementation base class |
| CStage | Stage instances represent a Stage in the Kanzi main loop |
| CStandardMaterial | Contains property types of Standard material |
| CStandardPbrMaterial | Contains property types for the Kanzi Physically Based Rendering (PBR) shaders |
| CStartupProfilerRegistry | The registry of startup profilers |
| ►CStateManager | State manager for managing states of nodes or application |
| CEasingArguments | Easing function arguments |
| CEnteredStateMessageArguments | Represents message arguments of EnteredState message of state manager |
| CGoToDefinedStateMessageArguments | Represents message arguments of GoToNextDefinedState message of state manager |
| CGoToNextDefinedStateMessageArguments | Represents message arguments of GoToNextDefinedState message of state manager |
| CGoToPreviousDefinedStateMessageArguments | Represents message arguments of GoToPreviousDefinedState message of state manager |
| CGoToStateMessageArguments | Represents message arguments of GoToState message of state manager |
| CLeftStateMessageArguments | Represents message arguments of LeftState message of state manager |
| CState | |
| CStateChangeMessageArguments | |
| CStateGroup | |
| CStateGroupRuntime | State group runtime |
| CStateManagerMessageArguments | Represents base message arguments of state manager messages |
| CStateManagerRuntime | |
| CStateObject | |
| CStateObjectRuntime | State object runtime |
| CStateRuntime | State runtime |
| CStateTransition | |
| CStateTransitionAnimation | |
| CTargetObject | TargetObject |
| CTransitionFinishedMessageArguments | Represents message arguments of TransitionFinished message of state manager |
| CTransitionMessageArguments | |
| CTransitionStartedMessageArguments | Represents message arguments of TransitionStarted message of state manager |
| CStepEasingFunction | Changes the value instantly |
| CStopWatch | Stop watch is a class for measuring time |
| ►CStyle | Style applying properties, node components and bindings to nodes |
| CBindingInfo | Stored info for a binding |
| CSurface | Surfaces provide images for Framebuffers where to render to |
| CTag | Tag represents a mark that can be added to a node to mark that the node is of certain kind |
| CTagFilter | Use the Tag Filter to collect 3D nodes that have a specific tag assigned |
| CTagFilterRuntime | Runtime for tag filter |
| CTaskDispatcher | Task dispatcher |
| CTaskDispatcherBase | Base class for TaskDispatcher implementation |
| CTextBlock2D | Text Block 2D displays a small amount of text in 2D |
| CTextBlock3D | Text Block 3D displays a small amount of text in 3D |
| CTextBlockConcept | Base class for the Text Block nodes that you can use to show a small amount of text in your application |
| CTextBlockConceptImpl | Implementation class for TextBlockConcept |
| CTextBox2D | TextBox2D provides the required overrides to handle 2D rendering and gesture handling for the 2D text input |
| CTextBox2DTraits | |
| CTextBox3D | TextBox3D provides the required overrides to handle 3D rendering and gesture handling for the 3D text input |
| CTextBox3DTraits | |
| ►CTextBoxConcept | Use the Text Box nodes to add single-line text input to your application |
| CCursorPositionMessageArguments | Message arguments for messages that contain the information about the position index of the cursor position |
| CDeleteSelectionMessageArguments | Message arguments for messages that delete the portion of the text that is selected |
| CEditingStateChangedMessageArguments | Message arguments for the messages about changing the editing state of a Text Box node |
| CEraseCharactersMessageArguments | Message arguments for messages that erase the characters at the cursor position |
| CInputMethodActionMessageArguments | Message arguments for the message about the input method action execution received on a Text Box node |
| CInputMethodAvailableMessageArguments | Message arguments for the InputMethodAvailableMessage and InputMethodUnavailableMessage |
| CModifyEditingStateMessageArguments | Message arguments for the messages that modify the editing state |
| CModifySelectionMessageArguments | Message arguments for the messages that modify the cursor position for a selection |
| CMoveCursorMessageArguments | Message arguments for messages that move the cursor position |
| CSelectedTextMessageArguments | Message arguments that hold the information about the selected text in the buffer of a Text Box node |
| CTextChangedMessageArguments | Message arguments for the messages about the content change of a Text Box node |
| CTextCompositionStateMessageArguments | Message arguments for the messages about the text composition state change of a Text Box node |
| CTextContentMessageArguments | Message arguments for the messages about the content of a Text Box node |
| CTextInsertionMessageArguments | Message arguments that hold the information for inserting text to a Text Box node |
| CTextRangeMessageArguments | Message arguments that hold the information for operations that target a text range, such as selecting or deleting text in a Text Box node |
| CTextBoxConceptImpl | TextBoxConceptImpl is an abstract class for implementing the Text Box node concept |
| ►CTextConcept | TextConcept is the base class for the nodes that implement text rendering |
| CTextFormatParameters | Structure that holds the parameters that TextConceptImpl::prepareTextFormat() needs |
| CTextConceptImpl | TextConceptImpl provides the common base implementation for text rendering nodes |
| CTextEditBuffer | TextEditBuffer is a model for text input |
| CTextFormat | Text format combines the data required for text layouting and the data required for rendering the text |
| CTextInputGesture | The text input key gesture |
| CTextInputLayout | Use TextInputLayout to precalculate information on text layout properties, such as glyph directionality, width, buffer index to glyph mapping, and so on |
| ►CTextInputManipulator | The text input manipulator handles key gestures used with TextBox nodes to move the cursor, select text, and delete text, and provides the basics of text editing capabilities in Kanzi |
| CCursorMovedMessageArguments | Message arguments used by the CursorMovedMessage |
| CInputMethodActionMessageArguments | Message argument used by the InputMethodActionMessage |
| CInputMethodAvailableChangedMessageArguments | Message argument used by the InputMethodAvailableChangedMessage |
| CInputMethodsDisconnectedMessageArguments | Message argument used by the InputMethodsDisconnectedMessage |
| CInputTypeChangedMessageArguments | Message argument used by the InputTypeChangedMessage |
| CReadOnlyStateChangedMessageArguments | Message argument used by the ReadOnlyStateChangedMessage |
| CSelectionChangedMessageArguments | Message arguments used by the SelectionChangedMessage |
| CTextChangedMessageArguments | Message argument used by the TextChangedMessage |
| CTextCompositionStateMessageArguments | Message argument used by the CompositionTextChangedMessage, CompositionTextCommittedMessage and TextCompositionCanceledMessage |
| CTextLayout | Structure for layout of arbitrary number of characters for text rendering |
| ►CTextLayouter | Use the TextLayouter to create layouts for display text strings, including line breaks, bidirectional text shaping, and similar |
| CCharacterInfo | Intermediate structure for layout of a single character |
| CIntermediateLayout | Intermediate structure for the layout of the text where the characters have not yet been positioned |
| CLineInfo | Structure for holding data about text lines |
| CTextManager | Use the TextManager class to: |
| CTextResource | Text resource |
| CTextShaper | TextShaper encapsulates different shaping libraries, used by TextLayouter to perform BiDi layouting, text shaping and glyph substitution |
| ►CTexture | Textures provide images that can be used with image nodes, texture brushes and materials for use in 3D rendering or material brushes |
| CCreateInfo | Struct which contains all the parameters that are needed for texture creation |
| CCreateInfo2D | Texture creation parameters for two dimensional texture |
| CCreateInfoCubemap | Texture creation parameters for cubemap texture that is initialized from six images |
| CCreateInfoHostCopy2D | Texture creation parameters for two dimensional texture that is updated from the CPU |
| CCreateInfoNode2DRenderTarget | Texture creation parameters for texture that can be used as render target for 2D nodes |
| CCreateInfoRenderpassRenderTarget | Texture creation parameters for texture that can be used as render target for renderpasses |
| CTextureBrush | Texture brush class |
| CTextureBrushRenderer | Texture brush renderer class |
| CTextureSwizzleMask | Texture swizzle mask |
| CTimeInterval | Interval in time specified as start and end timestamps |
| CTimeline | The Kanzi animation system consists of animations and timelines: animations define how the values of specific type change in time, and timelines map the animations to properties of objects you want to animate |
| CTimelineClock | Use TimelineClock to update a Timeline based on time |
| CTimelinePlayback | Playback object for Timelines |
| CTimelinePlaybackContext | Use TimelinePlaybackContext helper interface class to defines the context of an animation playback |
| CTimelineResource | A Resource wrapper class for animation timelines |
| CTimerTrigger | Timer Trigger |
| CToggleButton2D | Use the Toggle Button 2D node to create a 2D UI control that the user can interact with through clicking, tapping, or pressing a keyboard key, and that has multiple toggle states |
| CToggleButton3D | Use the Toggle Button 3D node to create a 3D UI control that the user can interact with through clicking, tapping, or pressing a keyboard key, and that has multiple toggle states |
| CToggleButtonGroup2D | Toggle Button Group 2D allows users of your application to select only one option from a set of options that are mutually exclusive |
| CToggleButtonGroup3D | Toggle Button Group 3D allows users of your application to select only one option from a set of options that are mutually exclusive |
| ►CToggleButtonGroupConcept | Use a Toggle Button Group to control a collection of Toggle Buttons so that only one Toggle Button can be toggled on at a time |
| CToggleButtonGroupConceptMessageArguments | |
| CToggledMessageArguments | |
| CToggleButtonGroupConceptImpl | Implementation class for ToggleButtonGroupConcept |
| CToSourceBinding | To Source bindings are one-way bindings that have an extra source to which to write the result value |
| CToSourceBindingRuntime | Runtime for ToSourceBinding |
| ►CTouchEvent | The event holds the information about a touch event occurrence |
| CTouchPoint | Holds information about a touch point, such as a finger |
| CTouchPoint | The structure describes the attributes for a touch point or mouse hit |
| CTouchPointIdEquals | Helper predicate functor which you can use to search for a touch point within a touch point container using the identifier of a touch point |
| CTouchPointStateEquals | Helper predicate functor which you can use to search within a touch point container using the state of a touch point |
| CTrajectory | Trajectory defines a series of points following a geometrical path |
| CTrajectory2DInputHandler | |
| CTrajectory2DInputLogic | |
| CTrajectory3DInputHandler | |
| CTrajectory3DInputLogic | |
| CTrajectoryLayout2D | Trajectory Layout 2D arranges its items along a trajectory |
| CTrajectoryLayout3D | Trajectory Layout 3D arranges its items along a trajectory |
| CTrajectoryLayoutConcept | Base class for TrajectoryLayout classes |
| CTrajectoryLayoutConceptImpl | TrajectoryLayoutConceptImpl provides the common base implementation for Trajectory Layout nodes |
| CTrajectoryListBox3D | Use the Trajectory List Box 3D node to create scrollable lists of items arranged along a Trajectory |
| CTrajectoryListBox3DTraits | |
| CTrigger | Trigger is the base class for defining events, conditions and actions for content-driven logic programming |
| CTriggerTemplate | TriggerTemplate is the base class for trigger templates |
| CTrySetFocusAction | Use the TrySetFocusAction action to transfer focus to any focusable item in a node tree |
| CTwoWayBinding | Two-way binding causes changes to either the source value or the target value to automatically update the other |
| CTwoWayBindingRuntime | Runtime for two-way binding |
| CTypedManualBindingSourceRuntime | Typed runtime for manual binding source |
| CTypedManualBindingTargetRuntime | Typed runtime for manual binding target |
| CTypedMessageBindingSourceRuntime | Runtime for message binding source |
| CTypedMessageBindingTargetRuntime | Typed runtime for message binding target |
| CTypedObjectPropertyBindingSourceRuntime | Runtime for object property binding source |
| CTypedObjectPropertyExpressionValueSourceRuntime | Typed runtime for object property expression value source |
| CTypedPropertyModifierBindingTargetRuntime | Specialized binding target for property modifiers installed to objects |
| CTypedRenderPropertyBindingSourceRuntime | Runtime for render property binding source |
| CTypedRenderPropertyExpressionValueSourceRuntime | Typed runtime for render property expression value source |
| CTypedRenderStatePropertyNotificationHandler | Specialized property state and value container for render state |
| CTypedRenderStatePropertyNotificationHandler< TextureSharedPtr > | TypedRenderStatePropertyNotificationHandler specialization |
| CTypedRenderValueBindingTargetRuntime | Typed runtime for render value binding target |
| ►CTypedValueRange | TypedValueRange is a template class for holding one type of object in a range |
| CTypedValueRangeLocation | Location implementation for typed value range |
| CTypedValueSourceBindingTargetRuntime | Specialized binding target for value sources where the binding target itself is the value source |
| CTypedVariableBindingSourceRuntime | Typed runtime for variable binding source |
| CTypedVariableBindingTargetRuntime | Typed runtime for variable binding target |
| CTypedVariableExpressionValueSourceRuntime | Typed runtime for variable expression value source |
| CUsingIntrusivePtr | Class that should be inherited by objects using intrusive_ptr |
| ►CValueAccumulatorBase | ValueAccumulatorBase is the base class for the Value Accumulator implementations for different data types |
| CPauseMessageArguments | Message arguments for the Pause message |
| CResumeMessageArguments | Message arguments for the Resume message |
| CStartMessageArguments | Message arguments for the Start message |
| CStopMessageArguments | Message arguments for the Stop message |
| CValueAccumulatorTimeline | Use ValueAccumulatorTimeline to create an animation that continuously adds the value of the input property to the target property |
| CValueAccumulatorTimelinePlayback | Playback for ValueAccumulatorTimeline |
| CValueAnimation | Interface template for value animations |
| CValueBindingSource | Constant value as binding source |
| CValueBindingSourceRuntime | Runtime for ValueBindingSource |
| CValueControlledExclusiveActivityHostConcept | Base class for the Exclusive Activity Host classes |
| ►CValueRange | ValueRange is an abstract range implementation that stores variant values |
| CValueRangeLocation | Location implementation for typed value range |
| CValueSourceBindingTargetRuntime | Base class for value source binding target runtimes |
| CVariableBindingHost | Binding variable host |
| CVariableBindingSource | Variable binding source |
| CVariableBindingSourceRuntime | Runtime for variable binding source |
| CVariableBindingTargetRuntime | Variable binding target runtime |
| CVariableExpressionValueSource | Variable expression value source |
| CVariableExpressionValueSourceRuntime | Runtime for variable expression value source |
| CVariant | Union container for manipulating an object from a heterogeneous set of types in a uniform manner |
| CVector2 | Vector with 2 floating point components: (x, y) |
| CVector3 | Vector with 3 floating point components: (x, y, z) |
| CVector4 | Vector with 4 floating point components: (x, y, z, w) |
| CVertexAttribute | A base class for mesh and shader program vertex attributes |
| CViewport2D | Use a Viewport 2D to set the size of a render target surface onto which content is projected |
| CViewport3D | Use a Viewport 3D to set the size of a render target surface onto which content is projected |
| ►CViewRange | View over another range |
| CViewRangeLocation | Location class for indexed view range |
| CViewRangeImpl | View range internal implementation class |
| CVisitorFunction | Wraps a focus scope visitor function into a FocusScopeVisitor |
| CVulkanGraphicsOutput | VulkanGraphicsOutput class |
| CWatermark | Watermark |
| CWin32DebugLogger | This logger class writes log messages to the Windows debugger console |
| CWindowedGraphicsOutput | WindowedGraphicsOutput class |
| CWindowEvent | Holds window specific events |
| CWindowRedrawRequestEvent | Specialized window event with InputEvent::WindowRedrawRequest type |
| CWindowResizedEvent | Specialized window event with InputEvent::WindowResized type |
| CWindowResizeRequestEvent | Specialized window event with InputEvent::WindowResizeRequest type |
| CWindowsIme | |
| CWindowsImeBackend | |
| CWriteLogAction | Use the WriteLogAction class to attach logging functionality to a trigger |
| CWriteOnlyDiskFile | Implements the File interface for writing files to a disk |
| ►Nwindowing | |
| CPosition | |
| CPositionF | |
| CPositionU | |
| CRegion | |
| CSize | |
| CSizeU | |
| Chash< kanzi::AbstractPropertyType > | Specialization of std::hash for AbstractPropertyType |
| Chash< kanzi::ResourceID > | |
| Chash< kanzi::string_view > | Hash for string_view |
| CKzsDesktop | Desktop object |
| CKzsDisplay | Display device object |
| CKzsInputDevice | Input device object |
| CKzsInputDeviceNative | Native implementation of input device |
| CKzsResourceFile | Resource structure |
| CKzsSurface | Surface for graphics output |
| CKzsSurfaceConfiguration | Configuration data for surfaces and windows |
| CkzsSurfaceConfigurationNativeFunctions | |
| CkzsSurfaceNativeFunctions | |
| CKzsSurfaceProperties | Properties for a surface |
| CKzsWindow | Kanzi window structure |
| CKzuEngine | Structure for graphics engine core functionality. Handles the state machine, pipeline and storage specific functionality |
| CKzuVirtualItemIterator | Iterator for KzuVirtualItemList |
| CKzuVirtualItemList | A virtual collection of items that supports iteration |
