Reflex

Reflex is the portable C++ framework for building graphical multimedia applications and audio plugins, featuring:

• Layered modular architecture with strict dependencies and minimal external requirements
• Uniform object model with intrusive references, lightweight views, and data-driven properties
• Unified structured data system including JSON, XML, RIFF, and PropertySheet formats
• Cross-platform abstraction layer for desktop apps, mobile apps, and audio plugins
• Native real-time audio and plugin support including VST and AU
• GPU-driven rendering and UI framework with layout, styling, animation, and events
• Hot-reloadable stylesheets, scripting, and integrated developer tooling
• Designed for high performance with small binaries, low memory usage, and deterministic runtime behaviour

What it's not

Reflex is not a DSP library or an audio-processing toolkit. It provides low-level abstraction over platform and plug-in APIs, but does not include DSP algorithms, synthesis engines, processing graphs, or other domain-specific audio layers. Those systems are expected to be built on top when needed.

Framework vs library

The most common way to use Reflex is as a framework. Reflex Creator template projects and the Bootstrap namespace provide the standard starting point for applications, with state/view separation, startup wiring, UI initialisation, and project scaffolding already in place.

Due to its modular nature, Reflex may also be used as a library. Lower-level modules can be embedded into existing host architectures and initialised independently, allowing integration into other frameworks such as JUCE.

Organisation

Reflex is organised into a set of small, focused sub-libraries with strict one-directional dependencies. Each directory contains a 'require.h' that aggregates the headers of its dependencies.

The source tree is divided into two major parts, reflex and reflex_ext.

reflex/

The core, canonical framework layer containing the fundamental primitives and primary APIs of Reflex.

Reflex: Core object model, containers, and reference system. Lightweight primitives forming the foundation for all Reflex modules.

System: Cross-platform OS abstraction (files, memory, threading, timing, SIMD detection).

SIMD: Portable SIMD layer exposing unified vector types over platform intrinsics.

Data: Structured data system (PropertySet), serialization, formats (JSON/XML/RIFF), encoding, compression, hashing.

File: File IO utilities, path handling, virtual file system, and shared resource management.

GLX: UI framework: layout, styling, events, and animation system.

VM: Scripting system: VM, compiler, runtime, module loading, and C++ bindings.

reflex_ext/

Contains higher-level extension modules, helper systems, widgets, tooling, and application scaffolding built on top of reflex/.

Async: Task system with worker threads, scheduling, and HTTP utilities.

File: Extensions to file system (e.g. monolithic archive format, extra utilities).

GLX: Additional UI widgets and helpers built on GLX.

IDE: Integrated debugging, live editing and hot-reload for stylesheets and scripts.

Bootstrap: Application scaffolding, lifecycle management, VFS setup, and project template foundation.

Fundamentals & Key Concepts

Reflex is built around a small set of core concepts which are used consistently throughout the framework. It is imperative to understand these concepts before diving deeper into the framework:

Object model and lifetime: Reflex > Object

Intrusive hierarchies and traversal: Reflex > Intrusive

Containers, views, and allocation: Reflex > Containers

Strings and text processing: Reflex > String

Keys and properties: Reflex > Data > PropertySet

Initialisation and globals: Reflex > Initialisation

Getting Started

A good starting point is the examples/Notes project. It is a small but complete working application demonstrating the separation between UI and application logic, recommended project structure, and typical usage of Reflex modules across GLX, Data, and Bootstrap.

Once familiar with the example, create your own project using Reflex Project Creator (bin/tools), which sets up the required modules, entry point, and Bootstrap scaffolding automatically.

From there, the natural development path is:

• Build your UI using Reflex::GLX - layout, styling, and events
• Manage structured state with Data::PropertySet and the serialization helpers
• Follow the patterns established in the Notes example for state/view separation and lifecycle management

Functions

IsSet, IsUnset

---

Reflex > Containers

Reflex provides a compact suite of container types designed around predictable behaviour, explicit allocation control, contiguous storage, and lightweight non-owning views.

Design Principles

• Runtime allocator model rather than allocator template parameters
• Explicit allocation policies for deterministic memory behaviour
• Zero-copy views and slicing where possible
• Contiguous storage preferred for iteration efficiency and cache locality
• Minimal and internally consistent APIs

Core Containers

Array

Array<T> is the primary owning dynamic container in Reflex. It provides contiguous storage, explicit allocation control, and fast iteration.

See Reflex::Array for storage, allocation, mutation, and usage details.

Strings

CString and WString are specialised Array types with guaranteed null termination after all modifications.

See Reflex/String for the string model, and Reflex::CString and Reflex::WString for the owning string types.

Views

ArrayView<T> and ArrayRegion<T> provide lightweight non-owning read-only and mutable slices into contiguous memory.

See Reflex::ArrayView and Reflex::ArrayRegion for lifetime, constness, and usage details.

Sequence

Sequence<TKey, TValue> is a contiguous associative container where keys are not required to be unique.

See Reflex::Sequence for ordering, duplicate-key, and lookup semantics.

Map

Map<TKey, TValue> is a simplified unique-key associative container built on top of Sequence.

See Reflex::Map for lookup and mutation semantics.

Queue

Queue<T> is a fixed-size SPSC (single producer / single consumer) ring buffer intended for deterministic real-time and multi-threaded pipelines.

See Reflex::Queue for its concurrency and capacity contract.

Allocation Model

Runtime Allocators

Reflex containers use allocator objects at runtime rather than allocator template parameters.

This allows containers to move across API and module boundaries without allocator-dependent types.

Iteration

Reflex containers support range-based iteration:

for (auto & value : array)
{
}

Reverse iteration helpers are also provided via rbegin() and rend().

Functions

Extend, Join, Left, Merge, Mid, Remove, Reorder, Replace, Reverse, ReverseIterate, ReverseSplice, Right, Sort, Splice, Split, ToRegion, ToView

Object Types

Allocation, Allocator

Value Types

CaseInsensitive, CaseSensitive, FieldCompare, KeyCompare, Map, Queue, Sequence

---

Reflex > Containers > Array

Reflex uses one contiguous-sequence model for owning arrays, borrowed views, and strings. Most free functions accept compatible Arrays, ArrayView values, ArrayRegion values, and strings through their view conversion.

Array

Array<T> owns contiguous, dynamically sized storage. Use it when the data must have an independent lifetime or be grown and modified.

See Array for capacity, allocation, and member operations.

View/Region

ArrayView<T> is a read-only borrowed range, while ArrayRegion<T> is its mutable counterpart. Both are lightweight pointer-and-size values which never allocate; they remain valid only while their source storage remains valid and unmoved.

See ArrayView and ArrayRegion for borrowing and lifetime details.

Strings Are Arrays

CString and WString are owning null-terminated specialisations of Array. Their View types are ordinary character ArrayView values, so generic array and view functions work directly on strings.

See String for string-specific details.

Common Workflows

Build an owning Array with Push for individual elements, Append for another contiguous range, or Extend when filling a known-size region in bulk.

Array::Push, Array::Append, and Extend.

Borrow with ToView or ToRegion, then slice without allocation with Mid, Left, Right, or Splice.

ToView, ToRegion, Mid, and Splice.

Search and transform compatible sequences with Search, SearchValue, Replace, Filter, Sort, and related free functions.

Search, SearchValue, Replace, and Sort.

Iteration

Arrays, views, regions, and strings support standard range-based iteration. Use ReverseIterate() when traversing the same contiguous sequence from its final element to its first.

for (auto & i : arr)
{
	// forward
}

for (auto & i : ReverseIterate(arr))
{
	// reverse
}

See ReverseIterate for the reverse-iteration helper.

Functions

Copy, Fill, Filter, GetArraySize, Inc, Nudge, ReverseSearch, Search, SearchValue, Trim, TrimLeft, TrimRight, Wipe

Value Types

Array, ArrayRegion, ArrayView

---

Reflex > Debug

Value Types

Output

---

Reflex > Initialisation

Reflex uses a controlled runtime initialisation model. Some systems, including allocators, modules, null-instances, and global state, are not safe to use before Reflex has initialised.

Static Initialisation

Avoid global objects which allocate memory or depend on Reflex runtime state.

Allocating types such as Array, CString, WString, Reference, TRef, and many Object-derived types may depend on systems which are not yet initialised during static construction.

Recommended Patterns

• Use constexpr CString::View or WString::View for global string constants
• Use The<T>::Acquire() for singleton-style global objects
• Use AcquireProperty<T>(Bootstrap::global, "id") for shared application state
• Use Reflex::Detail::Module when explicit module initialisation order is required

Allocating Globals

If a non-trivial global object is unavoidable, ensure the default allocator is instantiated in the same translation unit before the global object.

REFLEX_INSTANTIATE_DEFAULT_ALLOCATOR;
CString g_name = "example";

In general, prefer explicit initialisation over global construction.

---

Reflex > Intrusive

Reflex provides a small set of intrusive container primitives: Item, List, and Node.

These form the structural foundation of many higher-level framework systems including GLX::Object, GLX::Style, property hierarchies, and other tree-based APIs.

Most applications will not implement these classes directly, however you will interact with them implicitly when iterating over children, siblings, or hierarchical structures throughout the framework.

Intrusive Containers

An intrusive container stores linkage directly inside the object itself rather than inside external wrapper nodes.

Objects therefore remain allocated exactly where they were created while simultaneously participating in lists or hierarchies.

This model provides:

• No wrapper-node allocations
• Stable object addresses and references
• Lightweight traversal and iteration
• Efficient parent/child hierarchies
• A unified structural model across the framework

Reflex uses intrusive structures extensively for UI trees, style trees, property hierarchies, and related systems.

Core Types

List

List<TYPE, RETAIN, BASE> is a doubly-linked intrusive list.

The list itself does not allocate nodes - linkage exists inside the contained objects.

Common operations include:

• GetFirst()
• GetLast()
• GetNumItems()
• Range-based iteration

for (auto & item : list)
{
}

Item

Item represents a single element participating inside a List.

Objects which should appear in intrusive lists inherit from Item.

Common navigation helpers include:

• GetPrev()
• GetNext()

Node

Node combines both Item and List to form a hierarchical tree node.

A Node may simultaneously:

• Exist as a child inside another Node
• Contain child Nodes of its own

This forms the basis of Reflex hierarchical systems such as UI trees and style trees.

for (auto & child : object)
{
	// ...
}

Ownership and Retention

Depending on template configuration, intrusive lists may optionally retain contained objects automatically.

Many higher-level Reflex systems therefore combine intrusive hierarchy management with the Object reference counting system.

The exact ownership behaviour depends on the RETAIN template parameter and the surrounding framework subsystem.

Iteration

Intrusive lists and nodes support standard range-based iteration:

for (auto & child : object)
{
}

Reverse iteration helpers are also available via rbegin() and rend().

Value Types

Item, List, Node

---

Reflex > Logic

Functions

And, Not, Or, Poll, SetDelta, SetFiltered, Swap, True

---

Reflex > Math

Functions

Abs, Clip, Cos, Cube, Exp, Exp2, LinearInterpolate, Log, Log2, Max, Min, Modulo, MulAdd, Normalise, Pow, Quantise, QuantiseDown, QuantiseUp, Quartic, Reciprocal, RoundDown, RoundNearest, RoundUp, RoundUpPow2, Sign, Sin, Square, SquareRoot, Truncate

---

Reflex > Notifications

Reflex provides two lightweight notification primitives that together cover the majority of notification and change-tracking use cases. Both are intentionally minimal and give explicit control over notification semantics, lifetime, and cost.

State & Monitor

Pull-based change tracking.

Extremely lightweight and allocation-free. Clients explicitly poll a State for changes using a State::Monitor. Best suited for high-frequency or frame-based updates where control and predictability are critical, as well as multi-threaded scenarios.

Signal

Push-based notification.

Observers register callbacks (including lambdas) and are notified synchronously when the signal is emitted. Listener lifetime is managed automatically via reference-counted handles, making the client passive and convenient. Typically the caller will store the object received CreateListener via a Reference to keep it alive.

Signal is generally more expensive than State and should be avoided for very frequent notifications.

Usage

• Use State when changes occur often, when polling is already part of the update loop, when minimal overhead is required, or when notifications may cross thread boundaries.
• Use Signal in single-thread scenarios when events are infrequent, when callbacks improve clarity, or when automatic listener lifetime management is desired.

Value Types

Monitor, Signal, State

---

Reflex > Object

Reflex distinguishes reference-counted Object types from ordinary value types such as UInt32 and Array. Object types derive from Reflex::Object, are dynamically typed and non-copyable, and may participate in generic object APIs and dynamic properties.

Use ObjectOf<T> when a plain value must be promoted into an Object for those APIs.

Lifetime at a Glance

Object lifetime uses intrusive reference counting. Reference<T> owns an object and keeps it alive; TRef<T> is a temporary non-owning reference. Create with New<T>() when the receiving API owns the result, or Make<T>() when the caller needs immediate ownership.

See Reference, TRef, New, and Make for the ownership and creation contracts.

Stack Objects

Objects may also be instantiated on the stack. Such objects are destroyed by scope lifetime, and no Reference<T> or TRef<T> may outlive the stack object it refers to.

Object Values

ObjectOf<T> wraps a value inside an Object for reference-counted storage, dynamic properties, and generic object APIs.

See ObjectOf for construction and value access.

Dynamic Properties

Object declares a typed runtime property interface through SetProperty(), QueryProperty(), and UnsetProperty(). A property is identified by both its id and its type.

Object itself does not store properties. A derived type must implement the property callbacks; otherwise SetProperty() discards the supplied property.

Data::PropertySet is the standard implementation and is the usual choice when dynamic properties are needed.

See Object::SetProperty, Object::QueryProperty, Object::UnsetProperty, and Data::PropertySet.

Functions

AcquireProperty, AutoRelease, Deref, GetAbstractProperty, GetAdr, GetProperty, Make, New, QueryFunctionProperty, SetAbstractProperty, SetFunctionProperty, UnsetAbstractProperty, UnsetFunctionProperty

Object Types

Object

Value Types

ConstReference, ConstTRef, ObjectOf, Reference, TRef

---

Reflex > String

CString and WString are typedefs of Array<char> and Array<wchar_t> respectively, while CString::View and WString::View are typedefs of ArrayView<char> and ArrayView<wchar_t>.

Because of this, most string utilities operate generically on Array and ArrayView rather than on dedicated string-only types. Array-view helpers such as Mid(), Splice(), Search(), and Split() work directly on strings as well as on byte arrays and other contiguous sequences.

See Reflex/Containers/Array for the generic Array-family model and functions.

String Storage

CString and WString are owning string types which guarantee null termination after all modifications; generic Array<T> containers do not.

See CString and WString for storage and C API interoperability details.

Views

Many string operations return lightweight ArrayView values instead of allocating new strings.

See ArrayView for borrowing and invalidation rules.

Ownership

When ownership of a substring or slice is required, explicitly copy its view into CString or WString. This keeps allocations and ownership visible.

Typedefs

CString, CString::View, WString, WString::View

Functions

CC32, ID32, ID64, K32, Lowercase, MakeKey32, RawStringCopy, RawStringLength, ToCString, ToFloat32, ToFloat64, ToInt32, ToInt64, ToUInt32, ToUInt64, ToWString, Uppercase

---

Reflex > Types

Typedefs

Key32, Key64

Value Types

Address, Float32, Float64, Function, FunctionPointer, Idx, Int16, Int32, Int64, Int8, Key, NullType, Pair, Point, Rect, Size, Tuple, UInt16, UInt32, UInt64, UInt8, WChar

---

Reflex > Async

Async is a small util library built on top of the low-level System::Task and System::Thread primitives, providing high-level and convenient access to asynchronous operations. The API is designed to simplify correct async usage while keeping control over execution, lifetime, and thread safety explicit.

It covers the most common async use cases, including background execution with progress reporting and cancellation, HTTP requests, safe transfer of payloads across thread boundaries, and lifetime management of running tasks.

Lifetime

Async tasks are reference-counted. Clients typically hold a Reference <Async::Task>. Destroying this reference automatically requests cancellation of the task (assuming one-owner).

For custom workers, task cancellation is cooperative. Worker implementations must explicitly observe and respect the task's run flag via calling Cancelled() and if true, return early with { false, {} } to indicate failure.

Observation

Progress and completion are commonly monitored via polling using clocks created with CreateClock() or CreatePeriodic().

However the recommended solution is to use the AttachAwait helper function which handles this pattern safelt, including use of weak references for handling edge cases where the completion callback destroys the observer.

In UI code, do not use Async::CreateClock or Async::CreatePeriodic. Use the GLX equivalents (GLX::CreateAnimationClock, GLX::CreatePeriodicClock, or GLX::Object::OnClock), which guarantee a valid UI context for each callback.

Examples

//start a background task
auto task_ref = Make<Async::Worker>([](Async::Worker::Context & ctx) -> Async::Worker::Result
{
	auto result = New<Data::UInt32Property>(); //use whatever payload type is suitable

	UInt n = 0;
	while (!ctx.Cancelled() && n < 100)
	{
		System::SuspendThread(10);             //emulate work

		ctx.SetProgress(Float(n) / 99.0f);     //publish progress for UI

		n++;
	}

	if (ctx.Cancelled())
	{
		return { false, {} };
	}

	result->value = n;

	return { n == 100, result };
});

// monitor progress
m_clock_ref = Async::CreatePeriodicClock(0.1f, [task_ref]()	//!by capturing task_ref, the Task is kept alive as long as needed
{
	switch (task_ref->GetStatus())
	{
	case Async::Task::kStatusCompleted:
		if (auto result = Cast<Data::UInt32Property>(task_ref->GetResult()))	//use DynamicCast if your worker returns different types
		{
			//do something with result
		}
		break;

	default:
		break;
	}
});

Typedefs

HttpHeaders

Functions

AttachAwait, CancelAwait, CreateClock, CreateHttpRequest, CreatePeriodicClock

Enums

Status

Object Types

Task, Worker

Value Types

Context, Result

---

Reflex > Bootstrap

Reflex::Bootstrap is the standard application scaffolding layer used by the template projects.

It takes care of application entry, initialisation and globals, and hot-reloading support.

All default template projects use Bootstrap, and it is the recommended and supported API for application setup.

Advanced users may choose to build their own application-management layer, but Bootstrap is the intended starting point for normal Reflex applications.

Globals

global

Functions

GetClipboard, IsPlugin, SetClipboard, SetStyleSheet

Object Types

App, AudioPlugin, Global, View

Value Types

Streamable

---

Reflex > Data

The Reflex::Data namespace provides the core infrastructure for representing, transforming, and persisting structured data in a platform-independent way.

It sits beneath higher-level systems and is used throughout Reflex wherever data needs to be serialized, stored, transmitted, hashed, or converted between representations.

Data covers three main concerns: structured data representation, format-level serialization, and low-level data transformation utilities.

• Structured data: PropertySet, generic properties, and reflection-friendly containers used across the engine.
• Serialization & formats: Pluggable Format implementations for JSON, XML, RIFF, Reflex PropertySheet, and binary PropertySet.
• Data transformation: Compression, hashing, and string encoding utilities (e.g. EncodeUTF8).

You should expect to use the Data namespace extensively in application logic. When used correctly, it removes the need to roll your own data containers, serialization layers, encoding utilities, or hashing functions, as these concerns are already handled in a consistent and well-integrated way across Reflex.

---

Reflex > Data > Compression

Globals

kLZ4

Functions

Compress, Decompress

Object Types

CompressionAlgorithm, DecompressionAlgorithm

---

Reflex > Data > Encoding

Functions

BytesToHex, DecodeUCS2, DecodeUTF8, DecodeUrlSegment, EncodeUCS2, EncodeUTF8, EncodeUrlSegment, HexToBytes, IsHttps, MakeUrl, SplitUrl, SplitUrlResource

Value Types

Url

---

Reflex > Data > Format

Data::Format defines the interface for encoding and decoding structured data. A given Format implements how to serialize a PropertySet into bytes and how to reconstruct it back into a PropertySet.

Reflex provides several global, constant Format instances covering the common persistence use cases.

Common Formats

kPropertySetFormat

• Recommended binary format
• Fast, compact, and supports the widest range of Reflex property objects: PropertySet, BoolProperty, UInt32Property, UInt64Property, Int32Property, Int64Property, Float32Property, Float64Property, CStringProperty, WStringProperty, Key32Property, ArchiveObject, and KeyMap.

kPropertySheetFormat

• Human-readable text format
• Similar to JSON but with additional type info support.
• Supports PropertySet, PropertySetArray, BoolProperty, UInt32Property, UInt64Property, Int32Property, Int64Property, Float32Property, Float64Property, CStringProperty, WStringProperty, Key32Property, ArchiveObject, and KeyMap.

kJsonFormat

• Standard JSON
• Ideal for interoperability with web APIs and external tooling.
• Supports PropertySet, PropertySetArray, BoolProperty, UInt32Property, UInt64Property, Int32Property, Int64Property, Float32Property, Float64Property, CStringProperty, WStringProperty, and KeyMap. Unsupported values are emitted as null.

kReflexXmlFormat

• Supports a sub-set of XML
• Only attributes and nested elements (ignores text content between tags).
• Supports PropertySetArray, CStringProperty, BoolProperty, Int32Property, Float32Property, and KeyMap. Nested node payloads are represented as PropertySet children.

Typical Usage

Encoding

Data::PropertySet data;

Data::SetInt32(data, "version", 1);

auto child = Data::AcquirePropertySet(data, "child");
Data::SetFloat32Array(child, "values", {1.0f, 2.0f});

auto blob = Data::EncodePropertySet(Data::kPropertySetFormat, data);

File::Save(path, blob);

Decoding

auto bytes = File::Open(path);

Data::PropertySet root = Data::DecodePropertySet(Data::kPropertySetFormat, bytes);
if (root)
{
	auto v = Data::GetInt32(root, "version");
	auto sub = Data::GetPropertySet(root, "child");
	auto arr = Data::GetFloat32Array(sub, "values");
}

Choosing a Format

• Use kPropertySetFormat for application data, presets, configs, or anything Reflex-internal.
• Use kPropertySheetFormat when you need editable text files or want structured types without JSON's restrictions.
• Use kJsonFormat for web communication and external file formats.

Globals

kBinaryFormat, kJsonFormat, kPropertySetFormat, kPropertySheetFormat, kReflexMarkupFormat, kReflexXmlFormat

Functions

CopyPropertySet, DecodePropertySet, EncodePropertySet, ResetPropertySet

Object Types

Format, SerializableFormat

Value Types

DeserializeError

---

Reflex > Data > Hash

Reflex provides a small set of non-cryptographic hash functions for use in lookup keys, content identifiers, and integrity checks.

These are designed for speed and practicality, not for cryptographic security.

All functions operate on Archive::View and return an Archive (for SHA) or UInt32/UInt64.

Functions

CRC32, FNV1a32, FNV1a64, SHA1, SHA256

---

Reflex > Data > PropertySet

Data::PropertySet is Reflex's generic container for structured, tree-based data.

PropertySet allows arbitrary data to be attached to objects at runtime, without modifying class definitions or introducing ad-hoc subclasses.

Instead of encoding every variation in a type hierarchy, behavior and state can be composed dynamically by attaching properties as needed.

object.SetProperty("hover_time", 0.0f);
object.SetProperty("user_data", some_ref);

This bridges the performance and safety of C++ with the flexibility typically associated with dynamic languages. It enables rapid iteration, late-bound features, and data-driven behavior while remaining fully type-aware and debuggable.

Generic property system

PropertySet implements the root Reflex::Object property interface (OnSetProperty / OnUnsetProperty / OnQueryProperty).

This provides a uniform, generic property mechanism across the entire framework.

Properties are identified by id AND type, rather than id alone.

This complements C++'s strong typing model by allowing multiple, type-safe views of the same conceptual property without collapsing everything into a single loosely-typed value.

ps.SetProperty("my_id", 1);
ps.SetProperty("my_id", "string");

The example above creates two distinct properties:

• An Int32 property with id "my_id".
• A CString property with id "my_id".

Under the hood, this (id + type) pair is represented by Reflex::Address.

Structured and hierarchical data

PropertySet supports hierarchical data by allowing nested PropertySet instances.

This makes it suitable for representing structured trees of runtime state, configuration, or metadata when needed.

Unlike rigid schemas, PropertySet allows structure to evolve organically as systems interact.

Persistence and serialization

PropertySet is serializable, via the Format system.

This makes it suitable for storing presets, state snapshots, configuration files, and interchange data.

For persistent data, values should be written using the Data::SetXXX family of functions, which define the set of interoperable, format-safe property types. Using the Reflex::Data:: suite of property accessors also avoids template bloat occuring from use of the Reflex:: templated ones.

Data::SetFloat32(ps, "gain", 0.75f);
Data::SetCString(ps, "name", "Preset A");

PropertySet can be serialized using any Data::Format implementation:

auto blob = Data::EncodePropertySet(Data::kPropertySetFormat, ps);
//or
auto json = Data::DecodePropertySet(Data::kJsonFormat, ps);

Note that when writing text-based formats (JSON, Reflex PropertySheets) you need to register the key-strings, via Data::AcquireKeyMap and Data::RegisterKey.

Summary

• PropertySet enables dynamic, runtime data attachment without subclassing.
• It is a core mechanism for flexible, data-driven behavior in Reflex.
• Properties are identified by (id, type), allowing rich runtime composition.
• Serialization is supported via pluggable formats.

Use Iterate<TYPE>() to iterate over all properties of TYPE

Each item will have a [key,value] where key is Reflex::Address (comprising of the property id and type_id) and value a Reference <TYPE>

for (auto & [adr, ref] : test.Iterate<Data::CStringProperty>())
{
	output.Log(id.value, ref->value);
}

Typedefs

Float32Property, Float64Property, Int32Property, Int64Property, KeyMap, UInt32Property, UInt64Property

Functions

AcquireKeyMap, AcquirePropertySet, AcquirePropertySetArray, AddPropertySet, Assimilate, GetBool, GetFloat32, GetFloat64, GetInt32, GetInt64, GetKey, GetKey32, GetKeyMap, GetPropertySet, GetPropertySetArray, GetUInt32, GetUInt64, GetUInt8, Merge, RegisterKey, SetBinary, SetBool, SetCString, SetFloat32, SetFloat64, SetInt32, SetInt64, SetKey32, SetPropertySet, SetUInt32, SetUInt64, SetUInt8, SetWString, UnsetBinary, UnsetBool, UnsetCString, UnsetFloat32, UnsetFloat64, UnsetInt32, UnsetInt64, UnsetKey32, UnsetPropertySet, UnsetPropertySetArray, UnsetUInt32, UnsetUInt64, UnsetUInt8, UnsetWString

Object Types

ArchiveObject, ObjectArray, PropertySet

Value Types

PropertyIterator

---

Reflex > Data > Serialization

Reflex serialization provides a lightweight, explicit way to encode and decode strongly-typed data to and from a binary stream.

It is designed for deterministic layouts, low overhead, and full control over what is written.

Unlike PropertySet serialization (which targets structured, schema-light data), this API is intended for **compact, ordered, binary serialization** of known data layouts.

Archive

Data::Archive is a byte container used as the backing store for serialization.

It is a simple typedef over Array<UInt8>, and can be treated as a writable or readable byte stream.

Data::Archive outstream;

To read from an archive, use Data::Archive::View, which maintains a read cursor without copying data:

Data::Archive::View instream = outstream;

Archive::View performs deserialization directly from the underlying byte buffer. For simple value types, data is read by copying from the current stream position and advancing an internal read cursor. This avoids additional heap allocations and minimizes intermediate copying, making the operation suitable for performance-sensitive code paths.

Writing data (Serialize)

Use Data::Serialize to append strongly-typed values to an archive in sequence.

Data::Serialize(stream, 1, 2.0f);
Data::SerializeUTF8(stream, L"wide");

Values are written in the order provided. The resulting stream is compact and contains no metadata beyond what is required to decode variable-length data (such as strings).

Reading data (Deserialize)

Use Data::Deserialize to read values back in the same order they were written.

auto [i, f] = Data::Deserialize<Int32, Float32>(stream);
auto wstring = Data::DeserializeUTF8(stream);

Deserialization advances the read cursor stored in the Archive::View.

The template parameters define the expected types and enforce strong typing at the call site.

Validation

Within Reflex, deserialization fundamentally expects pre-validated input. Individual Data::Deserialize calls do not perform size or integrity checks - this is by design, not omission. A size check at the individual deserializer level is largely meaningless in isolation: confirming that 4 bytes remain before reading a UInt32 says nothing about whether that value is semantically correct.

The general approach therefore is validation at the stream boundary, before deserialization begins. Once a valid, correctly bounded Archive::View is established at the container level, deserializers downstream can and should proceed without checks.

The main exception is the higher-level SerializableFormat::Deserialize path, which does perform stream validation in order to support the Format::Decode-style APIs as those are intended to unpack external input data. See Data::Format and Data::SerializableFormat for more info.

Ordering and determinism

Serialization is order-dependent.

The reader must deserialize values in the exact order and type they were written.

This explicitness is intentional:

• No reflection or schema lookup.
• No runtime type ambiguity.
• No hidden allocations.

This makes the system well suited for file formats, IPC, network packets, caches, and other performance-sensitive data paths.

Strings and encoding

String serialization is explicit.

Use SerializeUTF8 / DeserializeUTF8 to encode wide strings into UTF-8 byte sequences.

Encoding is handled deterministically and is independent of platform wchar size.

Relationship to PropertySet

Use direct serialization when the data layout is known and fixed.

Use PropertySet serialization (EncodePropertySet) when flexibility, flexible version evolution, or dynamic composition is required.

Both systems share the same Data namespace but target different problem spaces.

Relationship to Pack / Unpack

Data::Pack and Data::Unpack provide a lower-level mechanism for converting a single value into a binary representation and restoring it again.

These functions operate on types that have a well-defined, “toll-free” binary representation - meaning the value can be viewed as a contiguous block of bytes without transformation. This typically includes:

• Integral and floating-point types.
• POD and trivially copyable types.
• Arrays of such types.

UInt32 t;
Data::Archive::View view = Data::Pack(t);

auto restored = Data::Unpack<UInt32>(view);

For types with a compile-time known binary size (for example, UInt32 is always 4 bytes), Pack / Unpack and Serialize / Deserialize produce the same binary representation. Internally, Serialize uses Pack / Unpack for these cases.

The distinction becomes important for variable-sized data.

Serialize is designed for writing *sequences* of values to a stream. As such, it includes any additional information required to reconstruct the data when reading, such as encoding the length of strings or arrays before their contents.

In contrast, Pack produces only the binary representation of the value itself. For example, when packing a string, the length is not prepended, as the size of the binary view implicitly defines the data extent.

Summary

• Data::Archive is a simple byte stream for serialization.
• Serialize / Deserialize write and read strongly-typed values in order.
• The API is explicit, deterministic, and allocation-aware.
• String encoding is handled explicitly via UTF-8 helpers.
• PropertySet serialization serves higher-level, structured data needs.

Typedefs

Archive, Archive::View

Functions

Deserialize, DeserializePropertySet, DeserializeUCS2, DeserializeUTF8, Pack, ReadLine, Serialize, SerializePropertySet, SerializeUCS2, SerializeUTF8, Unpack, WriteLine

---

Reflex > Data > Table

Data::Table is a lightweight, in-memory, typed table for structured application datasets.

It is intended for moderate-sized working sets that need direct C++ access, typed columns, compact storage, and a small set of practical query-style operations such as filter, sort, slice, group, count, and aggregate.

It is not a relational database engine. It does not aim to provide SQL, joins, transactions, or durable multi-user storage. Its role is closer to a fast Reflex-native working table for UI data, caches, imported datasets, tooling, and transformation pipelines.

Core model

A table has:

• A fixed schema.
• Zero or more rows.
• Typed columns identified by 'Key32'.

Each column stores metadata such as its id, data type, flags, and byte offset within a row. The schema is fixed for the lifetime of the table.

Fixed-width values are stored directly in row memory. Variable-width payloads such as strings, binary data, and arrays are stored in heap-backed table storage.

Access model

Rows are accessed through cursor-style objects such as 'RowCursor' and 'ConstRowCursor', with typed read/write helpers on resolved column descriptors.

In normal usage, callers resolve frequently used columns once with 'QueryColumn()' or 'GetColumns()', then reuse those descriptors while iterating rows or writing values.

Query helpers

The surrounding table API provides explicit query-style helpers rather than SQL strings:

• 'FindFirst' for the first matching row.
• 'SelectRows' for matching row indices.
• 'Select' for producing a filtered table.
• 'Slice' for projection and row subset copying.
• 'SortBy' for in-place ordering by one column.
• 'CountBy', 'GroupBy', and 'Aggregate' for summary/result tables.

Constraints

Structural mutations may invalidate existing row and cell cursors. A good mental model is that normal iterator invalidation rules apply: adding, removing, shrinking, or reallocating table storage should be assumed to invalidate previously held row/cell handles.

'Key32' comparisons are numeric by default, but some query and sort operations can use a supplied keymap to compare by key string instead.

Ordering of variable-width values is pragmatic and bytewise/lexicographic.

Individual variable-width cell payloads are currently limited to 'UInt16' size, so a single stored string, blob, or array cell cannot exceed roughly 65 KB of payload data.

Low-level serialize/deserialize support exists for compact persistence, but callers are expected to wrap that with their own versioning, schema checks, and application-level file logic where durability matters.

In practice, persistent table storage is often organized by placing one or more tables inside a 'File::Monolith'. When payloads are larger than the practical per-cell limit, the typical pattern is to store the large blob in its own monolith partition and keep only an id or lookup key in the table cell.

Typedefs

QueryData, WString16

Globals

kcount, kratio

Functions

Aggregate, AssumeColumn, CountBy, Delete, ExportRow, FindFirst, GroupBy, ImportRow, MakeAllRows, QueryColumn, Select, SelectRows, Slice, SortBy, ToWString, ToWString16

Enums

AggregateOp, ColumnType, QueryOp

Object Types

Table

Value Types

ColumnInfo, ConstRowCursor, RowCursor

---

Reflex > File

The Reflex::File namespace provides a unified, cross-platform interface for working with files, paths, and shared file-backed resources.

It is built on top of the System layer and is intended to be the primary API for file and resource access in application code.

File covers three closely related concerns: path manipulation, file I/O, and virtualised/shared resource access.

• Path utilities: helpers for common path operations such as SplitFilename, CheckExtension, ResolveExistingPath, and related functions.
• File I/O: high-level helpers for opening, saving, and reading files (e.g. File::Open, File::Save, File::ReadLine), avoiding direct interaction with low-level file handles.
• Virtual filesystems and resources: abstractions for unifying real, bundled, and embedded data sources.

---

Reflex > File > IO

Functions

AcquireTempFile, Copy, CreateMemoryReader, CreateMemoryWriter, DeleteTempFile, Extract, GetRemainder, Open, Peek, ReadBytes, ReadLine, ReadValue, Save, WriteBytes, WriteLine, WriteValue

Object Types

Monolith, PersistentPropertySet, ResourcePool, VirtualFileSystem

Value Types

EmbeddedResource, EnumerableEmbeddedResource

---

Reflex > File > Path

Globals

kPathDelimiter

Functions

CheckExtension, CorrectExtension, CorrectStrokes, CorrectTrailingStroke, Delete, DeleteDirectoryContent, DeletePath, Exists, GetSystemPath, GetVolumes, IsDirectory, MakeDirectory, MakePath, MakeRelativePath, RemoveDuplicateStrokes, RemoveTrailingStroke, Rename, ResolveExistingFolder, ResolveRelativePath, SplitExtension, SplitFilename

---

Reflex > GLX

GLX is Reflex's UI framework. It combines a retained object tree, a declarative layout system, stylesheet-based rendering, an event model, and time-based animation helpers into one consistent API surface.

Most GLX work falls into a small set of concepts which are used repeatedly across the framework:

• Every visible element is a GLX::Object in a parent -> child hierarchy
• Parents control layout flow, while children declare how they participate in that layout
• Visual appearance is defined in stylesheets and render layers rather than hard-coded drawing logic
• Input and application behavior are driven through bubbling events and delegate bindings
• Animated behavior is built from state transitions, explicit animations, and clocks

Key Guides

See the following guides before diving into specific widgets or helpers:

Object tree and layout: Layout

Stylesheets, layers, and states: Styling

Input dispatch and custom behavior: Events

Time-based transitions, clocks, and procedural updates: Animation

Minimal Example

auto panel = New<GLX::Object>();
GLX::SetFlow(panel, GLX::kFlowY);

auto title = New<GLX::Label>(L"Overview");
auto body = New<GLX::Object>();
auto button = New<GLX::Button>(L"Run");

GLX::AddInline(panel, title);
GLX::AddInlineFlex(panel, body);
GLX::AddFloat(body, button, GLX::kAlignmentTopRight);
GLX::BindClick(button, [](){});

---

Reflex > GLX > Animation

Base type for playable GLX animation objects that target a GLX object and advance over time.

Functions

AttachAnimationClock, AttachPeriodicClock, CreateAnimationClock, CreateCallbackAnimation, CreateColourPropertyAnimation, CreateFloatPropertyAnimation, CreateInterpolatedAnimation, CreateLogarithmicAnimation, CreateMarginPropertyAnimation, CreateMaxBoundsAnimation, CreateOpacityAnimation, CreatePeriodicClock, CreatePointPropertyAnimation, CreatePositionAnimation, CreateSizePropertyAnimation, CreateStateAnimation, CreateWaitAnimation, DetachClock, Enter, Exit, Run, Stop

Enums

Easing

Object Types

Animation, ContainerAnimation, InterpolatedAnimation, Multi, PlayList

---

Reflex > GLX > Events

The GLX Event System provides a unified way to send and receive input and custom messages across all UI objects.

Events are lightweight, dynamically extensible objects that bubble up through the view hierarchy until handled or consumed.

Fundamentals

GLX::Event derives from Data::PropertySet, allowing arbitrary name-value pairs to be attached dynamically.

It also has a Key32 id member for fast event type comparisons.

GLX::Object::Emit delivers an event to the target object, then bubbles it up through its parent hierarchy until a handler traps or consumes it.

Use GLX::Object::ProcessEvent when you want to dispatch an event directly to a single object without bubbling.

It is the callers responsiblity to ensure the event is retained before calling Emit or ProcessEvent.

Emitting Events

The low-level approach is to create and populate an Event instance manually and call Emit() on the target object.

auto e = Make<Event>("MyCustomEvent");
Data::SetBool(e, "selected", true);
my_view->Emit(e);

A more concise helper exists:

GLX::Emit(*this, "MyCustomEvent", "selected", true);

This ensures compile-time checking that arguments are provided in name-value pairs and that names decay to Key32.

Receiving Events

The lowest-level way to respond to events is by overriding bool GLX::Object::OnEvent(GLX::Object & src, GLX::Event & e).

bool MyView::OnEvent(GLX::Object & src, GLX::Event & e)
{
	switch (e.id.value)
	{
	case GLX::kMouseDown:
		// handle click
		if (GLX::GetClickFlags(e) & GLX::kClickFlagDbl)
		{
		}
		return true; // trap event

	case K32("MyCustomEvent"):
		// handle custom event
		return true;
	}

	return GLX::Object::OnEvent(src, e); // Always forward to base
}

Combined with the dispatch helpers, it's common to use if/else checks instead of a switch:

if (e.id == GLX::kMouseDown)
{
	return true;
}
else if (auto menu = GLX::GetMenu(e))
{
	menu->AddItem(L"Option 1");
	return true;
}

Always forward unhandled events to the base OnEvent implementation, or delegates and default behavior will not run.

Delegate-Based Binding

GLX supports inline delegate binding to avoid subclassing.

auto btn = GLX::AddInline(*this, GLX::Init(New<GLX::Button>(L"Click Me"), m_button_style));

GLX::BindClick(btn, []()
{
	// Handle click
});

BindEvent and BindEventVoid provide binding to a specific event id, while SetEventDelegate allows full forwarding of all events.

As BindEvent uses the event id also for the delegate id, each usage of BindEvent with the same event id will replace any previous delegate for that event id. To attach multiple event handlers use SetEventDelegate with different ids.

Event Helpers

Some useful helpers for dispatching events include...

UInt8 GetClickFlags(const Event & e);   //Returns click state flags.
bool IsLeftClick(const Event & e);      //True if left mouse button was used.
bool IsRightClick(const Event & e);     //True if right mouse button was used.
bool IsDoubleClick(const Event & e);    //True if a double click was detected.
Point GetMouseDelta(const Event & e);   //Mouse drag or wheel delta.
UInt8 GetModifierKeys(const Event & e); //Modifier key flags.
KeyCode GetKeyCode(const Event & e);    //Key code from key events.
WChar GetKeyCharacter(const Event & e);    //Character from key events.
TRef<Menu> GetMenu(Event & e);          //Returns Menu from kMenuOpen event.
TRef<Menu> GetMenu(Event & e, Key32 context); //Same, filtered by context.
Transaction GetTransactionStage(const Event & e); //Retrieve transaction stage.
TRef<Object> GetDragSource(Event & e);  //Retrieve drag source.

Example: Custom Event End-to-End

// Emit a custom event with a property
GLX::Emit(*this, K32("VolumeChanged"), "value", 0.75f);

// Handle it in a parent view
bool MyView::OnEvent(GLX::Object & src, GLX::Event & e)
{
	if (e.id == K32("VolumeChanged"))
	{
		auto v = Data::GetFloat32(e, "value");
		ApplyVolume(v);
		return true;
	}
	return Base::OnEvent(src, e);
}

Typedefs

KeyCode, ModifierKeys

Globals

kCharacter, kFocus, kKeyDown, kKeyUp, kLoseFocus, kMouseDown, kMouseDrag, kMouseEnter, kMouseLeave, kMouseUp, kMouseWheel, kPointerDown, kPointerDrag, kPointerUp, kTransaction, kfocusable

Functions

BindClick, BindEvent, BindEventVoid, CaptureWindow, CreateDragDropEndListener, Emit, EnableMouse, EnablePointerCapture, EnableTabNavigation, FocusBranch, GetClickFlags, GetDelta, GetFocus, GetKeyCharacter, GetKeyCode, GetModifierKeys, GetPointerFlags, GetPointerPosition, GetPointerSlot, GetPosition, GetTimestamp, IsDoubleClick, IsLeftClick, IsRightClick, QueryAntecedent, RedirectFocus, ScaleDelta, Send, SetEventDelegate, TransformPosition, UnbindEvent

Enums

PointerFlags, TransactionStage

Object Types

Event

---

Reflex > GLX > Events > Drag & Drop

GLX drag and drop passes a Reflex::Object payload through the event system. The payload can be any Object, including GLX::Object, Data::PropertySet, ObjectOf <TYPE>, or any custom object-type.

auto payload = Make<Data::PropertySet>();
Data::SetWString(payload, "path", L"example.txt");
GLX::StartDragDrop(payload, GLX::kMouseCursorPointer, GLX::kMouseCursorBlock);

Initiating a drag

To begin a drag, trap kMouseDown and kMouseDrag on the source object, and then use ExceedsDragThreshold(GetDelta(e)) to decide when the pointer movement is large enough to begin a drag operation.

bool MyView::OnEvent(GLX::Object & src, GLX::Event & e)
{
	if (e.id == GLX::kMouseDown)
	{
		return true;	//trapping down is enough to receive linked drag/up
	}
	else if (e.id == GLX::kMouseDrag)
	{
		if (GLX::ExceedsDragThreshold(GLX::GetDelta(e)))
		{
			GLX::StartDragDrop(Make<MyDragData>(), GLX::kMouseCursorPointer, GLX::kMouseCursorBlock);
			return true;
		}
	}

	return Base::OnEvent(src, e);
}

Accepting drops

A potential drop target becomes active by handling kDragDropTender and returning true. Once a target accepts kDragDropTender, it will then receive kDragDropEnter, kDragDropLeave, and kDragDropReceive events for that drag.

bool MyView::OnEvent(GLX::Object & src, GLX::Event & e)
{
	switch (e.id.value)
	{
	case GLX::kDragDropTender:
		return GLX::QueryDragDropData<MyDragData>(e);

	case GLX::kDragDropEnter:
		src.SetState("dragover");
		return true;

	case GLX::kDragDropLeave:
		src.UnsetState("dragover");
		return true;

	case GLX::kDragDropReceive:
		if (auto data = GLX::QueryDragDropData<MyDragData>(e))
		{
			ConsumeDrop(*data);
			return true;
		}
		return false;
	}

	return Base::OnEvent(src, e);
}

If you want to prevent this object and its parents from accepting the current drag, you can intercept the tender event, clear its id, and then allow it to continue upward as a non-drag event:

case GLX::kDragDropTender:
	e.id = kNullKey;	//change the Event id to effectively hide the event from parents
	return false;	//return false as this object doesnt want to receive the drop

Reading drag data

QueryDragDropData<TYPE>(e) is the standard typed helper. Internally it performs a DynamicCast on the object stored in the event's drag payload.

struct CustomDragData : public Reflex::Object
{
	REFLEX_OBJECT(CustomDragData, Reflex::Object);

	Array <WString> filepaths;
};

template <class TYPE> inline TYPE * Reflex::GLX::QueryDragDropData(GLX::Event & e)
{
	return DynamicCast<TYPE>(GetDragDropData(e));
}

If you use a custom payload type, make it object-castable with REFLEX_OBJECT so DynamicCast can recognise it.

When checking against multiple possible payload types, it is slightly more efficient to fetch the payload once and then test it manually:

auto drag_data = GLX::GetDragDropData(e);

if (auto custom = DynamicCast<CustomDragData>(drag_data))
{
}
else if (auto generic = DynamicCast<Data::PropertySet>(drag_data))
{
}

Cursor feedback

The drag API takes two cursors: the cursor shown while hovering an accepting target, and the cursor shown when the current target does not accept the drag. A simple setup is:

GLX::StartDragDrop(data, GLX::kMouseCursorPointer, GLX::kMouseCursorBlock);

For richer UI, a common pattern is to hide the OS drag cursor and render your own drag-preview object in the window foreground. Start the drag with invisible cursors:

GLX::StartDragDrop(data, GLX::kMouseCursorInvisible, GLX::kMouseCursorInvisible);

A typical custom-cursor implementation uses a global begin-listener to construct the preview from the drag payload type, attaches that object to the window foreground, disables mouse handling on it, and updates its position every frame.

A key rule is to exclude the visual cursor from hit-testing. Use GLX::EnableMouse(cursor, false, true) so it ignores mouse-over events.

m_drag_drop_visualiser = GLX::CreateDragDropBeginListener([this](Reflex::Object & drag_data)
{
	auto origin = GLX::GetFocus();
	TRef <GLX::WindowClient> window = origin->GetWindow();

	//create drag cursor
	auto cursor = New<GLX::Object>();
	GLX::SetText(cursor, GLX::GetText(origin));
	cursor->SetStyle(GLX::FindStyle(origin, "DragCursor"));
	GLX::EnableMouse(cursor, false, true);	//ensure cursor, or any children on cursor, do not doesnt intercept mouse (see EnableMouse for details)
	GLX::Enter(cursor, GLX::kEnterAnimationFade);
	GLX::AddAbsolute(window->GetForeground(), cursor, GLX::GetPointerPosition(window));

	//attach callbacks to window, so if window is destroyed they wont be called
	SetAbstractProperty(window, "dragdrop_clock", GLX::CreateAnimationClock([window, cursor](Float)
	{
		cursor->SetPosition(GLX::GetPointerPosition(window));
	}));
	auto run_opacity_animation = [cursor](GLX::Object & drop_target)
	{
		auto fade = GLX::CreateOpacityAnimation("opacity", 0.75f, 0.9f);
		if (IsNull(drop_target)) fade->Flip();
		GLX::Run(cursor, "opacity", 0.25f, fade);
	};
	run_opacity_animation(Null<GLX::Object>());	//call now to apply initial fade to cursor

	SetAbstractProperty(window, "dragdrop_target", GLX::CreateDragDropTargetListener([this, run_opacity_animation](GLX::Object & drop_target)
	{
		m_drop_target.Load()->UnsetState("dragover");	//using Reflex::Detail::WeakRef to cover case drop_target might be stack-based
		m_drop_target.Store(drop_target);
		drop_target.SetState("dragover");

		run_opacity_animation(drop_target);
	}));
	SetAbstractProperty(window, "dragdrop_end", GLX::CreateDragDropEndListener([this, window, cursor]()
	{
		GLX::Exit(cursor, true);	//detach cursor with fade

		m_drop_target.Clear();

		UnsetAbstractProperty(window, "dragdrop_clock");
		UnsetAbstractProperty(window, "dragdrop_target");
		UnsetAbstractProperty(window, "dragdrop_end");	//important always delete containing lambda last
	}));
});

To support multiple payload types, a convenient pattern is to register a small factory per drag-data type and choose the preview object in CreateDragDropBeginListener. This lets file drags, object drags, and generic property payloads each supply their own visual cursor.

In a multi-instance plugin environment, take care to do this once, otherwise each window would create a mousecursor.

Notes

• The drag payload is any Reflex::Object; Data::PropertySet is a convenient generic choice.
• kDragDropTender is the gatekeeper event. If it does not return true, the target will not receive the rest of the drag lifecycle.
• The 'examples/Drag & Drop Demo' project shows a complete working pattern, including moving UI objects between rows and restoring the source when the drop is not accepted.

Globals

kDragDropEnter, kDragDropLeave, kDragDropReceive, kDragDropReceiveExternal, kDragDropTender

Functions

CancelDragDrop, CreateDragDropBeginListener, CreateDragDropTargetListener, ExceedsDragThreshold, GetDragDropData, QueryDragDropData, StartDragDrop

---

Reflex > GLX > Layout

GLX layout is handled by a layout model attached to each GLX::Object.

By default every Object uses the standard layout model (kStandardLayout), which supports common 'box layout' behaviors: inline flow, inline flex, float (pin), stretch (fill), plus absolute positioning.

You typically don't write layout code directly. Instead:

• Set the parent's flow (how it arranges inline children) via SetFlow.
• Set a positioning mode for each child (how the parent treats that child) via the AddXXX or EnableXXX helpers.
• Optionally enable auto-fit on the parent (size-to-content).

A useful mental model:

• Parents control *flow*.
• Children control *positioning*.

Layout Models

Each Object owns a layout model (GLX::Detail::LayoutModel), which can be changed via Object::SetLayoutModel.

The following standard models are provided:

• kStandardLayout: single-line inline flow, plus float/overlay, and absolute positioning.
• kStandardLayoutWrapped: identical behavior, but inline children wrap onto new rows/columns when space runs out.

Custom layout models can be implemented by deriving from GLX::Detail::LayoutModel, but this is a secondary API. Most UIs should use the standard model and helpers described below.

Parent Flow

The parent controls how *inline* children are arranged. This includes the primary axis, optional inversion, and optional centering of the inline group.

• GLX::SetFlow(parent, GLX::kFlowX): inline children flow left -> right.
• GLX::SetFlow(parent, GLX::kFlowY): inline children flow top -> bottom.
• GLX::kFlowInvert: reverse the flow direction.
• GLX::kFlowCenter: center the inline group along the primary axis.

auto panel = New<GLX::Object>();
GLX::SetFlow(panel, GLX::kFlowY);                        //vertical stack
//GLX::SetFlow(panel, GLX::kFlowY | GLX::kFlowCenter);   //stack centered as a group

Flow only affects children in *inline* mode. Float and absolute children ignore flow entirely.

Auto-fit (size to content)

Auto-fit is enabled by default. This means an object will grow its content size to accommodate its children.

A child's contribution to content size is derived from:

• Its style size / max properties.
• Its render layers (e.g. Text layers naturally size to text).
• Its own children, if auto-fit is enabled on that child.

GLX::EnableAutoFit(panel, true, true);		//fit width + height to children
//GLX::EnableAutoFit(panel, true, false);	//fit width only

Auto-fit is commonly disabled on large scrolling containers, but useful for popups, pills, menus, and small panels.

Child Positioning Modes

Each child has a positioning mode that is interpreted by its parent's layout model.

In the standard model, this is set either:

• When adding the child via AddInline / AddFloat / AddAbsolute
• Explicitly via EnableInline / EnableFloat / EnableAbsolute.

The AddXXX helpers are convenience functions that:

• Configure the child's positioning mode (via the EnableXXX helpers)
• Attach the child to the parent (via Object::SetParent).

As positioning mode and position are child-properties, they persist when changing the parent:

auto parent = New<GLX::Object>();
auto another_parent = New<GLX::Object>();
auto child = New<GLX::Object>();

GLX::AddFloat(parent, child, GLX::kAlignmentTopRight);

child->Detach();
child->SetParent(another_parent); //child is still pinned top-right on the new parent

GLX::EnableFloat(child, GLX::kAlignmentBottomLeft);	//now moved to bottom left

Inline Positioning

Inline children participate in the parent's flow. They are laid out sequentially along the flow axis.

The Orientation parameter controls placement on the *orthogonal axis* (perpendicular to flow):

• kOrientationNear: near edge (top or left)
• kOrientationCenter: centered on the cross axis
• kOrientationFar: far edge (bottom or right)
• kOrientationFit: stretch to available cross-axis space (default)

auto row = New<GLX::Object>();
GLX::SetFlow(row, GLX::kFlowX);

auto icon = New<GLX::Object>();
auto label = New<GLX::Label>(L"Settings");

GLX::AddInline(row, icon, GLX::kOrientationCenter);  //y centered (ortho axis) on row
GLX::AddInline(row, label);                          //fit to row height

Inline Flex

Using flex allows the child to expand along the *primary axis* to consume remaining space.

Conceptually similar to “flex: 1”.

auto header = New<GLX::Object>();
GLX::SetFlow(header, GLX::kFlowX);

auto title = New<GLX::Label>(L"Project");
auto spacer = New<GLX::Object>();
auto close = New<GLX::Button>(L"X");

GLX::AddInline(header, title, GLX::kOrientationCenter);
GLX::AddInlineFlex(header, spacer);
GLX::AddInline(header, close, GLX::kOrientationCenter);

The remaining space is distributed across all children with flex enabled evenly.

To achieve an exact 50% / 50% horizontal split, enable flex on both children and disable horizontal auto-fit so their size is not influenced by content:

auto container = New<GLX::Object>();
GLX::SetFlow(header, GLX::kFlowX);

auto left = New<GLX::Label>(L"Left");
auto right = New<GLX::Button>(L"Right");

GLX::EnableAutoFit(left, false, true);    //Important: prevent content from affecting width
GLX::EnableAutoFit(right, false, true);

GLX::AddInlineFlex(container, left);
GLX::AddInlineFlex(container, right);

Float Positioning

Float positions a child relative to the parent's bounds but removes it from inline flow. Floated children do not affect layout of inline siblings.

Float positioning can be specified using:

• Alignment enum (single value)
• Two orientations (x, y)

auto view = New<GLX::Object>();

auto badge = New<GLX::Label>(L"NEW");
GLX::AddFloat(view, badge, GLX::kAlignmentTopRight);

auto spinner = New<GLX::Object>();
GLX::AddFloat(view, spinner, GLX::kAlignmentCenter);

auto sticky_footer = New<GLX::Object>();
GLX::AddFloat(view, sticky_footer, GLX::kOrientationFit, GLX::kOrientationFar);	//note use of 2nd variant with Orientation enum

Orientation values in float mode mean:

• Near: anchor to start edge
• Center: center on that axis
• Far: anchor to end edge
• Fit: stretch along that axis

Stretch (fill parent)

Stretch is a convenience mode for the most common float case: filling the parent on both axes.

It is shorthand for enabling float with kOrientationFit on X and Y.

GLX::AddStretch(parent, child);	//same as GLX::AddFloat(parent, child, GLX::kOrientationFit, GLX::kOrientationFit)

Absolute (explicit coordinates)

Absolute places a child at an explicit position in the parent's coordinate space.

auto canvas = New<GLX::Object>();
auto node = New<GLX::Object>();
GLX::AddAbsolute(canvas, node, {120.0f, 80.0f});

Genuine use-cases for absolute positioning are very rare, and should generally be avoided.

The majority of cases where you may think you need absolute positioning are likely covered by use of GLX::ScrollArea / GLX::ZoomArea or custom drawing.

Furthermore, typical genuine cases for absolute positioning will require a custom layout model, to ensure the child positions are updated in response to the parent size (during the Align phase)

Standard Layout Variants

When used correctly the standard layout model will cover most use cases in typical UI layouts. The additional standard layout variants cover most remaining use cases:

kStandardLayoutWrapped

To allow inline children to wrap, set the parent's layout model to kStandardLayoutWrapped.

Child APIs remain unchanged.

Typical use cases:

• Tag strips / pill lists
• Wrapping toolbars
• Flow-style grids without custom layout code

Typedefs

Point, Rect, Size

Functions

AddAbsolute, AddFloat, AddInline, AddInlineFlex, AddStretch, BranchContains, CalculateAbs, CalculateAbsoluteRect, CalculateRelativeRect, EnableAutoFit, GetBounds, LookupBranchIndex, LookupChildAtIndex, LookupIndex, QueryChildById, QueryElementById, SetBounds, SetFlow, UnsetBounds

Enums

Alignment, FlowFlags, Orientation

Object Types

Object, WindowClient

Value Types

Range

---

Reflex > GLX > Styling

GLX supports a powerful visual styling system designed to clearly separate presentation from layout. Layout logic is implemented in C++ or Reflex VM code, while stylesheets remain no-code, making them accessible to designers without impacting development.

Stylesheets avoid the unpredictable inheritance rules of CSS while enabling reuse and composition via includes, states, inheritance and aliases.

The unique bg/fg layer concept allows highly rich designs to be expressed almost entirely through vector primitives. With a wide set of predefined render layers, you can build fully resizable, vectorised UIs that eliminate reliance on pre-baked bitmaps and bloated binaries. Layers support advanced anti-aliasing for crisp visuals at any resolution.

Dynamic property binding (&property) further extends styles into the runtime, powering fluid, data-driven animations and live effects.

Stylesheets

Load a stylesheet from disk or resources using RetrieveStyleSheet.

A StyleSheet is itself a Style, so you typically apply it to your root view.

auto sheet = GLX::RetrieveStyleSheet(L":res:MyApp/styles.txt");
view->SetStyle(sheet);

In most cases, prefer the Bootstrap wrapper. Bootstrap manages hot-reloading and attaches a default set of conditional properties based on the environment.

Bootstrap::SetStyleSheet(view, L":res:MyApp/styles.txt");

Style lifecycle and OnSetStyle

Whenever a style is set or hot-reloaded, the framework calls OnSetStyle(const Style & style) on that object.

This is the right place to style sub-objects so they also update on hot-reload.

void MyApp::View::OnSetStyle(const GLX::Style & style)
{
	auto header_style = style["Header"];
	auto tab_style = header_style["Tab"];

	m_header->SetStyle(header_style);
	for (auto & tab : m_header) tab->SetStyle(tab_style);
}

Common Properties

Styles support a core set of properties that define sizing, spacing, colors, layers, and state transitions.

Margin properties

The 'margin' and 'padding' properties accept 1, 2, or 4 float values.

By default, values use Reflex ordering:

margin: 24;           // all edges
margin: 16,8;         // width, height
margin: 12,8,12,8;    // left, top, right, bottom

You can opt into CSS-style ordering:

#option margin_syntax css
margin: 24;           // all edges
margin: 16,8;         // vertical, horizontal
margin: 12,8,12,8;    // top, right, bottom, left

Margins define spacing outside the object's bounds, while padding defines spacing inside, around its content.

While margin and padding are set on Style's, most layers also accept an 'indent' property. e.g:

bg: Fill(indent: 8,12; corner: 4);

Size properties

'size' and 'max' accept 1 or 2 floats:

size: 64;        // 64 x 64
size: 200,48;    // width 200, height 48
max: 400,200;    // maximum size

'size' sets the minimum content size, while 'max' constrains it.

Color properties

The 'color' (or 'colour') property sets the "pen" colour, whereas 'bg_color' (or 'bg_colour') defines a rectangular fill colour. Colors always use 0-255 ranges for components, including the alpha channel.

colour: 128;                // greyscale
colour: 128,128;            // greyscale + alpha
colour: 255,128,0;          // RGB
bg_colour: 0,128,255,192;   // RGBA

You can also set colour via hex codes:

colour: $FF0000;

These map to normalized (0.0f - 1.0f) floats.

Most layers also support a colour property, which is multiplied by the "pen" colour.

bg: Border(width: 2; corner: 4; colour: 255,0,0);

Opacity

The 'opacity' property is a normalized single float value (0.0 - 1.0), applied multiplicatively to all layers and children of an object.

opacity: 0.75;

Layers

Each object supports two layer arrays: 'bg' (drawn before children) and 'fg' (drawn after children). Typically use bg, but for cases where rendering "on top of" content is required, use fg (e.g. InnerShadow).

Both properties take an array of layers. Layers can be freely combined, but the draw order is strictly in the order specified.

bg: Fill(colour: 240), Border(colour: 0, width: 1);
fg: Text(value: &label, font: Small, colour: 0);

Grouping layers

Some layers (such as Mask and Align) are grouping layers that include a 'content' property, which is itself a nested array of layers:

bg:
Mask
(
	mask: Fill(corner: 16);

	content:
	Image(source: artwork; fit: cover),
	Border(corner: 16; width: 2);
);

Transition time

The 'transition' property combined with @State selection is the simplest way to do a basic animation. It sets the blending time in seconds when switching between states.

transition: 0.25; // quarter second blend

States

States are style variants that override properties when active. They appear as @State blocks inside a style and are applied in top-to-bottom order, so later states override earlier ones when both are active.

Push and clear states in code with Object::SetState(Key32) and Object::UnsetState(Key32). Hover and focus are the only built-in states and are managed by GLX::Object automatically.

Button:
{
	transition: 0.25;
	size: 64;

	@State hover:
	{
		bg: Fill(colour: 236);
	};

	@State selected:
	{
		bg: Fill(colour: 80,176,240);
		fg: Text(colour: 255);
	};

	@State inactive:
	{
		fg: Text(colour: 128);
	};
}

Nested states let you specify combinations explicitly.

Button:
{
	@State inactive:
	{
		@State selected:
		{
			bg: Fill(colour: 96,120,140);
		};
	};
}

The Select, SelectChildren, SelectBranch helper functions set/unset the "selected" id. Activate(object, false) pushes "inactive" and disables input on that object.

Includes and Resources

Stylesheets can include other sheets for reuse and structure.

include: "common.txt", "controls.txt";

Stylesheets can define resources for use in layers like Text, Image, TextEdit.

@Font app_font:
{
	path: ":res:MyApp/fonts/Inter-Regular.ttf";
	size: 14;
};

@Bitmap logo:
{
	path: ":res:MyApp/bitmaps/logo.png"; // png,bmp supported; jpg mostly supported
};

Header:
{
	fg: Text(font: app_font; colour: 32; value: &title);
	bg: Image(source: logo; fit: contain);
}

Resources can be declared at the root of the sheet for global access or nested inside a style for specificity.

Inheritance and Aliasing

Stylesheets support reuse and composition through the inherit property and the special @Alias directive.

Using inherit, a style copies all properties from another style before applying its own overrides. This allows you to define a base style and then extend or specialize it with minimal duplication:

BigButton:
{
	inherit: Button;
	size: 128;
};

The inherit property accepts either a single style ID, or a path to a nested sub-style. For example, to inherit from a sub-style defined inside another style:

inherit: Dialog > Header;

Additionally, the @Alias style variant lets you reuse a style as a named property of another style. Unlike inherit, aliasing does not copy values, and instead directly references the source definition:

Popup:
{
	inherit: Button;
	@Alias menu; // alias a menu property defined previously
};

This makes aliasing useful when you want multiple styles to share the same reference (for example, to the same menu definition or resource) rather than duplicating properties.

Dynamic Binding

Any style property value can bind to a code-side variable by using &name. This allows live updates and animations without reapplying styles.

Commonly used for Text value or colours.

// Stylesheet
Flashing:
{
	size: 64;
	bg: Fill(corner: 12; colour: &dynamic_colour);
}

// C++
View::View()
{
	m_flashing = GLX::Init(New<GLX::Object>(), style["Flashing"]);
	SetProperty(m_flashing, "dynamic_color", New<GLX::ColorObject>(GLX::kWhite));
	GLX::AddFloat(*this, m_flashing, GLX::kAlignmentCenter);
	EnableOnClock(); // enable OnClock(delta) callback
}

void View::OnSetStyle(const GLX::Style & style)
{
	m_flashing->SetStyle(style["Flashing"]);
}

void View::OnClock(Float delta_seconds)
{
	auto colour = QueryProperty<GLX::ColorObject>(m_flashing, "dynamic_color");
	colour->r = /* update channel over time */;
	colour->g = /* update channel over time */;
	colour->b = /* update channel over time */;
	m_flashing->Redraw(); // trigger layer repaint
}

Stylesheet Conditionals

GLX stylesheets support conditional variables. When using the Bootstrap::SetStyleSheet(...) wrapper, a set of default variables based on the current environment is automatically attached to the stylesheet.

Stylesheets support preprocessor-style conditionals using #if, #elif, and #else. Each branch body must be wrapped in { ... }.

#if (theme == dark)
{
	background: $202124;
	colour: $f5f5f5;
}
#else
{
	background: $ffffff;
	colour: $111111;
}

Conditions can use symbolic comparisons, numeric comparisons, and "and" / "or":

#if (environment == desktop) and (screen_width >= 1200)
{
	padding: 24;
}

#if (environment == mobile) or (screen_width < 700)
{
	padding: 12;
}

Default Variables

When using the Bootstrap styling path, the default conditional variables are:

platform (windows, macos, linux, android, ios, webasm)
environment (desktop, mobile, plugin)
theme (light, dark)
screen_width, screen_height
font_scale

Symbolic values can be compared with "==" and "!=":

#if (platform == windows) { ... }
#if (theme == dark) { ... }
#if (environment == plugin) { ... }
#if (environment == desktop) or (environment == plugin) { ... }

Numeric values can be compared:

#if (screen_width < 1400) { ... }
#if (screen_height >= 900) { ... }
#if (font_scale > 1.0) { ... }

These values reflect the current platform, environment type, theme, screen size, and UI font scale.

Custom conditional variables can also be supplied, allowing you to define additional symbolic or numeric values for use in stylesheet conditionals. This can be used for app modes, product editions, feature flags, layout variants, or custom breakpoints.

Note: the 'Emulate Mobile' option available in the Config -> Graphics panel of the dev console is useful for testing screen_w, screen_h and the mobile environment, which are emulated in that mode.

Patterns and tips

• Use OnSetStyle to style sub-objects so hot-reload propagates automatically.
• Order @State blocks from least to most dominant: hover - selected - inactive. Use nested states for combinations.
• Prefer binding (&name) for any property you want to animate or update at runtime.
• Use hierarchical lookup style["Section"]["Title"] instead of duplicating properties.
• Put common primitives in included sheets to keep app sheets small and focused.

Typedefs

Colour, MouseCursor, Points

Functions

Activate, ActivateBranch, ClearText, FindStyle, GetClip, GetOpacity, GetText, IsActive, IsSelected, RGB, Rescale, RetrieveStyleSheet, Rotate, Select, SelectBranch, SelectChildren, SetClip, SetOnStyle, SetOpacity, SetState, SetText, ToggleState, Translate, UnsetClip, UnsetOnStyle, UnsetOpacity

Object Types

Style, StyleSheet

Value Types

Corners, Margin

---

Reflex > GLX > Styling > Canvas

Reflex GLX provides three canvas entry points for custom, code-driven drawing, ordered from simplest and fastest to most advanced:

• SetCanvas for monochrome geometry, using Array<Point> output.
• SetColourCanvas for multi-colour geometry, using Array<ColourPoint> output.
• SetGraphicCanvas for advanced cases where you need direct access to graphics, images, fonts, or a custom Graphic that can change every frame.

In stylesheets, these correspond to:

• bg: Canvas();
• bg: ColourCanvas();
• bg: GraphicCanvas();

Execution model

These canvas callbacks are not immediate-mode draw calls in the traditional sense. They are not invoked every frame just because the object is visible.

Instead, the callback prepares geometry for the renderer, effectively building VBO data that can be reused until something changes.

To request a new canvas build, call Redraw() on the object. For example:

m_object.Redraw();

Other state changes that already imply a visual refresh, such as Update(), Realign(), and related layout-reaccommodation paths, also schedule a redraw.

For animated content, a typical pattern is to trigger redraws from OnClock(Float):

void MyView::OnClock(Float dt)
{
	Redraw();
}

Choosing the right API

Prefer Canvas over ColourCanvas over GraphicCanvas, in that order, for performance and simplicity.

Use Canvas() when you are drawing simple monochrome paths and shapes.

Use ColourCanvas() when your geometry needs per-point colour.

Use GraphicCanvas() only when you need the extra power geometry plus textures (eg image/font) composition (which are non primary APIs).

Style usage

Canvas bindings are usually declared in styles with an optional id. Use the plain form when there is only one binding for the object:

bg: Canvas();

When you have multiple canvas bindings on the same object, give each one an id and bind them explicitly in code:

bg: Canvas(id: logo), Canvas(id: clouds);

SetCanvas(m_obj, {.id = K32("logo")}, draw_logo);
SetCanvas(m_obj, {.id = K32("clouds")}, draw_clouds);

The same pattern applies to colour and graphic canvases:

SetColourCanvas(m_obj, {}, draw_coloured_geometry);
SetGraphicCanvas(m_obj, {}, draw_advanced_graphic);

For Canvas and ColourCanvas, do not clear ctx.output. Append to it only. The system may batch multiple canvases together and compact them into a single VBO.

Simple Demo

A minimal Canvas demo can draw a star shape by appending a closed path to ctx.output:

void StarView::OnSetStyle(const GLX::Style & style)
{
	GLX::SetCanvas(*this, {}, [](GLX::CanvasContext & ctx)
	{
		auto cx = ctx.size.w * 0.5f;
		auto cy = ctx.size.h * 0.5f;
		auto outer = Min(ctx.size.w, ctx.size.h) * 0.42f;
		auto inner = outer * 0.45f;
		GLX::Point star[10];

		for (UInt i = 0; i < 10; i++)
		{
			auto a = -kPif * 0.5f + kPif * 0.2f * Float(i);
			auto r = (i & 1) ? inner : outer;
			star[i] = { cx + Cos(a) * r, cy + Sin(a) * r };
		}

		GLX::AddPath(ctx.output, star, true, 2.0f, GLX::kPathJoinRound, GLX::kPathCapRound);
	});
}

This demo uses SetCanvas because the geometry is monochrome. As with most layers, it will be drawn at the style colour, modulated by its own colour property. Use ColourCanvas only when you need per-point colour, and keep GraphicCanvas for the advanced cases where you need the full Graphic pipeline.

Example project

See examples/Custom Drawing for a practical demonstration of the Canvas API in use.

Typedefs

ColourPoints

Functions

AddDottedLine, AddEllipseFill, AddEllipseOutline, AddPath, AddPointsWithColour, AddPolygonFill, AddRectFill, AddRectOutline, AddRoundedFill, AddRoundedOutline, AddRoundedTriangleFill, AddRoundedTriangleOutline, AddTriangleFill, AddTriangleOutline, SetCanvas, SetColourCanvas, SetGraphicCanvas, UnsetCanvas

Value Types

CanvasContext, ColourCanvasContext, GraphicCanvasContext

---

Reflex > GLX > Styling > SVG

Reflex provides native SVG support, treating vector assets as first-class resources alongside bitmaps. SVGs can be imported and used in stylesheets via the @SVG resource declaration, or decoded in code for custom drawing via the geometry pipeline.

SVGs in Stylesheets

SVG usage in stylesheets is consistent with @Bitmap resources and the Image layer. Declare an SVG resource, then reference it in a style property.

Importing an SVG

Declare an SVG resource using the @SVG type:

@SVG my_svg_id:
{
	path: "assets/some.svg";
};

Then use it as an Image source:

bg: Image(source: my_svg_id; fit: contain; anchor: center);

SVG Size

@SVG also supports a size property. If the SVG file contains intrinsic dimensions, those will be used by default. However, some SVGs do not specify a size, in which case you must set one explicitly using standard size syntax:

@SVG my_svg_id:
{
	path: "assets/some.svg";
	size: 128;
};

Because SVGs are vector-based, size does not affect rendering quality in the way it does for bitmaps. However, the initial size is important as it affects the initial geometry preparation, including corner steps and other tessellation details.

Multi-Icon SVG Sets

Reflex supports icon sets where multiple icons are defined in a single SVG file using the '<symbol>' tag with unique IDs. Declare the SVG resource once, then select individual icons using the '>' frame selector - the same syntax used for bitmap sprite frames.

@SVG icons:
{
	path: "assets/icons.svg";
};

Reference a specific icon by its symbol ID:

bg: Image(source: icons > circle_icon; fit: contain; anchor: center);

As per-standard stylesheet syntax, if the symbol ID contains characters that are not a single token (such as a dash), wrap it in single quotes:

bg: Image(source: icons > 'circle-icon'; fit: contain; anchor: center);

Advanced Usage: SVG in Code

The examples/SVG Demo project demonstrates parsing an SVG file and coupling it with custom drawing. The basic workflow is:

• Load the SVG file into memory.
• Decode it using the XML decoder into a PropertySet.
• Use InspectSVG and DecodeSVG to convert it into geometry suitable for a VBO.
• Render using SetColourCanvas (as DecodeSVG produces Array<GLX::ColourPoint>).

C++ Example

void ViewImpl::OnUpdate()
{
	auto xml_bytes = File::Open(m_path_to_svg);
	auto xml = Make<Data::PropertySet>(Data::DecodePropertySet(Data::kReflexXmlFormat, xml_bytes));

	if (auto svgs = GLX::Detail::InspectSVG(xml))
	{
		GLX::SetColourCanvas(m_icon, {}, {[xml, svg = svgs.GetFirst()](GLX::ColourCanvasContext & ctx)
		{
			GLX::Detail::DecodeSVG(ctx.output, svg, size);
		}});
	}
	else
	{
		GLX::UnsetCanvas(m_icon, {});
	}
}

void ViewImpl::OnSetStyle(const GLX::Style & style)
{
	m_icon.SetStyle(style["Icon"]);
}

Note: In the example, capturing 'xml' as a Reference (produced by Make) in the lambda is critical to keep the PropertySet alive for the lifetime of the canvas binding.

Due to the complexity of the SVG format, decoding is expensive and should be avoided per-frame. In the example, the size_z guard in the example ensures the geometry is only re-decoded when the target size actually changes.

Stylesheet for Code-Driven SVG

Icon:
{
	bg: ColourCanvas();		//use Canvas() for monochrome geometry, ColourCanvas() for colour-point geometry
};

Summary

• Use @SVG to declare SVG resources, with the same Image layer syntax as @Bitmap.
• Set size explicitly for SVGs that lack intrinsic dimensions; initial size affects geometry preparation.
• Use the > frame selector with symbol IDs to reference individual icons from multi-icon SVG files.
• Single-quote symbol IDs that contain dashes or other non-token characters.
• For custom drawing, decode via the XML pipeline and use InspectSVG / DecodeSVG to produce ColourPoint geometry.
• Render code-driven SVGs with SetColourCanvas.

---

Reflex > GLX > Widgets

Widgets are the higher-level interactive controls built on top of GLX::Object and a small set of reusable behaviours.

Most of them are event-driven composites rather than standalone rendering systems: they emit requests such as select, open, load, remove, and transaction updates, and they usually apply named substyles to internal parts such as header, body, footer, item, tab, prev, or next.

A recurring pattern in this module is that visual feedback comes from ordinary GLX state flags such as selected, hover, open, and reorder, so stylesheet state handling is a big part of how these controls are customised.

Many of the classes here are also intended to be assembled together. Form, Selector, Button, and Menu all act as building blocks for larger widgets rather than being isolated controls.

Functions

CloseContextMenu, OpenContextMenu

Enums

SelectionMode

Object Types

AbstractList, AbstractViewBar, AbstractViewPort, Button, Form, Label, List, Menu, Popup, RangeBar, RotarySlider, ScrollArea, Selector, Split, TabGroup, TextArea, VirtualList, ZoomArea

---

Reflex > SIMD

The Reflex::SIMD namespace provides a high-performance, cross-platform abstraction for Single Instruction, Multiple Data (SIMD) operations. It allows for data-parallel processing of 4-element vectors using platform-specific hardware acceleration (such as SSE, AVX, or NEON) through a unified C++ interface.

Core Types

The library centers around the TypeV4<T> template, which represents a vector of four elements. Specialized typedefs are provided for common data types:

• FloatV4: A vector of 4 Float32 values.
• IntV4: A vector of 4 Int32 values.
• BoolV4: A mask type (using kBooleanTrue or kBooleanFalse) used for conditional SIMD logic.

Initialization and Access

Vectors can be initialized via broadcasting a single value, specifying four distinct values, or loading from memory.

using namespace Reflex::SIMD;

FloatV4 a(1.0f);                    // Broadcast: [1.0, 1.0, 1.0, 1.0]
FloatV4 b(1.0f, 2.0f, 3.0f, 4.0f);   // Explicit:  [1.0, 2.0, 3.0, 4.0]

Float32 data[4] = { 5.0f, 6.0f, 7.0f, 8.0f };
FloatV4 c = LoadUnaligned(data);     // Load from memory

Accessing individual elements can be done via the [] operator or by retrieving a Quad<T> structure. Use GetFirst() to efficiently grab the element at index 0.

Mathematical Operations

Standard arithmetic operators are overloaded to perform component-wise operations across all four lanes simultaneously.

• Arithmetic: +, -, *, / and MulAdd(a, b, c) (computes a * b + c).
• Comparison: ==, !=, >, >=, <, <= (returns a BoolV4 mask).
• Common Math: Abs, Sign, Min, Max, SquareRoot, Reciprocal.
• Advanced: Exp2, Log2, and LinearInterpolate(t, a, b).

Conditional Logic (Masking)

Because SIMD lanes cannot branch independently, conditional logic is handled via masking and the Select function.

// Choose between 'a' and 'b' based on a condition
BoolV4 mask = a > b;
FloatV4 result = Select(mask, a, b); // result[i] = mask[i] ? a[i] : b[i]

You can also analyze the state of a mask using these helpers:

• Any(mask): Returns true if at least one lane is true.
• Full(mask): Returns true if all four lanes are true.
• Empty(mask): Returns true if no lanes are true.
• Count(mask): Returns the number of true lanes (0-4).

Shuffling and Transposition

The library provides tools to reorder data within vectors or between two different vectors.

// Reorder elements within a vector
auto swapped = Shuffle<1, 0, 3, 2>(v);

// Interleave values from two vectors
auto lo = InterleaveLo(a, b);

// Transpose a 4x4 matrix represented by four vectors
Transpose(row0, row1, row2, row3);

Horizontal Operations

While most operations are vertical (lane-to-lane), some operations combine values across a single vector:

Float32 total = Sum(my_v4); // Adds all 4 components into a single scalar

Conversion

Explicit conversion between integer and floating-point vectors is required:

• ToFloatV4(IntV4): Converts integers to floats.
• ToIntV4(FloatV4): Converts floats to integers (rounding).
• Truncate(FloatV4): Converts floats to integers using truncation toward zero.

Typedefs

BoolV4, FloatV4, IntV4

Functions

Abs, And, Any, ClipNormal, Count, Empty, Exp, Exp2, Full, GetFlags, GetFree, Invert, Log, Log2, Max, Min, Modulo, Not, Or, Pow, Reciprocal, RoundDown, RoundNearest, Select, SelectNot, Sign, SquareRoot, operator!=, operator&, operator*, operator+, operator-, operator/, operator<, operator<=, operator==, operator>, operator>=, operator|

Enums

Boolean

Value Types

TypeV4

---

Reflex > System

The Reflex::System namespace is the low-level cross-platform abstraction layer for OS-facing services such as files, windows, rendering, application lifetime, and platform integration.

Reflex is designed so that application code can remain platform-agnostic. In normal use there is no need to interact with OS-specific APIs directly, as System provides the platform-independent primitives that the rest of Reflex builds upon.

Design intent

The System namespace is not intended to be the primary API used by application code.

Instead:

• Higher-level namespaces (Data, File, GLX etc.) are built on top of System.
• These higher-level APIs provide safer, more convenient, and more expressive interfaces.
• System exists to unify OS behavior and expose consistent primitives across all supported platforms.

Typical usage

In most cases, you should use the higher-level APIs rather than System directly.

For example, instead of working with System::FileHandle, use the File namespace for more convenient helper functions,

//Low-level (usually unnecessary)
auto file_handle = Make<System::FileHandle>(path);
Array <UInt8> bytes1(file_handle.GetSize());
auto bytes_read = file_handle->Read(bytes1.GetData(), bytes1.GetSize());
bytes1.SetSize(bytes_read);

//Recommended
auto bytes2 = File::Open(path);

When to use System directly

Direct use of the System namespace is appropriate in advanced or specialized cases, such as:

• When you need lower-level control than higher-level APIs expose.
• When implementing new subsystems or extending Reflex itself.
• When performance, lifetime, or resource management must be handled explicitly.

In these cases, System provides a stable, cross-platform foundation without leaking OS-specific concepts into application code.

Custom Implementations

As most System APIs are defined as pure-abstract interfaces, the System layer acts as an extensibility point as well as an OS abstraction. This allows you to provide alternate implementations (for example, a FileHandle that reads from an in-memory blob, a cloud stream, or a virtual file system) and pass them directly to other APIs operating on the System primitives.

Typedefs

ColourPoint, fPoint, fRect, fSize

Functions

Delete, Exists, GetElapsedTime, GetNumProcessor, GetOperatingSystemVersion, GetPath, GetProcessID, GetSystemID, GetTime, IsDirectory, MakeDirectory, Open, Rename

Enums

ImageFormat, KeyCode, ModifierKeys, MouseCursor, Path, Response

Object Types

DirectoryIterator, DiskIterator, DynamicLibrary, FileHandle, HttpConnection, Process, Renderer, Renderer::Canvas, Renderer::Graphic, Task, Thread, Window

Value Types

BitmapInfo, Colour, ReceiveDataFn, ReceiveHeaderFn

---

API Reference

---

Reflex

Reflex::CString

using CString = Array <char>;

Reflex::CString::View

using CString::View = ArrayView <char>;

Reflex::Key32

using Key32 = Key <UInt32>;

Reflex::Key64

using Key64 = Key <UInt64>;

Reflex::WString

using WString = Array <WChar>;

Reflex::WString::View

using WString::View = ArrayView <WChar>;

Reflex::Abs

TYPE Abs(TYPE value);

Reflex::AcquireProperty

Reference <TYPE> AcquireProperty(Object& object, Key32 id);
Reference <TYPE> AcquireProperty(Object& object, Key32 id, VARGS...);

Reflex::And

bool And(const VARGS...& args);

Reflex::AutoRelease

Reference <TYPE> AutoRelease(TYPE& object);

Reflex::CC32

UInt32 CC32(const char* string);

Reflex::Clip

TYPE Clip(const TYPE& value, const TYPE& min, const TYPE& max);

Reflex::Copy

void Copy(ArrayView <TYPE> src, ArrayRegion <TYPE> dst);

Reflex::Cos

TYPE Cos(TYPE value);

Reflex::Cube

TYPE Cube(TYPE value);

Reflex::Deref

TYPE& Deref(TYPE& type);
TYPE& Deref(TYPE* type);

Reflex::Exp

TYPE Exp(TYPE value);

Reflex::Exp2

TYPE Exp2(TYPE value);

Reflex::Extend

ArrayRegion <TYPE> Extend(Array <TYPE>& data, UInt32 n);

Reflex::Fill

void Fill(ArrayRegion <TYPE> region, const TYPE& value);

Reflex::Filter

Array <TYPE> Filter(ArrayView <TYPE> view, const TYPE& element_or_array);

Reflex::GetAbstractProperty

TRef <Object> GetAbstractProperty(Object& object, Key32 id);
ConstTRef <Object> GetAbstractProperty(const Object& object, Key32 id);

Reflex::GetAdr

TYPE* GetAdr(TYPE& type);

Reflex::GetArraySize

UInt32 GetArraySize(const TYPE& data);

Reflex::GetProperty

ConstTRef <TYPE> GetProperty(Object& object, Key32 id);

Reflex::ID32

UInt32 ID32(const char* string);

Reflex::ID64

UInt64 ID64(const char* string);

Reflex::Inc

ArrayRegion <TYPE> Inc(ArrayRegion <TYPE>& itr, UInt32 n);

Reflex::IsSet

bool IsSet(Key32 key);

Reflex::IsUnset

bool IsUnset(Key32 key);

Reflex::Join

Array <TYPE> Join(const VARGS...& ...);

Reflex::K32

UInt32 K32(const char* string);

Reflex::Left

ArrayView <TYPE> Left(ArrayView <TYPE> view, UInt32 position);

Reflex::LinearInterpolate

TYPE LinearInterpolate(TYPE x, TYPE in0, TYPE in1);

Reflex::Log

TYPE Log(TYPE value);

Reflex::Log2

TYPE Log2(TYPE value);

Reflex::Lowercase

Array <TYPE> Lowercase(const TYPE& string);
char Lowercase(char character);
WChar Lowercase(WChar character);

Reflex::Make

Reference <TYPE> Make(VARGS... args);

Reflex::MakeKey32

UInt32 MakeKey32(CString::View string);
UInt32 MakeKey32(WString::View string);

Reflex::Max

TYPE Max(TYPE a, TYPE b);

Reflex::Merge

Array <TYPE> Merge(ArrayView <TYPE> view, ArrayView <TYPE> delimiter);

Reflex::Mid

ArrayView <TYPE> Mid(ArrayView <TYPE> view, UInt32 position);
ArrayView <TYPE> Mid(ArrayView <TYPE> view, UInt32 position, UInt32 length);

Reflex::Min

TYPE Min(TYPE a, TYPE b);

Reflex::Modulo

TYPE Modulo(TYPE a, TYPE b);

Reflex::MulAdd

TYPE MulAdd(TYPE a, TYPE b, TYPE c);

Reflex::New

TRef <TYPE> New(VARGS... args);

Reflex::Normalise

TYPE Normalise(TYPE value, TYPE in0, TYPE in1);

Reflex::Not

bool Not(bool value);
bool Not(const TYPE& value);

Reflex::Nudge

ArrayRegion <TYPE> Nudge(ArrayRegion <TYPE> itr, Int32 n);

Reflex::Or

bool Or(const VARGS...& args);

Reflex::Poll

TYPE Poll(TYPE& value);

Reflex::Pow

TYPE Pow(TYPE x, TYPE y);

Reflex::Quantise

TYPE Quantise(TYPE value, TYPE step);

Reflex::QuantiseDown

TYPE QuantiseDown(TYPE value, TYPE step);

Reflex::QuantiseUp

TYPE QuantiseUp(TYPE value, TYPE step);

Reflex::Quartic

TYPE Quartic(TYPE value);

Reflex::QueryFunctionProperty

const ObjectOf < Function <RTN(VARGS...)> >* QueryFunctionProperty(const Object& owner, Key32 id);

Reflex::RawStringCopy

UInt32 RawStringCopy(const TYPE* from, TYPE* to, UInt32 capacity);

Reflex::RawStringLength

UInt32 RawStringLength(const TYPE* string);
UInt32 RawStringLength(const TYPE* string, UInt32 capacity);

Reflex::Reciprocal

TYPE Reciprocal(TYPE value);

Reflex::Remove

void Remove(Array <TYPE>& array, const TYPE& element_or_array);

Reflex::Reorder

void Reorder(Array <TYPE>& data, UInt32 from, UInt32 to);
void Reorder(ArrayRegion <TYPE> data, UInt32 from, UInt32 to);

Reflex::Replace

Array <TYPE> Replace(ArrayView <TYPE> view, const TYPE& from, const TYPE& to);

Reflex::Reverse

void Reverse(TYPE data);

Reflex::ReverseIterate

auto ReverseIterate(TYPE& iterable);
auto ReverseIterate(const TYPE& iterable);

Reflex::ReverseSearch

Idx ReverseSearch(ArrayView <TYPE> view, const TYPE& element_or_array);

Reflex::ReverseSplice

Pair < ArrayView <TYPE> , ArrayView <TYPE> > ReverseSplice(ArrayView <TYPE> view, UInt32 position);

Reflex::Right

ArrayView <TYPE> Right(ArrayView <TYPE> view, UInt32 position);

Reflex::RoundDown

TYPE RoundDown(TYPE value);

Reflex::RoundNearest

TYPE RoundNearest(TYPE value);

Reflex::RoundUp

TYPE RoundUp(TYPE value);

Reflex::RoundUpPow2

TYPE RoundUpPow2(TYPE value, TYPE start);

Reflex::Search

Idx Search(ArrayView <TYPE> view, const TYPE& element_or_array);

Reflex::SearchValue

TYPE* SearchValue(ArrayRegion <TYPE> region, const TYPE& element, TYPE* fallback);
const TYPE* SearchValue(ArrayView <TYPE> view, const TYPE& element, const TYPE* fallback);

Reflex::SetAbstractProperty

void SetAbstractProperty(Object& object, Key32 id, TRef <Object> property);

Reflex::SetDelta

TYPE SetDelta(TYPE& value, const TYPE& set);

Reflex::SetFiltered

bool SetFiltered(TYPE& value, const TYPE& set);

Reflex::SetFunctionProperty

void SetFunctionProperty(Object& owner, Key32 id, TYPE fn);

Reflex::Sign

TYPE Sign(TYPE value);

Reflex::Sin

TYPE Sin(TYPE value);

Reflex::Sort

void Sort(ArrayRegion <TYPE> values);

Reflex::Splice

Pair < ArrayView <TYPE> , ArrayView <TYPE> > Splice(ArrayView <TYPE> view, UInt32 position);

Reflex::Split

Array < ArrayView <TYPE> > Split(ArrayView <TYPE> view, const TYPE& delimiter);

Reflex::Square

TYPE Square(TYPE value);

Reflex::SquareRoot

TYPE SquareRoot(TYPE value);

Reflex::Swap

void Swap(TYPE& a, TYPE& b);

Reflex::ToCString

CString ToCString(const WString::View& string);
CString ToCString(const WString& string);
CString ToCString(UInt32 value);
CString ToCString(UInt64 value);
CString ToCString(Int32 value);
CString ToCString(Int64 value);
CString ToCString(Float32 value, UInt32 precision, bool discard_zeros);
CString ToCString(Float64 value, UInt32 precision, bool discard_zeros);

Reflex::ToFloat32

Float32 ToFloat32(const CString::View& string);
Float32 ToFloat32(const WString::View& string);
Float32 ToFloat32(Int32 value);
Float32 ToFloat32(Int64 value);
Float32 ToFloat32(UInt32 value);
Float32 ToFloat32(UInt64 value);

Reflex::ToFloat64

Float64 ToFloat64(const CString::View& string);
Float64 ToFloat64(const WString::View& string);

Reflex::ToInt32

Int32 ToInt32(const CString::View& string);
Int32 ToInt32(const WString::View& string);
Int32 ToInt32(Float32 value);
Int32 ToInt32(Float64 value);

Reflex::ToInt64

Int64 ToInt64(const CString::View& string);
Int64 ToInt64(const WString::View& string);

Reflex::ToRegion

ArrayRegion <TYPE> ToRegion(ArrayRegion <TYPE> value);
ArrayRegion <TYPE> ToRegion(Allocation <TYPE>& allocation);
ArrayRegion <TYPE> ToRegion(Array <TYPE>& value);

Reflex::ToUInt32

UInt32 ToUInt32(const CString::View& string);
UInt32 ToUInt32(const WString::View& string);

Reflex::ToUInt64

UInt64 ToUInt64(const CString::View& string);
UInt64 ToUInt64(const WString::View& string);

Reflex::ToView

ArrayView <TYPE> ToView(ArrayView <TYPE> value);
ArrayView <TYPE> ToView(ArrayRegion <TYPE> value);
ArrayView <TYPE> ToView(const TYPE& value);
ArrayView <TYPE> ToView(const Allocation <TYPE>& allocation);
ArrayView <TYPE> ToView(const Array <TYPE>& value);

Reflex::ToWString

WString ToWString(const CString::View& string);
WString ToWString(const CString& string);
WString ToWString(UInt32 value);
WString ToWString(UInt64 value);
WString ToWString(Int32 value);
WString ToWString(Int64 value);
WString ToWString(Float32 value, UInt32 precision, bool discard_zeros);
WString ToWString(Float64 value, UInt32 precision, bool discard_zeros);

Reflex::Trim

ArrayView <TYPE> Trim(ArrayView <TYPE> string);

Reflex::TrimLeft

ArrayView <TYPE> TrimLeft(ArrayView <TYPE> string);

Reflex::TrimRight

ArrayView <TYPE> TrimRight(ArrayView <TYPE> string);

Reflex::True

bool True(bool value);
bool True(Float32 value);
bool True(Float64 value);
bool True(UInt8 value);
bool True(UInt16 value);
bool True(UInt32 value);
bool True(UInt64 value);
bool True(Int8 value);
bool True(Int16 value);
bool True(Int32 value);
bool True(Int64 value);
bool True(const TYPE& value);
bool True(const TYPE* value);

Reflex::Truncate

Int32 Truncate(Float32 value);
Int32 Truncate(Float64 value);

Reflex::UnsetAbstractProperty

void UnsetAbstractProperty(Object& object, Key32 id);

Reflex::UnsetFunctionProperty

void UnsetFunctionProperty(Object& owner, Key32 id);

Reflex::Uppercase

Array <TYPE> Uppercase(const TYPE& string);
char Uppercase(char character);
WChar Uppercase(WChar character);

Reflex::Wipe

void Wipe(ArrayRegion <TYPE> region);

Reflex::Address

Key32 Address::id;

UInt32 Address::type_id;

template Reflex::Array <TYPE>

void Array::Allocate(UInt32 capacity);

void Array::Reserve(UInt32 capacity);

UInt32 Array::GetCapacity();

void Array::Compact();

TYPE& Array::Push();
TYPE& Array::Push(const TYPE& value);

void Array::Pop();

TYPE& Array::Insert(UInt32 idx);
TYPE& Array::Insert(UInt32 idx, const TYPE& value);

void Array::Remove(UInt32 idx);
void Array::Remove(UInt32 idx, UInt32 n);

void Array::Clear();

void Array::SetSize(UInt32 size);

UInt32 Array::GetSize();

void Array::Wipe();

void Array::Fill(const TYPE& value);

void Array::Append(ArrayView <TYPE> values);

void Array::Shrink(UInt32 n);

TYPE& Array::operator[](UInt32 idx);
const TYPE& Array::operator[](UInt32 idx);

TYPE& Array::GetFirst();
const TYPE& Array::GetFirst();

TYPE& Array::GetLast();
const TYPE& Array::GetLast();

TYPE* Array::GetData();
const TYPE* Array::GetData();

bool Array::Empty();

bool Array::operator bool();

bool Array::operator<(const ArrayView <TYPE>& value);

bool Array::operator==(const ArrayView <TYPE>& value);

bool Array::operator!=(const ArrayView <TYPE>& value);

template Reflex::ArrayRegion <TYPE>

TYPE* ArrayRegion::data;

UInt32 ArrayRegion::size;

template Reflex::ArrayView <TYPE>

const TYPE* ArrayView::data;

UInt32 ArrayView::size;

Reflex::CaseInsensitive

Reflex::CaseSensitive

template Reflex::ConstReference <TYPE>

template Reflex::ConstTRef <TYPE>

Reflex::FieldCompare

Reflex::Float32

Reflex::Float64

template Reflex::Function <RTN(VARGS...)>

void Function::Clear();

RTN Function::Invoke(VARGS...);

RTN Function::operator()(VARGS...);

template Reflex::FunctionPointer <RTN(VARGS...)>

Reflex::Idx

UInt32 Idx::value;

bool Idx::operator bool();

Reflex::Int16

Reflex::Int32

Reflex::Int64

Reflex::Int8

template Reflex::Item <TYPE>

List <TYPE>* Item::GetList();
const List <TYPE>* Item::GetList();

Item <TYPE>* Item::GetPrev();
const Item <TYPE>* Item::GetPrev();

Item <TYPE>* Item::GetNext();
const Item <TYPE>* Item::GetNext();

template Reflex::Key <TYPE>

TYPE Key::value;

Reflex::KeyCompare

template Reflex::List <TYPE>

UInt32 List::GetNumItem();

bool List::Empty();

Item <TYPE>* List::GetFirst();
const Item <TYPE>* List::GetFirst();

Item <TYPE>* List::GetLast();
const Item <TYPE>* List::GetLast();

template Reflex::Map <KEY,VALUE>

void Map::Clear();

TYPE1* Map::Search(const TYPE1& key, TYPE2* fallback);
const TYPE2* Map::Search(const TYPE1& key, const TYPE2* fallback);

TYPE2& Map::Set(const TYPE1& key, const TYPE2& value);

void Map::Unset(const TYPE1& key);

TYPE2& Map::operator[](const TYPE1& idx);
const TYPE2& Map::operator[](const TYPE1& idx);

State::Monitor

void Monitor::Connect(const State& state);

void Monitor::Invalidate();

void Monitor::Disconnect();

bool Monitor::Poll();

template Reflex::Node <TYPE>

Reflex::NullType

template Reflex::ObjectOf <TYPE>

Reflex::Output

void Output::Log(VARGS... args);

void Output::Warn(VARGS... args);

void Output::Error(VARGS... args);

template Reflex::Pair <TYPE1,TYPE2>

template Reflex::Point <TYPE>

TYPE Point::x;

TYPE Point::y;

template Reflex::Queue <TYPE,SIZE>

void Queue::Push(const TYPE& value);
void Queue::Push(TYPE temp);

bool Queue::Pop(TYPE& out);

bool Queue::Flush(TYPE& last_out);

template Reflex::Rect <TYPE>

Point <TYPE> Rect::origin;

Size <TYPE> Rect::size;

template Reflex::Reference <TYPE>

TYPE* Reference::Adr();

void Reference::Clear();

template Reflex::Sequence <KEY,VALUE>

Idx Sequence::Search(const KEY& key);

TYPE2* Sequence::SearchValue(const TYPE1& key, TYPE2* fallback);
const TYPE2* Sequence::SearchValue(const TYPE1& key, const TYPE2* fallback);

Idx Sequence::SearchGTE(const KEY& key);

Idx Sequence::SearchLT(const KEY& key);

TYPE2& Sequence::Set(const TYPE1& key, const TYPE2& value);

TYPE2& Sequence::Insert(const TYPE1& key, const TYPE2& value);

TYPE2& Sequence::Acquire(const TYPE1& key, VARGS... ...);

void Sequence::Remove(UInt32 idx);
void Sequence::Remove(UInt32 idx, UInt32 n);

bool Sequence::Empty();

UInt32 Sequence::GetSize();

TYPE2& Sequence::operator[](UInt32 idx);
const TYPE2& Sequence::operator[](UInt32 idx);

template Reflex::Signal <VARGS...>

template Reflex::Size <TYPE>

TYPE Size::w;

TYPE Size::h;

Reflex::State

template Reflex::TRef <TYPE>

TYPE* TRef::Adr();
const TYPE* TRef::Adr();

template Reflex::Tuple <VARGS...>

TYPE1 Tuple::a;

TYPE2 Tuple::b;

VARGS... Tuple::c (etc);

Reflex::UInt16

Reflex::UInt32

Reflex::UInt64

Reflex::UInt8

Reflex::WChar

template Reflex::Allocation <TYPE>

Inherits from Object

const UInt32 Allocation::size;

void Allocation::Shrink(UInt32 n);

TYPE& Allocation::operator[](UInt32 idx);
const TYPE& Allocation::operator[](UInt32 idx);

TYPE* Allocation::GetData();
const TYPE* Allocation::GetData();

Reflex::Allocator

Inherits from Object

Reflex::Object

void Object::RetainSt();

void Object::ReleaseSt();

void Object::RetainMt();

void Object::ReleaseMt();

void Object::UnsetProperty(Key32 id);

void Object::SetProperty(Key32 id, TYPE& property);

TYPE* Object::QueryProperty(Key32 id, TYPE& property);

Allocator* Object::GetAllocator();

---

Reflex > Async

Task::Status

kStatusPending
kStausFailed
kStatusCompleted

Async::HttpHeaders

using HttpHeaders = Array < Pair < Array <char> , Array <char> > >;

Async::AttachAwait

void AttachAwait(Data::PropertySet& object, Key32 clock_id, TRef <Task> task, const Function <void(bool, Object &)>& callback);
void AttachAwait(GLX::Object& object, Key32 clock_id, TRef <Task> task, const Function <void(bool, Object &)>& callback);

Async::CancelAwait

void CancelAwait(Data::PropertySet& object, Key32 clock_id);

Async::CreateClock

TRef <Object> CreateClock(const Function <void()>& callback);

Async::CreateHttpRequest

TRef <Task> CreateHttpRequest(const CString::View& method, const CString::View& url, const HttpHeaders& headers, const Data::Archive::View& body, Output& debug_output_opt);

Async::CreatePeriodicClock

TRef <Object> CreatePeriodicClock(Float32 interval, const Function <void()>& callback);

Worker::Context

bool Context::Cancelled();

void Context::SetProgress(Float32 value_normalized);

Worker::Result

bool Result::success;

Reference <Object> Result::payload;

Async::Task

Inherits from System::Thread

void Task::Cancel();

Float32 Task::GetProgress();

Task::Status Task::GetStatus();

TRef <Object> Task::GetResult();

Async::Worker

Inherits from System::Thread

---

Reflex > Bootstrap

Bootstrap::global

const global global;

Bootstrap::GetClipboard

Data::Archive::View GetClipboard(Key32 type);

Bootstrap::IsPlugin

bool IsPlugin();

Bootstrap::SetClipboard

void SetClipboard(Key32 type, const Data::Archive::View& data);

Bootstrap::SetStyleSheet

void SetStyleSheet(GLX::Object& view, const WString::View& path);

Bootstrap::Streamable

Bootstrap::App

Inherits from Object

const UInt32 App::magic;

const TRef <File::PersistentPropertySet> App::session;

void App::Reset();

bool App::Open(const WString& path);

bool App::Save(const WString& path);

WString::View App::GetFilename();

bool App::IsEdited();

Bootstrap::AudioPlugin

Inherits from App

Bootstrap::Global

Inherits from Data::PropertySet

const TRef <File::VirtualFileSystem> Global::filesystem;

const TRef <File::ResourcePool> Global::resourcepool;

const TRef <File::PersistentPropertySet> Global::prefs;

const CString Global::vendor;

const CString Global::product;

TRef <Object> Global::CreateDeepLinkListener(const Function <void(CString::View)>& callback);

TRef <Object> Global::EnableIde(bool enable);

bool Global::IdeEnabled();

void Global::CommitPreferences();

Bootstrap::View

Inherits from GLX::Object

---

Reflex > Data

Data::kBinaryFormat

const kBinaryFormat kBinaryFormat;

Data::kJsonFormat

const kJsonFormat kJsonFormat;

Data::kLZ4

const kLZ4 kLZ4;

Data::kPropertySetFormat

const kPropertySetFormat kPropertySetFormat;

Data::kPropertySheetFormat

const kPropertySheetFormat kPropertySheetFormat;

Data::kReflexMarkupFormat

const kReflexMarkupFormat kReflexMarkupFormat;

Data::kReflexXmlFormat

const kReflexXmlFormat kReflexXmlFormat;

Data::kcount

const kcount kcount;

Data::kratio

const kratio kratio;

Table::ColumnType

kColumnTypeBool
kColumnTypeUInt8
kColumnTypeUInt32
kColumnTypeUInt64
kColumnTypeInt32
kColumnTypeInt64
kColumnTypeFloat32
kColumnTypeFloat64
kColumnTypeKey32
kColumnTypeDate32
kColumnTypeDate64
kColumnTypeArrayOfUInt8
kColumnTypeArrayOfUInt32
kColumnTypeArrayOfUInt64
kColumnTypeArrayOfInt32
kColumnTypeArrayOfInt64
kColumnTypeArrayOfFloat32
kColumnTypeArrayOfFloat64
kColumnTypeArrayOfKey32
kColumnTypeStringASCII
kColumnTypeStringUTF8
kColumnTypeStringUCS2

Data::QueryOp

kQueryEquals
kQueryLessThan
kQueryGreaterThanOrEqual
kQueryGreaterThan
kQueryInequal

Data::AggregateOp

kAggregateMostFrequent
kAggregateMax
kAggregateMin

Data::Archive

using Archive = Array <UInt8>;

Data::Archive::View

using Archive::View = ArrayView <UInt8>;

Data::Float32Property

using Float32Property = ObjectOf <Float32>;

Data::Float64Property

using Float64Property = ObjectOf <Float64>;

Data::Int32Property

using Int32Property = ObjectOf <Int32>;

Data::Int64Property

using Int64Property = ObjectOf <Int64>;

Data::KeyMap

using KeyMap = ObjectOf < Map < Key <UInt32> , Array <char> > >;

Data::QueryData

using QueryData = Tuple < Key <UInt32> ,QueryOp, Array <UInt8> >;

Data::UInt32Property

using UInt32Property = ObjectOf <UInt32>;

Data::UInt64Property

using UInt64Property = ObjectOf <UInt64>;

Data::WString16

using WString16 = Array <char16_t>;

Data::AcquireKeyMap

TRef < ObjectOf < Map < Key <UInt32> , Array <char> > > > AcquireKeyMap(PropertySet& root);

Data::AcquirePropertySet

TRef <PropertySet> AcquirePropertySet(PropertySet& propertyset, Key32 id);
TRef <PropertySet> AcquirePropertySet(PropertySet& propertyset, ArrayView < Key <UInt32> > path);

Data::AcquirePropertySetArray

TRef < ObjectArray <PropertySet> > AcquirePropertySetArray(PropertySet& propertyset, Key32 id);

Data::AddPropertySet

TRef <PropertySet> AddPropertySet(ObjectArray <PropertySet>& array);

Data::Aggregate

Reference <Table> Aggregate(const Table& table, ArrayView < Pair < Key <UInt32> ,AggregateOp> > ops);

Data::Assimilate

void Assimilate(PropertySet& target, const PropertySet& source);

Data::AssumeColumn

const Table::ColumnInfo& AssumeColumn(ArrayView <Table::ColumnInfo> columns, Key32 id, Table::ColumnType type);
const Table::ColumnInfo& AssumeColumn(const Table& table, Key32 id, Table::ColumnType type);

Data::BytesToHex

CString BytesToHex(const Archive::View& bytes);

Data::CRC32

UInt32 CRC32(const Archive::View& bytes, UInt32 previous);

Data::Compress

Archive Compress(const CompressionAlgorithm& algorithm, const Archive::View& bytes);

Data::CopyPropertySet

PropertySet CopyPropertySet(const Format& format, const PropertySet& propertyset);

Data::CountBy

Reference <Table> CountBy(const Table& table, Key32 column, bool ratio);

Data::DecodePropertySet

PropertySet DecodePropertySet(const Format& format, const Archive::View& bytes, UInt32 options);

Data::DecodeUCS2

void DecodeUCS2(WString& output, const Archive::View& bytes);
WString DecodeUCS2(const Archive::View& bytes);

Data::DecodeUTF8

void DecodeUTF8(WString& output, const Archive::View& bytes);
WString DecodeUTF8(const Archive::View& bytes);

Data::DecodeUrlSegment

CString DecodeUrlSegment(const CString::View& view);

Data::Decompress

Archive Decompress(const DecompressionAlgorithm& algorithm, const Archive::View& bytes);

Data::Delete

void Delete(Table& table, ArrayView < Tuple < Key <UInt32> ,QueryOp, Array <UInt8> > > ops, bool match_all, const KeyMap* keymap);

Data::Deserialize

void Deserialize(Archive::View& stream, VARGS...& ...);
TYPE Deserialize(Archive::View& stream);
Tuple <VARGS...> Deserialize(Archive::View& stream);

Data::DeserializePropertySet

void DeserializePropertySet(Archive::View& stream, const SerializableFormat& format, PropertySet& out);

Data::DeserializeUCS2

void DeserializeUCS2(Archive::View& stream, WString& string_out);
WString DeserializeUCS2(Archive::View& stream);

Data::DeserializeUTF8

void DeserializeUTF8(Archive::View& stream, WString& string_out);
WString DeserializeUTF8(Archive::View& stream);

Data::EncodePropertySet

Archive EncodePropertySet(const Format& format, const PropertySet& propertyset);

Data::EncodeUCS2

void EncodeUCS2(Archive& output, const WString::View& string);
Archive EncodeUCS2(const WString::View& string);

Data::EncodeUTF8

void EncodeUTF8(Archive& output, const WString::View& string);
Archive EncodeUTF8(const WString::View& string);

Data::EncodeUrlSegment

CString EncodeUrlSegment(const CString::View& view);
CString EncodeUrlSegment(const WString::View& view);

Data::ExportRow

void ExportRow(const Table::ConstRowCursor& row, PropertySet& fields);
PropertySet ExportRow(const Table::ConstRowCursor& row);

Data::FNV1a32

UInt32 FNV1a32(const Archive::View& bytes, UInt32 previous);

Data::FNV1a64

UInt64 FNV1a64(const Archive::View& bytes, UInt64 previous);

Data::FindFirst

Table::ConstRowCursor FindFirst(const Table& table, ArrayView < Tuple < Key <UInt32> ,QueryOp, Array <UInt8> > > ops, bool match_all, const KeyMap* keymap);

Data::GetBool

bool GetBool(const Object& propertyset, Key32 id, bool fallback_opt);

Data::GetFloat32

Float32 GetFloat32(const Object& propertyset, Key32 id, Float32 fallback_opt);

Data::GetFloat64

Float64 GetFloat64(const Object& propertyset, Key32 id, Float64 fallback_opt);

Data::GetInt32

Int32 GetInt32(const Object& propertyset, Key32 id, Int32 fallback_opt);

Data::GetInt64

Int64 GetInt64(const Object& propertyset, Key32 id, Int64 fallback_opt);

Data::GetKey

CString::View GetKey(const KeyMap& keymap, Key32 key);

Data::GetKey32

Key32 GetKey32(const Object& propertyset, Key32 id, Key32 fallback_opt);

Data::GetKeyMap

ConstTRef < ObjectOf < Map < Key <UInt32> , Array <char> > > > GetKeyMap(const PropertySet& root);

Data::GetPropertySet

ConstTRef <PropertySet> GetPropertySet(const Object& propertyset, Key32 id);
ConstTRef <PropertySet> GetPropertySet(const PropertySet& propertyset, ArrayView < Key <UInt32> > path);

Data::GetPropertySetArray

ArrayView < ConstReference <PropertySet> > GetPropertySetArray(const PropertySet& propertyset, Key32 id);

Data::GetUInt32

UInt32 GetUInt32(const Object& propertyset, Key32 id, UInt32 fallback_opt);

Data::GetUInt64

UInt64 GetUInt64(const Object& propertyset, Key32 id, UInt64 fallback_opt);

Data::GetUInt8

UInt8 GetUInt8(const Object& propertyset, Key32 id, UInt8 fallback_opt);

Data::GroupBy

Reference <Table> GroupBy(const Table& table, Key32 column, ArrayView < Pair < Key <UInt32> ,AggregateOp> > ops);

Data::HexToBytes

Archive HexToBytes(const CString::View& hex);

Data::ImportRow

void ImportRow(const Table::RowCursor& row, const PropertySet& fields);

Data::IsHttps

bool IsHttps(const CString::View& url);

Data::MakeAllRows

Array <UInt32> MakeAllRows(const Table& table);

Data::MakeUrl

CString MakeUrl(const Url& url);

Data::Merge

PropertySet Merge(const PropertySet& a, const PropertySet& b);

Data::Pack

Archive::View Pack(const TYPE& value);

Data::QueryColumn

const Table::ColumnInfo* QueryColumn(ArrayView <Table::ColumnInfo> columns, Key32 id);
const Table::ColumnInfo* QueryColumn(const Table& table, Key32 id);

Data::ReadLine

bool ReadLine(Archive::View& stream, WString& line_out);
bool ReadLine(Archive::View& stream, CString& line_out);

Data::RegisterKey

Key32 RegisterKey(KeyMap& keymap, const CString::View& string);

Data::ResetPropertySet

void ResetPropertySet(const Format& format, PropertySet& propertyset);

Data::SHA1

Archive SHA1(const Archive::View& bytes);

Data::SHA256

Archive SHA256(const Archive::View& bytes);

Data::Select

Reference <Table> Select(const Table& table, ArrayView < Tuple < Key <UInt32> ,QueryOp, Array <UInt8> > > ops, ArrayView < Key <UInt32> > columns, bool match_all, const KeyMap* keymap);

Data::SelectRows

Array <UInt32> SelectRows(const Table& table, ArrayView < Tuple < Key <UInt32> ,QueryOp, Array <UInt8> > > ops, bool match_all, const KeyMap* keymap);

Data::Serialize

void Serialize(Archive& stream, const VARGS...& ...);

Data::SerializePropertySet

void SerializePropertySet(Archive& stream, const SerializableFormat& format, const PropertySet& in);

Data::SerializeUCS2

void SerializeUCS2(Archive& stream, const WString::View& string);

Data::SerializeUTF8

void SerializeUTF8(Archive& stream, const WString::View& string);

Data::SetBinary

void SetBinary(Object& propertyset, Key32 id, Archive::View value);

Data::SetBool

void SetBool(Object& propertyset, Key32 id, bool value);

Data::SetCString

void SetCString(Object& propertyset, Key32 id, CString::View value);

Data::SetFloat32

void SetFloat32(Object& propertyset, Key32 id, Float32 value);

Data::SetFloat64

void SetFloat64(Object& propertyset, Key32 id, Float64 value);

Data::SetInt32

void SetInt32(Object& propertyset, Key32 id, Int32 value);

Data::SetInt64

void SetInt64(Object& propertyset, Key32 id, Int64 value);

Data::SetKey32

void SetKey32(Object& propertyset, Key32 id, Key32 value);

Data::SetPropertySet

void SetPropertySet(Object& propertyset, Key32 id, TRef <PropertySet> value);

Data::SetUInt32

void SetUInt32(Object& propertyset, Key32 id, UInt32 value);

Data::SetUInt64

void SetUInt64(Object& propertyset, Key32 id, UInt64 value);

Data::SetUInt8

void SetUInt8(Object& propertyset, Key32 id, UInt8 value);

Data::SetWString

void SetWString(Object& propertyset, Key32 id, WString::View value);

Data::Slice

Reference <Table> Slice(const Table& table, ArrayView < Key <UInt32> > columns, ArrayView <UInt32> row_indices);

Data::SortBy

void SortBy(Table& table, Key32 column, bool ascending, const KeyMap* keymap);

Data::SplitUrl

Url SplitUrl(const CString::View& url);

Data::SplitUrlResource

Pair < ArrayView <char> , ArrayView <char> > SplitUrlResource(const CString::View& url);

Data::ToWString

WString ToWString(ArrayView <char16_t> string);

Data::ToWString16

WString16 ToWString16(WString::View string);

Data::Unpack

void Unpack(const Archive::View& bytes, TYPE& output);
TYPE Unpack(const Archive::View& bytes);

Data::UnsetBinary

void UnsetBinary(Object& propertyset, Key32 id);

Data::UnsetBool

void UnsetBool(Object& propertyset, Key32 id);

Data::UnsetCString

void UnsetCString(Object& propertyset, Key32 id);

Data::UnsetFloat32

void UnsetFloat32(Object& propertyset, Key32 id);

Data::UnsetFloat64

void UnsetFloat64(Object& propertyset, Key32 id);

Data::UnsetInt32

void UnsetInt32(Object& propertyset, Key32 id);

Data::UnsetInt64

void UnsetInt64(Object& propertyset, Key32 id);

Data::UnsetKey32

void UnsetKey32(Object& propertyset, Key32 id);

Data::UnsetPropertySet

void UnsetPropertySet(Object& propertyset, Key32 id);

Data::UnsetPropertySetArray

void UnsetPropertySetArray(PropertySet& propertyset, Key32 id);

Data::UnsetUInt32

void UnsetUInt32(Object& propertyset, Key32 id);

Data::UnsetUInt64

void UnsetUInt64(Object& propertyset, Key32 id);

Data::UnsetUInt8

void UnsetUInt8(Object& propertyset, Key32 id);

Data::UnsetWString

void UnsetWString(Object& propertyset, Key32 id);

Data::WriteLine

void WriteLine(Archive& stream, const WString::View& line);
void WriteLine(Archive& stream, const CString::View& line);

Table::ColumnInfo

Key32 ColumnInfo::id;

Table::ColumnType ColumnInfo::type;

UInt8 ColumnInfo::flags;

UInt16 ColumnInfo::offset;

Table::ConstRowCursor

SerializableFormat::DeserializeError

template PropertySet::PropertyIterator <TYPE>

Table::RowCursor

void RowCursor::SetIndex(UInt32 row);

UInt32 RowCursor::GetIndex();

void RowCursor::Clear();

Data::Url

CString Url::scheme;

Pair < Array <char> , Array <char> > Url::user;

CString Url::domain;

UInt16 Url::port;

CString Url::resource;

CString Url::fragment;

Data::ArchiveObject

Inherits from Object

Data::CompressionAlgorithm

Inherits from DecompressionAlgorithm

UInt32 CompressionAlgorithm::GetMaxCompressedSize(UInt32 size);

UInt32 CompressionAlgorithm::Compress(const Archive::View& input, UInt8* output);

Data::DecompressionAlgorithm

Inherits from Object

bool DecompressionAlgorithm::Decompress(const Archive::View& input, Archive& output);

Data::Format

Inherits from Object

void Format::Reset(PropertySet& propertyset);

bool Format::Encode(Archive& out, const PropertySet& data);

bool Format::Decode(PropertySet& out, const Archive::View& data, UInt32 options);

template Data::ObjectArray <TYPE>

Inherits from Object

Data::PropertySet

Inherits from Object

bool PropertySet::Empty();

bool PropertySet::operator bool();

PropertySet::PropertyIterator <TYPE> PropertySet::Iterate();

Data::SerializableFormat

Inherits from Format

void SerializableFormat::Serialize(Archive& stream, const PropertySet& propertyset);

SerializableFormat::DeserializeError SerializableFormat::Deserialize(Archive::View& stream, PropertySet& propertyset);

Data::Table

Inherits from Object

void Table::Allocate(UInt32 num_row);

void Table::Clear();

void Table::Extend(UInt32 num_extra_row);

void Table::Shrink(UInt32 num_less_row);

void Table::Compact();

UInt32 Table::GetNumRow();

ArrayView <Table::ColumnInfo> Table::GetColumns();

Table::RowCursor Table::AddRow();

void Table::RemoveRow(UInt32 idx);

UInt32 Table::CalculateStorageSize();

void Table::Serialize(System::FileHandle& stream);

---

Reflex > File

File::kPathDelimiter

const kPathDelimiter kPathDelimiter;

File::AcquireTempFile

Tuple < Array <WChar> , Reference <System::FileHandle> > AcquireTempFile(const WString::View& filename);

File::CheckExtension

bool CheckExtension(const WString::View& path, const WString::View& extension);

File::Copy

bool Copy(const WString& from, const WString& to);
bool Copy(System::FileHandle& from, System::FileHandle& to, UInt32 chunksize_opt);

File::CorrectExtension

WString CorrectExtension(const WString::View& path, const WString::View& extension);

File::CorrectStrokes

WString CorrectStrokes(const WString::View& path);

File::CorrectTrailingStroke

WString CorrectTrailingStroke(const WString::View& path);

File::CreateMemoryReader

TRef <System::FileHandle> CreateMemoryReader(ConstTRef <Data::ArchiveObject> data);

File::CreateMemoryWriter

TRef <System::FileHandle> CreateMemoryWriter(TRef <Data::ArchiveObject> data);

File::Delete

bool Delete(const WString& path);

File::DeleteDirectoryContent

void DeleteDirectoryContent(const WString& path);

File::DeletePath

void DeletePath(const WString& path);

File::DeleteTempFile

bool DeleteTempFile(Tuple < Array <WChar> , Reference <System::FileHandle> >& temp_file);

File::Exists

bool Exists(const WString& path);

File::Extract

Data::Archive Extract(const EmbeddedResource& resource);

File::GetRemainder

UInt64 GetRemainder(const System::FileHandle& file_handle);

File::GetSystemPath

WString GetSystemPath(System::Path path);

File::GetVolumes

Array < Pair < Array <WChar> , Array <WChar> > > GetVolumes();

File::IsDirectory

bool IsDirectory(const WString& path);

File::MakeDirectory

bool MakeDirectory(const WString& path);

File::MakePath

void MakePath(const WString& path);

File::MakeRelativePath

WString MakeRelativePath(const WString::View& base_dir, const WString::View& path);

File::Open

Data::Archive Open(const WString& path);

File::Peek

Data::Archive Peek(System::FileHandle& file_handle, UInt32 bytes);

File::ReadBytes

Data::Archive ReadBytes(System::FileHandle& file_handle);
Data::Archive ReadBytes(System::FileHandle& file_handle, UInt32 bytes);

File::ReadLine

bool ReadLine(System::FileHandle& file_handle, CString& line_out);
bool ReadLine(System::FileHandle& file_handle, WString& line_out);

File::ReadValue

bool ReadValue(System::FileHandle& file_handle, TYPE& value_out);
TYPE ReadValue(System::FileHandle& file_handle);

File::RemoveDuplicateStrokes

WString RemoveDuplicateStrokes(const WString::View& path);

File::RemoveTrailingStroke

WString::View RemoveTrailingStroke(const WString::View& path);

File::Rename

bool Rename(const WString& from, const WString& to);

File::ResolveExistingFolder

WString::View ResolveExistingFolder(const WString::View& path);

File::ResolveRelativePath

WString ResolveRelativePath(const WString::View& path);

File::Save

bool Save(const WString& filename, const Data::Archive::View& data);

File::SplitExtension

Pair < ArrayView <WChar> , ArrayView <WChar> > SplitExtension(const WString::View& path);

File::SplitFilename

Pair < ArrayView <WChar> , ArrayView <WChar> > SplitFilename(const WString::View& path);

File::WriteBytes

UInt32 WriteBytes(System::FileHandle& file_handle, const Data::Archive::View& bytes);

File::WriteLine

void WriteLine(System::FileHandle& file_handle, const CString::View& line);
void WriteLine(System::FileHandle& file_handle, const WString::View& line);

File::WriteValue

bool WriteValue(System::FileHandle& file_handle, TYPE value);

File::EmbeddedResource

Data::Archive::View EmbeddedResource::data;

UInt32 EmbeddedResource::uncompressed_size;

File::EnumerableEmbeddedResource

Inherits from EmbeddedResource

Key32 EnumerableEmbeddedResource::group;

Key32 EnumerableEmbeddedResource::id;

File::Monolith

Inherits from Object

bool Monolith::IsWriteable();

bool Monolith::Status();

void Monolith::Clear();

bool Monolith::Remove(Key64 partitionid);

TRef <System::FileHandle> Monolith::Write(Key64 partitionid, UInt32 size);

bool Monolith::Commit();

TRef <System::FileHandle> Monolith::Read(Key64 partitionid);

File::PersistentPropertySet

Inherits from Data::PropertySet

File::ResourcePool

Inherits from Object

File::VirtualFileSystem

Inherits from Object

---

Reflex > GLX

GLX::kCharacter

const kCharacter kCharacter;

GLX::kDragDropEnter

const kDragDropEnter kDragDropEnter;

GLX::kDragDropLeave

const kDragDropLeave kDragDropLeave;

GLX::kDragDropReceive

const kDragDropReceive kDragDropReceive;

GLX::kDragDropReceiveExternal

const kDragDropReceiveExternal kDragDropReceiveExternal;

GLX::kDragDropTender

const kDragDropTender kDragDropTender;

GLX::kFocus

const kFocus kFocus;

GLX::kKeyDown

const kKeyDown kKeyDown;

GLX::kKeyUp

const kKeyUp kKeyUp;

GLX::kLoseFocus

const kLoseFocus kLoseFocus;

GLX::kMouseDown

const kMouseDown kMouseDown;

GLX::kMouseDrag

const kMouseDrag kMouseDrag;

GLX::kMouseEnter

const kMouseEnter kMouseEnter;

GLX::kMouseLeave

const kMouseLeave kMouseLeave;

GLX::kMouseUp

const kMouseUp kMouseUp;

GLX::kMouseWheel

const kMouseWheel kMouseWheel;

GLX::kPointerDown

const kPointerDown kPointerDown;

GLX::kPointerDrag

const kPointerDrag kPointerDrag;

GLX::kPointerUp

const kPointerUp kPointerUp;

GLX::kTransaction

const kTransaction kTransaction;

GLX::kfocusable

const kfocusable kfocusable;

GLX::FlowFlags

kFlowX
kFlowY
kFlowInvert
kFlowCenter

GLX::Orientation

kOrientationNear
kOrientationCenter
kOrientationFar
kOrientationFit

GLX::Alignment

kAlignmentTopLeft
kAlignmentTop
kAlignmentTopRight
kAlignmentLeft
kAlignmentCenter
kAlignmentRight
kAlignmentBottomLeft
kAlignmentBottom
kAlignmentBottomRight

GLX::PointerFlags

kPointerFlagDouble
kPointerFlagRightMouseButton
kPointerFlagMulti
kClickFlagRmb
kClickFlagDbl

InterpolatedAnimation::Easing

kLinear
kEaseIn2x
kEaseIn3x
kEaseOut2x
kEaseOut3x
kEaseInOutCos
kEaseInOut2x

GLX::TransactionStage

kTransactionStageNone
kTransactionStageBegin
kTransactionStagePerform
kTransactionStageEnd
kTransactionStageCancel

AbstractList::SelectionMode

kSelectionModeSingle
kSelectionModeMulti
kSelectionModeMultiToggle

GLX::Colour

using Colour = System::Colour;

GLX::ColourPoints

using ColourPoints = Array < Tuple < Point <Float32> ,System::Colour> >;

GLX::KeyCode

using KeyCode = System::KeyCode;

GLX::ModifierKeys

using ModifierKeys = System::ModifierKeys;

GLX::MouseCursor

using MouseCursor = System::MouseCursor;

GLX::Point

using Point = System::fPoint;

GLX::Points

using Points = Array < Point <Float32> >;

GLX::Rect

using Rect = System::fRect;

GLX::Size

using Size = System::fSize;

GLX::Activate

void Activate(Object& object, bool state);

GLX::ActivateBranch

void ActivateBranch(Object& object, bool state);

GLX::AddAbsolute

TRef <Object> AddAbsolute(Object& parent, Object& child);
TRef <Object> AddAbsolute(Object& parent, Object& child, Point position);

GLX::AddDottedLine

void AddDottedLine(Points& points, Point from, Point to, Size pixel_size);

GLX::AddEllipseFill

void AddEllipseFill(Points& points, const Rect& rect, Float32 start, Float32 sweep);

GLX::AddEllipseOutline

void AddEllipseOutline(Points& points, const Rect& rect, Size width, Float32 start, Float32 sweep);

GLX::AddFloat

TRef <Object> AddFloat(Object& parent, Object& child, Orientation x_position, Orientation y_position);
TRef <Object> AddFloat(Object& parent, Object& child, Alignment alignment);

GLX::AddInline

TRef <Object> AddInline(Object& parent, Object& child, Orientation ortho_position);

GLX::AddInlineFlex

TRef <Object> AddInlineFlex(Object& parent, Object& child, Orientation ortho_position);

GLX::AddPath

void AddPath(Points& points, const ArrayView < Point <Float32> >& path, bool& closed);

GLX::AddPointsWithColour

void AddPointsWithColour(ColourPoints& colour_points, const ArrayView < Point <Float32> >& colour, const Colour& input);

GLX::AddPolygonFill

void AddPolygonFill(Points& points, const ArrayView < Point <Float32> >& input);

GLX::AddRectFill

void AddRectFill(Points& points, const Rect& rect);
void AddRectFill(ColourPoints& colour_points, const Colour& colour, const Rect& rect);

GLX::AddRectOutline

void AddRectOutline(Points& points, const Rect& rect, const Margin& width, Size pixel_size);
void AddRectOutline(ColourPoints& colour_points, const Colour& colour, const Rect& rect, const Margin& width, Size pixel_size);

GLX::AddRoundedFill

void AddRoundedFill(Points& points, const Rect& rect, const Corners& corners, Float32 corner_step);
void AddRoundedFill(Points& points, const Rect& rect, Float32 corner, Float32 corner_step);

GLX::AddRoundedOutline

void AddRoundedOutline(Points& points, const Rect& rect, const Margin& width, const Corners& corners, Float32 corner_step);
void AddRoundedOutline(Points& points, const Rect& rect, const Margin& width, Float32 corner, Float32 corner_step);

GLX::AddRoundedTriangleFill

void AddRoundedTriangleFill(Points& points, const Rect& rect, Float32 corner, Alignment direction, Size pixel_size);

GLX::AddRoundedTriangleOutline

void AddRoundedTriangleOutline(Points& points, const Rect& rect, Float32 width, Float32 corner, Alignment direction, Size pixel_size);

GLX::AddStretch

TRef <Object> AddStretch(Object& parent, Object& child);

GLX::AddTriangleFill

void AddTriangleFill(Points& points, const Rect& rect, Alignment direction);

GLX::AddTriangleOutline

void AddTriangleOutline(Points& points, const Rect& rect, Float32 width, Alignment direction, Size pixel_size);

GLX::AttachAnimationClock

void AttachAnimationClock(Object& object, Key32 id, const Function <void(Float32)>& callback);

GLX::AttachPeriodicClock

void AttachPeriodicClock(Object& object, Key32 id, Float32 interval, const Function <void()>& callback);

GLX::BindClick

TRef <Object> BindClick(Object& object, const Function <void()>& callback);

GLX::BindEvent

void BindEvent(Object& object, Key32 event_id, const Function <bool(Object&, Event&)>& callback);

GLX::BindEventVoid

void BindEventVoid(Object& object, Key32 event_id, const Function <void()>& callback);

GLX::BranchContains

bool BranchContains(const Object& parent, const Object& child);

GLX::CalculateAbs

Pair < Point <Float32> , Size <Float32> > CalculateAbs(const Object& object);
Pair < Point <Float32> , Size <Float32> > CalculateAbs(const Object& parent, const Object& object);

GLX::CalculateAbsoluteRect

Rect CalculateAbsoluteRect(const Object& object);

GLX::CalculateRelativeRect

Rect CalculateRelativeRect(const Object& parent, const Object& object);

GLX::CancelDragDrop

void CancelDragDrop();

GLX::CaptureWindow

Tuple <System::BitmapInfo, Array <UInt8> > CaptureWindow(const WindowClient& window);

GLX::ClearText

void ClearText(Object& object, Key32 id_opt);

GLX::CloseContextMenu

void CloseContextMenu();

GLX::CreateAnimationClock

TRef <Object> CreateAnimationClock(const Function <void(Float32)>& callback);

GLX::CreateCallbackAnimation

TRef <Animation> CreateCallbackAnimation(const Function <void(Object&)>& callback);

GLX::CreateColourPropertyAnimation

TRef <InterpolatedAnimation> CreateColourPropertyAnimation(Key32 property_id, const Colour& from, const Colour& to);

GLX::CreateDragDropBeginListener

TRef <Object> CreateDragDropBeginListener(const Function <void(Object&)>& callback);

GLX::CreateDragDropEndListener

TRef <Object> CreateDragDropEndListener(const Function <void()>& callback);

GLX::CreateDragDropTargetListener

TRef <Object> CreateDragDropTargetListener(const Function <void(Object&)>& callback);

GLX::CreateFloatPropertyAnimation

TRef <InterpolatedAnimation> CreateFloatPropertyAnimation(Key32 property_id, Float32 from, Float32 to);

GLX::CreateInterpolatedAnimation

TRef <InterpolatedAnimation> CreateInterpolatedAnimation(const Function <void(Object&, Float32)>& callback);

GLX::CreateLogarithmicAnimation

TRef <Animation> CreateLogarithmicAnimation(Float32 from, Float32 to, const Function <void(Object&, Float32)>& callback, Float32 decay_factor);

GLX::CreateMarginPropertyAnimation

TRef <InterpolatedAnimation> CreateMarginPropertyAnimation(Key32 property_id, const Margin& from, const Margin& to);

GLX::CreateMaxBoundsAnimation

TRef <Animation> CreateMaxBoundsAnimation(Key32 bounds_id, bool yaxis, Float32 from, Float32 to);

GLX::CreateOpacityAnimation

TRef <InterpolatedAnimation> CreateOpacityAnimation(Object& target, Key32 id, Float32 from, Float32 to);

GLX::CreatePeriodicClock

TRef <Object> CreatePeriodicClock(Float32 interval, const Function <void()>& callback);

GLX::CreatePointPropertyAnimation

TRef <InterpolatedAnimation> CreatePointPropertyAnimation(Key32 property_id, Point from, Point to);

GLX::CreatePositionAnimation

TRef <InterpolatedAnimation> CreatePositionAnimation(bool y, Float32 from, Float32 to);

GLX::CreateSizePropertyAnimation

TRef <InterpolatedAnimation> CreateSizePropertyAnimation(Key32 property_id, Size from, Size to);

GLX::CreateStateAnimation

TRef <Animation> CreateStateAnimation(Key32 state);

GLX::CreateWaitAnimation

TRef <InterpolatedAnimation> CreateWaitAnimation();

GLX::DetachClock

void DetachClock(Object& object, Key32 id);

GLX::Emit

bool Emit(Object& src, Key32 id, VARGS... id_value_pairs);

GLX::EnableAutoFit

void EnableAutoFit(Object& object, bool x, bool y);

GLX::EnableMouse

void EnableMouse(Object& object, bool enable, bool intercept);

GLX::EnablePointerCapture

void EnablePointerCapture(Event& e, bool enable, bool incremental);

GLX::EnableTabNavigation

void EnableTabNavigation(Object& root);

GLX::Enter

void Enter(Object& object, UInt8 flags);

GLX::ExceedsDragThreshold

bool ExceedsDragThreshold(Point drag, Float32 sens);

GLX::Exit

void Exit(Object& object, bool detach, UInt8 or_flags_opt);

GLX::FindStyle

ConstTRef <Style> FindStyle(const Object& object, Key32 id);
ConstTRef <Style> FindStyle(const Style& style, Key32 id);

GLX::FocusBranch

void FocusBranch(Object& branch_root);

GLX::GetBounds

const Pair < Size <Float32> , Size <Float32> >& GetBounds(const Object& object, Key32 id);

GLX::GetClickFlags

UInt8 GetClickFlags(const Event& e);

GLX::GetClip

Pair <bool,bool> GetClip(const Object& object, Key32 id);

GLX::GetDelta

Point GetDelta(const Event& e);

GLX::GetDragDropData

TRef <Object> GetDragDropData(Event& e);

GLX::GetFocus

TRef <Object> GetFocus();

GLX::GetKeyCharacter

WChar GetKeyCharacter(const Event& e);

GLX::GetKeyCode

KeyCode GetKeyCode(const Event& e);

GLX::GetModifierKeys

UInt8 GetModifierKeys(const Event& e);

GLX::GetOpacity

Float32 GetOpacity(const Object& object, Key32 id);

GLX::GetPointerFlags

UInt8 GetPointerFlags(const Event& e);

GLX::GetPointerPosition

Point GetPointerPosition(const Object& object, const Event& e);
Point GetPointerPosition(const WindowClient& window);

GLX::GetPointerSlot

UInt8 GetPointerSlot(const Event& e);

GLX::GetPosition

Point GetPosition(const Event& e);

GLX::GetText

WString::View GetText(const Object& object, Key32 id_opt);

GLX::GetTimestamp

Float64 GetTimestamp(const Event& e);

GLX::IsActive

bool IsActive(const Object& object);

GLX::IsDoubleClick

bool IsDoubleClick(const Event& e);

GLX::IsLeftClick

bool IsLeftClick(const Event& e);

GLX::IsRightClick

bool IsRightClick(const Event& e);

GLX::IsSelected

bool IsSelected(const Object& object);

GLX::LookupBranchIndex

Idx LookupBranchIndex(const Object& parent, const Object& child);

GLX::LookupChildAtIndex

TRef <Object> LookupChildAtIndex(Object& parent, UInt32 idx);

GLX::LookupIndex

Idx LookupIndex(const Object& child);

GLX::OpenContextMenu

Reference <Menu> OpenContextMenu(Object& src, Key32 context_opt, Key32 style_opt);

GLX::QueryAntecedent

const Event* QueryAntecedent(const Event& e, Key32 id, const Event* fallback);

GLX::QueryChildById

Object* QueryChildById(Object& parent, Key32 id, Object* fallback);

GLX::QueryDragDropData

TYPE* QueryDragDropData(Event& e);

GLX::QueryElementById

Object* QueryElementById(Object& object, Key32 id, Object* fallback);

GLX::RGB

Colour RGB(UInt8 grey);
Colour RGB(UInt8 grey, UInt8 alpha);
Colour RGB(UInt8 red, UInt8 green, UInt8 blue);
Colour RGB(UInt8 red, UInt8 green, UInt8 blue, UInt8 alpha);

GLX::RedirectFocus

void RedirectFocus(Object& branch_root, Object& object);

GLX::Rescale

void Rescale(const ArrayRegion < Point <Float32> >& points, Size scale);
void Rescale(const ArrayRegion < Tuple < Point <Float32> ,System::Colour> >& colour_points, Size scale);

GLX::RetrieveStyleSheet

ConstTRef <StyleSheet> RetrieveStyleSheet(const WString::View& path, const Data::PropertySet& options_opt);

GLX::Rotate

void Rotate(const ArrayRegion < Point <Float32> >& points, Point origin, Float32 angle_normalised);
void Rotate(const ArrayRegion < Tuple < Point <Float32> ,System::Colour> >& colour_points, Point origin, Float32 angle_normalised);

GLX::Run

void Run(Object& target, Key32 id, TRef <Animation> animation);
void Run(Object& target, Key32 id, Float32 time, TRef <Animation> animation);
void Run(Object& target, Key32 id, Float32 time, InterpolatedAnimation::Easing easing, TRef <InterpolatedAnimation> animation);

GLX::ScaleDelta

Point ScaleDelta(const Object& object, Point window_coordinates_delta);

GLX::Select

void Select(Object& object, bool select);

GLX::SelectBranch

void SelectBranch(Object& object, bool select);

GLX::SelectChildren

void SelectChildren(Object& object, bool select);

GLX::Send

bool Send(Object& src, Key32 id, VARGS... id_value_pairs);

GLX::SetBounds

void SetBounds(Object& object, Key32 id, const Size& min, const Size& max);

GLX::SetCanvas

void SetCanvas(Object& object, Key32 id, const Function <void(GLX::CanvasContext&)>& callback);

GLX::SetClip

void SetClip(Object& object, Key32 id, bool x, bool y);

GLX::SetColourCanvas

void SetColourCanvas(Object& object, Key32 id, const Function <void(GLX::ColourCanvasContext&)>& callback);

GLX::SetEventDelegate

void SetEventDelegate(Object& object, Key32 delegate_id, const Function <bool(Object&, Event&)>& callback);

GLX::SetFlow

void SetFlow(Object& object, FlowFlags flags);

GLX::SetGraphicCanvas

void SetGraphicCanvas(Object& object, Key32 id, const Function <void(GLX::GraphicCanvasContext&)>& callback);

GLX::SetOnStyle

void SetOnStyle(Object& object, Key32 delegate_id, const Function <void(const Style &)>& callback);

GLX::SetOpacity

void SetOpacity(Object& object, Key32 id, Float32 opacity);

GLX::SetState

void SetState(Object& object, Key32 state, bool value);

GLX::SetText

void SetText(Object& object, const WString& value, Key32 id_opt);

GLX::StartDragDrop

void StartDragDrop(TRef <Object> data, MouseCursor dragover, MouseCursor block);

GLX::Stop

void Stop(Object& target, Key32 id);

GLX::ToggleState

bool ToggleState(Object& object, Key32 state);

GLX::TransformPosition

Point TransformPosition(const Object& object, Point window_coordinates_position);

GLX::Translate

void Translate(const ArrayRegion < Point <Float32> >& points, Point offset);
void Translate(const ArrayRegion < Tuple < Point <Float32> ,System::Colour> >& colour_points, Point offset);

GLX::UnbindEvent

void UnbindEvent(Object& object, Key32 event_id);

GLX::UnsetBounds

void UnsetBounds(Object& object, Key32 id);

GLX::UnsetCanvas

void UnsetCanvas(Object& object, Key32 id);

GLX::UnsetClip

void UnsetClip(Object& object, Key32 id);

GLX::UnsetOnStyle

void UnsetOnStyle(Object& object, Key32 delegate_id);

GLX::UnsetOpacity

void UnsetOpacity(Object& object, Key32 id);

GLX::CanvasContext

GLX::ColourCanvasContext

GLX::Corners

GLX::GraphicCanvasContext

GLX::Margin

Size Margin::near;

Size Margin::far;

GLX::Range

Float32 Range::start;

Float32 Range::length;

GLX::AbstractList

Inherits from Object

void AbstractList::SetSelectionMode(AbstractList::SelectionMode mode);

UInt32 AbstractList::GetNumItem();

void AbstractList::SelectAll();

void AbstractList::SelectNone();

bool AbstractList::Select(UInt32 idx, bool multi);

void AbstractList::Deselect(UInt32 idx);

bool AbstractList::SelectNext(bool extend);

bool AbstractList::SelectPrev(bool extend);

void AbstractList::EnumerateSelection(UInt32 start, UInt32 range, const Function <void(UInt idx, UInt n)>& callback);

void AbstractList::Reveal(UInt32 idx);

GLX::AbstractViewBar

Inherits from Object

GLX::AbstractViewPort

Inherits from Object

void AbstractViewPort::SetContent(TRef <Object> content, Key32 style_id_opt);

TRef <Object> AbstractViewPort::GetContent();
ConstTRef <Object> AbstractViewPort::GetContent();

void AbstractViewPort::InvertScrollAxis(bool invert);

TRef <Object> AbstractViewPort::CreateListener(const Function <void()>& callback);

void AbstractViewPort::SetMinView(Size size);

Size AbstractViewPort::GetMinView();

Size AbstractViewPort::GetExtent();

void AbstractViewPort::SetView(const Rect& view);

const Rect& AbstractViewPort::GetView();

Size AbstractViewPort::GetPixelsPerUnit();

void AbstractViewPort::StartScroll(bool yaxis, Float32 offset);

void AbstractViewPort::StopScroll(bool yaxis);

void AbstractViewPort::Reveal(bool yaxis, Float32 offset, Float32 range, Float32 padding, bool animate);

void AbstractViewPort::EnableAutoScroll(Float32 amount, bool scoped);

void AbstractViewPort::DisableAutoScroll();

ConstTRef <Object> AbstractViewPort::GetBody();

TRef <AbstractViewBar> AbstractViewPort::GetViewBar(bool yaxis);

GLX::Animation

Inherits from Object

void Animation::SetTime(Float32 time);

void Animation::SetTarget(Object& target);

void Animation::Play();

GLX::Button

Inherits from Object

GLX::ContainerAnimation

Inherits from Animation

void ContainerAnimation::Clear();

void ContainerAnimation::Add(Animation& animation);

GLX::Event

Inherits from Data::PropertySet

Key32 Event::id;

TRef <Event> Event::Clone();

GLX::Form

Inherits from Object

const TRef <Label> Form::header;

const TRef <Object> Form::body;

GLX::InterpolatedAnimation

Inherits from Animation

GLX::Label

Inherits from Object

GLX::List

Inherits from AbstractList

GLX::Menu

Inherits from ScrollArea

void Menu::Clear();

TRef <Object> Menu::AddItem(const WString::View& label);
TRef <Object> Menu::AddItem(TRef <Object> item);

TRef <Object> Menu::AddSeparator();
TRef <Object> Menu::AddSeparator(TRef <Object> item);

TRef <Object> Menu::AddSubMenu(const WString::View& label);
TRef <Object> Menu::AddSubMenu(TRef <Object> item);

TRef <Object> Menu::GetParentItem();

bool Menu::OpenSubMenu(Object& item);

GLX::Multi

Inherits from ContainerAnimation

GLX::Object

Inherits from Data::PropertySet

void Object::SetParent(Object& object);

void Object::Clear();

void Object::InsertBefore(Object& object);

void Object::InsertAfter(Object& object);

void Object::Detach();

void Object::SendBottom();

void Object::SendTop();

void Object::SetMouseCursor(MouseCursor mousecursor);

MouseCursor Object::GetMouseCursor();

void Object::SetStyle(const Style& style);

ConstTRef <Style> Object::GetStyle();

ConstTRef <Style> Object::GetCurrentStyle();

void Object::UnsetState(Key32 state);

void Object::SetState(Key32 state);

bool Object::CheckState(Key32 state);

void Object::EnablePointer(bool enable, bool active);

Pair <bool,bool> Object::PointerEnabled();

void Object::EnableMultiTouch(bool enable);

bool Object::MultiTouchEnabled();

void Object::Focus();

bool Object::ProcessEvent(Object& src, Event& e);

bool Object::Emit(Event& e);

void Object::RebuildLayout();

void Object::Redraw();

void Object::Update();

void Object::OnAttachWindow();

void Object::OnDetachWindow();

void Object::OnClock(Float32 delta);

void Object::OnUpdate();

void Object::OnSetStyle(const Style& style);

bool Object::OnEvent(Object& src, Event& e);

GLX::PlayList

Inherits from ContainerAnimation

void PlayList::EnableLoop(bool enable);

GLX::Popup

Inherits from Object

GLX::RangeBar

Inherits from AbstractViewBar

GLX::RotarySlider

Inherits from Object

void RotarySlider::SetSensitivity(Float32 pixels);

bool RotarySlider::SetRange(Float32 min, Float32 max, Float32 step);

Pair <Range,Float32> RotarySlider::GetRange();

void RotarySlider::SetDefault(Float32 value);

Float32 RotarySlider::GetDefault();

void RotarySlider::Reset();

bool RotarySlider::SetValue(Float32 value);

Float32 RotarySlider::GetValue();

GLX::ScrollArea

Inherits from AbstractViewPort

GLX::Selector

Inherits from Object

void Selector::EnableContentAutoFit(bool enable);

void Selector::Clear();

void Selector::AddPanel(TRef <Object> item, Key32 style_id_opt);

void Selector::RemovePanel(UInt32 idx);

UInt32 Selector::GetNumPanel();

TRef <Object> Selector::GetPanel(UInt32 idx);

void Selector::SelectPanel(UInt32 idx);

Idx Selector::GetCurrentIndex();

GLX::Split

Inherits from Object

GLX::Style

Inherits from Data::PropertySet

const Key32 Style::id;

void Style::SetParent(Style& style);

void Style::Clear();

void Style::InsertBefore(Style& style);

void Style::InsertAfter(Style& style);

void Style::Detach();

void Style::Attach(Style& child);

GLX::StyleSheet

Inherits from Style

const Key32 StyleSheet::path;

GLX::TabGroup

Inherits from Form

void TabGroup::Clear();

TRef <Object> TabGroup::AddPanel(const WString::View& label, TRef <Object> content, Key32 style_id, Key32 tab_style_id);

void TabGroup::RemovePanel(UInt32 idx);

TRef <Selector> TabGroup::GetSelector();
ConstTRef <Selector> TabGroup::GetSelector();

GLX::TextArea

Inherits from ScrollArea

void TextArea::ClearText();

void TextArea::SetText(const WString& label);

WString::View TextArea::GetText();

GLX::VirtualList

Inherits from AbstractList

void VirtualList::SetPopulateCallback(const Function <void(UInt start, ArrayRegion <Reference<GLX::Object>> items, const GLX::Style & style)>& callback);

void VirtualList::ClearItems();

void VirtualList::SetNumItem(UInt32 n, bool force_refresh);

void VirtualList::Rebuild();

TRef <Object> VirtualList::GetItem(UInt32 idx);

GLX::WindowClient

Inherits from Object

GLX::ZoomArea

Inherits from AbstractViewPort

---

Reflex > SIMD

SIMD::Boolean

kBooleanFalse
kBooleanTrue

SIMD::BoolV4

using BoolV4 = TypeV4 <Boolean>;

SIMD::FloatV4

using FloatV4 = TypeV4 <Float32>;

SIMD::IntV4

using IntV4 = TypeV4 <Int32>;

SIMD::Abs

FloatV4 Abs(const FloatV4& value);
IntV4 Abs(const IntV4& value);

SIMD::And

BoolV4 And(const BoolV4& a, const BoolV4& b);

SIMD::Any

bool Any(const BoolV4& value);

SIMD::ClipNormal

FloatV4 ClipNormal(const FloatV4& value);

SIMD::Count

Int32 Count(const BoolV4& value);

SIMD::Empty

bool Empty(const BoolV4& value);

SIMD::Exp

FloatV4 Exp(const FloatV4& value);

SIMD::Exp2

FloatV4 Exp2(const FloatV4& value);

SIMD::Full

bool Full(const BoolV4& value);

SIMD::GetFlags

Int32 GetFlags(const BoolV4& value);

SIMD::GetFree

UInt32 GetFree(const BoolV4& value);

SIMD::Invert

FloatV4 Invert(const FloatV4& value);

SIMD::Log

FloatV4 Log(const FloatV4& value);

SIMD::Log2

FloatV4 Log2(const FloatV4& value);

SIMD::Max

FloatV4 Max(const FloatV4& a, const FloatV4& b);
IntV4 Max(const IntV4& a, const IntV4& b);

SIMD::Min

FloatV4 Min(const FloatV4& a, const FloatV4& b);
IntV4 Min(const IntV4& a, const IntV4& b);

SIMD::Modulo

FloatV4 Modulo(const FloatV4& a, const FloatV4& b);

SIMD::Not

BoolV4 Not(const BoolV4& a);

SIMD::Or

BoolV4 Or(const BoolV4& a, const BoolV4& b);

SIMD::Pow

FloatV4 Pow(const FloatV4& x, const FloatV4& y);

SIMD::Reciprocal

FloatV4 Reciprocal(const FloatV4& value);

SIMD::RoundDown

FloatV4 RoundDown(const FloatV4& value);

SIMD::RoundNearest

FloatV4 RoundNearest(const FloatV4& value);

SIMD::Select

TypeV4 <TYPE> Select(const BoolV4& mask, const TypeV4 <TYPE>& true_value, const TypeV4 <TYPE>& false_value);
TypeV4 <TYPE> Select(const BoolV4& mask, const TypeV4 <TYPE>& true_value);

SIMD::SelectNot

TYPE SelectNot(const BoolV4& a, const TYPE& b);

SIMD::Sign

FloatV4 Sign(const FloatV4& value);

SIMD::SquareRoot

FloatV4 SquareRoot(const FloatV4& x);

SIMD::operator!=

BoolV4 operator!=(const FloatV4& a, const FloatV4& b);
BoolV4 operator!=(const IntV4& a, const IntV4& b);
BoolV4 operator!=(const BoolV4& a, const BoolV4& b);

SIMD::operator&

IntV4 operator&(const IntV4& a, const IntV4& b);

SIMD::operator*

FloatV4 operator*(const FloatV4& a, const FloatV4& b);
IntV4 operator*(const IntV4& a, const IntV4& b);

SIMD::operator+

FloatV4 operator+(const FloatV4& a, const FloatV4& b);
IntV4 operator+(const IntV4& a, const IntV4& b);

SIMD::operator-

FloatV4 operator-(const FloatV4& value);
FloatV4 operator-(const FloatV4& a, const FloatV4& b);
IntV4 operator-(const IntV4& a, const IntV4& b);

SIMD::operator/

FloatV4 operator/(const FloatV4& a, const FloatV4& b);

SIMD::operator<

BoolV4 operator<(const FloatV4& a, const FloatV4& b);
BoolV4 operator<(const IntV4& a, const IntV4& b);

SIMD::operator<=

BoolV4 operator<=(const FloatV4& a, const FloatV4& b);

SIMD::operator==

BoolV4 operator==(const FloatV4& a, const FloatV4& b);
BoolV4 operator==(const IntV4& a, const IntV4& b);
BoolV4 operator==(const BoolV4& a, const BoolV4& b);

SIMD::operator>

BoolV4 operator>(const FloatV4& a, const FloatV4& b);
BoolV4 operator>(const IntV4& a, const IntV4& b);

SIMD::operator>=

BoolV4 operator>=(const FloatV4& a, const FloatV4& b);

SIMD::operator|

IntV4 operator|(const IntV4& a, const IntV4& b);

template SIMD::TypeV4 <TYPE>

TYPE TypeV4::data;

TypeV4 <TYPE>& TypeV4::operator=(const TypeV4 <TYPE>& value);
TypeV4 <TYPE>& TypeV4::operator=(TYPE value);

void TypeV4::Set(TYPE value);
void TypeV4::Set(TYPE a, TYPE b, TYPE c, TYPE d);

TypeV4 <TYPE>& TypeV4::operator+=(const TypeV4 <TYPE>& value);

TypeV4 <TYPE>& TypeV4::operator-=(const TypeV4 <TYPE>& value);

TypeV4 <TYPE>& TypeV4::operator*=(const TypeV4 <TYPE>& value);

TypeV4 <TYPE>& TypeV4::operator/=(const TypeV4 <TYPE>& value);

TYPE& TypeV4::operator[](UInt32 idx);
const TYPE& TypeV4::operator[](UInt32 idx);

TYPE* TypeV4::GetData();
const TYPE* TypeV4::GetData();

TYPE TypeV4::ReadFirst();

---

Reflex > System

System::Path

kPathTemp
kPathDesktop
kPathApplicationData
kPathUserData
kPathUserDocuments

HttpConnection::Response

kResponseAborted
kResponseNoConnection
kResponseOK
kResponsePartialContent
kResponseMovedPermanently
kResponseFound
kResponseBadRequest
kResponseUnauthorized
kResponseForbidden
kResponseNotFound
kResponseInternalServerError
kResponseServiceUnavailable

System::MouseCursor

kMouseCursorInvisible
kMouseCursorArrow
kMouseCursorWait
kMouseCursorMove
kMouseCursorLeftRight
kMouseCursorTopBottom
kMouseCursorTopLeftBottomRight
kMouseCursorBottomLeftTopRight
kMouseCursorPointer
kMouseCursorDrag
kMouseCursorText
kMouseCursorBlock
kMouseCursorZoom
kNumMouseCursor

System::KeyCode

kKeyCodeNull
kKeyCodeF1
kKeyCodeF12
kKeyCodeTab
kKeyCodeEnter
kKeyCodeEscape
kKeyCodeSpace
kKeyCodeBackspace
kKeyCodeInsert
kKeyCodeDelete
kKeyCodeHome
kKeyCodeEnd
kKeyCodePageUp
kKeyCodePageDown
kKeyCodeUp
kKeyCodeDown
kKeyCodeLeft
kKeyCodeRight
kKeyCodeNumericDivide
kKeyCodeNumericMultiply
kKeyCodeNumericMinus
kKeyCodeNumericPlus
kKeyCode1
kKeyCode0
kKeyCodeMinus
kKeyCodePlus
kKeyCodeSlash
kKeyCodeA
kKeyCodeZ
kKeyCodeBracketOpen
kKeyCodeBracketClose
kNumKeyCode

System::ModifierKeys

kModifierKeyShift
kModifierKeyCtrl
kModifierKeyAlt
kModifierKeySystem

System::ImageFormat

kImageFormatRGB
kImageFormatBGR
kImageFormatRGBA
kImageFormatBGRA
kImageFormatLuminance

System::ColourPoint

using ColourPoint = Tuple < Point <Float32> ,Colour>;

System::fPoint

using fPoint = Point <Float32>;

System::fRect

using fRect = Rect <Float32>;

System::fSize

using fSize = Size <Float32>;

System::Delete

bool Delete(const WString& path);

System::Exists

bool Exists(const WString& path);

System::GetElapsedTime

Float64 GetElapsedTime();

System::GetNumProcessor

UInt32 GetNumProcessor();

System::GetOperatingSystemVersion

CString GetOperatingSystemVersion();

System::GetPath

WString GetPath(Path path_id);

System::GetProcessID

UInt32 GetProcessID();

System::GetSystemID

UInt64 GetSystemID();

System::GetTime

UInt64 GetTime();

System::IsDirectory

bool IsDirectory(const WString& path);

System::MakeDirectory

bool MakeDirectory(const WString& path);

System::Open

bool Open(const WString& path);

System::Rename

bool Rename(const WString& from, const WString& to);

System::BitmapInfo

ImageFormat BitmapInfo::format;

Int32 BitmapInfo::pixel_density;

Size <Int32> BitmapInfo::size;

System::Colour

Float32 Colour::r;

Float32 Colour::g;

Float32 Colour::b;

Float32 Colour::a;

HttpConnection::ReceiveDataFn

HttpConnection::ReceiveHeaderFn

System::DirectoryIterator

Inherits from Object

System::DiskIterator

Inherits from Object

System::DynamicLibrary

Inherits from Object

System::FileHandle

Inherits from Object

bool FileHandle::IsWriteable();

UInt64 FileHandle::GetSize();

void FileHandle::SetPosition(UInt64 position);

UInt64 FileHandle::GetPosition();

UInt32 FileHandle::Read(void* bytes, UInt32 buffer_capacity);

UInt32 FileHandle::Write(const void* bytes, UInt32 size);

bool FileHandle::Truncate();

bool FileHandle::Flush(bool commit);

System::HttpConnection

Inherits from Object

void HttpConnection::SetTimeout(Float32 connection, Float32 transfer);

HttpConnection::Response HttpConnection::Request(const CString::View& method, const CString::View& resource, const ArrayView < Pair < Array <char> , Array <char> > >& headers, const ArrayView <UInt8>& body, const HttpConnection::ReceiveHeaderFn& receive_header, const HttpConnection::ReceiveDataFn& receive_data);

System::Process

Inherits from Thread

System::Renderer

Inherits from Object

System::Renderer::Canvas

Inherits from Object

System::Renderer::Graphic

Inherits from Object

System::Task

Inherits from Object

System::Thread

Inherits from Task

System::Window

Inherits from Object

---