### Window Control Setup in CSharpMarkup

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Demonstrates the basic setup for a Window control, including setting its title, size, content, and event handlers for loading and closing.

```csharp
new Window()
    .Title("My App")
    .Resizable(800, 600)
    .Content(...)
    .OnLoaded(() => ...)
    .OnClosed(() => ...)
```

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

### Minimal Application Setup and Run

Source: https://github.com/aprillz/mewui/blob/main/docs/ApplicationLifecycle.md

Demonstrates the minimal setup required to create and run a MewUI application with a basic window. This is typically called after all necessary platform and backend configurations are complete.

```csharp
var window = new Window()
    .Title("Hello")
    .Content(new TextBlock().Text("Hello, MewUI"));

Application.Run(window);
```

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

### Full Hot Reload Example

Source: https://github.com/aprillz/mewui/blob/main/docs/HotReload.md

A complete example demonstrating how to enable Hot Reload and register a build callback for a window. The DateTime.Now will update after a code change and Hot Reload.

```csharp
#if DEBUG
[assembly: System.Reflection.Metadata.MetadataUpdateHandler(
    typeof(Aprillz.MewUI.HotReload.MewUiMetadataUpdateHandler))]
#endif

using Aprillz.MewUI;
using Aprillz.MewUI.Markup;
using Aprillz.MewUI.Controls;

// 1) Register a build callback (DateTime updates after code change + Hot Reload)
var window = new Window()
    .OnBuild(w => w
        .Title("Hot Reload Demo")
        .Content(new StackPanel()
            .Spacing(8)
            .Children(
                new TextBlock().Text($"Now: {DateTime.Now}"),
                new Button().Content("Click")
            )));

// 2) Select platform/backend and run
Application.Create()
    .UseWin32()
    .UseDirect2D()
    .Run(window);
```

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

### State-Driven Border and Pixel Snapping Example

Source: https://github.com/aprillz/mewui/blob/main/docs/CustomControls.md

Demonstrates how to use utility methods to determine DPI scale, get the visual state, pick an accent border, and snap bounds to pixels for drawing. Use this for rendering custom control borders that adapt to different states and DPI settings.

```csharp
var dpiScale = GetDpi() / 96.0;
var state = GetVisualState(isPressed: isPressed, isActive: isActive);
var border = PickAccentBorder(Theme, BorderBrush, state, hoverMix: 0.6);

var bounds = LayoutRounding.SnapBoundsRectToPixels(Bounds, dpiScale);
DrawBackgroundAndBorder(context, bounds, Background, border, cornerRadiusDip: 0);
```

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

### MewUI C# Markup Example

Source: https://github.com/aprillz/mewui/blob/main/README.md

Demonstrates building a simple UI with a window, label, and button using MewUI's fluent C# markup. This example shows how to set window properties and handle button clicks.

```csharp
var window = new Window()
    .Title("Hello MewUI")
    .Size(520, 360)
    .Padding(12)
    .Content(
        new StackPanel()
            .Spacing(8)
            .Children(
                new Label()
                    .Text("Hello, Aprillz.MewUI")
                    .FontSize(18)
                    .Bold(),
                new Button()
                    .Content("Quit")
                    .OnClick(() => Application.Quit())
            )
    );

Application.Run(window);
```

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

### Manage Multiple Windows

Source: https://github.com/aprillz/mewui/blob/main/docs/ApplicationLifecycle.md

This example demonstrates how to create and manage multiple windows. The 'Tools' window is shown when the 'Main' window is loaded.

```csharp
var main = new Window()
    .Title("Main")
    .Content(new TextBlock().Text("Main window"));

var tools = new Window()
    .Title("Tools")
    .Content(new TextBlock().Text("Tools window"));

main.OnLoaded(() => tools.Show());
Application.Run(main);
```

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

### Add WebView2 Integration

Source: https://github.com/aprillz/mewui/blob/main/docs/Installation.md

Install the WebView2 integration package for Windows if needed.

```bash
dotnet add package Aprillz.MewUI.Win32.WebView2
```

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

### Install Windows Metapackage

Source: https://github.com/aprillz/mewui/blob/main/docs/Installation.md

Use this command to add the Windows metapackage to your project.

```bash
dotnet add package Aprillz.MewUI.Windows
```

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

### CheckBox Control Setup in CSharpMarkup

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Illustrates the setup for a CheckBox, including its label text and binding its checked state to an observable value.

```csharp
new CheckBox()
    .Text("Enable feature")
    .BindIsChecked(vm.IsEnabled)
```

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

### Install Cross-Platform Metapackage

Source: https://github.com/aprillz/mewui/blob/main/docs/Installation.md

Use this command to add the cross-platform metapackage to your project.

```bash
dotnet add package Aprillz.MewUI
```

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

### Label Control Setup in CSharpMarkup

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Shows how to create and configure a Label control with text content, font styling, and size.

```csharp
new Label()
    .Text("Hello World")
    .Bold()
    .FontSize(16)
```

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

### Initialize and Use WebView2 Control

Source: https://github.com/aprillz/mewui/blob/main/src/MewUI.Win32.WebView2/README.md

Demonstrates basic initialization of the WebView2 control, setting its source, executing JavaScript, and handling web messages. Ensure the WebView2 Runtime is installed.

```csharp
var webView = new WebView2();
webView.Source = new Uri("https://example.com");

// JavaScript execution
string result = await webView.ExecuteScriptAsync("document.title");

// Web message handling
webView.WebMessageReceived += (sender, e) => {
    Console.WriteLine($"Message: {e.WebMessageAsJson}");
};
```

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

### TextBox Control Setup in CSharpMarkup

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Demonstrates how to set up a TextBox with placeholder text and bind its content to an observable value.

```csharp
new TextBox()
    .Placeholder("Enter name...")
    .BindText(vm.Name)
```

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

### Install Individual Packages

Source: https://github.com/aprillz/mewui/blob/main/docs/Installation.md

Reference specific MewUI packages in your project file when not using metapackages.

```xml
<ItemGroup>
  <PackageReference Include="Aprillz.MewUI.Core" Version="0.10.3" />
  <PackageReference Include="Aprillz.MewUI.Platform.Win32" Version="0.10.3" />
  <PackageReference Include="Aprillz.MewUI.Backend.Gdi" Version="0.10.3" />
</ItemGroup>
```

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

### Main Window Setup and Events

Source: https://context7.com/aprillz/mewui/llms.txt

Configure the main window's title, size, padding, content, and various event handlers like `OnLoaded`, `OnClosed`, `OnSizeChanged`, `OnDpiChanged`, `OnThemeChanged`, and `OnFirstFrameRendered`. Native resources are created at `Show()` or `Application.Run()` time.

```csharp
using Aprillz.MewUI;
using Aprillz.MewUI.Controls;

// Main window — shown by Application.Run
var main = new Window()
    .Title("Main Window")
    .Resizable(800, 600)   // resizable with initial size
    .Padding(12)
    .Content(new Label().Text("Main"))
    .OnLoaded(() => Console.WriteLine("Window loaded"))
    .OnClosed(() => Application.Quit())
    .OnSizeChanged(size => Console.WriteLine($
```

```csharp
Size: {size})
    .OnDpiChanged((oldDpi, newDpi) => Console.WriteLine($"DPI: {newDpi}"))
    .OnThemeChanged((old, cur) => Console.WriteLine($"Theme: {cur.Variant}"))
    .OnFirstFrameRendered(() => Console.WriteLine("First frame!"));

// Tool window launched from Loaded
main.OnLoaded(() =>
{
    var tools = new Window()
        .Title("Tools")
        .Fixed(300, 200)           // fixed size
        .Content(new Label().Text("Tools"));
    tools.Show();
});

// Modal dialog
var dialog = new Window()
    .Title("Confirm")
    .FitContentSize(400, 300)     // size adapts to content
    .Content(new Label().Text("Are you sure?"));

// await dialog.ShowDialogAsync(owner: main);

// Key preview at the window level
main.OnPreviewKeyDown(e =>
{
    if (e.Key == Key.Escape) { Application.Quit(); e.Handled = true; }
});

Application.Run(main);
```

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

### Button Control Setup in CSharpMarkup

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Illustrates the configuration of a Button control, including its content, click event handler, and conditional click logic.

```csharp
new Button()
    .Content("Click Me")
    .OnCanClick(() => isFormValid)
    .OnClick(() => Submit())
```

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

### Add Aprillz.MewUI Package

Source: https://github.com/aprillz/mewui/blob/main/NUGET_README.md

Install the Aprillz.MewUI metapackage or platform-specific packages using the .NET CLI.

```sh
# Cross-platform (all-in-one)
dotnet add package Aprillz.MewUI

# Or platform-specific
dotnet add package Aprillz.MewUI.Windows
dotnet add package Aprillz.MewUI.Linux
dotnet add package Aprillz.MewUI.MacOS
```

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

### Add MewUI NuGet Packages

Source: https://context7.com/aprillz/mewui/llms.txt

Use `dotnet add package` to install the all-in-one metapackage or platform-specific ones. Individual packages allow for fine-grained composition.

```bash
# Cross-platform (all platforms + all backends)
dotnet add package Aprillz.MewUI

# Windows only
dotnet add package Aprillz.MewUI.Windows

# Linux only
dotnet add package Aprillz.MewUI.Linux

# macOS only
dotnet add package Aprillz.MewUI.MacOS

# Individual packages (fine-grained composition)
# dotnet add package Aprillz.MewUI.Core
# dotnet add package Aprillz.MewUI.Platform.Win32
# dotnet add package Aprillz.MewUI.Backend.Direct2D

# Additional optional packages
dotnet add package Aprillz.MewUI.Svg
dotnet add package Aprillz.MewUI.Win32.WebView2
```

```xml
<!-- csproj: individual packages, all at the same version -->
<ItemGroup>
  <PackageReference Include="Aprillz.MewUI.Core" Version="0.10.3" />
  <PackageReference Include="Aprillz.MewUI.Platform.Win32" Version="0.10.3" />
  <PackageReference Include="Aprillz.MewUI.Backend.Direct2D" Version="0.10.3" />
</ItemGroup>
```

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

### Create and Configure a TabControl

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Instantiate a TabControl and define its tab items, each with a header and content. This example shows how to define multiple tabs programmatically.

```csharp
new TabControl()
    .TabItems(
        new TabItem().Header("Home").Content(...),
        new TabItem().Header("Settings").Content(...)
    )
```

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

### MultiLineTextBox Control Setup in CSharpMarkup

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Shows the configuration for a MultiLineTextBox, including placeholder, word wrap, height, and text binding.

```csharp
new MultiLineTextBox()
    .Placeholder("Enter notes...")
    .Wrap(true)
    .Height(100)
```

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

### Configure Render Loop Settings

Source: https://context7.com/aprillz/mewui/llms.txt

After `Application.Run` starts, configure render loop mode, target FPS, and VSync via `Application.Current.RenderLoopSettings`. Set `TargetFps` to 0 for unlimited frames.

```csharp
// After Application.Run starts, configure via Application.Current
Application.Current.RenderLoopSettings.SetContinuous(true); // continuous vs. on-request
Application.Current.RenderLoopSettings.VSyncEnabled = false;
Application.Current.RenderLoopSettings.TargetFps = 60; // 0 = unlimited
```

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

### UI Binding Example for LoginViewModel

Source: https://github.com/aprillz/mewui/blob/main/docs/Binding.md

Demonstrates how to bind UI elements like TextBox, CheckBox, Label, and Button to the properties of a LoginViewModel. Includes text binding, checked binding, and click event handling.

```csharp
var vm = new LoginViewModel();

new StackPanel()
    .Vertical()
    .Spacing(8)
    .Children(
        new TextBox()
            .Placeholder("Username")
            .BindText(vm.Username),

        new TextBox()
            .Placeholder("Password")
            .BindText(vm.Password),

        new CheckBox()
            .Content("Remember me")
            .BindIsChecked(vm.RememberMe),

        new Label()
            .Foreground(Color.FromRgb(200, 60, 60))
            .BindText(vm.ErrorMessage),

        new Button()
            .Content("Login")
            .OnCanClick(() => !vm.IsLoading.Value)
            .OnClick(() => vm.Login())
    )
```

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

### Add SVG Support

Source: https://github.com/aprillz/mewui/blob/main/docs/Installation.md

Install the SVG package separately if you need SVG parsing and rendering capabilities.

```bash
dotnet add package Aprillz.MewUI.Svg
```

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

### TemplateContext Registration and Get

Source: https://github.com/aprillz/mewui/blob/main/docs/ItemsAndTemplates.md

Demonstrates registering named UI elements within a TemplateContext for later retrieval. This is crucial for efficient access to elements during the bind phase.

```csharp
public sealed class TemplateContext : IDisposable
{
    public void Register<T>(string name, T element) where T : UIElement;
    public T Get<T>(string name) where T : UIElement;
    // Internal lifecycle management (not part of the public contract).
}
```

```csharp
ctx.Get<TextBlock>("Name").Text = item.Name;
```

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

### Create a Custom Control in C#

Source: https://context7.com/aprillz/mewui/llms.txt

Derive from Control and override MeasureContent and OnRender. Use DIP for layout and pixel-snap for rendering. Example shows a ColorSwatch control.

```csharp
using Aprillz.MewUI.Controls;
using Aprillz.MewUI.Rendering;

// Minimal custom control example derived from Control
public sealed class ColorSwatch : Control
{
    private Color _color = Color.Red;

    public Color SwatchColor
    {
        get => _color;
        set
        {
            if (_color == value) return;
            _color = value;
            InvalidateVisual();   // layout unchanged; only repaint
        }
    }

    // Theme default sizing
    protected override double DefaultMinHeight => Theme.Metrics.BaseControlHeight;
    protected override Color DefaultBorderBrush => Theme.Palette.ControlBorder;

    // Measure in DIP — no pixel math here
    protected override Size MeasureContent(Size available)
        => new Size(Width, Theme.Metrics.BaseControlHeight);

    // Render — pixel-snap, then draw
    protected override void OnRender(IGraphicsContext context)
    {
        var dpiScale = GetDpi() / 96.0;
        var bounds   = LayoutRounding.SnapBoundsRectToPixels(Bounds, dpiScale);
        double radius = Theme.Metrics.ControlCornerRadius;

        // Background fill
        DrawBackgroundAndBorder(context, bounds, _color, BorderBrush, radius);

        // Centered text label
        context.DrawText(
            $("#{_color.R:X2}{_color.G:X2}{_color.B:X2}"),
            bounds,
            GetFont(),
            Theme.Palette.WindowText,
            TextAlignment.Center,
            TextAlignment.Center,
            TextWrapping.NoWrap);
    }

    protected override void OnMouseDown(MouseEventArgs e)
    {
        base.OnMouseDown(e);
        if (!IsEffectivelyEnabled || e.Button != MouseButton.Left) return;
        Focus();
        // Toggle example
        SwatchColor = SwatchColor == Color.Red ? Color.Blue : Color.Red;
        e.Handled = true;
    }

    protected override void OnThemeChanged(Theme oldTheme, Theme newTheme)
    {
        base.OnThemeChanged(oldTheme, newTheme);
        InvalidateVisual();
    }
}

// Usage
new ColorSwatch()
    .Width(120)
    .Height(36)
    .Margin(4)
```

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

### Button Style with Transitions

Source: https://github.com/aprillz/mewui/blob/main/docs/Styling.md

Adds transitions for background, border brush, and foreground properties to animate changes between states. This example assumes setters and triggers are defined elsewhere.

```csharp
var style = new Style(typeof(Button))
{
    Transitions =
    [
        Transition.Create(Control.BackgroundProperty),
        Transition.Create(Control.BorderBrushProperty),
        Transition.Create(Control.ForegroundProperty),
    ],
    Setters = [...],
    Triggers = [...],
};
```

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

### MewUI Theme Configuration (Pre-run)

Source: https://context7.com/aprillz/mewui/llms.txt

Sets default theme properties like `ThemeVariant`, `Accent`, `ThemeSeed` (for light and dark modes), and `ThemeMetrics` before the application starts. This configures the global appearance of the UI.

```csharp
using Aprillz.MewUI;

// --- Pre-run configuration ---
ThemeManager.Default       = ThemeVariant.System;  // System | Light | Dark
ThemeManager.DefaultAccent = Accent.Blue;           // built-in preset

ThemeManager.DefaultLightSeed = ThemeSeed.DefaultLight with
{
    WindowText       = Color.FromRgb(20, 20, 20),
    ControlBackground = Color.FromRgb(245, 245, 245),
};
ThemeManager.DefaultDarkSeed = ThemeSeed.DefaultDark with
{
    WindowText = Color.FromRgb(240, 240, 240),
};
ThemeManager.DefaultMetrics = ThemeMetrics.Default with
{
    ControlCornerRadius = 6,
    FontSize   = 13,
    FontFamily = "Noto Sans",
};
```

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

### MewUI Data Binding: ViewModel Pattern Implementation

Source: https://context7.com/aprillz/mewui/llms.txt

Shows a practical implementation of the ViewModel pattern using ObservableValue<T> for managing UI state and logic. This example includes properties for username, password, loading status, and error messages, along with a login method. Requires importing Aprillz.MewUI.Binding.

```csharp
using Aprillz.MewUI.Binding;
using Aprillz.MewUI.Controls;

// --- ViewModel pattern ---
class LoginViewModel
{
    public ObservableValue<string> Username { get; } = new("");
    public ObservableValue<string> Password { get; } = new("");
    public ObservableValue<bool>   IsLoading { get; } = new(false);
    public ObservableValue<string> Error     { get; } = new("");

    public void Login()
    {
        if (string.IsNullOrEmpty(Username.Value)) { Error.Value = "Username required"; return; }
        IsLoading.Value = true;
        // ... async login logic ...
    }
}

var vm = new LoginViewModel();

var form = new StackPanel().Vertical().Spacing(8).Children(
    new TextBox().Placeholder("Username").BindText(vm.Username),
    new TextBox().Placeholder("Password").BindText(vm.Password),
    new Label().Foreground(Color.FromRgb(200, 60, 60)).BindText(vm.Error),
    new Button()
        .Content("Login")
        .OnCanClick(() => !vm.IsLoading.Value)
        .OnClick(() => vm.Login()));
```

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

### Create a Basic Window with Controls

Source: https://github.com/aprillz/mewui/blob/main/NUGET_README.md

Demonstrates creating a simple window with a label and a button using MewUI's fluent C# markup. Ensure you have the necessary using directives.

```csharp
using Aprillz.MewUI;
using Aprillz.MewUI.Controls;

var window = new Window()
    .Title("Hello MewUI")
    .Size(520, 360)
    .Padding(12)
    .Content(
        new StackPanel()
            .Spacing(8)
            .Children(
                new Label().Text("Hello, Aprillz.MewUI").FontSize(18).Bold(),
                new Button().Content("Quit").OnClick(() => Application.Quit())
            )
    );

Application.Run(window);
```

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

### Create and Configure an Image

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Instantiate an Image, specify the source file, set its size, and define the stretching mode.

```csharp
new Image()
    .SourceFile("logo.png")
    .Size(64, 64)
    .StretchMode(ImageStretch.Uniform)
```

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

### Create and Configure a ComboBox

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Instantiate a ComboBox, provide a list of items, set a placeholder text, and specify the initially selected index.

```csharp
new ComboBox()
    .Items("Small", "Medium", "Large")
    .Placeholder("Select size...")
    .SelectedIndex(1)
```

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

### Publish with Publish Profile (CLI)

Source: https://github.com/aprillz/mewui/blob/main/docs/Installation.md

Execute the publish command using a pre-configured publish profile.

```bash
dotnet publish -p:PublishProfile=Win-Direct2D
```

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

### Publish with GDI Backend (CLI)

Source: https://github.com/aprillz/mewui/blob/main/docs/Installation.md

Publish your Windows application, keeping only the lightweight GDI rendering backend.

```bash
dotnet publish -r win-x64 -p:MewUIBackend=Gdi
```

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

### DelegateTemplate with TemplateContext

Source: https://github.com/aprillz/mewui/blob/main/docs/ItemsAndTemplates.md

Standard implementation of IDataTemplate. This example shows how to use TemplateContext for named element registration and lookup during the build and bind phases.

```csharp
var template = new DelegateTemplate<Person>(
    build: ctx =>
    {
        // Default-template shape: a single TextBlock.
        // Use TemplateContext when you want named access and reuse.
        return new TextBlock().Register(ctx, "Text");
    },
    bind: (view, item, index, ctx) =>
    {
        ctx.Get<TextBlock>("Text").Text = item.Name;
    });
```

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

### Define Type-Based Rules

Source: https://github.com/aprillz/mewui/blob/main/docs/Styling.md

Automatically apply a style to all controls of a specific type within a StyleSheet. This example applies a flatButtonStyle to all Buttons within a toolbar.

```csharp
var toolbar = new StackPanel().Horizontal().Spacing(4);
toolbar.StyleSheet = new StyleSheet();
toolbar.StyleSheet.Define<Button>(flatButtonStyle);

// All Buttons inside toolbar get flatButtonStyle automatically
toolbar.Add(new Button().Content("Cut"));
toolbar.Add(new Button().Content("Copy"));
toolbar.Add(new Button().Content("Paste"));
toolbar.Add(new CheckBox().Content("Bold")); // unaffected — only Button is matched
```

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

### Create and Configure a TabItem

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Instantiate a TabItem, setting its header text, content, and enabled state.

```csharp
new TabItem()
    .Header("Settings")
    .Content(new StackPanel().Children(...))
    .IsEnabled(true)
```

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

### Create and Configure a ListBox

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Instantiate a ListBox, populate it with items, set the initially selected index, and define its height.

```csharp
new ListBox()
    .Items("Apple", "Banana", "Cherry")
    .SelectedIndex(0)
    .Height(120)
```

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

### MewUI Application Lifecycle and Registration

Source: https://context7.com/aprillz/mewui/llms.txt

Demonstrates registering platform hosts and rendering backends for MewUI applications. `Application.Run(window)` is the main entry point. The `Application.Create()` builder chain is preferred for fixed single-target apps.

```csharp
using Aprillz.MewUI;
using Aprillz.MewUI.Backends;
using Aprillz.MewUI.PlatformHosts;

// Option A: runtime OS detection (cross-platform apps)
if (OperatingSystem.IsWindows())
{
    Win32Platform.Register();
    Direct2DBackend.Register(); // or GdiBackend.Register() / OpenGLWin32Backend.Register()
}
else if (OperatingSystem.IsLinux())
{
    X11Platform.Register();
    MewVGX11Backend.Register();
}
else if (OperatingSystem.IsMacOS())
{
    MacOSPlatform.Register();
    MewVGMacOSBackend.Register();
}

// Handle unhandled UI-thread exceptions before Run
Application.DispatcherUnhandledException += e =>
{
    MessageBox.Show(e.Exception.ToString(), "Unhandled exception");
    e.Handled = true;
};

var window = new Window()
    .Title("Hello MewUI")
    .Size(520, 360)
    .Padding(12)
    .Content(new Label().Text("Ready."));

Application.Run(window);

// Option B: builder chain (single platform/backend target)
Application.Create()
    .UseWin32()
    .UseDirect2D()
    .Run(window);

// Option C: multi-target with compile symbols
Application.Create()
#if WINDOWS || DEV
    .UseWin32()
    .UseDirect2D()
#elif LINUX
    .UseX11()
    .UseOpenGL()
#endif
    .Run(window);
```

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

### Get Base Style for a Type

Source: https://github.com/aprillz/mewui/blob/main/docs/Styling.md

Retrieve the base style for a specific control type statically. This is useful when styles are shared globally and do not require a Theme instance for retrieval.

```csharp
// No Theme instance needed
var baseStyle = Style.ForType<Button>();
```

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

### Define Symbols in csproj for Multi-Targeting

Source: https://github.com/aprillz/mewui/blob/main/docs/ApplicationLifecycle.md

Example of defining conditional compilation symbols in a csproj file based on RuntimeIdentifier. This allows fixing the application chain for specific build targets.

```xml
<PropertyGroup>
  <TargetFrameworks>net10.0-windows;net10.0</TargetFrameworks>
  <!-- assume CI/publish injects the RID via: dotnet publish -r ... -->
  <RuntimeIdentifiers>win-x64;linux-x64;osx-x64;osx-arm64</RuntimeIdentifiers>
</PropertyGroup>

<!-- dev runs (RID is often empty): use the runtime OS branching path -->
<PropertyGroup Condition="'$(RuntimeIdentifier)' == ''">
  <DefineConstants>$(DefineConstants);DEV</DefineConstants>
</PropertyGroup>

<!-- publish/CI (RID is set): fix OS symbols based on RID -->
<PropertyGroup Condition="'$(RuntimeIdentifier)' != '' and $(RuntimeIdentifier.StartsWith('win-'))">
  <DefineConstants>$(DefineConstants);WINDOWS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition="'$(RuntimeIdentifier)' != '' and $(RuntimeIdentifier.StartsWith('linux-'))">
  <DefineConstants>$(DefineConstants);LINUX</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition="'$(RuntimeIdentifier)' != '' and $(RuntimeIdentifier.StartsWith('osx-'))">
  <DefineConstants>$(DefineConstants);MACOS</DefineConstants>
</PropertyGroup>
```

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

### Publish with MewVG Backend (CLI)

Source: https://github.com/aprillz/mewui/blob/main/docs/Installation.md

Publish your Windows application, keeping only the MewVG rendering backend.

```bash
dotnet publish -r win-x64 -p:MewUIBackend=MewVG
```

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

### Publish with Direct2D Backend (CLI)

Source: https://github.com/aprillz/mewui/blob/main/docs/Installation.md

Publish your Windows application, keeping only the Direct2D rendering backend.

```bash
dotnet publish -r win-x64 -p:MewUIBackend=Direct2D
```

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

### GridView Column Template Configuration

Source: https://github.com/aprillz/mewui/blob/main/docs/ItemsAndTemplates.md

Defines a column for a GridView using a template. This example shows how to specify the build and bind logic for cells within a specific column, including registering elements with TemplateContext.

```csharp
var grid = new GridView();
grid.Columns(
    new GridViewColumn<Person>()
        .Header("Name")
        .Width(160)
        .Bind(
            build: ctx => new TextBlock().Register(ctx, "Text"),
            bind: (TextBlock t, Person p, int _, TemplateContext __) => t.Text = p.Name));
```

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

### Select MewUI Rendering Backend for Publish

Source: https://context7.com/aprillz/mewui/llms.txt

Control the rendering backend included in the published output using the `MewUIBackend` MSBuild property. This ensures only the necessary assemblies are included.

```bash
# Keep only Direct2D (Windows)
dotnet publish -r win-x64 -p:MewUIBackend=Direct2D

# Keep only GDI (Windows, ultra-lightweight)
dotnet publish -r win-x64 -p:MewUIBackend=Gdi

# Keep only MewVG (Windows/Linux/macOS, NanoVG-based)
dotnet publish -r win-x64 -p:MewUIBackend=MewVG

# Cross-platform: RID filtering auto-removes non-target assemblies
dotnet publish -r linux-x64          # keeps Core + X11 + MewVG.X11 only
dotnet publish -r osx-arm64          # keeps Core + MacOS + MewVG.MacOS only
```

```xml
<!-- Properties/PublishProfiles/Win-Direct2D.pubxml -->
<Project>
  <PropertyGroup>
    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
    <MewUIBackend>Direct2D</MewUIBackend>
  </PropertyGroup>
</Project>
```

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

### Theme-Aware Style Setters

Source: https://github.com/aprillz/mewui/blob/main/docs/Styling.md

Styles can use Func<Theme, T> setters to automatically adapt to theme changes. This example uses the theme's palette for the button background, ensuring it works in both light and dark themes without manual recreation.

```csharp
// This style works in both Light and Dark themes without recreation
Setter.Create(Control.BackgroundProperty, (Theme t) => t.Palette.ButtonFace)
```

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

### Register Platform and Backend Packages

Source: https://github.com/aprillz/mewui/blob/main/docs/ApplicationLifecycle.md

Detects the operating system at runtime and registers the appropriate platform host and graphics backend packages. This approach is suitable for multi-target applications where the OS is determined dynamically.

```csharp
using Aprillz.MewUI;
using Aprillz.MewUI.Backends;
using Aprillz.MewUI.PlatformHosts;

// Detect OS at runtime and register only the platform/backend valid for that OS.
// (In this example: Windows=Win32, Linux=X11, macOS is planned.)
if (OperatingSystem.IsWindows())
{
    Win32Platform.Register();
    Direct2DBackend.Register(); // or GdiBackend.Register() / OpenGLWin32Backend.Register()
}
else if (OperatingSystem.IsLinux())
{
    X11Platform.Register();
    OpenGLX11Backend.Register();
}
else if (OperatingSystem.IsMacOS())
{
    // TODO: register once macOS platform host/backend are implemented
    throw new PlatformNotSupportedException("macOS platform host is not implemented yet.");
}
else
{
    throw new PlatformNotSupportedException("Unsupported OS.");
}

Application.Run(mainWindow);
```

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

### MewUI Data Binding: Computed and Multi-Source Values

Source: https://context7.com/aprillz/mewui/llms.txt

Demonstrates how to create computed values that update automatically based on changes in multiple source ObservableValue<T> properties. This example shows updating a label with a combined first and last name. Requires importing Aprillz.MewUI.Binding.

```csharp
var firstName = new ObservableValue<string>("");
var lastName  = new ObservableValue<string>("");

new Label().Apply(lbl =>
{
    void Update() => lbl.Text = $"{firstName.Value} {lastName.Value}".Trim();
    firstName.Changed += Update;
    lastName.Changed  += Update;
    Update();
});
```

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

### Single-Target App Creation Chain

Source: https://github.com/aprillz/mewui/blob/main/docs/ApplicationLifecycle.md

Simplifies app creation for projects fixed to a single platform and graphics backend. Assumes project references are already set for the target environment.

```csharp
using Aprillz.MewUI;
using Aprillz.MewUI.Backends;
using Aprillz.MewUI.PlatformHosts;

Application.Create()
    .UseWin32()
    .UseDirect2D()
    .Run(mainWindow);
```

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

### Layout Panels: UniformGrid, WrapPanel, SplitPanel

Source: https://context7.com/aprillz/mewui/llms.txt

Demonstrates the creation and basic configuration of UniformGrid for equal cells, WrapPanel for wrapping content, and SplitPanel for draggable resizing.

```csharp
new UniformGrid()
    .Columns(3)
    .Spacing(8)
    .Children(
        new Button().Content("1"),
        new Button().Content("2"),
        new Button().Content("3"),
        new Button().Content("4"),
        new Button().Content("5"),
        new Button().Content("6")
    )
```

```csharp
new WrapPanel()
    .Orientation(Orientation.Horizontal)
    .Spacing(6)
    .ItemWidth(80)
    .ItemHeight(30)
    .Children(/* ... */)
```

```csharp
new SplitPanel()
    .Orientation(Orientation.Horizontal)
    .Children(
        new Label().Text("Left pane"),
        new Label().Text("Right pane")
    )
```

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

### Create and Configure a RadioButton

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Instantiate a RadioButton with a text label, assign it to a group, and set its initial checked state.

```csharp
new RadioButton()
    .Text("Option A")
    .GroupName("options")
    .IsChecked(true)
```

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

### Run MewUI Immediately with Curl

Source: https://github.com/aprillz/mewui/blob/main/README.md

This command allows you to run MewUI immediately without cloning the repository or setting up a project. It downloads and executes code directly from GitHub. Requires .NET 10 SDK.

```bash
curl -sL https://raw.githubusercontent.com/aprillz/MewUI/refs/heads/main/samples/FBASample/fba_gallery.cs -o - | dotnet run -
```

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

### Set Backend in csproj

Source: https://github.com/aprillz/mewui/blob/main/docs/Installation.md

Configure the desired MewUI rendering backend directly within your project file.

```xml
<PropertyGroup>
  <MewUIBackend>Direct2D</MewUIBackend>
</PropertyGroup>
```

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

### Display Logic: Conversion at Binding vs. ViewModel

Source: https://github.com/aprillz/mewui/blob/main/docs/Binding.md

Illustrates the best practice of performing display formatting (e.g., currency) within the UI layer using binding converters, rather than embedding it in the ViewModel.

```csharp
// Good — conversion at binding
new Label().BindText(vm.Price, p => $"${p:N0}")

// Bad — formatting in ViewModel
class ViewModel { public ObservableValue<string> FormattedPrice { get; } }
```

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

### Register Window Build Callback with OnBuild

Source: https://github.com/aprillz/mewui/blob/main/docs/HotReload.md

Use the OnBuild helper to set a build callback for a window. This callback is re-invoked by Hot Reload to update the window's content. It also runs the initial build.

```csharp
var window = new Window()
    .OnBuild(w =>
    {
        w.Title("Hot Reload Demo");
        w.Content(new StackPanel()
            .Spacing(8)
            .Children(
                new TextBlock().Text("Edit code and Hot Reload."),
                new Button().Content("Click")
            ));
    });
```

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

### Create and Bind a ProgressBar

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Instantiate a ProgressBar, set its minimum and maximum values, and bind its progress value to an observable property.

```csharp
new ProgressBar()
    .Minimum(0)
    .Maximum(100)
    .BindValue(vm.Progress)
```

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

### Button Control with Click and CanClick Handlers

Source: https://context7.com/aprillz/mewui/llms.txt

Shows how to create a Button, set its content and width, and define click behavior using OnClick and conditional enabling with OnCanClick.

```csharp
var isFormValid = new ObservableValue<bool>(false);

new Button()
    .Content("Save")
    .Width(80)
    .OnCanClick(() => isFormValid.Value)   // disables button when false
    .OnClick(() =>
    {
        Console.WriteLine("Saved!");
        window.RequerySuggested();         // manually re-evaluate CanClick
    })
```

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

### Create and Configure a GroupBox

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Instantiate a GroupBox (HeaderedContentControl) with a header text and content defined by a StackPanel.

```csharp
new GroupBox()
    .Header("Options")
    .Content(new StackPanel().Children(...))
```

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

### Configure Theme via ApplicationBuilder

Source: https://github.com/aprillz/mewui/blob/main/docs/Theme.md

Sets theme metrics, seeds, and backend configurations using the ApplicationBuilder before running the application.

```csharp
using Aprillz.MewUI;
using Aprillz.MewUI.Backends;
using Aprillz.MewUI.PlatformHosts;

var mainWindow = new Window()
    .Title("Theme + Builder")
    .Content(new TextBlock().Text("Hello"));

Application.Create()
    .UseMetrics(ThemeMetrics.Default with { ControlCornerRadius = 6, FontSize = 13, FontFamily = "Noto Sans" })
    .UseSeed(
        ThemeSeed.DefaultLight with { WindowText = Color.FromRgb(20, 20, 20) },
        ThemeSeed.DefaultDark  with { WindowText = Color.FromRgb(240, 240, 240) })
    // If needed, configure mode/accent as well (System/Blue are defaults so you can omit them)
    // .UseTheme(ThemeVariant.System)
    // .UseAccent(Accent.Blue)
    .UseWin32()
    .UseDirect2D()
    .Run(mainWindow);
```

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

### Label, TextBox, and MultiLineTextBox Controls

Source: https://context7.com/aprillz/mewui/llms.txt

Illustrates the basic usage of Label for displaying text with styling, TextBox for single-line input, and MultiLineTextBox for multi-line input.

```csharp
new Label()
    .Text("Hello, World!")
    .FontSize(18)
    .Bold()
    .TextAlignment(TextAlignment.Center)
    .TextWrapping(TextWrapping.Wrap)
```

```csharp
new TextBox()
    .Placeholder("Username")
    .IsReadOnly(false)
    .AcceptTab(false)
    .OnTextChanged(text => Console.WriteLine($"Changed: {text}"))
```

```csharp
new MultiLineTextBox()
    .Placeholder("Enter notes...")
    .Wrap(true)
    .Height(100)
    .AcceptTab(true)
```

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

### Configure Render Loop Settings

Source: https://github.com/aprillz/mewui/blob/main/docs/ApplicationLifecycle.md

Customize the render loop behavior by setting the mode to continuous, disabling VSync, and setting the target FPS to unlimited.

```csharp
Application.Current.RenderLoopSettings.SetContinuous(true);
Application.Current.RenderLoopSettings.VSyncEnabled = false;
Application.Current.RenderLoopSettings.TargetFps = 0; // unlimited
```

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

### Window Control Methods

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Methods for configuring and managing Window elements.

```APIDOC
## Individual Control Extension Methods - Window

### Title(string)

**Description**: Sets the title of the window.

### Width(double)

**Description**: Sets the width of the window.

### Height(double)

**Description**: Sets the height of the window.

### Size(width, height)

**Description**: Sets both the width and height of the window.

### Resizable(width, height)

**Description**: Makes the window resizable with specified initial dimensions.

### Fixed(width, height)

**Description**: Sets the window to a fixed size.

### FitContentWidth(maxWidth, fixedHeight)

**Description**: Adjusts the window width to fit its content, with constraints.

### FitContentHeight(fixedWidth, maxHeight)

**Description**: Adjusts the window height to fit its content, with constraints.

### FitContentSize(maxWidth, maxHeight)

**Description**: Adjusts both width and height to fit content, with constraints.

### Content(Element)

**Description**: Sets the main content of the window.

### OnLoaded(Action)

**Description**: Registers a callback for when the window has finished loading.

### OnClosed(Action)

**Description**: Registers a callback for when the window is closed.

### OnActivated(Action)

**Description**: Registers a callback for when the window becomes active.

### OnDeactivated(Action)

**Description**: Registers a callback for when the window loses activation.

### OnSizeChanged(Action<Size>)

**Description**: Registers a callback for when the window's size changes.

### OnDpiChanged(Action<uint, uint>)

**Description**: Registers a callback for when the window's DPI settings change.

### OnThemeChanged(Action<Theme, Theme>)

**Description**: Registers a callback for when the window's theme changes.

### OnFirstFrameRendered(Action)

**Description**: Registers a callback for when the first frame of the window is rendered.

### OnPreviewKeyDown(Action<KeyEventArgs>)

**Description**: Registers a callback for previewing key down events.

### OnPreviewKeyUp(Action<KeyEventArgs>)

**Description**: Registers a callback for previewing key up events.

### OnPreviewTextInput(Action<TextInputEventArgs>)

**Description**: Registers a callback for previewing text input events.
```

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

### Grid Layout with String Syntax

Source: https://context7.com/aprillz/mewui/llms.txt

Define rows and columns for a `Grid` using string syntax (e.g., "Auto,*,2*,100"). `Auto` fits content, `*` represents a star-sized unit, and pixel values define fixed sizes. `AutoIndexing()` simplifies child placement.

```csharp
// String syntax: "Auto,*,2*,100"
// Auto = fit content, * = 1 star, 2* = 2 stars, 100 = 100px
new Grid()
    .Rows("Auto,*,Auto")
    .Columns("120,*")
    .Spacing(4)
    .AutoIndexing()    // Row/Column auto-increments for children; no .Row()/.Column() needed
    .Children(
        new Label().Text("Name:"),
        new TextBox().Placeholder("Enter name..."),

        new Label().Text("Notes:"),
        new MultiLineTextBox().Height(80).Placeholder("Notes..."),

        new Button().Content("Cancel").ColumnSpan(1),
        new Button().Content("OK")
    )
```

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

### Basic MewUI Application in .NET 10

Source: https://context7.com/aprillz/mewui/llms.txt

A minimal .NET 10 file-based application using MewUI. No .csproj file is required. Ensure the MewUI package is referenced.

```csharp
// .NET 10 file-based app (no .csproj needed)
#:sdk Microsoft.NET.Sdk
#:property OutputType=Exe
#:property TargetFramework=net10.0
#:package Aprillz.MewUI@0.10.3

using Aprillz.MewUI;
using Aprillz.MewUI.Controls;

var window = new Window().Title("Hello").Content(new Label().Text("Hello MewUI"));
Application.Run(window);
// Run: dotnet run your_app.cs
```

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

### Basic C# Markup Pattern

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Demonstrates the fundamental fluent API pattern for building UI elements with C# Markup. Extension methods return 'this' to enable method chaining.

```csharp
new Button()
    .Content("Click Me")
    .Width(100)
    .OnClick(() => Console.WriteLine("Clicked!"))
```

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

### MewUI Data Binding: Generic Bind<T> for Any MewProperty

Source: https://context7.com/aprillz/mewui/llms.txt

Demonstrates the generic Bind<T> method for binding any MewProperty<T>, including custom properties and those requiring value conversion. This provides flexibility for complex binding scenarios. Requires importing Aprillz.MewUI.Binding.

```csharp
var statusColor = new ObservableValue<Color>(Color.Green);
new Label().Bind(Control.BackgroundProperty, statusColor);

// With conversion
var temperature = new ObservableValue<double>(20);
new Label().Bind(Control.ForegroundProperty, temperature,
    convert: t => t > 30 ? Color.Red : Color.Blue);

// Two-way with convertBack
var intValue = new ObservableValue<int>(42);
new TextBox().Bind(TextBase.TextProperty, intValue,
    convert:     i => i.ToString(),
    convertBack: s => int.TryParse(s, out var v) ? v : 0);
```

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

### Apply Pattern for Initialization

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Use the Apply pattern for complex initialization or setting properties not directly supported by fluent methods. The Apply method takes an Action to configure the object.

```csharp
public static T Apply<T>(this T obj, Action<T> action)
{
    action(obj);
    return obj;
}

// Usage example
new TextBox()
    .OnTextChanged(text => Console.WriteLine(text))
    .Apply(tb => tb.MaxLength = 100)
```

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

### Publish using a Publish Profile

Source: https://github.com/aprillz/mewui/blob/main/docs/Installation.md

Define backend selection and runtime identifier within a publish profile for consistent publishing.

```xml
<!-- Properties/PublishProfiles/Win-Direct2D.pubxml -->
<Project>
  <PropertyGroup>
    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
    <MewUIBackend>Direct2D</MewUIBackend>
  </PropertyGroup>
</Project>
```

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

### Storing Element References with Ref

Source: https://github.com/aprillz/mewui/blob/main/docs/CSharpMarkup.md

Shows how to use the `Ref` extension method to store a reference to a UI element in a variable for later use. This is useful for direct manipulation or accessing element properties.

```csharp
new TextBox()
    .Ref(out var nameBox)  // Store reference in nameBox variable
    .Text("Hello")
```

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

### ComboBox and ListBox Controls for Selection

Source: https://context7.com/aprillz/mewui/llms.txt

Shows how to use ComboBox for a dropdown selection and ListBox for displaying a list of selectable items.

```csharp
new ComboBox()
    .Items("Small", "Medium", "Large")
    .Placeholder("Select size...")
    .SelectedIndex(1)
    .OnSelectionChanged(i => Console.WriteLine($"Selected index: {i}"))
```

```csharp
new ListBox()
    .Items("Apple", "Banana", "Cherry")
    .SelectedIndex(0)
    .ItemHeight(28)
    .Height(120)
    .OnSelectionChanged(i => Console.WriteLine($"Selected: {i}"))
```

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

### CheckBox, RadioButton, and ToggleSwitch Controls

Source: https://context7.com/aprillz/mewui/llms.txt

Demonstrates the implementation of CheckBox for boolean selection, RadioButton for exclusive group selection, and ToggleSwitch for binary state changes.

```csharp
new CheckBox()
    .Text("Enable notifications")
    .IsChecked(true)
    .OnCheckedChanged(v => Console.WriteLine($"Checked: {v}"))
```

```csharp
new RadioButton()
    .Text("Option A")
    .GroupName("options")
    .IsChecked(true)
```

```csharp
new ToggleSwitch()
    .Text("Dark Mode")
    .OnCheckedChanged(on => Application.Current.SetTheme(on ? ThemeVariant.Dark : ThemeVariant.Light))
```

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

### Register and Apply Styles with StyleSheet in C#

Source: https://context7.com/aprillz/mewui/llms.txt

Demonstrates registering named and type-based styles using StyleSheet. Named styles are applied via StyleName, while type-based rules automatically apply to all children of a specific type within the container.

```csharp
// --- StyleSheet: named styles ---
window.StyleSheet = new StyleSheet();
window.StyleSheet.Define("accent", accentButton);
window.StyleSheet.Define("flat",   flatButton);

var saveBtn = new Button { StyleName = "accent" };
saveBtn.Content("Save");

// --- StyleSheet: type-based rules (auto-apply to all children) ---
var toolbar = new StackPanel().Horizontal().Spacing(4);
toolbar.StyleSheet = new StyleSheet();
toolbar.StyleSheet.Define<Button>(flatButton);   // all Buttons inside toolbar get flatButton

toolbar.Add(new Button().Content("Cut"));
toolbar.Add(new Button().Content("Copy"));
toolbar.Add(saveBtn);  // "accent" overrides the type rule via StyleName

// --- Local value — overrides all style triggers ---
var redBtn = new Button().Content("Red");
redBtn.Background = Color.FromRgb(200, 60, 60);  // triggers won't change this
```

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

### Define and Apply Custom Button Styles

Source: https://github.com/aprillz/mewui/blob/main/docs/Styling.md

Demonstrates defining two distinct styles for buttons: a 'flatButton' and an 'accentButton'. It shows how to register these styles in a global stylesheet and apply them to UI elements using type rules, StyleName, and local overrides. This approach allows for theme-aware styling and state-based visual changes.

```csharp
// Define styles (static, shared, theme-aware)
var flatButton = new Style(typeof(Button))
{
    BasedOn = Style.ForType<Button>(),
    Setters =
    [
        Setter.Create(Control.BackgroundProperty,
            (Theme t) => t.Palette.ButtonHoverBackground.WithAlpha(0)),
        Setter.Create(Control.BorderBrushProperty, Color.Transparent),
        Setter.Create(Control.BorderThicknessProperty, 0.0),
    ],
    Triggers =
    [
        new StateTrigger
        {
            Match = VisualStateFlags.Hot,
            Setters = [Setter.Create(Control.BackgroundProperty,
                (Theme t) => t.Palette.ButtonHoverBackground)],
        },
    ],
};

var accentButton = new Style(typeof(Button))
{
    BasedOn = Style.ForType<Button>(),
    Setters =
    [
        Setter.Create(Control.BackgroundProperty, (Theme t) => t.Palette.Accent),
        Setter.Create(Control.ForegroundProperty, (Theme t) => t.Palette.AccentText),
        Setter.Create(Control.BorderBrushProperty, (Theme t) => t.Palette.Accent),
    ],
    Triggers =
    [
        new StateTrigger
        {
            Match = VisualStateFlags.Hot,
            Setters = [
                Setter.Create(Control.BackgroundProperty,
                    (Theme t) => t.Palette.Accent.Lerp(t.Palette.WindowBackground, 0.15)),
            ],
        },
        new StateTrigger
        {
            Match = VisualStateFlags.Pressed,
            Setters = [
                Setter.Create(Control.BackgroundProperty,
                    (Theme t) => t.Palette.Accent.Lerp(t.Palette.WindowBackground, 0.25)),
            ],
        },
    ],
};

// Register in StyleSheet
window.StyleSheet = new StyleSheet();
window.StyleSheet.Define("accent", accentButton);

// Apply via StyleSheet type rule (container-level)
var toolbar = new StackPanel().Horizontal().Spacing(4);
toolbar.StyleSheet = new StyleSheet();
toolbar.StyleSheet.Define<Button>(flatButton);
toolbar.Add(new Button().Content("Cut"));
toolbar.Add(new Button().Content("Copy"));

// Apply via StyleName (per-element)
var saveBtn = new Button { StyleName = "accent" };
saveBtn.Content("Save");
toolbar.Add(saveBtn);

// Local override — ignores all style triggers
var customBtn = new Button().Content("Custom");
customBtn.Background = Color.FromRgb(200, 60, 60);
toolbar.Add(customBtn);
```