### Install Linux Development Dependencies for NoesisGUI

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.GettingStartedNative

This command installs essential OpenGL (mesa-common-dev) and X11 (libx11-dev) development headers required for building NoesisGUI applications on Ubuntu Linux.

```bash
sudo apt-get install mesa-common-dev libx11-dev
```

--------------------------------

### NoesisGUI Android Build Prerequisites and Environment Setup

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.GettingStartedNative

This section outlines the essential software requirements and environment variable configurations necessary for successfully building NoesisGUI applications for Android. It details required tools like GNU Make, JDK, Android NDK, and specific SDK package versions, along with critical environment variables and PATH binaries.

```APIDOC
Required Tools:
  - GNU Make: 4.2.1+
  - JDK: 22+
  - Android NDK: r28.1+

Tested Android SDK Package Versions:
  - build-tools;36.0.0: Version 36.0.0 (Android SDK Build-Tools 36)
  - ndk;28.1.13356709: Version 28.1.13356709 (NDK (Side by side) 28.1.13356709)
  - platform-tools: Version 35.0.2 (Android SDK Platform-Tools)
  - platforms;android-36: Version 2 (Android SDK Platform 36)

Environment Variables:
  - ANDROID_NDK: Path to NDK (e.g., C:\\Android\\SDK\\ndk\\28.1.13356709)
  - ANDROID_PLATFORM: Path to SDK platforms (e.g., C:\\Android\\SDK\\platforms\\android-36)
  - JAVA_HOME: Path to Java installation (e.g., C:\\Program Files\\Java\\jdk-22)

Binaries in PATH:
  - NDK prebuilt toolchains: clang, clang++, llvm-strip, llvm-objcopy
  - Java compiler: javac
  - Build-tools: d8, aapt, zipalign, apksigner
  - Platform-tools: adb
```

--------------------------------

### Build NoesisGUI Samples for WebGL with Emscripten

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.GettingStartedNative

This command compiles the NoesisGUI samples for WebGL using GNU Make and the Emscripten toolchain, targeting the 'Release' build configuration for web deployment.

```bash
make -f NoesisGUI-wasm.mk CONFIG=Release
```

--------------------------------

### Build NoesisGUI Samples on Linux with Make

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.GettingStartedNative

This command compiles the NoesisGUI samples on Linux using GNU Make, targeting the 64-bit architecture and the 'Release' build configuration for optimized performance.

```bash
make -f NoesisGUI-linux-x86_64.mk CONFIG=Release
```

--------------------------------

### NoesisGUI Sample Application Command Line Switches

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.GettingStartedNative

This section details the various command line arguments supported by NoesisGUI sample applications. These switches allow users to customize rendering options, anti-aliasing, logging verbosity, input emulation, and resource paths for hot-reloading.

```APIDOC
Command Line Switches:
  --render [D3D11|GL|Metal|...]: Overrides the default renderer.
  --vsync [0|1]: Disables vertical synchronization.
  --samples N: Enables multisample anti-aliasing (MSAA), by default it is off.
  --ppaa [0|1]: Enables cheap anti-aliasing (enabled by default).
  --linear: For switching to linear rendering, by default rendering happens in gamma space.
  --lcd [0|1]: Enables subpixel rendering compatible with LCD displays.
  --log_binding: To increase the verbosity of logging when using data binding.
  --emulate_touch: Enables emulation of touch input from mouse events.
  --root dir_path: To read resources from the specified filesystem path (for hot-reloading).
```

--------------------------------

### NoesisGUI C++ DoubleAnimation Start Method Usage

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Animation.SingleTimelines

Demonstrates how to create a DoubleAnimation and start it on a target object and property using the Start method. This example sets From and To values and specifies HandoffBehavior_Compose.

```C++
Ptr<DoubleAnimation> animation = NsCreateComponent<DoubleAnimation>();
animation->SetFrom(40.0f);
animation->SetTo(60.0f);
animation->Start(targetObject, targetProperty, HandoffBehavior_Compose);
```

--------------------------------

### Build NoesisGUI Android Samples with Makefile

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.GettingStartedNative

This command builds the NoesisGUI Android samples using the specified makefile. It targets the ARM architecture and sets the build configuration to Release, compiling the project with optimized settings.

```Makefile
make -f NoesisGUI-android-arm.mk CONFIG=Release
```

--------------------------------

### NoesisGUI Sample Application Keyboard Shortcuts

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.GettingStartedNative

This section lists the keyboard shortcuts available within NoesisGUI sample applications. These shortcuts provide quick access to various debug and visualization tools, including debug toolbar, wireframe mode, batch coloring, pixel overdraw, per-primitive anti-aliasing, performance stats, and RenderDoc capture.

```APIDOC
Shortcut Keys:
  CTRL + T: Display the debug toolbar.
  CTRL + W: Toggles wireframe mode when rendering triangles.
  CTRL + B: Each batch submitted to the GPU is given a unique solid color.
  CTRL + O: Display pixel overdraw using blending layers. Different colors are used for each type of triangle: green for normal, red for opacities and blue for clipping masks.
  CTRL + P: Per-primitive Antialiasing extrudes the contours of the geometry and smooths them. Useful when GPU multisampling is not enabled.
  CTRL + F: Display a performance stats panel.
  F10: Takes a RenderDoc capture.
```

--------------------------------

### Example NoesisGUI License Key Format

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.Licensing

Illustrates the standard format for a NoesisGUI license key, consisting of a project name and the unique alphanumeric key provided upon purchase. This format is used across all SDKs.

```plaintext
NAME: Globex Corporation
KEY : 0KrZJjrt2SYwlUcIzZMGor47iaWruwED83qFJSQR9QXgAKqQ
```

--------------------------------

### XAML LocExtension Usage Example

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/App.ApplicationLauncher._LocExtension

This example demonstrates the full setup for using LocExtension in XAML, including referencing a localization ResourceDictionary via noesis:Loc.Source and utilizing noesis:RichText.Text for BBCode markup. It shows how to bind Image Source and TextBlock content to localized resources, and how to apply a converter with a parameter.

```XAML
<StackPanel
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:noesis="clr-namespace:NoesisGUIExtensions"
  noesis:Loc.Source="Language_en-gb.xaml">
  <Image Source="{noesis:Loc Flag}"/>
  <TextBlock noesis:RichText.Text="{noesis:Loc SoundLabel}"/>
  <TextBlock noesis:RichText.Text="{noesis:Loc TitleLabel, Converter={StaticResource CaseConverter}, ConverterParameter=UpperCase}"/>
</StackPanel>
```

--------------------------------

### Install Default Theme Providers using NoesisApp Framework

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.SDKGuide

Utilizes a helper function from the Noesis Application Framework to install all necessary resource providers for the default theme. This also sets the theme's default font and configures system fallback fonts for broader character support.

```C++
NoesisApp::SetThemeProviders();
```

--------------------------------

### Set NoesisGUI License in C++ SDK

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.Licensing

Provides code examples for setting the NoesisGUI license in C++ projects. This includes direct programmatic setting using Noesis::GUI::SetLicense for projects without the Application Framework, and defining NS_LICENSE_NAME and NS_LICENSE_KEY preprocessor macros in NoesisLicense.h for projects utilizing the Application Framework.

```C++
Noesis::GUI::SetLicense("Globex Corporation", "0KrZJjrt2SYwlUcIzZMGor47iaWruwED83qFJSQR9QXgAKqQ");
```

```C++
// NS_LICENSE_NAME and NS_LICENSE_KEY must be replaced with values your were given when purchasing
// your Noesis license. If you don't want to modify this file (it will be overwritten with each new
// version) you can globally define NS_LICENSE_NAME and NS_LICENSE_KEY in your project.

#define NS_LICENSE_NAME "Globex Corporation"
#define NS_LICENSE_KEY "0KrZJjrt2SYwlUcIzZMGor47iaWruwED83qFJSQR9QXgAKqQ"
```

--------------------------------

### Noesis C++: Ptr<> Implicit Conversion and Usage Examples

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.CppArchitectureGuide

Illustrates how `Ptr<>` instances implicitly convert to raw pointers, allowing seamless integration with APIs expecting raw pointers. Examples include setting a XAML provider and initializing a renderer, showcasing `Ptr<>`'s transparent usage in common Noesis operations.

```cpp
// Read XAMLs from current working directory
GUI::SetXamlProvider(MakePtr<LocalXamlProvider>("."));

// Renderer initialization with an OpenGL device
Ptr<RenderDevice> device = GLFactory::CreateDevice();
_view->GetRenderer()->Init(device);
```

--------------------------------

### XAML Localization ResourceDictionary Example

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/App.ApplicationLauncher._LocExtension

This example shows the content of a "Language_en-gb.xaml" ResourceDictionary, defining localized resources such as an ImageBrush for a flag and System.String entries for text labels, including one with BBCode markup.

```XAML
<ResourceDictionary
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:sys="clr-namespace:System;assembly=mscorlib">
  <ImageBrush x:Key="Flag" ImageSource="Flag_en-gb.png" Stretch="Fill"/>
  <sys:String x:Key="TitleLabel">[b]Localization Sample[/b]</sys:String>
  <sys:String x:Key="SoundLabel">A [i]sound[/i] label</sys:String>
</ResourceDictionary>
```

--------------------------------

### Set NoesisGUI License in C# SDK

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.Licensing

Provides code examples for setting the NoesisGUI license in C# projects. This includes programmatic setting via Noesis.GUI.SetLicense for projects not using the Application Framework, and embedding the license in a NoesisLicense.txt file for projects that use the Application Framework.

```C#
Noesis.GUI.SetLicense("Globex Corporation", "0KrZJjrt2SYwlUcIzZMGor47iaWruwED83qFJSQR9QXgAKqQ");
```

```plaintext
Globex Corporation
0KrZJjrt2SYwlUcIzZMGor47iaWruwED83qFJSQR9QXgAKqQ
```

--------------------------------

### Noesis C++: Value Converter Implementation with Boxing/Unboxing

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.CppArchitectureGuide

Provides a practical example of a value converter (`ThousandConverter`) demonstrating the combined use of boxing and unboxing. It shows how an input `BaseComponent` is unboxed to an integer, processed, and then the result is boxed back into a `BaseComponent` for output.

```cpp
bool ThousandConverter::TryConvert(BaseComponent* value, const Type*, BaseComponent*, Ptr<BaseComponent>& result)
{
    if (Boxing::CanUnbox<int>(value))
    {
        char str[16];
        int v = Boxing::Unbox<int>(value);
        snprintf(str, sizeof(str), "%.2f K", (float)v / 1000.0f);
        result = Boxing::Box(str);
        return true;
    }

    return false;
}
```

--------------------------------

### ItemContainerGenerator: StartBatch Method

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core._ItemContainerGenerator

Starts a container generation batch.

```APIDOC
StartBatch()
  Returns: void
```

--------------------------------

### AnimationTimeline Method: Start

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Animation._Int32Animation

Begins the animation timeline creating a compatible clock.

```APIDOC
AnimationTimeline.Start(target, dp, timeManager, handoff) (Method):
  Begins the animation timeline creating a compatible clock
```

--------------------------------

### Initialize NoesisGUI with Custom Handlers

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.SDKGuide

This C++ code demonstrates the essential steps for initializing NoesisGUI. It shows how to set a custom log handler to capture NoesisGUI messages and how to install a license using `Noesis::GUI::SetLicense` before the main initialization call `Noesis::GUI::Init()`.

```C++
void main()
{
    Noesis::SetLogHandler([](const char*, uint32_t, uint32_t level, const char*, const char* msg)
    {
        // [TRACE] [DEBUG] [INFO] [WARNING] [ERROR]
        const char* prefixes[] = { "T", "D", "I", "W", "E" };
        printf("[NOESIS/%s] %s\n", prefixes[level], msg);
    });

    // Sets the active license
    Noesis::GUI::SetLicense(NS_LICENSE_NAME, NS_LICENSE_KEY);

    // Noesis initialization. This must be the first step before using any NoesisGUI functionality
    Noesis::GUI::Init();

    // ...
}
```

--------------------------------

### Timeline Property: BeginTime

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Animation._Int32Animation

Gets or sets the time at which this Timeline should begin. A timeline's own SpeedRatio setting does not affect its BeginTime. For example, a timeline with a BeginTime of 5 seconds, a SpeedRatio of 2, and a parent timeline with a SpeedRatio of 1 starts after 5 seconds, not 2.5.

```APIDOC
Timeline.BeginTime (Dependency Property, Reflection Property):
  Gets or sets the time at which this Timeline should begin. A timeline's own SpeedRatio setting does not affect its BeginTime. For example, a timeline with a BeginTime of 5 seconds, a SpeedRatio of 2, and a parent timeline with a SpeedRatio of 1 starts after 5 seconds, not 2.5.
```

--------------------------------

### Programmatic UI Creation: Button in C++ and C#

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.XamlIntroduction

These code examples show the procedural equivalent of creating the same Button and Grid UI elements as the XAML example. They demonstrate how to dynamically construct UI in C++ and C#, contrasting with XAML's declarative approach.

```C++
Ptr<Button> button = *new Button();
button->SetContent("Click Me!");

Ptr<Grid> grid = *new Grid();
grid->GetChildren()->Add(button);
```

```C#
Button button = new Button();
button.Content = "Click Me!";

Grid grid = new Grid();
grid.Children.Add(button);
```

--------------------------------

### Define a XAML Resource Dictionary File

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.Resources

Example of a separate XAML file (e.g., CommonResources.xaml) that uses ResourceDictionary as its root element and defines a resource like a SolidColorBrush.

```XAML
<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
        <SolidColorBrush x:Key="RedBrush" Color="#80800000"/>
</ResourceDictionary>
```

--------------------------------

### Define Main Window for Custom Rendering Example

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.CustomRenderTutorial

This XAML snippet defines the main application window for a custom rendering example in NoesisGUI. It sets the window's class, XML namespaces, title, size behavior, and resize mode. Crucially, it embeds a custom 'Game' element from the local namespace, which is intended to encapsulate the custom rendering logic for the application.

```XAML
<Window x:Class="CustomRender.MainWindow"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:local="clr-namespace:CustomRender"
  Title="NoesisGUI - CustomRender"
  SizeToContent="WidthAndHeight"
  ResizeMode="NoResize">

  <local:Game Width="800" Height="600"/>

</Window>
```

--------------------------------

### API Reference: Timeline Methods

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Animation._AnimationTimeline

Documents methods available for the Timeline class, including creating transitions, getting current values, and starting animations. Methods are marked with .

```APIDOC
Timeline Methods:
  CreateTransitionFrom(easing): Returns a new timeline used as transition (used by VisualStateManager)
  GetCurrentValue(defaultOrigin, defaultDestination, clock): Calculates the current animated value depending on current clock state
  Start(target, dp, timeManager, handoff): Begins the animation timeline creating a compatible clock
```

--------------------------------

### NoesisGUI BeginStoryboard Class API Reference

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Animation._BeginStoryboard

Detailed API documentation for the BeginStoryboard class, including its inheritance hierarchy, properties, and methods.

```APIDOC
BeginStoryboard Class
  Namespace: Noesis

  Inheritance Hierarchy:
    - DispatcherObject
    - DependencyObject
    - TriggerAction
    - BeginStoryboard

  Properties:
    - HandoffBehavior (Reflection Property): Gets or sets the proper hand-off behavior to start an animation clock in this storyboard
    - Name (Reflection Property): Gets or sets the name of the BeginStoryboard object. By naming the BeginStoryboard object, the Storyboard can be controlled after it is started
    - Storyboard (Dependency Property): Gets or sets the Storyboard that this BeginStoryboard starts

  Properties (Inherited from DispatcherObject):
    - ThreadId (Reflection Property): Gets the thread this DispatcherObject is associated with. Returns NoThreadId when this object is not attached to any thread.

  Attached Properties: None

  Methods (Inherited from TriggerAction):
    - Invoke(target, nameScope): Performs the action over the supplied element
    - Seal(): Seals the actions
    - SealActions(actions): Seals all actions in the collection
```

--------------------------------

### Core Window Methods

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/App.ApplicationLauncher._Window

This section lists methods directly associated with the GUI core window, covering its lifecycle events (activation, deactivation, closing), initialization, view management, and rendering operations.

```APIDOC
Activated() - Occurs when window becomes the foreground window
Close() - Manually closes window
Closed() - Occurs after window has been closed
Deactivated() - Occurs when window becomes a background window.
Init(display, context, samples, ppaa, lcd, emulateTouch) - Initializes the window with the given display and render context
LocationChanged() - Occurs when the window's location changes
RecreateView(context, emulateTouch) - Creates a new view in the given render context
Render(time) - Renders frame at the given time
ResetView() - Destroys the active view
Shutdown() - Frees allocated render resources
StateChanged() - Occurs when the window's WindowState property changes
```

--------------------------------

### NoesisGUI Core Library Initialization and Handlers

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.Changelog_v30

Illustrates the standard procedure for initializing the NoesisGUI library, including setting custom handlers for logging, error reporting, and memory management, along with providing the necessary license details.

```C++
Noesis::GUI::SetLogHandler(Loghandler);
Noesis::GUI::SetErrorHandler(ErrorHandler);
Noesis::GUI::SetMemoryCallbacks(MemoryCallbacks);
Noesis::GUI::Init(NS_LICENSE_NAME, NS_LICENSE_KEY);
```

--------------------------------

### UIElement Class Methods Reference

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/App.ApplicationLauncher._Window

Detailed API documentation for the methods available on the UIElement class, covering functionalities such as event handling, layout updates, mouse and touch input management, and focus manipulation.

```APIDOC
UIElement Class:
  Methods:
    AddHandler(ev, handler): Adds a handler to the specified routed event
    Arrange(finalRect): Positions child elements and determines a size for a UIElement. Parent elements call this method from their ArrangeCore implementation to form a recursive layout update. This method constitutes the second pass of a layout update
    CaptureMouse(): Attempts to force capture of the mouse to this element
    CaptureTouch(touchDevice): Attempts to force capture of a touch to this element
    Focus(): Attempts to set focus to this element
    Focus(engage): Attempts to set focus to this element indicating if control should be engaged or not
    GetKeyboard(): Gets keyboard input manager
    GetMouse(): Public methods in UIElement Gets mouse input manager
    GetTouchCaptured(touchDevice): Gets element captured by the specified touch device
    GetUIParent(): Gets the logical or visual parent for this element
    GetUIView(): Finds the View where this element is connected to traversing visual or logical ancestors
    InvalidateArrange(): Invalidates the arrange state (layout) for the element. After the invalidation, the element will have its layout updated, which will occur asynchronously unless subsequently forced by UpdateLayout
    InvalidateMeasure(): Invalidates the measurement state (layout) for the element
    InvalidateVisual(): Invalidates the rendering of the element, and forces a complete new layout pass. OnRender is called after the layout cycle is completed
    IsArrangeValid(): Indicates if arrange is valid
    IsMeasureValid(): Indicates if measured size is valid
    Measure(availableSize): Updates the DesiredSize of a UIElement. Parent elements call this method from their own MeasureCore implementations to form a recursive layout update. Calling this method constitutes the first pass of a layout update in the layout system
    MoveFocus(request): Request to move the focus from this element to another element. Returns true if focus is moved successfully, returns false if there is no next element
    PredictFocus(direction): When overridden in a derived class, returns the element that would receive focus for a specified focus traversal direction, without actually moving focus to that element
    RaiseEvent(e): Raises a specific routed event. The RoutedEvent to be raised is identified within the RoutedEventArgs instance that is provided (as the RoutedEvent property of that event data)
    ReleaseAllTouchCaptures(): Releases all captured touch devices from this element
    ReleaseMouseCapture(): Releases the mouse capture, if this element held the capture
    ReleaseTouchCapture(touchDevice): Attempts to release the specified touch device from this element
    RemoveHandler(ev, handler): Removes a handler from the specified routed event
    TranslatePoint(point, relativeTo): Translates a point relative to this element to coordinates of the specified element
    UpdateLayout(): Ensures that all visual child elements of this element are properly updated for layout
```

--------------------------------

### FrameworkElement Events Reference

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/App.ApplicationLauncher._Window

Documents a comprehensive list of routed and non-routed events available on the FrameworkElement class, covering various UI lifecycle stages and interactions like context menus, data context changes, loading, sizing, and tooltips.

```APIDOC
FrameworkElement Events:
  Routed Event ContextMenuClosing: Occurs just before any context menu on the element is closed
  Routed Event ContextMenuOpening: Occurs when any context menu on the element is opened
  Non-routed Event DataContextChanged: Occurs when the data context for this element changes
  Non-routed Event Initialized: Occurs when this element is initialized
  Routed Event Loaded: Occurs when the element is laid out, rendered, and ready for interaction
  Routed Event Reloaded: Occurs when this element xaml gets reloaded as a result of a hot-reload operation
  Routed Event RequestBringIntoView: Occurs when BringIntoView is called on this element
  Routed Event SizeChanged: Occurs when either ActualHeight or ActualWidth properties change value on this element
  Routed Event ToolTipClosing: Occurs just before any tooltip on the element is closed
  Routed Event ToolTipOpening: Occurs when any tooltip on the element is opened
  Routed Event Unloaded: Occurs when the element is removed from within an element tree of loaded elements
```

--------------------------------

### Command Line Example for Hot Reload Root Path

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.ProvidersTutorial

Demonstrates how to use the `--root` command line switch to specify a custom root directory for resources. This allows overriding default embedded implementations and enabling hot reloading for local file system content, facilitating dynamic updates without application restarts.

```Shell
Samples.HelloWorld --root W:/Noesis/NoesisSDK/Native/Src/Packages/Samples/HelloWorld/Data
```

--------------------------------

### Set XAML Properties Using Attribute Syntax

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.XamlIntroduction

This example illustrates how to set properties of an object element using attribute syntax. The 'Fill' property of a Rectangle is set to 'Red', demonstrating how string values are converted by the XAML parser.

```XAML
<Grid xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Fill="Red" />
</Grid>
```

--------------------------------

### DependencyObject Class Methods

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Animation._BeginStoryboard

Documentation for methods available on the DependencyObject class, related to managing dependency properties, animations, and object state.

```APIDOC
DependencyObject:
  ClearAnimation(dp): Clears the animation value of a property
  ClearLocalValue(dp): Clears the local value of a property The property to be cleared is specified by a [DependencyProperty](Gui.DependencySystem._DependencyProperty.html) identifier
  CoerceValue(dp): Coerces and validates the effective property value
  DependencyPropertyChanged(): Returns the PropertyChanged event
  Destroyed(): Destroyed delegate is raised when object is going to be destroyed
  GetBaseValue(dp): Returns the base value without animation nor coerce (this never returns [Expression](Gui.DependencySystem._Expression.html) like GetLocalValue)
  GetExpression(dp): Gets the expression, if any, used to evaluate the specified property value
  GetLocalValue(dp): Returns the local value of a dependency property, if it exists
  GetValue(dp): Returns the current effective value of a dependency property on this instance of a [DependencyObject](Gui.DependencySystem._DependencyObject.html)
  GetValueObject(dp): Returns the current effective value of a dependency property on this instance of a [DependencyObject](Gui.DependencySystem._DependencyObject.html) as a boxed value
  GetValueProvider(dp): Gets the provider that returns the effective value for the specified dependency property
  HasAnimatedProperties(): Returns true if there is any animated property
  InvalidateProperty(dp, priority): Re-evaluates the effective value for the specified dependency property if necessary If null is passed, a full re-evaluation could be needed
  IsCached(dp, provider): Returns if the value is stored in the cache. If true, the priority is returned in the provider field
  IsSealed(): Gets a value that indicates whether this instance is currently sealed (read-only)
  SetAnimation(dp, value): Sets the animated value of a property
  SetCurrentValue(dp, value): Sets the current value of a dependency property. The current value is set on the coerce field, without modifying source or animated value
  SetCurrentValueObject(dp, value): Sets the current value of a dependency property using a boxed value
  SetExpression(dp, expression): Sets the expression to be evaluated dynamically to obtain the value of the property
  SetValue(dp, value): Sets the local value of a dependency property
  SetValueObject(dp, value): Sets the local value (boxed) of a dependency property
```

--------------------------------

### XAML Path Element FlowDirection Example

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.BidiTutorial

This XAML snippet demonstrates how to define Path elements to draw arrows. It illustrates the effect of FlowDirection, showing how paths can inherit direction from a StackPanel or have it explicitly set, affecting the measurement of start and end points.

```XAML
<StackPanel xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  FlowDirection="RightToLeft">

  <Path Stroke="Blue" StrokeThickness="4"
    Data="M300,10L350,30M10,30L352,30M300,50L350,30"/>

  <Path Stroke="Red" StrokeThickness="4"
    Data="M300,10L350,30M10,30L352,30M300,50L350,30"
    FlowDirection="RightToLeft"/>

  <Path Stroke="Green" StrokeThickness="4"
    Data="M300,10L350,30M10,30L352,30M300,50L350,30"
    FlowDirection="LeftToRight"/>

</StackPanel>
```

--------------------------------

### Set NoesisGUI XAML Provider for Specific URI Scheme

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.ProvidersTutorial

This example illustrates how to install a XAML provider that handles URIs using a specific scheme. For instance, it can be configured to process all URIs that begin with 'noesis:///', like 'noesis:///MainWindow.xaml'.

```C++
// This will handle uris like 'noesis:///MainWindow.xaml'
Noesis::GUI::SetSchemeXamlProvider("noesis", xamlProvider);
```

--------------------------------

### XAML Example: Using MoveFocusAction with KeyTrigger

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/App.Interactivity._MoveFocusAction

Demonstrates how to use the MoveFocusAction within a XAML Grid, triggered by a KeyTrigger (e.g., 'D' key) to move focus to the right. This snippet shows the necessary namespace declarations and the interaction trigger setup.

```XAML
<Grid
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:b="http://schemas.microsoft.com/xaml/behaviors"
  xmlns:noesis="clr-namespace:NoesisGUIExtensions;assembly=Noesis.GUI.Extensions">
  <b:Interaction.Triggers>
    <b:KeyTrigger Key="D">
      <noesis:MoveFocusAction Direction="Right"/>
    </b:KeyTrigger>
  </b:Interaction.Triggers>
</Grid>
```

--------------------------------

### Initialize NoesisGUI and Set Global Resource Providers

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.ProvidersTutorial

This snippet demonstrates the essential step of initializing NoesisGUI and then installing global providers for XAML, Texture, and Font resources. These global providers serve as fallbacks for requests not handled by more specific providers.

```C++
Noesis::GUI::Init();

// Install global providers
Noesis::GUI::SetXamlProvider(xamlProvider);
Noesis::GUI::SetTextureProvider(textureProvider);
Noesis::GUI::SetFontProvider(fontProvider);
```

--------------------------------

### XAML Example: Demonstrating Horizontal and Vertical StackPanel Layouts

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.LayoutPanelTutorial

This XAML code provides a comprehensive example of using StackPanels within a Grid. It showcases two horizontal StackPanels and one vertical StackPanel, illustrating how child Border elements are arranged based on the 'Orientation' property and various alignment settings. It also defines gradient brushes for visual styling.

```XAML
<Grid
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="LightGray"
    TextElement.Foreground="Black"
    Margin="10" HorizontalAlignment="Center" VerticalAlignment="Center">

  <Grid.Resources>
    <LinearGradientBrush x:Key="HorBrush" StartPoint="0,0" EndPoint="1,0">
      <GradientStop Offset="0" Color="#FF9BDEFF"/>
      <GradientStop Offset="1" Color="#FF69B5FF"/>
    </LinearGradientBrush>
    <LinearGradientBrush x:Key="VerBrush" StartPoint="0,0" EndPoint="0,1">
      <GradientStop Offset="0" Color="#FF9BDEFF"/>
      <GradientStop Offset="1" Color="#FF69B5FF"/>
    </LinearGradientBrush>
  </Grid.Resources>

  <Grid.ColumnDefinitions>
    <ColumnDefinition Width="*"/>
    <ColumnDefinition Width="4"/>
    <ColumnDefinition Width="Auto"/>
    <ColumnDefinition Width="200"/>
  </Grid.ColumnDefinitions>

  <Grid.RowDefinitions>
    <RowDefinition Height="Auto"/>
    <RowDefinition Height="Auto"/>
    <RowDefinition Height="*"/>
  </Grid.RowDefinitions>
  <TextBlock Text="Horizontal StackPanels" HorizontalAlignment="Center" Grid.ColumnSpan="2" Margin="0,8,0,0"/>
  <StackPanel x:Name="StackPanel1" Background="White" Margin="8,8,8,0" Grid.Row="1" Orientation="Horizontal" HorizontalAlignment="Center" d:LayoutOverrides="Height" >
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource HorBrush}" Margin="4" Padding="0" Width="40" Height="80"/>
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource HorBrush}" Margin="4" Padding="0" Width="40" Height="25" VerticalAlignment="Top"/>
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource HorBrush}" Margin="4" Padding="0" Width="40" Height="25"/>
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource HorBrush}" Margin="4" Padding="0" Width="40" Height="25" VerticalAlignment="Bottom"/>
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource HorBrush}" Margin="4" Padding="0" Width="80"/>
  </StackPanel>
  <StackPanel x:Name="StackPanel2" Background="White" Margin="8" Grid.Row="2" Orientation="Horizontal" HorizontalAlignment="Center" >
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource HorBrush}" Margin="4" Padding="0" Width="40" Height="80"/>
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource HorBrush}" Margin="4" Padding="0" Width="40" Height="25" VerticalAlignment="Top"/>
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource HorBrush}" Margin="4" Padding="0" Width="40" Height="25"/>
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource HorBrush}" Margin="4" Padding="0" Width="40" Height="25" VerticalAlignment="Bottom"/>
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource HorBrush}" Margin="4" Padding="0" Width="80"/>
  </StackPanel>
  <Rectangle Fill="#80808080" Grid.RowSpan="3" StrokeThickness="0" Grid.Column="1"/>
  <TextBlock Text="Vertical StackPanels" HorizontalAlignment="Center" Grid.ColumnSpan="2" d:LayoutOverrides="GridBox" Grid.Column="2" Margin="0,8,0,0"/>
  <StackPanel x:Name="StackPanel3" Background="White" Margin="8" Grid.Row="1" HorizontalAlignment="Center" VerticalAlignment="Center" Grid.Column="2" Grid.RowSpan="2" >
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource VerBrush}" Margin="4" Padding="0" Width="80" Height="40"/>
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource VerBrush}" Margin="4" Padding="0" HorizontalAlignment="Left" Width="25" Height="40"/>
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource VerBrush}" Margin="4" Padding="0" HorizontalAlignment="Center" Width="25" Height="40"/>
    <Border BorderBrush="Black" BorderThickness="1" CornerRadius="8" Background="{DynamicResource VerBrush}" Margin="4" Padding="0" HorizontalAlignment="Right" Width="25" Height="40"/>
```

--------------------------------

### Apply Complex Gradients with XAML Property Element Syntax

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.XamlIntroduction

This example extends property element syntax to apply a complex linear gradient fill to a Rectangle. It demonstrates how to define a LinearGradientBrush with multiple GradientStop elements to create a multi-colored diagonal gradient.

```XAML
<Grid xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <!-- This rectangle is painted with a diagonal linear gradient. -->
  <Rectangle Width="200" Height="200">
    <Rectangle.Fill>
      <LinearGradientBrush StartPoint="0,0" EndPoint="1,1">
        <GradientStop Color="Yellow" Offset="0.0" />
        <GradientStop Color="Red" Offset="0.25" />
        <GradientStop Color="Blue" Offset="0.75" />
        <GradientStop Color="LimeGreen" Offset="1.0" />
      </LinearGradientBrush>
    </Rectangle.Fill>
  </Rectangle>
</Grid>
```

--------------------------------

### API Methods for Gui.Animation._AnimationTimeline

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Animation._Int64AnimationBase

Documents methods specific to the AnimationTimeline class, including creating transitions and starting animations.

```APIDOC
CreateTransitionFrom(easing): Returns a new timeline used as transition (used by VisualStateManager)
GetCurrentValue(defaultOrigin, defaultDestination, clock): Calculates the current animated value depending on current clock state
Start(target, dp, timeManager, handoff): Begins the animation timeline creating a compatible clock
```

--------------------------------

### AnimationTimeline Class Methods

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Animation._Int32AnimationBase

Methods for the AnimationTimeline class, including creating transitions and starting animations.

```APIDOC
AnimationTimeline Methods:
  CreateTransitionFrom(easing): Returns a new timeline used as transition (used by VisualStateManager)
  GetCurrentValue(defaultOrigin, defaultDestination, clock): Calculates the current animated value depending on current clock state
  Start(target, dp, timeManager, handoff): Begins the animation timeline creating a compatible clock
```

--------------------------------

### Demonstrate Image Stretch Modes in XAML

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.ImagesTutorial

Illustrates the four different stretch modes (None, Fill, Uniform, UniformToFill) for the Image control in NoesisGUI, showing how an image adapts to available space while preserving or modifying its dimensions and aspect ratio.

```XAML
<Grid xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      Background="White" TextElement.Foreground="Black">
  <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center">
    <TextBlock Text="Original Image" TextAlignment="Center"/>
    <Border BorderBrush="Black" BorderThickness="1" Margin="5,0" HorizontalAlignment="Center"
     VerticalAlignment="Center">
      <Image Source="Images/melon1.png" Stretch="None"/>
    </Border>
    <Grid Margin="0,10,0,0">
      <Grid.ColumnDefinitions>
        <ColumnDefinition/>
        <ColumnDefinition/>
        <ColumnDefinition/>
        <ColumnDefinition/>
      </Grid.ColumnDefinitions>
      <Grid.RowDefinitions>
        <RowDefinition/>
        <RowDefinition/>
      </Grid.RowDefinitions>
      <TextBlock Text="None" TextAlignment="Center" Grid.Column="0"/>
      <TextBlock Text="Fill" TextAlignment="Center" Grid.Column="1"/>
      <TextBlock Text="Uniform" TextAlignment="Center" Grid.Column="2"/>
      <TextBlock Text="UniformToFill" TextAlignment="Center" Grid.Column="3"/>
      <Border BorderBrush="Black" BorderThickness="1" Margin="5,0"
              Width="120" Height="200" Grid.Column="0" Grid.Row="1">
        <Image Source="Images/melon1.png" Stretch="None"/>
      </Border>
      <Border BorderBrush="Black" BorderThickness="1" Margin="5,0"
              Width="120" Height="200" Grid.Column="1" Grid.Row="1">
        <Image Source="Images/melon1.png" Stretch="Fill"/>
      </Border>
      <Border BorderBrush="Black" BorderThickness="1" Margin="5,0"
              Width="120" Height="200" Grid.Column="2" Grid.Row="1">
        <Image Source="Images/melon1.png" Stretch="Uniform"/>
      </Border>
      <Border BorderBrush="Black" BorderThickness="1" Margin="5,0"
              Width="120" Height="200" Grid.Column="3" Grid.Row="1">
        <Image Source="Images/melon1.png" Stretch="UniformToFill"/>
      </Border>
    </Grid>
  </StackPanel>
</Grid>
```

--------------------------------

### Implement Inline Reflection for C++ Templates

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.CppArchitectureGuide

This example illustrates the NS_IMPLEMENT_INLINE_REFLECTION macro, which can be used as a single macro for both declaration and implementation of reflection. While generally not recommended due to increased header bloating, it is sometimes necessary, especially for template classes like Vector2.

```C++
template<class T> struct Vector2
{
    T x;
    T y;

    NS_IMPLEMENT_INLINE_REFLECTION(Vector2, NoParent)
    {
        NsProp("x", &Vector2::x);
        NsProp("y", &Vector2::y);
    }
}
```

--------------------------------

### API Reference: Gui.Core.FrameworkElement Methods

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core._ContentPresenter

Detailed API documentation for the methods available in the Gui.Core.FrameworkElement class, including their signatures, descriptions, and parameters where applicable. This covers core UI framework functionalities.

```APIDOC
FrameworkElement Methods:
  AncestorChanged(): Notifies when an ancestor has changed its parent
  AncestorNameScopeChanged(): Notifies when a NameScope in an ancestor has changed any of its items
  AncestorResourcesChanged(): Notifies when a change occurred in the resources dictionary of this element or an ancestor
  ApplyTemplate(): Template management Called on every Measure. Returns true if Visuals were added to the tree
  BringIntoView(): Attempts to bring this element into view, within any scrollable regions it is contained within.
  BringIntoView(targetRectangle): Attempts to bring the provided region size of this element into view, within any scrollable regions it is contained within.
    Parameters:
      targetRectangle: The region size to bring into view.
  ClearFrameworkTemplate(): Clears current template
  Clone(parent, templatedParent, template_): Returns a clone of this element. Used when applying a template
    Parameters:
      parent: The parent element.
      templatedParent: The templated parent element.
      template_: The template to use.
  ConnectEvent(source, event, handler): Attaches specified event to code-behind content. Return false when code-behind does not define the specified event handler
    Parameters:
      source: The event source.
      event: The event to connect.
      handler: The event handler.
  ConnectField(object, name): Attached specified named object to code-behind field
    Parameters:
      object: The object to attach.
      name: The name of the field.
  FindName(name): Provides accessors that simplifies access to the NameScope registration methods
    Parameters:
      name: The name to find.
  FindResource(key): Finds a resource looking in the logical parent chain
    Parameters:
      key: The key of the resource.
  GetBindingExpression(dp): Returns a binding expression if the target property has an active binding; otherwise, returns null
    Parameters:
      dp: The dependency property.
  GetFrameworkTemplate(): Gets applied template on this element
  GetParentOrTemplatedParent(): Gets the logical parent or the templated parent when logical parent is not available
  GetStateGroupsRoot(): Gets root for VisualState management
  GetTemplateChild(name): Looks for a named element in the applied template
    Parameters:
      name: The name of the child element.
  GetTemplateRoot(): Gets the root element of the applied template
  GetTimeManager(): Gets the TimeManager that controls current element
  IsLoaded(): Gets a value that indicates whether this element has been loaded for presentation.
  SetBinding(dp, binding): Attaches a binding to this element, based on the provided binding object
    Parameters:
      dp: The dependency property.
      binding: The binding object.
  SetBinding(dp, path): Attaches a binding to this element, based on the provided source property name as a path qualification to the data source
    Parameters:
      dp: The dependency property.
      path: The path qualification.
  SetResourceReference(dp, name): Sets up a resource reference in the target property to search for a resource with the specified name
    Parameters:
      dp: The dependency property.
      name: The name of the resource.
```

--------------------------------

### XAML Content Property Usage for Border Element

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.XamlIntroduction

Demonstrates the XAML content property feature using the Border element. The first example implicitly sets the Child property, while the second explicitly uses the Border.Child property element, both resulting in identical behavior.

```XAML
<Border>
  <TextBox Width="300"/>
</Border>
<!--explicit equivalent-->
<Border>
  <Border.Child>
    <TextBox Width="300"/>
  </Border.Child>
</Border>
```

--------------------------------

### NoesisGUI GUI Element and Container Reference

Source: https://www.noesisengine.com/docs/Gui.Core.Index.html/Gui.Core.LayoutPanelTutorial

Reference documentation for various GUI elements and container types available in NoesisGUI, categorized by their functionality. Includes details on element positioning properties like Alignment, Margin, and Padding, as well as different types of content, item, decorator, and panel containers.

```APIDOC
Element Positioning:
  Alignment:
    - HorizontalAlignment
    - VerticalAlignment
  - Margin
  - Padding
Containers:
  Content Containers:
    - ContentControl
    - HeaderedContentControl
  Items Containers:
    - ItemsControl
    - HeaderedItemsControl
  Decorators:
    - Viewbox
  Panels:
    - Canvas
    - StackPanel
    - UniformGrid
    - WrapPanel
    - DockPanel
    - Grid
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.