Actions are small operations that Kanzi executes when the trigger event that contains that action occurs
and the trigger conditions are met. Action is the base class for actions. For example, if you want to perform
a simple operation, such as set a value of a property, you can use a trigger with the SetPropertyAction
action.
An Activity is a part of application UI that is responsible for a task.
For example, a media player application can have Activity nodes, such as radio, music player, and AUX.
However, an Activity can also be a smaller task, such as an Activity for the popup volume indicator that appears only when the user changes the volume in a media player.
An Activity can be visual, but does not have to be.
For example, an Activity that is visual can instantiate a prefab to show a popup window, while an Activity that is not visual can be music playback which plays music in the background regardless of other Activity nodes.
An Activity is a part of application UI that is responsible for a task.
For example, a media player application can have Activity nodes, such as radio, music player, and AUX.
However, an Activity can also be a smaller task, such as an Activity for the popup volume indicator that appears only when the user changes the volume in a media player.
An Activity can be visual, but does not have to be.
For example, an Activity that is visual can instantiate a prefab to show a popup window, while an Activity that is not visual can be music playback which plays music in the background regardless of other Activity nodes.
ActivityCodeBehind is code that is associated with a particular Activity node, and has access to the properties of that Activity node.
You can use this to:
Animation binding processor executes an animation and calculates the value for use in expression bindings.
The processor itself is not executed unless an operation code within binding operation codes refers to it by index.
Use the Animation Player to play back an animation timeline that you set using the
TimelineProperty property in that Animation Player. Kanzi resolves paths to animated nodes
relative to the node where you attach an Animation Player.
Base abstraction for Actions for DataTrigger, such as ForwardingApplyAction and ApplyActivationAction.
An ApplyAction applies the changes described in the Action on apply(), and reverts them on unapply().
An ApplyActivationAction keeps an Activity node activated for as long as the condition is met in
a DataTrigger that contains this action. When the trigger condition is no longer met, Kanzi rolls back the state of
the Activity node to the state before the action was applied. Use the ApplyActivationAction only with a DataTrigger.
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. When the trigger condition is no longer met, Kanzi rolls back the value
of that property to the value before the action was applied, or to the value set while Kanzi was
applying an ApplyPropertyAction. Use the ApplyPropertyAction only with a DataTrigger.
Binding is the simplest form of binding. It performs a copy from source to target without caching the
value. To learn more about bindings, see AbstractBinding.
Font implementation for bitmap fonts. Supported bitmap fonts consist of a plain text fnt definition file
and one or more bitmaps containing the pre-rendered glyphs at a certain size.
Image is the basic runtime primitive to load, hold, and convert image data in memory.
Each image has width, height, pixel format, image data in memory, and can contain mipmap images.
Use the Blit Render Pass to blit one or more textures to the screen of the current rendering context using
a material. After the blit operation, a Blit Render Pass passes the control to its descendants and then
further to its siblings and parent.
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.
Click input manipulator recognizes the click and tap gestures from the incoming touch events.
The click manipulator generates the messages required to implement the logic for UI elements
that users can click or tap. For example, use the input manipulator to create a button.
ClickManipulatorComponent installs a ClickManipulator to a node. Use ClickManipulatorComponent to
enable nodes to react to click and touch input events and to control
the behavior of the installed ClickManipulator.
Code Behind is a workflow where you associate code with an instance of a node instead of a type.
In Code Behind you write code that you want to associate with the view or controller parts of the model-view-controller pattern.
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. If you set multiple composition targets,
rendering can write to all specified buffers at the same time.
See MultipleCompositionTargets “Using multiple composition targets”.
After Kanzi renders the descendant render passes of a Composition Target Render Pass, the Composition Target
Render Pass restores the earlier composition settings.
Use the Content Layout 2D node to present content in a 2D UI control as a single item.
You can use the Content Layout 2D node to create a control that adapts to the size of its content,
or a control where the content adapts to the size of the control.
Use the Cubemap Render Pass to create a cubemap texture that represents the scene from some location.
You can use the result of the Cubemap Render Pass as a cubemap texture. For example, use the Cubemap
Render Pass to create dynamic reflections of the environment on the surface of 3D nodes.
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.
A child Activity node of a Data-Driven Exclusive Activity Host uses the prefab set in the ActivityTemplateProperty.
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.
A child Activity node of a Data-Driven Exclusive Activity Host uses the prefab set in the ActivityTemplateProperty.
DataObject is the base class for data.
All data within the data source is described as a tree of data objects.
The base class provides support for the hierarchy as the derived classes provide support for different value types.
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. Kanzi allows you to define the
format and structure of your data source by defining a Kanzi Engine data source plugin.
Use a DataTrigger to apply an action to either set a property value of a target node or activate an Activity node. A DataTrigger keeps that action applied for as long as the condition in that DataTrigger is met. When the condition in that DataTrigger is no longer met, Kanzi reverts the changes that it applied using that DataTrigger. Note that in a DataTrigger you can use only ApplyAction actions: ApplyActivationAction and ApplyPropertyAction.
Use the Dock Layout 2D node to place nodes relative to each other along the sides of a Dock Layout 2D node.
To set the side along which you want to place a node in a Dock Layout 2D node, use the
DockLayoutConcept::SideProperty property.
Use the Dock Layout 3D node to place nodes relative to each other along the sides of a Dock Layout 3D node.
To set the side along which you want to place a node in a Dock Layout 3D node, use the
DockLayoutConcept::SideProperty property.
Drag-and-drop input manipulator recognizes the drag-and-drop gesture from incoming touch events. It generates messages required to
implement the logic for objects which react to the drag-and-drop gesture. For example, use the drag-and-drop input manipulator to
move objects in an application.
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. The Draw Objects Render Pass renders objects from the
object source you set in the ObjectSourceProperty property with the Camera node that the
Scene node uses. The Camera node that a Draw Objects Render Pass uses must be in the same
Scene node as the objects that the Draw Objects Render Pass renders.
Use trigger conditions to set which conditions must be met for a Trigger to set off. For example, you can define
conditions to set off a trigger when the user navigates to a specific Page node, enable the user to click a button
only when that button is visible, or enable the user to scroll a Scroll View node only when a specific Page node is
active.
The base class for the Kanzi input manipulators. Use the input manipulators to recognize gestures,
such as click or pinch, or hardware key gestures from incoming events. Kanzi has specialized subclasses
to handle touch gestures and hardware key gestures. Kanzi converts and handles mouse events as touch
gestures.
Kanzi uses C++ std::string internally, and its internal representation differs from the Rust
String type. Rust strings represent a sequence of UTF-8 code points, while C++ strings are
an array of c_char.
KeyManipulator class is a key input manipulator that detects key gestures. Kanzi recognizes a
key gesture when it receives an event with a key code and an optional key modifier. When Kanzi
recognizes a key gesture, an input manipulator:
Keyboard declares the messages dispatched to the nodes when Kanzi handles a hardware key event.
The key events handled by Kanzi are the press and release events. These key events are converted into
KeyDownMessage and KeyUpMessage, that includes the translated logical key value and the key modifiers.
Key modifiers are special keys that modify the logical key meaning when pressed together with that
logical key.
Deprecated: In Kanzi 3.8. To handle key messages, use KeyManipulator.
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.
Long-press input manipulator recognizes the long-press gesture from the incoming touch events. It generates the required messages to
implement logic for nodes that react to the long-press gesture. For example, use the long-press input manipulator to open a context menu.
LongPressManipulatorComponent installs a LongPressManipulator to a node. Use LongPressManipulatorComponent to
enable nodes to react to long press and touch input events and to control the behavior of the installed
LongPressManipulator.
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.
A material is an instance of a material type (ShaderProgram) that contains the property values for the material type properties.
These values can be overridden in the nodes that use the material.
Mesh stores the geometry data for rendering Model3D nodes. A mesh has one or more clusters. Each cluster has
material and primitives. Primitives are typically triangles stored as vertex data and index data.
MessageArguments is the base class for arguments passed in messages. An instance of MessageArguments together with an
instance of MessageType forms a Kanzi message. In Kanzi when you dispatch a message, you dispatch a message of certain
type and arguments.
An instance of a MessageType represents a single message type in the Kanzi message system.
A message type exists throughout the lifetime of an application.
Multi-click input manipulator recognizes multi-click and multi-tap gestures from incoming touch events. It generates the messages required to
implement the logic for nodes that change the state when users multi-click or multi-tap the node. For example, use the multi-click input
manipulator to zoom in and out a map.
MultiClickManipulatorComponent installs a MultiClickManipulator to a node. Use MultiClickManipulatorComponent to
enable nodes to react to multi-click and multi-touch input events and to control
the behavior of the installed MultiClickManipulator.
The NavigationManipulatorComponent node component installs a NavigationManipulator to a node, and configures the navigation key gestures of the manipulator.
NodeComponent is the base class for all node components.
Node component is an isolated piece of logic which can be attached to any node
in order to add additional functionality to it. Examples of node component could be
Trigger which performs specific actions when certain conditions are met or AnimationPlayer
which animates specific properties of the node it is attached to and its child nodes.
Invokes associated actions on setting of a property type, specified by SourcePropertyTypeProperty, on a source node, specified by SourceNodeProperty.
By default, invocation is performed also when setting to identical values. This behavior can be changed with IgnoreIdenticalValueProperty.
Use Page nodes to create the structure of an application user interface. For example, you can create different parts of the user interface, such as Home, Media Browser, Navigation, or Settings screens, each in their own hierarchy of Page nodes.
Pan input manipulator recognizes a pan gesture from the incoming touch events. It generates
messages for different phases of the pan gesture. You can use these messages to implement the
logic to move nodes, to pan or to flick scrollable content. For example, you can use the pan
input manipulator to scroll a map.
PanManipulatorComponent installs a PanManipulator to a node. Use PanManipulatorComponent to
enable nodes to react to pan events and to control the behavior of the installed PanManipulator.
Pinch input manipulator recognizes the pinch gesture from the incoming touch events. It
generates the required messages to implement the logic for objects which react to the pinch
gesture. For example, use the pinch input manipulator to zoom in or zoom out a map using the
pinch gesture.
Use the Pipeline State Render Pass to set for its child render passes the depth
and stencil testing, transparency, and culling. This render pass sets the rendering
state before passing the control to its descendants. After the descendant render passes
of a Pipeline State Render Pass execute, Kanzi restores the rendering state.
If a Pipeline State Render Pass does not have any descendants, Kanzi does not apply
the rendering state you set in that render pass.
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.
Progressive rendering viewport 2D is a viewport which splits rendering its scene
across multiple frames. Progressive rendering viewport is useful when it is required
to render complex scene which can take significant amount of time when rendered normally
and thus increasing frame time. Progressive rendering viewport renders parts of the scene
frame by frame thus decreasing time required to render the scene per frame.
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.
Use Property Driven Animation Player when you want to use a property type to control a
keyframe animation.
Property Driven Animation Player applies an animation with the time taken from a specific
property in the node, to which you attach the player, every time that property changes.
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. In a Property Target Easing Interpolator you can set the easing
curve, easing mode, and the duration of the transition. When you set a property value without a Property Target
Easing Interpolator, Kanzi applies the value to that property immediately. For example, when you
use the Object::setProperty() function, Kanzi applies the value immediately.
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.
With a Property Target Interpolator you can automatically animate the change of a
property value to achieve a smooth transition. Without a Property Target Interpolator
Kanzi immediately applies a new value to a property. For example, when you
use the Object::setProperty() function, Kanzi immediately applies a new value.
An instance of a PropertyType represents a single property type in the Kanzi property system.
A property type exists throughout the lifetime of an application, including the property types
that you create during the runtime of an application.
Renderbuffers provide the images that can be rendered to by attaching them to the framebuffer as color or depth stencil images.
Unlike textures, you cannot access renderbuffers using the samplers from shaders. When you direct rendering to a framebuffer,
the depth and stencil tests require either renderbuffer or texture attached to the framebuffer.
Represents the base class for all resources.
This base class contains information related to the type of the resource and the
loading status of the resource data. The actual resource data is specific to the sub-classes.
Resource binding processor creates a resource reference that is used to resolve a string into a resource.
The resource binding processor is associated with a resolve instruction in the expression binding, where
the binding uses string input to resolve a binding into a resource value.
When the resolved resource changes, Kanzi updates the binding.
A resource dictionary is a container that maps resource IDs to resources. A node can
refer to resources by setting resource IDs to resource ID properties. You can set a resource
dictionary to the node or to any of its parent nodes to define which resources the node uses.
You can use a resource dictionary to group similar resources to logical entity, such as themes or locales,
and change a resource dictionary of a node to change multiple resources at the same time.
A resource dictionary selector is a type of a resource dictionary that redirects resource queries to its only nested dictionary.
This type of dictionary is used internally by Screen to implement switching of locales and themes in theme groups.
You can use Screen::setLocale to set the current locale and Screen::activateTheme to activate a theme in a theme group.
Use the ResourceManager to access and use resources in kzb files. The resource manager maintains
kzb files and provides mechanisms to load resources from kzb files.
Use the Scroll View 2D node to create an input plane to enable user input from gestures.
For example, you can use the scroll message with its parameters generated by a Scroll View
node to move a map plane or rotate a mesh.
Use the Scroll View 3D node to create an input plane to enable user input from gestures.
For example, you can use the scroll message with its parameters generated by a Scroll View
node to move a map plane or rotate a mesh.
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.
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.
Stack Layout 2D arranges its items on a line along the axis you specify in the DirectionProperty. The default value of the DirectionProperty is x axis.
Stack Layout 3D arranges its items on a line along the axis you specify in the DirectionProperty. The default value of the DirectionProperty is x axis.
Contains property types for the Kanzi Physically Based Rendering (PBR) shaders. Use the PBR
materials to create assets that behave realistically in many lighting conditions. These
properties represent physical properties on a material and are therefore intuitive when
being set.
Many properties have a standard and detail variation that you can use to apply material
properties in layers. The detail maps use DetailTextureTilingProperty and
DetailTextureOffsetProperty to tile differently than the standard map and are typically
used to provide fine detail.
The Occlusion, Metallic, and Roughness maps are designed to read from different color
channels. Therefore it is possible to provide a single texture for all three.
You can use TaskDispatcher to schedule execution of callbacks to the UI thread.
You can access Kanzi UI objects only on the thread that you create them on.
You can wrap code that accesses UI objects with tasks and submit them from any thread to the TaskDispatcher.
The UI thread will execute these tasks during its main loop.
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. For example, you can enable
the application user to:
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.
To Source bindings are one-way bindings that have an extra source to which to write the result value.
To Source binding is the opposite of a regular one-way binding. To Source binding updates the source property
whenever the target property changes.
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.
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.
Toggle Button Group 2D allows users of your application to select only one option from a set of
options that are mutually exclusive. Toggle Buttons in a Toggle Button Group behave like radio
buttons, where only one Toggle Button can be active at a time. Use the CurrentButtonIndexProperty
property to check which Toggle Button in the Toggle Button Group is selected.
Toggle Button Group 3D allows users of your application to select only one option from a set of
options that are mutually exclusive. Toggle Buttons in a Toggle Button Group behave like radio
buttons, where only one Toggle Button can be active at a time. Use the CurrentButtonIndexProperty
property to check which Toggle Button in the Toggle Button Group is selected.
Trajectory defines a series of points following a geometrical path. For example,
use a trajectory as align paths for 3d objects or animation paths.
You can create trajectory as a spline, circle or line trajectory.
ValueAccumulatorBase is the base class for the Value Accumulator implementations for
different data types. It defines the common property and message types
for different Value Accumulators.
Use a Viewport 2D to set the size of a render target surface onto which content is projected.
Viewport 2D is a 2D node that can project a 3D scene through a camera. Viewport 2D is a special
node because it can render both 2D nodes, such as Image, Page, Button 2D, and a Scene,
which is a 3D node.
Represents a weak reference to an instance of C++ kanzi::Object.
Can be passed to functions accepting &Object (or its derivatives), yet, if the object is
stale, the functions will return an error STALE_OBJECT instead.
Use the WriteLogAction class to attach logging functionality to a trigger. When
a trigger that has a WriteLogAction attached is set off, the action is executed
and it writes the string that you set in the LogTextProperty to the Kanzi Studio
Log window in the log category KZ_LOG_CATEGORY_GENERIC.
Legacy version of enum “kanzi.ActivityConcept.Status”.
Defines possible states of an Activity.
Activity Host nodes can activate and deactivate their child Activities.
This enumeration defines the possible states of an Activity during the
the process of activation and deactivation.
You can use this functionality to react to changes in Activity status in
your application code and in Kanzi Studio.
See: Activity, StatusProperty
Font hinting options.
Hinting refers to the adjustments in the outline-filling process of a glyph,
so that the glyph lines up within the rasterized grid.
Legacy version of enum “kanzi.NodeComponent.State”.
State indicating if component is attached to a node, detached from any node
or in process of attaching/detaching.
Each property type can have one or more change flags that indicate the effects of changing the value of that property.
For example, when the Text property of a Text Block node changes, Kanzi must recalculate the layout of that Text Block,
which is why the TextConcept::TextProperty has the PropertyTypeChangeFlagMeasure.
Base class for Activity Host classes.
This class defines common types, properties and messages for Activity Host classes.
See: ExclusiveActivityHost2D, ExclusiveActivityHost3D, ParallelActivityHost2D, ParallelActivityHost3D.
Button nodes provide an area that receives key and touch input which Kanzi translates to state events.
In addition to the area that receives input, the Toggle Button nodes provide a toggled state.
Use the Content Layout nodes to present complex content as one element in the UI.
You can use a Content Layout node to create a control that adapts to the size of its content,
or a control where the content adapts to the size of the control.
Base class for the Data-Driven Exclusive Activity Host classes.
This class defines the common types, functionality, and properties for the Data-Driven Exclusive Activity Host classes.
See: DataDrivenExclusiveActivityHost2D, DataDrivenExclusiveActivityHost3D
Example of a static DataObjectList which only supports insertions.
Note that DataObjectList is expected to be used for more complex logic involving RPC,
databases or lazy initialization:
ScrollViewConcept is the base class that provides the functionality for the ScrollView2D and ScrollView3D classes.
Both of these Scroll View types inherit the ScrollViewConceptImpl, a specialization of the base class:
Use the Text %Box nodes to add single-line text input to your application. Use TextBox3D to add text
input in 3D space and TextBox2D to add text input in 2D space.
Base class for the Exclusive Activity Host classes.
This class defines the types and properties for the Exclusive Activity Host classes for which the activation of the child Activities is controlled by a property or a DataObject value.
See: ExclusiveActivityHost2D, ExclusiveActivityHost3D.
Use this trait to implement the load tasks that load new resources.
A load task is split into an optional load and mandatory finish functions.
The load function may be called in a background worker thread, instead of the main thread.
And so only thread independent work should be done here.
While the finish function is guaranteed to be called in the main thread.
Trait used for iterating over iterators returned by Kanzi.
Note that next method is unsafe, since we cannot statically ensure that a given iterator
wasn’t invalidated by underlying collection modifications.