Added namespace docs

docfx/apispec/namespace-app.md

@@ -0,0 +1,27 @@
+---
+uid: Terminal.Gui.App
+summary: The `App` namespace holds @Terminal.Gui.Application and associated classes.
+---
+
[email protected] provides the main entry point and core application logic for Terminal.Gui applications. This static singleton class is responsible for initializing and shutting down the Terminal.Gui environment, managing the main event loop, handling input and output, and providing access to global application state.
+
+Typical usage involves calling `Application.Init()` to initialize the application, creating and running a `Window`, and then calling `Application.Shutdown()` to clean up resources. The class also provides methods for culture support, idle handlers, and rendering the application state as a string.
+
+## Example Usage
+
+```csharp
+Application.Init();
+var win = new Window()
+{
+    Title = $"Example App ({Application.QuitKey} to quit)"
+};
+Application.Run(win);
+win.Dispose();
+Application.Shutdown();
+```
+
+## See Also
+
+- [Logging](logging.md)
+- [Mainloop](mainloop.md)
+<!-- - [Application](application.md) -->

docfx/apispec/namespace-configuration.md

@@ -0,0 +1,30 @@
+---
+uid: Terminal.Gui.Configuration
+summary: The `Configuration` namespace provides comprehensive configuration management for Terminal.Gui applications.
+---
+
[email protected] provides a robust system for managing application settings, themes, and runtime configuration. This namespace includes the configuration manager, property attributes, and scoping mechanisms that allow applications to persist and load settings from various sources.
+
+The configuration system supports multiple scopes (Settings, Themes, AppSettings) and sources (user directory, application directory, etc.), enabling flexible deployment and customization scenarios. It also provides theme inheritance and hot-reloading capabilities for dynamic configuration updates.
+
+## Key Components
+
+- **ConfigurationManager**: Central system for loading, applying, and managing configuration
+- **ConfigProperty**: Attribute for marking properties as configurable
+- **Scopes**: Settings, Theme, and AppSettings contexts
+- **Sources**: Multiple storage locations for configuration persistence
+
+## Example Usage
+
+```csharp
+// Mark a property as configurable
+[ConfigProperty]
+public static bool MyFeatureEnabled { get; set; } = true;
+
+// Load configuration from default sources
+ConfigurationManager.Enable(ConfigLocations.All);
+```
+
+## Deep Dive
+
+- [Configuration Management Deep Dive](~/docs/config.md) - Comprehensive configuration system documentation

docfx/apispec/namespace-drawing.md

@@ -0,0 +1,28 @@
+---
+uid: Terminal.Gui.Drawing
+summary: The `Drawing` namespace provides comprehensive text rendering, color management, and visual styling for Terminal.Gui applications.
+---
+
[email protected] contains the core drawing primitives and visual styling system for Terminal.Gui. This namespace handles everything from basic color and attribute management to complex line drawing and text formatting capabilities.
+
+The drawing system supports both simple and advanced scenarios, including Unicode text rendering, automatic line joining for complex shapes, thickness-based adornments, and comprehensive color schemes with semantic visual roles.
+
+## Key Components
+
+- **Attribute**: Defines visual styling (foreground, background, text style)
+- **Color**: Terminal color support including TrueColor and named colors
+- **Scheme**: Maps semantic visual roles to concrete attributes
+- **LineCanvas**: Advanced line drawing with automatic glyph joining
+- **Thickness**: Framework for defining border and adornment widths
+- **Glyphs**: Standard set of drawing characters for UI elements
+
+## Example Usage 
+
+```csharp
+// Get the attribute for a Focused view
+Attribute? focusedAttribute = GetAttributeForRole(VisualRole.Focused);
+
+// Move to 5,5 and output a string with the focused attribute
+Move (5,5);
+AddStr("Hello");
+```

docfx/apispec/namespace-drivers.md

@@ -0,0 +1,30 @@
+---
+uid: Terminal.Gui.Drivers
+summary: The `Drivers` namespace provides cross-platform terminal abstraction and console driver implementations.
+---
+
[email protected] contains the platform abstraction layer that enables Terminal.Gui to run consistently across Windows, macOS, and Linux/Unix systems. This namespace includes console drivers, terminal capability detection, and platform-specific optimizations.
+
+The driver system handles low-level terminal operations including cursor management, color support detection, input processing, and screen buffer management. It provides a unified API while accommodating the unique characteristics of different terminal environments.
+
+## Key Components
+
+- **ConsoleDriver**: Base class for platform-specific terminal implementations
+- **WindowsDriver**: Windows Console API implementation
+- **CursesDriver**: Unix/Linux ncurses-based implementation
+- **NetDriver**: Cross-platform .NET Console implementation
+
+## Example Usage
+
+```csharp
+// Driver selection is typically automatic
+Application.Init();
+
+// Access current driver capabilities
+var driver = Application.Driver;
+bool supportsColors = driver.SupportsTrueColor;
+```
+
+## Deep Dive
+
+See the [Cross-Platform Driver Model](~/docs/drivers.md) for comprehensive details. 

docfx/apispec/namespace-input.md

@@ -0,0 +1,42 @@
+---
+uid: Terminal.Gui.Input
+summary: The `Input` namespace provides comprehensive input handling for keyboard, mouse, and command processing.
+---
+
[email protected] contains the input processing system for Terminal.Gui applications, including keyboard event handling, mouse interaction, and the command execution framework. This namespace defines the core input primitives and event structures used throughout the framework.
+
+The input system provides both low-level input events and high-level command abstractions, enabling applications to handle everything from basic key presses to complex gesture recognition and command routing.
+
+## Key Components
+
+- **Key**: Represents keyboard input with modifier support
+- **MouseEventArgs**: Comprehensive mouse event information
+- **Command**: Enumeration of standard application commands
+- **KeyBinding**: Associates keys with commands
+- **MouseBinding**: Associates mouse events with commands
+
+## Example Usage
+
+```csharp
+// First, add command handlers
+AddCommand(Command.Up, commandContext => Move(commandContext, -16));
+AddCommand(Command.Down, commandContext => Move(commandContext, 16));
+AddCommand(Command.Accept, HandleAcceptCommand);
+
+// Then bind keys to commands
+KeyBindings.Add(Key.CursorUp, Command.Up);
+KeyBindings.Add(Key.CursorDown, Command.Down);
+KeyBindings.Add(Key.Enter, Command.Accept);
+
+// Then bind mouse events to commands
+MouseBindings.Add(MouseFlags.Button1DoubleClicked, Command.Accept);
+MouseBindings.Add(MouseFlags.WheeledDown, Command.ScrollDown);
+MouseBindings.ReplaceCommands(MouseFlags.Button3Clicked, Command.Context);
+```
+
+## Deep Dives
+
+- [Keyboard Input](~/docs/keyboard.md) - Comprehensive keyboard input handling
+- [Mouse Input](~/docs/mouse.md) - Comprehensive mouse input handling
+- [Commands](~/docs/command.md) - Command execution framework details
+

docfx/apispec/namespace-text.md

@@ -0,0 +1,35 @@
+---
+uid: Terminal.Gui.Text
+summary: The `Text` namespace provides advanced text processing, formatting, and Unicode handling capabilities.
+---
+
[email protected] contains the text processing and formatting system for Terminal.Gui applications. This namespace handles Unicode text rendering, text measurement, formatting with alignment and wrapping, and hot key processing for accessible user interfaces.
+
+The text system supports complex text scenarios including bidirectional text, combining characters, wide characters, and sophisticated formatting options with both horizontal and vertical alignment capabilities.
+
+## Key Components
+
+- **TextFormatter**: Advanced text formatting with alignment and wrapping
+- **Rune**: Unicode character representation and processing
+- **TextDirection**: Support for left-to-right and right-to-left text
+- **TextAlignment**: Horizontal and vertical text positioning
+
+## Text Processing Features
+
+- **Unicode Support**: Full Unicode character set including combining characters
+- **Text Formatting**: Word wrapping, alignment, and hot key processing
+- **Accessibility**: Hot key support for keyboard navigation
+
+## Example Usage 
+
+```csharp
+// Create a text formatter with default settings
+var formatter = new TextFormatter();
+
+// Format a string with alignment
+var formatted = formatter.Format("Hello, World!", 10, 10, TextAlignment.Center);
+```
+
+## Deep Dive
+
+- [Text Formatting](~/docs/drawing.md) - Comprehensive text formatting documentation

docfx/apispec/namespace-viewbase.md

@@ -0,0 +1,55 @@
+---
+uid: Terminal.Gui.ViewBase
+summary: The `ViewBase` namespace contains the foundational view system and core UI building blocks.
+---
+
[email protected] provides the fundamental view architecture that forms the foundation of all Terminal.Gui user interface elements. This namespace contains the base View class, adornment system, layout primitives, and core view behaviors that enable the rich UI capabilities of Terminal.Gui.
+
+The View system implements the complete view lifecycle, coordinate systems, event handling, focus management, and the innovative adornment system that separates content from visual decoration.
+
+## Key Components
+
+- @Terminal.Gui.ViewBase.View - Base class for all UI elements with complete lifecycle management
+- @Terminal.Gui.ViewBase.Adornment - Visual decorations (Margin, Border, Padding) outside content area
+- @Terminal.Gui.ViewBase.View.Viewport - Scrollable window into view content with built-in scrolling support
+- @Terminal.Gui.ViewBase.ViewArrangement - Flags controlling user interaction (Movable, Resizable, etc.)
+- @Terminal.Gui.ViewBase.Pos and @Terminal.Gui.ViewBase.Dim - Flexible positioning and sizing system with relative and absolute options
+
+## View Architecture
+
+- **Hierarchy**: SuperView/SubView relationships with automatic lifecycle management
+- **Coordinate Systems**: Multiple coordinate spaces (Frame, Viewport, Content, Screen)
+- **Layout Engine**: Automatic positioning and sizing with constraint-based layout
+- **Event System**: Comprehensive event handling with cancellation support
+- **Focus Management**: Built-in keyboard navigation and focus chain management
+
+## Example Usage
+
+```csharp
+// Create a view with a Border adornment and Title
+var view = new View()
+{
+    X = Pos.Center(),
+    Y = Pos.Center(),
+    Width = Dim.Percent(50),
+    Height = Dim.Percent(30),
+    Title = "My View",
+    BorderStyle = LineStyle.Rounded
+};
+
+// Enable user arrangement
+view.Arrangement = ViewArrangement.Movable | ViewArrangement.Resizable;
+
+// Add to SuperView 
+superView.Add(view);
+```
+
+## See Also
+
+- [View Deep Dive](~/docs/View.md) - Comprehensive view system documentation
+- [List of Views](~/docs/views.md) - List of all built-in views
+- [Layout Deep Dive](~/docs/layout.md) - Layout system and coordinate spaces
+- [Arrangement Deep Dive](~/docs/arrangement.md) - User interaction and view arrangement
+- [Navigation Deep Dive](~/docs/navigation.md) - Focus management and keyboard navigation
+- [Scrolling Deep Dive](~/docs/scrolling.md) - Built-in scrolling capabilities
+- [Events Deep Dive](~/docs/events.md) - Event handling patterns 

docfx/apispec/namespace-views.md

@@ -0,0 +1,11 @@
+---
+uid: Terminal.Gui.Views
+summary: The `Views` namespace contains the complete collection of built-in UI controls and widgets.
+---
+
[email protected] provides a comprehensive set of pre-built user interface controls, derived from @Terminal.Gui.ViewBase.View, that cover common application needs. From simple labels and buttons to complex data grids and tree views, this namespace contains production-ready controls with consistent behavior, theming, and accessibility support.
+
+All Views in this namespace are built on the @Terminal.Gui.ViewBase.View foundation and inherit the complete feature set including adornments, scrolling, focus management, and user arrangement capabilities.
+
+For a complete list of all views with examples, see the [List of Views](~/docs/views.md) page.
+

docfx/docfx.json

@@ -54,6 +54,7 @@
         ]
       }
     ],
+    "overwrite": "apispec/*.md",
     "globalMetadata": {
       "_appName": "Terminal.Gui v2",
       "_appTitle": "Terminal.Gui v2",

docfx/docs/index.md

@@ -34,5 +34,5 @@ Welcome to the Terminal.Gui documentation! This comprehensive guide covers every
 
 ## API Reference
 
-For detailed API documentation, see the [API Reference](~/api).
+For detailed API documentation, see the [API Reference](~/api/Terminal.Gui).