SharpConsoleUI

https://nickprotop.github.io/ConsoleEx/docfx/_site/
Admin
SharpConsoleUI is a comprehensive C# library for building rich, interactive console user interfaces...
Tokens:788,315
Snippets:10,414
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install terminal profile examples

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/SCHOST.html

Examples of registering and removing terminal profiles.

```bash
schost install --exe ./publish/app/MyApp.exe       # Register WT profile
schost install --uninstall                          # Remove WT profile
__
```

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

### Implement Multi-Step Install Wizard

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/FLOWS.html

A complete example demonstrating a multi-step wizard with state management, progress reporting, and commit barriers.

```csharp
public sealed class InstallState
{
    public string? Location { get; set; }
    public bool Installed { get; set; }
}

FlowResult<InstallState> result = await Flow.Wizard<InstallState>()
    .WithStepIndicator()
    .WithTitle("Install Wizard")

    // Step 1 (code-driven): confirm to begin
    .Step(async (ctx, s) =>
    {
        bool go = await ctx.Confirm(
            "Welcome",
            "This wizard installs the demo package. Begin?",
            ok: "Begin", cancel: "Cancel");
        return go ? FlowVerdict.Next : FlowVerdict.Cancel;
    })

    // Step 2 (content + buttons): pick a location, Next gated on a selection being made
    .Step(s => new LocationPickerContent(
            "Choose an install location:",
            new[] { "/opt/demo", "/usr/local/demo", "~/demo" },
            choice => s.Location = choice))
        .WithStepTitle("Location")
        .NextLabel("Install")
        .CanGoNext((ctx, s) => !string.IsNullOrWhiteSpace(s.Location))
        .OnNext((ctx, s) =>
            Task.FromResult(string.IsNullOrWhiteSpace(s.Location)
                ? FlowVerdict.Stay
                : FlowVerdict.Next))

    // Step 3 (code-driven, final): run the work, commit, then finish
    .Step(async (ctx, s) =>
    {
        await ctx.RunWithProgress<bool>(
            "Installing",
            $"Installing to {s.Location}…",
            async (ct, progress) =>
            {
                for (int k = 1; k <= 4; k++)
                {
                    ct.ThrowIfCancellationRequested();
                    progress.Report($"Step {k}/4: writing {s.Location}…");
                    await Task.Delay(450, ct);
                }
                return true;
            });

        s.Installed = true;
        ctx.Commit();           // Back can never revisit this step
        return FlowVerdict.Finish;
    })

    .Run(ws, myWindow);

if (result.Completed)
{
    var s = result.Value!;
    ShowBanner($"Installed to {s.Location}");
}
else if (result.Cancelled)
{
    ShowStatus("Installation cancelled.");
}
```

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

### Initialize project examples

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/SCHOST.html

Examples of initializing projects using auto-detection or specific paths.

```bash
schost init                              # Auto-detect .csproj in current directory
schost init MyApp/MyApp.csproj           # Specific project
schost init Examples/NavigationViewDemo  # Directory containing .csproj
__
```

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

### Run SharpConsoleUI Examples

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/EXAMPLES.html

Command to execute a specific example project from the repository.

```bash
dotnet run --project Examples/<ExampleName>
```

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

### Position the Start Menu

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/STATUS_SYSTEM.html

Examples of placing the Start Menu in different panel zones.

```csharp
BottomPanelConfig: panel => panel
    .Left(Elements.StartMenu())
    .Center(Elements.TaskBar())
```

```csharp
TopPanelConfig: panel => panel
    .Left(Elements.StatusText("[bold]My App[/]"))
    .Right(Elements.StartMenu())
```

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

### Build ConsoleEx Examples

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/EXAMPLES.html

Use the .NET CLI to compile the solution and verify all example projects.

```bash
dotnet build ConsoleEx.sln
```

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

### Package project examples

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/SCHOST.html

Examples of packaging applications for different platforms and requirements.

```bash
schost pack                          # Package for current platform
schost pack -r win-x64 --installer   # Windows installer
schost pack -o ./dist -r linux-x64   # Linux package to ./dist
__
```

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

### Start

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Drivers.IConsoleDriver.html

Starts the console driver.

```APIDOC
## void Start()

### Description
Starts the console driver, initializing input handling and enabling mouse/keyboard events.
```

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

### Complete Window Configuration Example

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/BUILDERS.html

A comprehensive example demonstrating multiple configuration methods and an event handler.

```csharp
var mainWindow = new WindowBuilder(windowSystem)
    .WithTitle("Task Manager")
    .WithSize(80, 25)
    .Centered()
    .WithColors(Color.White, Color.DarkBlue)
    .Resizable()
    .Movable()
    .WithMinimumSize(60, 20)
    .OnKeyPressed((sender, e) =>
    {
        if (e.KeyInfo.Key == ConsoleKey.Escape)
        {
            windowSystem.CloseWindow(sender as Window);
            e.Handled = true;
        }
    })
    .Build();
```

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

### Run Compositor Effects Examples

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/COMPOSITOR_EFFECTS.html

Commands to navigate to the example project directory and execute the application.

```bash
cd Examples/CompositorEffectsExample
dotnet run
```

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

### Build and install schost locally

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/SCHOST.html

Package the tool from source and install it as a global tool.

```bash
cd tools/schost
dotnet pack src/schost -c Release
dotnet tool install --global --add-source src/schost/nupkg SharpConsoleUI.Host
```

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

### Install schost via NuGet

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/SCHOST.html

Install the tool globally using the .NET CLI.

```bash
dotnet tool install -g SharpConsoleUI.Host
```

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

### Example Usage of PluginServiceBase

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Plugins.PluginServiceBase.html

An example demonstrating how to create a custom service by inheriting from PluginServiceBase.

```APIDOC
## Example

```csharp
public class MyService : PluginServiceBase
{
    public override string ServiceName => "MyService";
    public override string Description => "My custom service";

    public MyService()
    {
        RegisterOperation("GetValue", "Gets a value", () => GetValue());
        RegisterOperation("SetValue", "Sets a value",
            new[] { new ServiceParameter("value", typeof(int), true) },
            (p) => SetValue(GetParameter<int>(p, "value")));
    }

    private int GetValue() => 42;
    private void SetValue(int value) { /* ... */ }
}
```
```

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

### Configure and Add a Start Menu

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/STATUS_SYSTEM.html

Initializes a Start Menu within a panel configuration, setting layout, app name, and shortcut keys.

```csharp
using SharpConsoleUI.Panel;

var options = new ConsoleWindowSystemOptions(
    BottomPanelConfig: panel => panel
        .Left(Elements.StartMenu()
            .WithText("☰ Start")
            .WithShortcutKey(ConsoleKey.Spacebar, ConsoleModifiers.Control)
            .WithOptions(new StartMenuOptions
            {
                Layout = StartMenuLayout.TwoColumn,
                AppName = "My App",
                AppVersion = "1.0.0"
            }))
        .Center(Elements.TaskBar())
);
```

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

### Install SCHOST Project Template

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/SCHOST.html

Use the dotnet CLI to install the SCHOST application template.

```bash
dotnet new install tools/schost/templates/schost-app
```

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

### Single-step Flow Example

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/FLOWS.html

A complete example showing a flow that uses confirmation and progress reporting.

```csharp
var result = await Flow.Run<string>(ws, myWindow, async ctx =>
{
    // Ask a question first
    bool proceed = await ctx.Confirm(
        "Deploy",
        "Deploy to the staging server?",
        ok: "Deploy");

    if (!proceed)
        throw new OperationCanceledException(); // surfaces as FlowResult.Cancelled

    // Run the work with progress
    string log = await ctx.RunWithProgress<string>(
        "Deploying",
        "Connecting…",
        async (ct, progress) =>
        {
            progress.Report("Uploading artifacts…");
            await DeployAsync(ct);
            return "Deployment successful";
        });

    return log;
});

if (result.Completed)
    ShowBanner(result.Value!);
```

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

### Example Service Plugin Implementation

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Plugins.PluginServiceBase.html

An example demonstrating how to inherit from PluginServiceBase and register operations in the constructor. Use RegisterOperation to define available commands and their handlers.

```csharp
public class MyService : PluginServiceBase
{
    public override string ServiceName => "MyService";
    public override string Description => "My custom service";

    public MyService()
    {
        RegisterOperation("GetValue", "Gets a value", () => GetValue());
        RegisterOperation("SetValue", "Sets a value",
            new[] { new ServiceParameter("value", typeof(int), true) },
            (p) => SetValue(GetParameter<int>(p, "value")));
    }

    private int GetValue() => 42;
    private void SetValue(int value) { /* ... */ }
}
```

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

### Access Start property

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.TextSelection.html

Property to get or initialize the start position of the selection.

```csharp
public TextPosition Start { get; init; }__
```

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

### Start()

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Controls.SpinnerControl.html

Initiates the spinner animation.

```APIDOC
## Start()

### Description
Starts animating.
```

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

### Get normalized start position

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.TextSelection.html

Retrieves the start position that is guaranteed to be the earlier of the two positions.

```csharp
public TextPosition NormalizedStart { get; }
```

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

### Get Scrollable Content Start Position - ScrollableTop

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Layout.WindowContentLayout.html

Gets the Y-coordinate where the scrollable content begins. This is determined during the arrange pass.

```csharp
public int ScrollableTop { get; }
```

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

### Setup window system

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/tutorials/01-hello-window.html

Initialize the driver and window system required to manage UI rendering.

```csharp
using SharpConsoleUI;
using SharpConsoleUI.Drivers;

var driver = new NetConsoleDriver(RenderMode.Buffer);
var windowSystem = new ConsoleWindowSystem(driver);
__
```

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

### Get Window by GUID

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.WindowStateService.html

Retrieves a window using its unique GUID. Returns the window if found, otherwise returns null.

```csharp
public Window? GetWindow(string guid)__
```

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

### Get Start Button Bounds

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Rendering.RenderCoordinator.html

Retrieves the bounds of the start button for mouse hit testing. Panels manage their own bounds internally.

```csharp
public Rectangle StartButtonBounds { get; }
```

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

### Initialize Project and Install Dependencies

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/VIDEO_PLAYBACK.html

Commands to create a new console project and add the required SharpConsoleUI package.

```bash
dotnet new console -n MyVideoPlayer
cd MyVideoPlayer
dotnet add package SharpConsoleUI
```

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

### Configure Windows-like Start Menu

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/STATUS_SYSTEM.html

Adds a start menu to the bottom panel and registers custom actions for file operations.

```csharp
var options = new ConsoleWindowSystemOptions(
    TopPanelConfig: panel => panel
        .Left(Elements.StatusText("[bold cyan]My App[/] - Press [yellow]Ctrl+Space[/] for menu")),
    BottomPanelConfig: panel => panel
        .Left(Elements.StartMenu()
            .WithOptions(new StartMenuOptions { AppName = "My App", AppVersion = "1.0.0" }))
        .Center(Elements.TaskBar())
);

var windowSystem = new ConsoleWindowSystem(
    new NetConsoleDriver(RenderMode.Buffer),
    options: options);

// Register actions
var startMenu = windowSystem.BottomPanel!.FindElement<StartMenuElement>("startmenu")!;
startMenu.RegisterAction("New", () => CreateNew(), "File", 10);
startMenu.RegisterAction("Open", () => OpenFile(), "File", 20);
__
```

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

### BuildAndShow method

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Builders.WindowBuilder.html

Builds the window and immediately adds it to the window system.

```csharp
public Window BuildAndShow(bool activate = true)__
```

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

### Guid Property

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Window.html

Gets the unique identifier for this window instance.

```csharp
public string Guid { get; }
```

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

### LayoutLine Y Field

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Html.LayoutLine.html

Gets or sets the starting Y-coordinate (row) of the line.

```csharp
public int Y
```

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

### LayoutLine X Field

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Html.LayoutLine.html

Gets or sets the starting X-coordinate (column) of the line.

```csharp
public int X
```

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

### StartMenuSectionHeaderBackgroundColor Property

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Themes.ModernGrayTheme.html

Gets or sets the background color for Start menu section headers.

```csharp
public override Color? StartMenuSectionHeaderBackgroundColor { get; set; }
```

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

### Quick Start Toolbar Implementation

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/controls/ToolbarControl.html

Initializes a toolbar with buttons, separators, and styling using the fluent builder pattern.

```csharp
var toolbar = Controls.Toolbar()
    .AddButton("New", (s, btn) => CreateNew())
    .AddButton("Open", (s, btn) => OpenFile())
    .AddButton("Save", (s, btn) => SaveFile())
    .AddSeparator()
    .AddButton("Settings", (s, btn) => ShowSettings())
    .WithSpacing(1)
    .WithBackgroundColor(Color.Grey11)
    .WithBelowLine()
    .StickyTop()
    .Build();

window.AddControl(toolbar);
```

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

### StartMenuInfoStripForegroundColor Property

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Themes.ModernGrayTheme.html

Gets or sets the foreground color for the Start menu info strip.

```csharp
public override Color? StartMenuInfoStripForegroundColor { get; set; }
```

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

### Run DemoApp

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/EXAMPLES.html

Executes the flagship multi-window demonstration application.

```bash
dotnet run --project Examples/DemoApp
```

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

### StartMenuHeaderForegroundColor Property

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Themes.ModernGrayTheme.html

Gets or sets the foreground color for the Start menu header area.

```csharp
public override Color? StartMenuHeaderForegroundColor { get; set; }
```

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

### Start console driver

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Drivers.NetConsoleDriver.html

Starts the console driver, initializing input handling and enabling mouse/keyboard events.

```csharp
public void Start()
```

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

### Initialize an existing project

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/SCHOST.html

Commands to initialize configuration for an existing project and launch it.

```bash
# Initialize config (interactive prompts)
schost init path/to/MyApp.csproj

# Launch in configured terminal
schost run

# Package for distribution
schost pack
__
```

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

### Retrieve Plugin Action Providers

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Plugins.PluginBase.html

Gets action providers for Start menu integration using a reflection-free pattern.

```csharp
public virtual IReadOnlyList<IPluginActionProvider> GetActionProviders()
```

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

### Quick Start FigleControl

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/controls/FigleControl.html

Basic usage example for creating and adding a centered, colored Figlet banner to a window.

```csharp
var banner = Controls.Figlet("Hello")
    .Centered()
    .WithColor(Color.Cyan)
    .Build();

window.AddControl(banner);
```

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

### Implement a complete dashboard with SharpConsoleUI

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/tutorials/02-dashboard.html

This example demonstrates the full lifecycle of a dashboard, including control initialization, async data updates, and layout assembly.

```csharp
using SharpConsoleUI;
using SharpConsoleUI.Builders;
using SharpConsoleUI.Controls;
using SharpConsoleUI.Drivers;
using SharpConsoleUI.Layout;

var driver = new NetConsoleDriver(RenderMode.Buffer);
var windowSystem = new ConsoleWindowSystem(driver);

// All controls declared before the WindowBuilder call (captured by the async lambda).
var statsPanel = Controls.ScrollablePanel()
    .Rounded()
    .WithHeader(" Stats ")
    .WithVerticalAlignment(VerticalAlignment.Fill)
    .Build();

var uptimeLabel = Controls.Markup().AddLine("Uptime: --").WithName("uptime").Build();
var timeLabel   = Controls.Markup().AddLine("Time:   --").WithName("time").Build();

var graph = Controls.LineGraph()
    .WithName("cpu")
    .WithHeight(8)
    .WithMinValue(0)
    .WithMaxValue(100)
    .AddSeries("CPU", Color.Cyan1)
    .Build();

var logPanel = Controls.ScrollablePanel()
    .Rounded()
    .WithHeader(" Log ")
    .WithAutoScroll()
    .WithVerticalAlignment(VerticalAlignment.Fill)
    .Build();

var startTime = DateTime.Now;
var random    = new Random();

var window = new WindowBuilder(windowSystem)
    .WithTitle("Dashboard")
    .Maximized()
    .WithAsyncWindowThread(async (win, ct) =>
    {
        while (!ct.IsCancellationRequested)
        {
            await Task.Delay(1000, ct);

            var elapsed = DateTime.Now - startTime;
            var cpu     = random.Next(10, 90);

            win.FindControl<MarkupControl>("uptime")?.SetContent(
                new List<string> { $"Uptime: [green]{elapsed:hh\:mm\:ss}[/]" });

            win.FindControl<MarkupControl>("time")?.SetContent(
                new List<string> { $"Time:   [cyan]{DateTime.Now:HH:mm:ss}[/]" });

            win.FindControl<LineGraphControl>("cpu")?.AddDataPoint("CPU", cpu);

            var color = cpu > 70 ? "red" : "green";
            logPanel.AddControl(Controls.Markup()
                .AddLine($"[dim]{DateTime.Now:HH:mm:ss}[/] CPU [{color}]{cpu}%[/]")
                .Build());
        }
    })
    .Build();

// Wire up layout after Build().
statsPanel.AddControl(uptimeLabel);
statsPanel.AddControl(timeLabel);
statsPanel.AddControl(graph);

window.AddControl(
    Controls.HorizontalGrid()
        .WithAlignment(HorizontalAlignment.Stretch)
        .WithVerticalAlignment(VerticalAlignment.Fill)
        .Column(col => col.Flex(1).Add(statsPanel))
        .Column(col => col.Flex(2).Add(logPanel))
        .Build());

windowSystem.AddWindow(window);
windowSystem.Run();
```

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

### Initialize the project

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/tutorials/01-hello-window.html

Commands to create a new console project and install the required NuGet package.

```bash
dotnet new console -n HelloWindow
cd HelloWindow
dotnet add package SharpConsoleUI
__
```

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

### SyntaxToken StartIndex Property

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Controls.SyntaxToken.html

Gets or sets the starting character index of the token. This property is initialized upon object creation.

```csharp
public int StartIndex { get; init; }
```

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

### Start Method

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Controls.SpinnerControl.html

Initiates the animation sequence for the control.

```csharp
public void Start()__
```

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

### Initialize ConsoleWindowSystem with Themes

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/THEMES.html

Configure the window system at startup using the default theme, a named theme, or a specific theme instance.

```csharp
using SharpConsoleUI;
using SharpConsoleUI.Drivers;
using SharpConsoleUI.Themes;

// Option 1: Use default theme (ModernGray)
var windowSystem = new ConsoleWindowSystem(new NetConsoleDriver(RenderMode.Buffer));

// Option 2: Specify theme by name
var windowSystem = new ConsoleWindowSystem(
    new NetConsoleDriver(RenderMode.Buffer),
    themeName: "Ocean"
);

// Option 3: Provide theme instance
var windowSystem = new ConsoleWindowSystem(
    new NetConsoleDriver(RenderMode.Buffer),
    theme: new ModernGrayTheme()
);
```

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

### GutterRenderContext X Property

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Controls.GutterRenderContext.html

Gets the starting X coordinate for the columns rendered by this gutter. This property is initialized and cannot be changed after creation.

```csharp
public int X { get; init; }
```

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

### ResizeState StartMousePos Property

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.ResizeState.html

Gets the mouse position when the resize operation started. This is crucial for calculating the delta of mouse movement during the resize.

```csharp
public Point StartMousePos { get; init; }
```

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

### Create a Simple List

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/controls/ListControl.html

Demonstrates building a basic list with predefined items and an activation event handler.

```csharp
var list = Controls.List()
    .AddItem("Option 1")
    .AddItem("Option 2")
    .AddItem("Option 3")
    .WithHeight(5)
    .OnItemActivated((s, item, w) =>
    {
        windowSystem.NotificationStateService.ShowNotification(
            "Selected", item.Text, NotificationSeverity.Success);
    })
    .Build();

window.AddControl(list);
```

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

### StartMenuOptions Class

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Configuration.StartMenuOptions.html

Configuration options for Start menu appearance and behavior. Use object initializer syntax to set properties. Property changes raise OptionsChanged so the Start menu can react at runtime.

```APIDOC
## Class: StartMenuOptions

### Description
Configuration options for Start menu appearance and behavior. Use object initializer syntax to set only the properties you need. Property changes raise OptionsChanged so the Start menu can react at runtime.

### Properties
- **AppName** (string?) - Application name shown in the Start menu header. Defaults to "SharpConsoleUI".
- **AppVersion** (string?) - Application version shown in the Start menu header. Defaults to library version.
- **BackgroundColor** (Color?) - Background color. Null resolves from theme MenuDropdownBackgroundColor.
- **BackgroundGradient** (GradientBackground?) - Optional gradient background for the Start menu window.
- **BottomBarItems** (List<IWindowControl>) - Custom controls added to the bottom bar between exit button and info text.
- **Categories** (List<StartMenuCategory>) - Custom categories for the Start menu sidebar.
- **ForegroundColor** (Color?) - Foreground color. Null resolves from theme MenuDropdownForegroundColor.
- **HeaderIcon** (string) - Icon displayed next to the app name in the header. Defaults to "☰" (U+2630).
- **HighlightBackgroundColor** (Color?) - Highlight background color. Null resolves from theme MenuDropdownHighlightBackgroundColor.
- **HighlightForegroundColor** (Color?) - Highlight foreground color. Null resolves from theme MenuDropdownHighlightForegroundColor.
- **InfoStripItems** (List<string>) - Info-strip items displayed in the bottom bar (right side).
- **Layout** (StartMenuLayout) - Layout mode: SingleColumn (compact) or TwoColumn (with window list).
- **ShowIcons** (bool) - Whether to show Unicode icons next to headers and exit.
- **ShowSystemCategory** (bool) - Show built-in System category (themes, settings, about, performance).
- **ShowWindowList** (bool) - Show Windows list (right column in TwoColumn, submenu in SingleColumn).
- **SidebarStyle** (StartMenuSidebarStyle) - Sidebar display style: IconRail, IconLabel, or TextLabel.

### Methods
- **RaiseOptionsChanged()** - Raises the OptionsChanged event. Call after bulk-mutating Categories, InfoStripItems, or BottomBarItems.

### Events
- **OptionsChanged** - Raised when any property value changes.
```

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

### Run Text Editor Example

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/EXAMPLES.html

Executes the multiline text editor demonstration.

```bash
dotnet run --project Examples/TextEditorExample
__
```

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

### ResizeState StartWindowSize Property

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.ResizeState.html

Gets the window's size when the resize operation started. This is the base size from which new dimensions are calculated during the resize.

```csharp
public Size StartWindowSize { get; init; }
```

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

### Initialize and Use Registry

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/REGISTRY.html

Demonstrates how to initialize the registry via ConsoleWindowSystem and perform basic read/write operations.

```csharp
var windowSystem = new ConsoleWindowSystem(
    new NetConsoleDriver(RenderMode.Buffer),
    registryConfiguration: RegistryConfiguration.ForFile("myapp.json")
);

// Access the registry through RegistryStateService
var registry = windowSystem.RegistryStateService;

// Open a section (created automatically if it doesn't exist)
var prefs = registry.OpenSection("app/preferences");

// Read a value (returns default if key is absent)
string theme = prefs.GetString("theme", "ModernGray");
bool autoSave = prefs.GetBool("autoSave", true);

// Write a value
prefs.SetString("theme", "Solarized");
prefs.SetBool("autoSave", false);

// Registry saves automatically on windowSystem.Dispose() / end of Run()
```

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

### ClockElement Format Property

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Panel.ClockElement.html

Sets or gets the time format string for the ClockElement. Examples include 'HH:mm' or 'HH:mm:ss'.

```csharp
public string Format { get; set; }
```

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

### ResizeState StartWindowPos Property

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.ResizeState.html

Gets the window's position when the resize operation started. Used in conjunction with mouse movement to determine the new window position.

```csharp
public Point StartWindowPos { get; init; }
```

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

### Instance Property

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Plugins.PluginService.html

Gets the service instance.

```csharp
public object Instance { get; init; }
```

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

### Run a project

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/SCHOST.html

Command syntax for building and launching an application.

```bash
schost run [project] [--no-build] [--inline]
__
```

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

### PtyShim Class

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.PtyShim.html

The PtyShim class is a static class designed to be called at the very start of Main before any UI initialization. It handles the detection and setup for PTY shim mode.

```APIDOC
## Class PtyShim

**Namespace:** SharpConsoleUI

**Assembly:** SharpConsoleUI.dll

**Description:**
Entry-point helper that detects and runs the in-process PTY shim mode. Call RunIfShim(string[]) at the very start of `Main` before any UI initialisation.

```csharp
public static class PtyShim
```

**Inheritance:**
- object
- PtyShim

**Inherited Members:**
- object.Equals(object)
- object.Equals(object, object)
- object.GetHashCode()
- object.GetType()
- object.MemberwiseClone()
- object.ReferenceEquals(object, object)
- object.ToString()
```

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

### Execute Plugin Service Operation

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Plugins.IPluginService.html

Example of how to get a plugin service and execute a specific operation with or without parameters. Ensure to cast the return value to the expected type.

```csharp
var service = windowSystem.GetPluginService("Diagnostics");
long memory = (long)service.Execute("GetMemoryUsage");

var report = (string)service.Execute("GetDetailedReport", new Dictionary<string, object>
{
    ["includeGC"] = true,
    ["includeThreads"] = false
});
```

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

### Run Desktop Background Demo

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/EXAMPLES.html

Executes the Desktop Background demonstration project. Navigate to System → Desktop Background within the app to configure settings.

```bash
dotnet run --project Examples/DemoApp
# Navigate to System → Desktop Background
__
```

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

### Get Bottom Status Bar Height

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Rendering.RenderCoordinator.html

Calculates and returns the height occupied by the bottom status bar, which can be 0 or 1. This calculation accounts for panels, status text, and the Start button.

```csharp
public int GetBottomStatusHeight()
```

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

### Run NavigationViewDemo

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/EXAMPLES.html

Executes the desktop-style application demonstration using the NavigationView pattern.

```bash
dotnet run --project Examples/NavigationViewDemo
```

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

### Configure Desktop Background at Startup

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/DESKTOP_BACKGROUND.html

Initialize the desktop background using ConsoleWindowSystemOptions during system startup.

```csharp
using SharpConsoleUI.Rendering;

var options = new ConsoleWindowSystemOptions(
    DesktopBackground: DesktopBackgroundConfig.FromGradient(
        ColorGradient.FromColors(new Color(10, 15, 40), new Color(2, 3, 10)),
        GradientDirection.Vertical)
);

var windowSystem = new ConsoleWindowSystem(
    new NetConsoleDriver(RenderMode.Buffer),
    options: options);
```

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

### Get Display Name

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.NotificationSeverity.html

Gets the display name for this severity level.

```csharp
public string? Name { get; }
```

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

### Get Icon Character

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.NotificationSeverity.html

Gets the icon character for this severity level.

```csharp
public string Icon { get; }
```

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

### Initialize configuration

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/SCHOST.html

Command syntax for initializing a schost.json file.

```bash
schost init [project]
__
```

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

### Run Video Player Demo

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/EXAMPLES.html

Executes the Video Player demonstration project. Navigate to Utilities → Video Player within the app to access the player.

```bash
dotnet run --project Examples/DemoApp
# Navigate to Utilities → Video Player
__
```

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

### Start and stop driver

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Drivers.HeadlessConsoleDriver.html

Starts or stops the driver; these are no-ops for the headless driver.

```csharp
public void Start()__
```

```csharp
public void Stop()__
```

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

### Run the application

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/tutorials/01-hello-window.html

Register the window and start the main event loop.

```csharp
windowSystem.AddWindow(window);
windowSystem.Run();
__
```

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

### Get TabPage

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Events.TabEventArgs.html

Gets the tab page that was added or removed. This property is read-only.

```csharp
public TabPage TabPage { get; }
```

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

### FromPattern Method

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Rendering.DesktopBackgroundConfig.html

Creates a configuration instance using a specific desktop pattern.

```csharp
public static DesktopBackgroundConfig FromPattern(DesktopPattern pattern)__
```

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

### Get Severity Enum Value

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.NotificationSeverity.html

Gets the severity level enum value.

```csharp
public NotificationSeverityEnum Severity { get; }
```

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

### Initialize RegistryStateService

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/STATE-SERVICES.html

Shows how to initialize the service by passing a RegistryConfiguration to the ConsoleWindowSystem.

```csharp
var windowSystem = new ConsoleWindowSystem(
    new NetConsoleDriver(RenderMode.Buffer),
    registryConfiguration: RegistryConfiguration.ForFile("myapp.json")
);

// Null if no RegistryConfiguration was provided
RegistryStateService? registry = windowSystem.RegistryStateService;
```

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

### Run()

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.ConsoleWindowSystem.html

Starts the main event loop of the window system.

```APIDOC
## Run()

### Description
Starts the main event loop of the window system. Blocks until Shutdown(int) is called.

### Returns
- **int** - The exit code set by Shutdown(int) or 1 if an unhandled exception occurred.
```

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

### Initialize DesktopBackgroundService

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.DesktopBackgroundService.html

Constructor for creating a new instance of the service.

```csharp
public DesktopBackgroundService(Func<ITheme> getTheme, Action onDesktopDirty)__
```

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

### Get Tab Index

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Events.TabEventArgs.html

Gets the index where the tab was added or removed. This property is read-only.

```csharp
public int Index { get; }
```

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

### Shell Pipeline Integration Examples

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/SHELL_SCRIPTING.html

Demonstrates how to pipe data into interactive pickers and handle selections in various shell environments.

```bash
# Pipe a list into a picker, capture the selection
selected=$(ls /etc | my-picker)
if [ $? -eq 0 ]; then
    echo "User picked: $selected"
fi

# Multi-stage pipeline
git branch --list | my-picker | xargs git checkout
__
```

```powershell
# Pipe objects via JSON
$service = Get-Service |
    ConvertTo-Json |
    dotnet run my-table-picker.cs |
    ConvertFrom-Json

if ($service) {
    Restart-Service $service.Name
}
__
```

```fish
set branch (git branch --list | my-picker)
test $status -eq 0; and git checkout $branch
__
```

```nushell
ls | to json | my-table-picker | from json
__
```

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

### Configure Full-featured Application Suite

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/STATUS_SYSTEM.html

Demonstrates advanced configuration including custom gradients, clock display, plugin loading, and multiple menu actions.

```csharp
var options = new ConsoleWindowSystemOptions(
    TopPanelConfig: panel => panel
        .Left(Elements.StatusText("[bold cyan]Application Suite[/]"))
        .Right(Elements.Performance())
        .Right(Elements.Separator())
        .Right(Elements.Clock().WithFormat("HH:mm:ss")),
    BottomPanelConfig: panel => panel
        .Left(Elements.StartMenu()
            .WithText("☰ Menu")
            .WithOptions(new StartMenuOptions
            {
                AppName = "My IDE",
                AppVersion = "3.0.0",
                SidebarStyle = StartMenuSidebarStyle.IconLabel,
                BackgroundGradient = new GradientBackground(
                    ColorGradient.FromColors(new Color(25, 25, 60), new Color(15, 15, 35)),
                    GradientDirection.Vertical)
            }))
        .Center(Elements.TaskBar())
);

var windowSystem = new ConsoleWindowSystem(
    new NetConsoleDriver(RenderMode.Buffer),
    options: options);

// Load plugins
windowSystem.PluginStateService.LoadPlugin<MyPlugin>();

// Register custom actions
var startMenu = windowSystem.BottomPanel!.FindElement<StartMenuElement>("startmenu")!;
startMenu.RegisterAction("New Project", () => CreateProject(), "File", 10);
startMenu.RegisterAction("Open Project", () => OpenProject(), "File", 20);
startMenu.RegisterAction("Settings", () => ShowSettings(), "Edit", 10);
startMenu.RegisterAction("Terminal", () => OpenTerminal(), "Tools", 10);
__
```

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

### Getting Dirty Character Count

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Drivers.ConsoleBuffer.html

Gets the count of dirty characters in the back buffer.

```csharp
public int GetDirtyCharacterCount()
```

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

### PluginStateService Usage Example

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/STATE-SERVICES.html

Demonstrates loading plugins, subscribing to events, querying state, and interacting with plugin-provided services and UI.

```csharp
// Load a plugin
windowSystem.PluginStateService.LoadPlugin<MyPlugin>();

// Get current state
var state = windowSystem.PluginStateService.CurrentState;
windowSystem.LogService.LogInfo($"Loaded plugins: {state.LoadedPluginCount}");
windowSystem.LogService.LogInfo($"Registered services: {state.RegisteredServiceCount}");
windowSystem.LogService.LogInfo($"Registered controls: {state.RegisteredControlCount}");

// Subscribe to plugin events
windowSystem.PluginStateService.PluginLoaded += (sender, e) =>
{
    windowSystem.LogService.LogInfo($"Plugin loaded: {e.Info.Name} v{e.Info.Version}");
    windowSystem.NotificationStateService.ShowNotification(
        "Plugin Loaded",
        $"{e.Info.Name} is now available",
        NotificationSeverity.Success
    );
};

windowSystem.PluginStateService.StateChanged += (sender, e) =>
{
    windowSystem.LogService.LogInfo($"Plugin count: {e.PreviousState.LoadedPluginCount} → {e.NewState.LoadedPluginCount}");
};

// Check if a plugin is loaded
if (windowSystem.PluginStateService.IsPluginLoaded("MyPlugin"))
{
    windowSystem.LogService.LogInfo("MyPlugin is available");
}

// Get a plugin by name
var myPlugin = windowSystem.PluginStateService.GetPlugin("MyPlugin");
if (myPlugin != null)
{
    windowSystem.LogService.LogInfo($"Found plugin: {myPlugin.Info.Description}");
}

// Create plugin control
var logExporter = windowSystem.PluginStateService.CreateControl("LogExporter");
if (logExporter != null)
{
    mainWindow.AddControl(logExporter);
}

// Create plugin window
var debugWindow = windowSystem.PluginStateService.CreateWindow("DebugConsole");
if (debugWindow != null)
{
    windowSystem.AddWindow(debugWindow);
}

// Access plugin service
var diagnostics = windowSystem.PluginStateService.GetService("Diagnostics");
if (diagnostics != null)
{
    var report = (string)diagnostics.Execute("GetDiagnosticsReport")!;
    windowSystem.LogService.LogInfo(report);
}

// Get all registered service names
var services = windowSystem.PluginStateService.RegisteredServiceNames;
windowSystem.LogService.LogInfo($"Available services: {string.Join(", ", services)}");

// Plugins are registered in-process — there is no directory auto-loading
// (removed for NativeAOT compatibility). Register each plugin explicitly:
windowSystem.PluginStateService.LoadPlugin<MyPlugin>();
```

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

### ANSI Output Example

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/RENDERING_PIPELINE.html

Example of the ANSI-formatted string output generated by the serialization process.

```text
\x1b[37;40mHello \x1b[31mWorld\x1b[37m!
         ^^^^^^^^^^       ^^^^
         Set colors       Change FG only
```

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

### Initialize the Console Window System

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/tutorials/05-music-player.html

Sets up the console window system with system panels disabled and launches the player window with a sample playlist.

```csharp
using SharpConsoleUI;
using SharpConsoleUI.Configuration;
using SharpConsoleUI.Drivers;
using TermTunes.Data;
using TermTunes.UI;
using TermTunes.ViewModels;

var ws = new ConsoleWindowSystem(
    new NetConsoleDriver(RenderMode.Buffer),
    options: new ConsoleWindowSystemOptions(
        ShowTopPanel: false,
        ShowBottomPanel: false));

var player = new PlayerViewModel(SamplePlaylist.Build());
new PlayerWindow(ws, player).Create();

return ws.Run();
```

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

### Build method

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Builders.WindowBuilder.html

Builds and returns the window with all configured settings applied.

```csharp
public Window Build()__
```

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

### Integrate Plugins with Start Menu

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/STATUS_SYSTEM.html

Loading plugins and implementing IActionProvider to expose custom actions in the menu.

```csharp
// Load your plugin
windowSystem.PluginStateService.LoadPlugin<MyPlugin>();

// Plugin actions appear automatically in the Start Menu
// based on the actions registered by the plugin
```

```csharp
public class MyPlugin : IPlugin, IActionProvider
{
    public IEnumerable<StartMenuAction> GetActions()
    {
        yield return new StartMenuAction
        {
            Name = "My Custom Action",
            Category = "MyPlugin",
            Order = 10,
            Action = () => { /* action logic */ }
        };
    }
}
```

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

### Configure Dashboard with Performance Metrics

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/STATUS_SYSTEM.html

Sets up a dashboard with a 30 FPS target and displays real-time performance metrics in the top panel.

```csharp
var options = new ConsoleWindowSystemOptions(
    TargetFPS: 30,
    TopPanelConfig: panel => panel
        .Left(Elements.StatusText(""))
        .Right(Elements.Performance()),
    BottomPanelConfig: panel => panel
        .Left(Elements.StatusText("Press [yellow]F10[/] to exit"))
);

var windowSystem = new ConsoleWindowSystem(
    new NetConsoleDriver(RenderMode.Buffer),
    options: options);

windowSystem.PanelStateService.TopStatus = "[bold cyan]System Dashboard[/]";
__
```

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

### Start Menu Theme Properties

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Themes.ITheme.html

Color properties for various sections of the Start menu interface.

```csharp
Color? StartMenuHeaderBackgroundColor { get; }
```

```csharp
Color? StartMenuHeaderForegroundColor { get; }
```

```csharp
Color? StartMenuInfoStripForegroundColor { get; }
```

```csharp
Color? StartMenuSectionHeaderBackgroundColor { get; }
```

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

### Resolve Start Menu Header Foreground

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Helpers.ColorResolver.html

Resolves the Start menu header foreground color.

```csharp
public static Color ResolveStartMenuHeaderForeground(Color? explicitValue, IContainer? container)__
```

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

### Resolve Start Menu Header Background

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Helpers.ColorResolver.html

Resolves the Start menu header background color.

```csharp
public static Color ResolveStartMenuHeaderBackground(Color? explicitValue, IContainer? container)__
```

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

### StartMenuDialog.Show Method

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Dialogs.StartMenuDialog.html

This method displays the Start menu. It offers a toggle behavior, closing the menu if it's already open.

```APIDOC
## StartMenuDialog.Show

### Description
Shows the Start menu for the given element. If the Start menu is already open, it will be closed (toggle behavior).

### Method
`public static void Show(ConsoleWindowSystem windowSystem, StartMenuElement element)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

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

### Start Menu Layout Constants

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Configuration.ControlDefaults.html

Constants defining dimensions and constraints for the Start menu layout.

```csharp
public const int StartMenuCompactPaneWidth = 4
```

```csharp
public const int StartMenuContentPanelWidth = 30
```

```csharp
public const int StartMenuExpandedPaneWidth = 14
```

```csharp
public const int StartMenuMaxHeight = 20
```

```csharp
public const int StartMenuMaxLeftColumnWidth = 35
```

```csharp
public const int StartMenuMaxRightColumnWidth = 40
```

```csharp
public const int StartMenuMaxVisibleWindows = 15
```

```csharp
public const int StartMenuMinLeftColumnWidth = 22
```

```csharp
public const int StartMenuMinRightColumnWidth = 24
```

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

### Build a Settings Interface

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/controls/TabControl.html

Demonstrates a complex layout using multiple panels and input controls within tabs.

```csharp
var generalSettings = new ScrollablePanelBuilder()
    .AddControl(Controls.Header("General Settings"))
    .AddControl(Controls.Prompt("Username:").WithName("username").Build())
    .AddControl(Controls.Checkbox("Enable notifications"))
    .AddControl(Controls.Checkbox("Auto-save"))
    .Build();

var displaySettings = new ScrollablePanelBuilder()
    .AddControl(Controls.Header("Display Settings"))
    .AddControl(Controls.Checkbox("Dark mode"))
    .AddControl(Controls.Checkbox("Show line numbers"))
    .Build();

var tabControl = Controls.TabControl()
    .AddTab("General", generalSettings)
    .AddTab("Display", displaySettings)
    .AddTab("Advanced", advancedSettings)
    .WithHeight(25)
    .Fill()
    .Build();

window.AddControl(tabControl);
```

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

### Get Modal Count

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.ModalState.html

Gets the total number of modal windows currently open in the state.

```csharp
public int ModalCount { get; }
```

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

### Markup Syntax Examples

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/controls/MarkupControl.html

Examples of color, style, and combined markup tags supported by the control.

```text
"[red]Red text[/]"
"[green]Green text[/]"
"[blue]Blue text[/]"
"[yellow]Yellow text[/]"
"[cyan]Cyan text[/]"
"[magenta]Magenta text[/]"
"[white]White text[/]"
"[black]Black text[/]"

// Extended colors
"[orange3]Orange text[/]"
"[purple]Purple text[/]"
"[grey]Grey text[/]"

// RGB colors
"[rgb(255,128,0)]Custom color[/]"
"[#FF8000]Hex color[/]"
__
```

```text
"[bold]Bold text[/]"
"[italic]Italic text[/]"
"[underline]Underlined text[/]"
"[strikethrough]Strikethrough text[/]"
"[dim]Dimmed text[/]"
"[reverse]Reversed text[/]"
__
```

```text
"[bold red]Bold red text[/]"
"[italic blue]Italic blue text[/]"
"[bold yellow underline]Multiple styles[/]"
__
```

```text
"Use [[double brackets]] to display literal brackets"
"This shows [red]colored[/] and [[red]] literal markup"
__
```

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

### Create a new SCHOST project

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/SCHOST.html

Commands to install the template, generate a new project, and run or package it.

```bash
# Install the template
dotnet new install tools/schost/templates/schost-app

# Create a project
dotnet new schost-app -n MyApp --title "My App"
cd MyApp

# Run it
schost run

# Package it
schost pack --installer
__
```

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

### Configure a Responsive NavigationView

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/controls/NavigationView.html

Demonstrates initializing a NavigationView with responsive thresholds and event handling for display mode changes.

```csharp
var nav = Controls.NavigationView()
    .WithNavWidth(28)
    .WithPaneHeader("[bold white]  ◆  MyApp[/]")
    .WithPaneDisplayMode(NavigationViewDisplayMode.Auto)
    .WithExpandedThreshold(80)
    .WithCompactThreshold(50)
    .WithAnimateTransitions(true)
    .AddItem("Dashboard", icon: "◈", content: panel =>
    {
        panel.AddControl(Controls.Label("Dashboard content"));
    })
    .AddItem("Settings", icon: "⚙", content: panel =>
    {
        panel.AddControl(Controls.Checkbox("Dark mode").Checked(true).Build());
    })
    .WithAlignment(HorizontalAlignment.Stretch)
    .Fill()
    .Build();

// React to mode changes
nav.DisplayModeChanged += (sender, mode) =>
{
    // mode is Expanded, Compact, or Minimal
};
```

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

### Run Compositor Effects Example

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/EXAMPLES.html

Executes the compositor-style buffer manipulation demonstration.

```bash
dotnet run --project Examples/CompositorEffectsExample
__
```

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

### Set Tree Guide Style

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Builders.TreeControlBuilder.html

Configures the visual guide style used in the tree structure.

```csharp
public TreeControlBuilder WithGuide(TreeGuide guide)__
```

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

### Create Controls via Builders, Constructors, and Helpers

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/CONTROLS.html

Demonstrates different approaches to instantiating and configuring controls.

```csharp
// Using builders (recommended)
var button = Controls.Button("Click Me")
    .WithWidth(20)
    .OnClick((s, e, w) => { })
    .Build();

// Using constructors
var button = new ButtonControl
{
    Text = "Click Me",
    Width = 20
};
button.OnClick += (s, e) => { };

// Using static helpers
var label = Controls.Label("Simple text");
var header = Controls.Header("Title");
```

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

### Initialize and play a local video file

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/controls/VideoControl.html

Creates a video control from a local file path, adds an overlay, and starts playback.

```csharp
var video = Controls.Video("movie.mp4")
    .WithOverlay()
    .Fill()
    .Build();

window.AddControl(video);
video.Play();
```

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

### Resolve Start Menu Foreground

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Helpers.ColorResolver.html

Resolves the Start menu foreground color using the provided theme.

```csharp
public static Color ResolveStartMenuForeground(Color? explicitValue, ITheme? theme)__
```

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

### Run Image Viewer Demo

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/EXAMPLES.html

Executes the image viewer demonstration project.

```bash
dotnet run --project Examples/DemoApp
# Navigate to Rendering → Image Viewer
__
```

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

### Resolve Start Menu Background

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Helpers.ColorResolver.html

Resolves the Start menu background color using the provided theme.

```csharp
public static Color ResolveStartMenuBackground(Color? explicitValue, ITheme? theme)__
```

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

### Register Start Menu Actions

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/STATUS_SYSTEM.html

Methods for adding custom actions to the Start Menu, categorized by functionality.

```csharp
// Get the StartMenuElement from the panel
var startMenu = windowSystem.BottomPanel!.FindElement<StartMenuElement>("startmenu")!;

// Register actions by category
startMenu.RegisterAction("New Document", () =>
{
    var window = new Window(windowSystem) { Title = "New Document", Width = 60, Height = 20 };
    windowSystem.AddWindow(window);
}, category: "File", order: 10);
```

```csharp
var startMenu = windowSystem.BottomPanel!.FindElement<StartMenuElement>("startmenu")!;

// File category
startMenu.RegisterAction("New Document", () => CreateNewDoc(), "File", 10);
startMenu.RegisterAction("Open File", () => OpenFile(), "File", 20);
startMenu.RegisterAction("Save", () => Save(), "File", 30);

// Edit category
startMenu.RegisterAction("Undo", () => Undo(), "Edit", 10);
startMenu.RegisterAction("Preferences", () => ShowPrefs(), "Edit", 20);

// Tools category
startMenu.RegisterAction("Calculator", () => OpenCalc(), "Tools", 10);
startMenu.RegisterAction("Terminal", () => OpenTerminal(), "Tools", 20);

// Help category
startMenu.RegisterAction("User Guide", () => ShowGuide(), "Help", 10);
startMenu.RegisterAction("About", () => ShowAbout(), "Help", 20);
```

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

### Initialize

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Drivers.IConsoleDriver.html

Initializes the driver with a reference to the window system.

```APIDOC
## void Initialize(ConsoleWindowSystem windowSystem)

### Description
Initializes the driver with a reference to the window system. Called by ConsoleWindowSystem after state services are created.

### Parameters
- **windowSystem** (ConsoleWindowSystem) - The window system instance
```

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

### Scaffold the project

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/tutorials/02-dashboard.html

Initialize a new console application and install the required SharpConsoleUI package.

```bash
dotnet new console -n Dashboard
cd Dashboard
dotnet add package SharpConsoleUI
```

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

### Get Inactive Title Foreground Color

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.NotificationSeverity.html

Gets the inactive title foreground color (always white).

```csharp
public Color InactiveTitleForegroundColor(ConsoleWindowSystem consoleWindowSystem)
```

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

### Get Inactive Border Foreground Color

Source: https://nickprotop.github.io/ConsoleEx/docfx/_site/api/SharpConsoleUI.Core.NotificationSeverity.html

Gets the inactive border foreground color (always white).

```csharp
public Color InactiveBorderForegroundColor(ConsoleWindowSystem consoleWindowSystem)
```
Tokens:
Raw