Fixes #4932 - Enable Inline apps in addition to Full Screen

[Copilot]

Fixes

• Fixes Enable Inline rendering in addition to current AlternateScreenBuffer #4932
• Fixes Make non-fullscreen apps possible #272
• Fixes Add app-owned opt-in ANSI startup readiness gate for terminal capability queries #4935

Adds AppModel.Inline mode so Terminal.Gui apps can render inline in the primary scrollback buffer (like Claude Code CLI / GitHub Copilot CLI) instead of switching to the alternate screen buffer via CSI ?1049h.

Here's the new ./Examples/InlineColorPicker example which shows how easy it is to run any View as a CLI:

How Inline Mode Works

Concept

In AppModel.Inline, the app renders within the terminal's primary scrollback buffer starting at the current cursor position. No alternate screen buffer (CSI ?1049h) is used. On exit, the rendered content stays in scrollback history and the shell prompt appears immediately below.

Architecture: App.Screen as the coordinate system

The key architectural insight is that IApplication.Screen is the source of truth for where the app renders:

• FullScreen mode: App.Screen == Driver.Screen (full terminal, Y=0)
• Inline mode: App.Screen is a sub-rectangle of Driver.Screen
  • App.Screen.Y = terminal row where the inline region starts
  • App.Screen.Height = number of rows the app occupies (sized by content)
  • App.Screen.Width = full terminal width

All coordinate offsetting flows from this single property — AnsiOutput.SetCursorPositionImpl adds App.Screen.Y to all row coordinates, and mouse events subtract it.

Startup sequence

1. CPR query: On init, AnsiSizeMonitor sends ESC[6n (Device Status Report) to discover the current cursor row
2. Startup gate: AnsiStartupGate defers the first LayoutAndDraw until both the CPR response and terminal size query complete
3. Initial sizing: First LayoutAndDraw does a layout pass with full terminal size, measures the view's desired height, then sets App.Screen to the sub-rectangle starting at the cursor row
4. Scroll reservation: If the view doesn't fit below the cursor, newlines are emitted to scroll the terminal up, and the cursor row is adjusted (clamped to 0)

Dynamic growth

As content is added (e.g., items added to a ListView), subsequent LayoutAndDraw calls detect when the view's desired height exceeds App.Screen.Height and grow the region:

• First grows down (into empty terminal rows below the inline region)
• Then grows up (scrolls the terminal) only when there's no room below
• Height is always capped at the terminal height

Resize handling

On terminal resize: reset cursor row to 0, clear the terminal (CSI H + CSI 2J), and re-do initial sizing from scratch. This matches the behavior of Claude Code CLI.

Output buffer

In inline mode, OutputBufferImpl.ClearContents() initializes cells with IsDirty = false (not true as in fullscreen). Only cells explicitly drawn by the app are flushed to the terminal — the rest of the visible terminal stays untouched.

Mouse coordinates

Mouse events arrive in absolute terminal coordinates. ApplicationMouse.RaiseMouseEvent subtracts App.Screen.Y from ScreenPosition.Y before dispatching to views. A save/restore pattern prevents the MouseInterpreter generator from seeing already-adjusted coordinates during synthesized double-click events.

Clean exit

On shutdown, the cursor is moved to App.Screen.Y + App.Screen.Height (the row below the rendered region) so the shell prompt appears in the right place. CSI ?1049l is NOT emitted.

---

Usage

using IApplication app = Application.Create ();
app.AppModel = AppModel.Inline;
app.Init ();

// RunnableWrapper provides the inline container with Dim.Auto sizing
RunnableWrapper<ColorPicker> wrapper = new () { Width = Dim.Fill () };
app.Run (wrapper);

ForceInlineCursorRow (testing)

For unit tests that can't do real CPR queries, IApplication.ForceInlineCursorRow bypasses the startup gate and sets the cursor row directly:

app.ForceInlineCursorRow = 10;  // Simulate cursor at terminal row 10
app.Init (DriverRegistry.Names.ANSI);

Examples

Example	Description
Examples/InlineCLI/	Claude Code / Copilot CLI-style inline prompt with ListView
Examples/InlineColorPicker/	Inline ColorPicker with color name output

Test Coverage

Test File	Tests	Description
InlineModeTests.cs	31	Comprehensive: Screen positioning, sizing, overflow, dynamic growth, resize, Driver vs App Screen, View.Frame, ForceInlineCursorRow, mouse adjustment, output buffer
InlineResizeTests.cs	2	Resize resets to row 0, width updates
InlineMouseOffsetTests.cs	1	Mouse double-subtraction bug regression
AnsiOutputInlineModeTests.cs	3	Alternate screen buffer skipped in inline mode
AnsiSizeMonitorTests.cs	12	CPR parsing, startup gate completion
AnsiStartupGateTests.cs	3	Gate registration, completion, timeout
AppModelTests.cs	8	AppModel enum, configuration
InlineDrawTimingTests.cs	12	First-render deferral, gate bypass

[tig]

@copilot this misses the requirement that Application/Driver.Screen needs to be set based on the first layout. The example should be setting its runnable view.height = dim.auto(minimumContentSize: 10) and .y = pos.anchorend().

[Copilot]

@copilot this misses the requirement that Application/Driver.Screen needs to be set based on the first layout. The example should be setting its runnable view.height = dim.auto(minimumContentSize: 10)...

Addressed in 82b8fac:

1. ApplicationImpl.Screen.cs: After the first layout pass in inline mode, LayoutAndDraw now reads the runnable view's computed Frame.Height and resizes Screen to match. It then re-layouts with the new Screen size so the view fills the inline region correctly.

2. InlineCLI example: Updated to use Y = Pos.AnchorEnd() and Height = Dim.Auto(minimumContentDim: 10) as specified in the design.

3. Added two new tests: InlineMode_LayoutAndDraw_Sets_Screen_Height_From_Runnable_View and FullScreenMode_LayoutAndDraw_Does_Not_Resize_Screen.

[tig]

@copilot what happens if the cursor is at the bottom of the terminal and the first layout results in a screen.height of 10? (For example)

[Copilot]

Pull request overview

Adds a new AppModel.Inline rendering mode to Terminal.Gui so apps can render inline in the terminal’s primary scrollback buffer (instead of switching to the alternate screen buffer), with supporting driver/runtime plumbing, tests, and examples.

Changes:

• Introduces AppModel and propagates it through IApplication → component factory → driver/output to control inline vs fullscreen rendering.
• Implements inline-mode output semantics (skip alt-buffer, cursor-row offset, “initially clean” output buffer, dirty-line skipping, startup-gate deferral).
• Adds new examples (InlineCLI, InlineColorPicker) and extensive unit tests for inline rendering, resize, mouse offsetting, and startup-gate behavior.

Reviewed changes

Copilot reviewed 53 out of 53 changed files in this pull request and generated 8 comments.

Show a summary per file

File	Description
Tests/UnitTestsParallelizable/Drivers/Output/InlineDrawTimingTests.cs	DEBUG-only tracing tests for first-render deferral timing in inline mode.
Tests/UnitTestsParallelizable/Drivers/Output/AppModelTests.cs	Tests AppModel enum and inline-mode OutputBufferImpl.ClearContents behavior.
Tests/UnitTestsParallelizable/Drivers/AnsiHandling/KittyKeyboardProtocolDetectorTests.cs	Adds coverage for startup-gate registration/completion.
Tests/UnitTestsParallelizable/Drivers/AnsiHandling/AnsiStartupGateTests.cs	New tests for gate readiness, completion, and timeout.
Tests/UnitTestsParallelizable/Drivers/AnsiDriver/AnsiSizeMonitorTests.cs	Extends tests for size readiness, CPR parsing, and inline/fullscreen readiness rules.
Tests/UnitTestsParallelizable/Drivers/Ansi/AnsiOutputInlineModeTests.cs	Verifies AnsiOutput behavior differences between fullscreen and inline.
Tests/UnitTestsParallelizable/Application/ScreenTests.cs	Updates Screen behavior tests and adds inline sizing assertions.
Tests/UnitTestsParallelizable/Application/Mouse/InlineMouseOffsetTests.cs	Regression test for inline mouse coordinate adjustment with synthesized events.
Tests/UnitTestsParallelizable/Application/InlineResizeTests.cs	Tests inline resize resets (screen origin and cursor-row state).
Tests/UnitTestsParallelizable/Application/ApplicationMainLoopTests.cs	Tests startup-gate deferral behavior in the main loop.
Terminal.sln	Adds InlineCLI/InlineColorPicker projects and extra solution platforms.
Terminal.Gui/Views/Runnable/RunnableWrapper.cs	New helper runnable wrapper to run a view and extract a typed result.
Terminal.Gui/Views/Color/ColorPicker.cs	Minor refactors/formatting and autocomplete setup adjustments.
Terminal.Gui/ViewBase/Adornment/BorderView.cs	Alters title focus rendering logic.
Terminal.Gui/Drivers/Output/OutputBufferImpl.cs	Adds inline-mode buffer semantics and ClearContents(initiallyDirty) overload.
Terminal.Gui/Drivers/Output/OutputBase.cs	Skips rendering rows that have no dirty cells.
Terminal.Gui/Drivers/Output/IOutputBuffer.cs	Exposes DirtyLines so outputs can skip clean rows.
Terminal.Gui/Drivers/ISizeMonitor.cs	Adds default interface properties for initial size readiness and cursor row.
Terminal.Gui/Drivers/InlineState.cs	New inline-mode state container (cursor row).
Terminal.Gui/Drivers/IDriver.cs	Adds AnsiStartupGate, InlineState, and AppModel to the driver API.
Terminal.Gui/Drivers/IComponentFactory.cs	Propagates AppModel into output creation.
Terminal.Gui/Drivers/DriverImpl.cs	Tracks terminal size separately from output buffer size; supports inline buffer resizing.
Terminal.Gui/Drivers/ComponentFactoryImpl.cs	Implements the AppModel property for factories.
Terminal.Gui/Drivers/AnsiHandling/TerminalColorDetector.cs	Registers terminal-color queries with the startup gate.
Terminal.Gui/Drivers/AnsiHandling/KittyKeyboardProtocolDetector.cs	Registers kitty keyboard probe with the startup gate.
Terminal.Gui/Drivers/AnsiHandling/IAnsiStartupGate.cs	New startup gate interface.
Terminal.Gui/Drivers/AnsiHandling/AnsiStartupQuery.cs	New enum for tracked startup queries.
Terminal.Gui/Drivers/AnsiHandling/AnsiStartupGate.cs	New gate implementation (query register/complete/timeout).
Terminal.Gui/Drivers/AnsiDriver/AnsiSizeMonitor.cs	Adds CPR query/parsing and gate completion for size/cursor readiness.
Terminal.Gui/Drivers/AnsiDriver/AnsiOutput.cs	Inline-mode output path (no alt-buffer) and cursor offset via App.Screen.
Terminal.Gui/Drivers/AnsiDriver/AnsiComponentFactory.cs	Creates AnsiOutput with the configured AppModel.
Terminal.Gui/Configuration/SourceGenerationContext.cs	Registers AppModel for source-gen JSON serialization.
Terminal.Gui/App/Mouse/ApplicationMouse.cs	Adjusts mouse coordinates for inline mode with save/restore semantics.
Terminal.Gui/App/MainLoop/MainLoopCoordinator.cs	Wires startup gate into driver and ANSI probes; wires App.Screen getter into AnsiOutput.
Terminal.Gui/App/MainLoop/ApplicationMainLoop.cs	Defers first render until startup gate is ready; enables inline output buffer mode.
Terminal.Gui/App/Legacy/Application.Driver.cs	Adds static change events for AppModel and ForceInlineCursorRow.
Terminal.Gui/App/IApplication.cs	Adds instance properties for AnsiStartupGate, AppModel, ForceInlineCursorRow.
Terminal.Gui/App/AppModel.cs	New enum defining fullscreen vs inline rendering modes.
Terminal.Gui/App/ApplicationImpl.Screen.cs	Implements inline App.Screen sub-rectangle behavior, growth, and resize reset.
Terminal.Gui/App/ApplicationImpl.Run.cs	Defers initial LayoutAndDraw when startup gate isn’t ready.
Terminal.Gui/App/ApplicationImpl.Lifecycle.cs	Subscribes/unsubscribes to new static property change events.
Terminal.Gui/App/ApplicationImpl.Driver.cs	Propagates AppModel into factories and creates startup gate for inline mode.
Terminal.Gui/App/ApplicationImpl.cs	Initializes instance AppModel/ForceInlineCursorRow from legacy static properties.
Terminal.Gui/App/Application.cs	Adds configurable static Application.AppModel and ForceInlineCursorRow.
plans/inline-mode-plan.md	Adds an implementation plan/architecture notes for inline mode.
Examples/UICatalog/UICatalogRunnable.cs	Refactors About dialog logo rendering and adds a version label.
Examples/UICatalog/Logo.cs	New reusable logo view (gradient ASCII art).
Examples/PromptExample/Program.cs	Simplifies prompt example layout and sets main window text/alignment.
Examples/InlineColorPicker/Program.cs	New inline-mode runnable example that prints selected color to stdout.
Examples/InlineColorPicker/InlineColorPicker.csproj	New example project.
Examples/InlineCLI/README.md	Documents inline-mode example usage.
Examples/InlineCLI/InlineCLI.csproj	New example project.
Examples/InlineCLI/InlineCLI.cs	New inline CLI-style interactive example built with inline mode.

[tig]

This is slicker than snot. An OptionSelector as a CLI:

Here's the code

// InlineSelect — demonstrates using RunnableWrapper<OptionSelector, int?> in inline mode.
//
// Renders an OptionSelector inline in the terminal with options from the command line.
// Supports horizontal or vertical orientation via --horizontal / --vertical flags.
// Hot keys are auto-assigned from option text.
//
// Usage:
//   dotnet run --project Examples/InlineSelect -- Apple Banana Cherry
//   dotnet run --project Examples/InlineSelect -- --horizontal Red Green Blue Yellow
//   dotnet run --project Examples/InlineSelect -- --vertical One Two Three

using Terminal.Gui.App;
using Terminal.Gui.ViewBase;
using Terminal.Gui.Views;

// Parse command-line arguments
Orientation orientation = Orientation.Vertical;
List<string> options = [];

foreach (string arg in args)
{
    if (arg is "--horizontal" or "-h")
    {
        orientation = Orientation.Horizontal;
    }
    else if (arg is "--vertical" or "-v")
    {
        orientation = Orientation.Vertical;
    }
    else
    {
        options.Add (arg);
    }
}

if (options.Count == 0)
{
    Console.Error.WriteLine ("Usage: InlineSelect [--horizontal|--vertical] <option1> <option2> ...");

    return 1;
}

// Enable inline mode before Init
Application.AppModel = AppModel.Inline;

IApplication app = Application.Create ().Init ();

// Build the OptionSelector with command-line options
OptionSelector selector = new ()
{
    Labels = options,
    Orientation = orientation,
    AssignHotKeys = true
};

// Wrap in RunnableWrapper — auto-extracts Value via IValue<int?>
RunnableWrapper<OptionSelector, int?> wrapper = new (selector)
{
    Title = "Select an option (Enter to accept, Esc to cancel)",
    Width = Dim.Fill ()
};

// Run inline — blocks until user accepts or cancels
app.Run (wrapper);

int? result = wrapper.Result;

app.Dispose ();

if (result is { } selectedIndex && selectedIndex >= 0 && selectedIndex < options.Count)
{
    Console.WriteLine (options [selectedIndex]);

    return 0;
}

return 1;

[BDisp]

Finally, this impressive feature has been implemented. Congratulations on your effort and resilience. Although the terminal gets all jumbled up in the back buffer when resizing, what's most relevant is that the currently visible app is all aligned and properly adjusted. Thanks.

[YourRobotOverlord]

This is a great addition to the library! I love it!

[BDisp]

I've already tested all 3 examples and they're all fantastic. It's like running scripts from the command line and maintaining the results across all calls. I love that too.

[YourRobotOverlord]

This is so much nicer than every one of the CLIs that I've tried, especially for editing your input. None of the others I've used allow modifier keys while editing, like Ctrl+Del. You're stuck hammering or holding the edit keys to make large changes. None of them support text selection, either. Or Undo/Redo.
This could level up basically any CLI I use regularly.