Updated docfx and fixed most warnings

Terminal.Gui/Drawing/Color.cs

@@ -226,8 +226,6 @@ public readonly partial record struct Color : ISpanParsable<Color>, IUtf8SpanPar
     /// <param name="inputColor"></param>
     /// <remarks>
     ///     Distance is defined here as the Euclidean distance between each color interpreted as a <see cref="Vector3"/>.
-    ///     <para/>
-    ///     The order of the values in the passed Vector3 must be
     /// </remarks>
     /// <returns></returns>
     [SkipLocalsInit]

Terminal.Gui/Views/Toplevel.cs

@@ -93,11 +93,11 @@ public partial class Toplevel : View
     public bool IsLoaded { get; private set; }
 
     // TODO: IRunnable: Re-implement as an event on IRunnable; IRunnable.Activating/Activate
-    /// <summary>Invoked when the Toplevel <see cref="RunState"/> becomes the <see cref="Application.Current"/> Toplevel.</summary>
+    /// <summary>Invoked when the Toplevel <see cref="RunState"/> active.</summary>
     public event EventHandler<ToplevelEventArgs>? Activate;
 
     // TODO: IRunnable: Re-implement as an event on IRunnable; IRunnable.Deactivating/Deactivate?
-    /// <summary>Invoked when the Toplevel<see cref="RunState"/> ceases to be the <see cref="Application.Current"/> Toplevel.</summary>
+    /// <summary>Invoked when the Toplevel<see cref="RunState"/> ceases to be active.</summary>
     public event EventHandler<ToplevelEventArgs>? Deactivate;
 
     /// <summary>Invoked when the Toplevel's <see cref="RunState"/> is closed by <see cref="Application.End(RunState)"/>.</summary>

UICatalog/Scenarios/ArrangementEditor.cs

@@ -81,7 +81,7 @@ public sealed class ArrangementEditor : View
 
     /// <summary>
     ///     Gets or sets whether the ArrangementEditor should automatically select the View to edit
-    ///     based on the values of <see cref="AutoSelectSuperView"/> and <see cref="AutoSelect"/>.
+    ///     based on the values of <see cref="AutoSelectSuperView"/>.
     /// </summary>
     public bool AutoSelectViewToEdit { get; set; }
 

UICatalog/Scenarios/ExpanderButton.cs

@@ -144,8 +144,7 @@ public class ExpanderButton : Button
     }
 
     /// <summary>
-    ///     Fired when the orientation has changed. Can be cancelled by setting
-    ///     <see cref="OrientationEventArgs.Cancel"/> to true.
+    ///     Fired when the orientation has changed. Can be cancelled.
     /// </summary>
     public event EventHandler<CancelEventArgs<bool>> CollapsedChanging;
 

UICatalog/UICatalog.cs

@@ -32,7 +32,7 @@ namespace UICatalog;
 ///     <para>
 ///         <list type="number">
 ///             <item>
-///                 <description>Be an easy to use showcase for Terminal.Gui concepts and features.</description>
+///                 <description>Be an easy-to-use showcase for Terminal.Gui concepts and features.</description>
 ///             </item>
 ///             <item>
 ///                 <description>Provide sample code that illustrates how to properly implement said concepts & features.</description>
@@ -42,10 +42,6 @@ namespace UICatalog;
 ///             </item>
 ///         </list>
 ///     </para>
-///     <para>
-///         See the project README for more details
-///         (https://github.com/gui-cs/Terminal.Gui/tree/master/UICatalog/README.md).
-///     </para>
 /// </remarks>
 public class UICatalogApp
 {

docfx/docfx.json

@@ -26,6 +26,9 @@
     }
   ],
   "build": {
+    "xref": [
+      "https://learn.microsoft.com/en-us/dotnet/.xrefmap.json"
+    ],
     "template": [
       "default",
       "_exported_templates/modern"

docfx/docs/View.md

@@ -4,11 +4,11 @@
 
 ### Hierarchy
 
-  * *[View](~/api/Terminal.Gui.View.yml)* - The base class for implementing higher-level visual/interactive Terminal.Gui elements. Implemented in the [View](~/api/Terminal.Gui.View.yml) base class.
+  * *@"Terminal.Gui.View"* - The base class for implementing higher-level visual/interactive Terminal.Gui elements. Implemented in the @Terminal.Gui.View base class.
   
-  * *SubView* - A View that is contained in another view and will be rendered as part of the containing view's *ContentArea*. SubViews are added to another view via the [View.Add](~/api/Terminal.Gui.View.Add.yml) method. A View may only be a SubView of a single View. Each View has a [Subviews](~/api/Terminal.Gui.View.Subviews.yml) property that is a list of all Subviews that have been added.
+  * *SubView* - A View that is contained in another view and will be rendered as part of the containing view's **ContentArea**. SubViews are added to another view via the @"Terminal.Gui.View.Add(Terminal.Gui.View)" method. A View may only be a SubView of a single View. Each View has a @Terminal.Gui.View.Subviews property that is a list of all Subviews that have been added.
   
-  * *[SuperView](~/api/Terminal.Gui.View.SuperView.yml)* - The View that is a container for SubViews. Each View has a [SuperView](~/api/Terminal.Gui.View.SuperView.yml) property that references it's SuperView after it has been added.
+  * *@"Terminal.Gui.View.SuperView"* - The View that is a container for SubViews. Each View has a @Terminal.Gui.View.SuperView property that references it's SuperView after it has been added.
   
   * *Child View* - A view that holds a reference to another view in a parent/child relationship. Terminal.Gui uses the terms "Child" and "Parent" sparingly. Generally Subview/SuperView is preferred.
   

docfx/docs/arrangement.md

@@ -5,17 +5,17 @@ Terminal.Gui provides a feature of Layout known as **Arrangement**, which contro
 
 * **Arrangement** - Describes the feature of [Layout](layout.md) which controls how the user can use the mouse and keyboard to arrange views and enables either **Tiled** or **Overlapped** layouts.
 
-* **Arrange Mode** - When a user presses `Ctrl+F5` (configurable via the [Application.ArrangeKey](~/api/Terminal.Gui.Application.ArrangeKey)) the application goes into **Arrange Mode**. In this mode, indicators are displayed on an arrangeable view indicating which aspect of the View can be arranged. If [Movable](~/api/Terminal.Gui.ViewArrangement.Movable.yml), a `◊` will be displayed in the top-left corner of the [Border](~/api/Terminal.Gui.View.Border). If [Sizable](~/api/Terminal.Gui.ViewArrangement.Sizable.yml), pressing `Tab` (or `Shift+Tab`) will cycle to an an indictor in the bottom-right corner of the Border. The up/down/left/right cursor keys will act appropriately. `Esc`, `Ctrl+F5` or clicking outside of the Border will exit Arrange Mode.
+* **Arrange Mode** - When a user presses `Ctrl+F5` (configurable via the @Terminal.Gui.Application.ArrangeKey) the application goes into **Arrange Mode**. In this mode, indicators are displayed on an arrangeable view indicating which aspect of the View can be arranged. If @Terminal.Gui.ViewArrangement.Movable, a `◊` will be displayed in the top-left corner of the @Terminal.Gui.View.Border. If @Terminal.Gui.ViewArrangement.Resizable , pressing `Tab` (or `Shift+Tab`) will cycle to an an indictor in the bottom-right corner of the Border. The up/down/left/right cursor keys will act appropriately. `Esc`, `Ctrl+F5` or clicking outside of the Border will exit Arrange Mode.
 
-* **Modal** - A modal view is one that is run as an "application" via `Application.Run(Toplevel)` where `Modal == true`. `Dialog`, `Messagebox`, and `Wizard` are the prototypical examples. When run this way, there IS a `z-order` but it is highly-constrained: the modal view has a z-order of 1 and everything else is at 0. 
+* **Modal** - A modal view is one that is run as an "application" via @Terminal.Gui.Application.Run(System.Func{System.Exception,System.Boolean},Terminal.Gui.ConsoleDriver) where `Modal == true`. `Dialog`, `Messagebox`, and `Wizard` are the prototypical examples. When run this way, there IS a `z-order` but it is highly-constrained: the modal view has a z-order of 1 and everything else is at 0. 
 
-* **Movable** - Describes a View that can be moved by the user using the keyboard or mouse. **Movable** is enabled on a per-View basis by setting the [ViewArrangement.Movable](~/api/Terminal.Gui.ViewArrangement.Movable.yml) flag on [View.Arrangement](~/api/Terminal.Gui.View.Arrangement.yml). Dragging on the top [Border](~/api/Terminal.Gui.View.Border) of a View will move such a view. Pressing `Ctrl+F5` will activate **Arrange Mode** letting the user move the view with the up/down/left/right cursor keys.
+* **Movable** - Describes a View that can be moved by the user using the keyboard or mouse. **Movable** is enabled on a per-View basis by setting the @Terminal.Gui.ViewArrangement.Movable flag on @Terminal.Gui.View.Arrangement. Dragging on the top @Terminal.Gui.View.Border of a View will move such a view. Pressing `Ctrl+F5` will activate **Arrange Mode** letting the user move the view with the up/down/left/right cursor keys.
 
-* **Overlapped** - A form of layout where SubViews of a View are visually arranged such that their Frames overlap. In Overlap view arrangements there is a Z-axis (Z-order) in addition to the X and Y dimension. The Z-order indicates which Views are shown above other views. **Overlapped** is enabled on a per-View basis by setting the [ViewArrangement.Overlapped](~/api/Terminal.Gui.ViewArrangement.Overlapped.yml) flag on [View.Arrangement](~/api/Terminal.Gui.View.Arrangement.yml). 
+* **Overlapped** - A form of layout where SubViews of a View are visually arranged such that their Frames overlap. In Overlap view arrangements there is a Z-axis (Z-order) in addition to the X and Y dimension. The Z-order indicates which Views are shown above other views. **Overlapped** is enabled on a per-View basis by setting the @Terminal.Gui.ViewArrangement.Overlapped flag on @Terminal.Gui.View.Arrangement. 
 
-* **Sizable** - Describes a View that can be sized by the user using the keyboard or mouse. **Sizable** is enabled on a per-View basis by setting the [ViewArrangement.Sizable](~/api/Terminal.Gui.ViewArrangement.Sizable.yml) flag on [View.Arrangement](~/api/Terminal.Gui.View.Arrangement.yml). Dragging on the left, right, or bottom [Border](~/api/Terminal.Gui.View.Border) of a View will size that side of such a view. Pressing `Ctrl+F5` will activate **Arrange Mode** letting the user size the view with the up/down/left/right cursor keys.
+* **Sizable** - Describes a View that can be sized by the user using the keyboard or mouse. **Sizable** is enabled on a per-View basis by setting the @Terminal.Gui.ViewArrangement.Resizable flag on @Terminal.Gui.View.Arrangement. Dragging on the left, right, or bottom @Terminal.Gui.View.Border of a View will size that side of such a view. Pressing `Ctrl+F5` will activate **Arrange Mode** letting the user size the view with the up/down/left/right cursor keys.
 
-* **Tiled** - A form of layout where SubViews of a View are visually arranged such that their Frames do not typically overlap. With **Tiled** views, there is no 'z-order` to the Subviews of a View. In most use-cases, subviews do not overlap with each other (the exception being when it's done intentionally to create some visual effect). As a result, the default layout for most TUI apps is "tiled", and by default [View.Arrangement](~/api/Terminal.Gui.View.Arrangement.yml) is set to [ViewArrangement.Fixed](~/api/Terminal.Gui.ViewArrangement.Fixed.yml).
+* **Tiled** - A form of layout where SubViews of a View are visually arranged such that their Frames do not typically overlap. With **Tiled** views, there is no 'z-order` to the Subviews of a View. In most use-cases, subviews do not overlap with each other (the exception being when it's done intentionally to create some visual effect). As a result, the default layout for most TUI apps is "tiled", and by default @Terminal.Gui.View.Arrangement is set to @Terminal.Gui.ViewArrangement.Fixed.
 
 * **Runnable** - Today, Overlapped and Runnable are intrinsically linked. A runnable view is one where `Application.Run(Toplevel)` is called.  Each *Runnable* view where (`Modal == false`) has it's own `RunState` and is, effectively, a self-contained "application". `Application.Run()` non-preemptively dispatches events (screen, keyboard, mouse , Timers, and Idle handlers) to the associated `Toplevel`. It is possible for such a `Toplevel` to create a thread and call `Application.Run(someotherToplevel)` on that thread, enabling pre-emptive user-interface multitasking (`BackgroundWorkerCollection` does this). 
 

docfx/docs/config.md

@@ -32,14 +32,15 @@ The `UI Catalog` application provides an example of how to use the [`Configurati
 
 (Note, this list may not be complete; search the source code for `SerializableConfigurationProperty` to find all settings that can be configured.)
 
-  * [Application.QuitKey](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_QuitKey)
-  * [Application.NextTabKey](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_NextTabKey)
-  * [Application.PrevTabKey](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_PrevTabKey)
-  * [Application.NextTabGroupKey](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_NextTabGroupKey)
-  * [Application.PrevTabGroupKey](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_PrevTabGroupKey)
-  * [Application.ForceDriver](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_ForceDriver)
-  * [Application.Force16Colors](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_Force16Colors)
-  * [Application.IsMouseDisabled](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_IsMouseDisabled)
+  * @Terminal.Gui.Application.QuitKey
+  * @Terminal.Gui.Application.NextTabKey
+  * @Terminal.Gui.Application.PrevTabKey
+  * @Terminal.Gui.Application.NextTabGroupKey
+  * @Terminal.Gui.Application.PrevTabGroupKey
+  * @Terminal.Gui.Application.ArrangeKey
+  * @Terminal.Gui.Application.ForceDriver
+  * @Terminal.Gui.Application.Force16Colors
+  * @Terminal.Gui.Application.IsMouseDisabled
   
 ## Glyphs
 

docfx/docs/drawing.md

@@ -1,12 +1,12 @@
 # Drawing (Text, Lines, and Color)
 
-Terminal.Gui provides a set of APIs for formatting text, line drawing, and character-based graphing. The fundamental concept is a [Cell](~/api/Terminal.Gui.Cell.yml) which ocupises a particular row and column in the terminal. A Cell includes the character (glyph) that should be rendred by the terminal, and attributes that indicate how the glphy should be rendered (e.g. the foreground and background color).
+Terminal.Gui provides a set of APIs for formatting text, line drawing, and character-based graphing. The fundamental concept is a @Terminal.Gui.Cell which occupies a particular row and column in the terminal. A Cell includes the character (glyph) that should be rendred by the terminal, and attributes that indicate how the glyph should be rendered (e.g. the foreground and background color).
 
 Color is supported on all platforms, including Windows, Mac, and Linux. The default colors are 24-bit RGB colors, but the library will gracefully degrade to 16-colors if the terminal does not support 24-bit color, and black and white if the terminal does not support 16-colors.
 
 ## View Drawing API
 
-A [View](~/api/Terminal.Gui.View.yml) will typically draw text when the [OnDrawContent](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_OnDrawContent_) is called (or the `DrawContent` event is received).
+A @Terminal.Gui.View will typically draw text when the @Terminal.Gui.Border.OnDrawContent(System.Drawing.Rectangle) is called (or the `DrawContent` event is received).
 
 Outputting unformatted text involves:
 
@@ -16,28 +16,28 @@ c) Outputting glyphs by calling `AddRune` or `AddStr`.
 
 Outputting formatted text involves:
 
-a) Adding the text to a [TextFormatter](~/api/Terminal.Gui.TextFormatter.yml) object.
-b) Setting formatting options, such as [TextFormatter.TextAlignment](~/api/Terminal.Gui.TextFormatter.TextAlignment.yml).
-c) Calling [TextFormatter.Draw](~/api/Terminal.Gui.TextFormatter.Draw.yml).
+a) Adding the text to a @Terminal.Gui.TextFormatter object.
+b) Setting formatting options, such as @Terminal.Gui.TextFormatter.TextAlignment.
+c) Calling @Terminal.Gui.TextFormatter.Draw.
 
-Line drawing is accomplished using the [LineCanvas](~/api/Terminal.Gui.LineCanvas.yml) API:
+Line drawing is accomplished using the @Terminal.Gui.LineCanvas API:
 
-a) Add the lines via [LineCanvas.Add](~/api/Terminal.Gui.LineCanvas.Add.yml).
-b) Either render the line canvas via [LineCanvas.Draw](~/api/Terminal.Gui.LineCanvas.Draw.yml) or let the [View](~/api/Terminal.Gui.View.yml) do so automatically (which enables automatic line joining across Views).
+a) Add the lines via @Terminal.Gui.LineCanvas.Add.
+b) Either render the line canvas via @Terminal.Gui.LineCanvas.GetMap() or let the @Terminal.Gui.View do so automatically (which enables automatic line joining across Views).
 
 ## Coordinate System for Drawing
 
-The [View](~/api/Terminal.Gui.View.yml) draw APIs, including the `OnDrawContent` method, the `DrawContent` event, and the [View.Move](~/api/Terminal.Gui.View.Move.yml) method, all take coordinates specified in *Viewport-Relative* coordinates. That is, `0, 0` is the top-left cell visible to the user.
+The @Terminal.Gui.View draw APIs, including the `OnDrawContent` method, the `DrawContent` event, and the @Terminal.Gui.View.Move method, all take coordinates specified in *Viewport-Relative* coordinates. That is, `0, 0` is the top-left cell visible to the user.
 
-See [Layout](layout.html) for more details of the Terminal.Gui coordinate system.
+See [Layout](layout.md) for more details of the Terminal.Gui coordinate system.
 
 ## Cell
 
-The [Cell](~/api/Terminal.Gui.Cell.yml) class represents a single cell on the screen. It contains a character and an attribute. The character is of type `Rune` and the attribute is of type [Attribute](~/api/Terminal.Gui.Attribute.yml).
+The @Terminal.Gui.Cell class represents a single cell on the screen. It contains a character and an attribute. The character is of type `Rune` and the attribute is of type @Terminal.Gui.Attribute.
 
-`Cell` is not exposed directly to the developer. Instead, the [ConsoleDriver](~/api/Terminal.Gui.ConsoleDriver.yml) classes manage the `Cell` array that represents the screen.
+`Cell` is not exposed directly to the developer. Instead, the @Terminal.Gui.ConsoleDriver.yml) classes manage the `Cell` array that represents the screen.
 
-To draw a `Cell` to the screen, use [View.Move](~/api/Terminal.Gui.View.Move.yml) to specify the row and column coordinates and then use the [View.AddRune](~/api/Terminal.Gui.View.AddRune.yml) method to draw a single glyph. To draw a string, use [View.AddStr](~/api/Terminal.Gui.View.AddStr.yml). 
+To draw a `Cell` to the screen, use Terminal.Gui.View.Move(System.Int32,System.Int32) to specify the row and column coordinates and then use the @Terminal.Gui.View.AddRune(System.Int32,System.Int32,System.Text.Rune) method to draw a single glyph.  
 
 ## Unicode
 
@@ -47,29 +47,29 @@ See the Character Map sample app in the [UI Catalog](https://gui-cs.github.io/Te
 
 ## Attribute 
 
-The [Attribute](~/api/Terminal.Gui.Attribute.yml) class represents the formatting attributes of a `Cell`. It exposes properties for the foreground and background colors. The foreground and background colors are of type [Color](~/api/Terminal.Gui.Color.yml). In the future, it will expose properties for bold, underline, and other formatting attributes.
+The @Terminal.Gui.Attribute class represents the formatting attributes of a `Cell`. It exposes properties for the foreground and background colors. The foreground and background colors are of type @Terminal.Gui.Color. In the future, it will expose properties for bold, underline, and other formatting attributes.
 
 ## Color
 
-The `Color` class represents a color. It provides automatic mapping between the legacy 4-bit (16-color) system and 24-bit colors. It contains properties for the red, green, and blue components of the color. The red, green, and blue components are of type [byte](~/api/Terminal.Gui.byte.yml). The `Color` class also contains a static property for each of the 16 ANSI colors.
+The `Color` class represents a color. It provides automatic mapping between the legacy 4-bit (16-color) system and 24-bit colors. It contains properties for the red, green, and blue components of the color. The `Color` class also contains a static property for each of the 16 ANSI colors.
 
 ## Color Schemes
 
-Terminal.Gui supports named collections of colors called [ColorScheme](~/api/Terminal.Gui.ColorScheme.yml)s. Three built-in color schemes are provided: "Default", "Dark", and "Light". Additional color schemes can be defined via [Configuration Manager](). 
+Terminal.Gui supports named collections of colors called @Terminal.Gui.ColorScheme. Three built-in color schemes are provided: "Default", "Dark", and "Light". Additional color schemes can be defined via [Configuration Manager](config.md). 
 
 Color schemes support defining colors for various states of a View. The following states are supported:
 
 * Normal - The color of normal text.
-* HotNormal - The color of text indicating a [Hotkey]().
+* HotNormal - The color of text indicating a @Terminal.Gui.View.Hotkey.
 * Focus - The color of text that indicates the view has focus.
 * HotFocus - The color of text indicating a hot key, when the view has focus.
 * Disabled - The state of a view when it is disabled.
 
-Change the colors of a view by setting the [View.ColorScheme](~/api/Terminal.Gui.View.ColorScheme.yml) property.
+Change the colors of a view by setting the @Terminal.Gui.View.ColorScheme property.
 
 ## Text Formatting
 
-Terminal.Gui supports text formatting using the [TextFormatter]() class. The [TextFormatter](~/api/Terminal.Gui.TextFormatter.yml) class provides methods for formatting text using the following formatting options:
+Terminal.Gui supports text formatting using @Terminal.Gui.View.TextFormatter. @Terminal.Gui.TextFormatter provides methods for formatting text using the following formatting options:
 
 * Horizontal Alignment - Left, Center, Right
 * Vertical Alignment - Top, Middle, Bottom
@@ -78,19 +78,15 @@ Terminal.Gui supports text formatting using the [TextFormatter]() class. The [Te
 
 ## Glyphs
 
-Terminal.Gui supports rendering glyphs using the [Glyph](~/api/Terminal.Gui.Glyph.yml) class. The [Glyph](~/api/Terminal.Gui.Glyph.yml) class represents a single glyph. It contains a character and an attribute. The character is of type `Rune` and the attribute is of type [Attribute](~/api/Terminal.Gui.Attribute.yml). A set of static properties are provided for the standard glyphs used for standard views (e.g. the default indicator for [Button](~/api/Terminal.Gui.Button.yml)) and line drawing (e.g. [LineCanvas](~/api/Terminal.Gui.LineCanvas.yml)).
+Terminal.Gui supports rendering glyphs using the @Terminal.Gui.Glyph class. The @Terminal.Gui.Glyph class represents a single glyph. It contains a character and an attribute. The character is of type `Rune` and the attribute is of type @Terminal.Gui.Attribute. A set of static properties are provided for the standard glyphs used for standard views (e.g. the default indicator for @Terminal.Gui.Button) and line drawing (e.g. @Terminal.Gui.LineCanvas).
 
 ## Line Drawing
 
-Terminal.Gui supports drawing lines and shapes using box-drawing glyphs. The [LineCanvas](~/api/Terminal.Gui.LineCanvas.yml) class provides *auto join*, a smart TUI drawing system that automatically selects the correct line/box drawing glyphs for intersections making drawing complex shapes easy. See [Line Canvas](https://gui-cs.github.io/Terminal.GuiV2Docs/docs/overview.html#line-canvas) for details. The `Snake` and `Line Drawing` Scenarios in the [UI Catalog](https://gui-cs.github.io/Terminal.GuiV2Docs/docs/overview.html#ui-catalog) sample app are both examples of the power of [LineCanvas](~/api/Terminal.Gui.LineCanvas.yml).
+Terminal.Gui supports drawing lines and shapes using box-drawing glyphs. The @Terminal.Gui.LineCanvas class provides *auto join*, a smart TUI drawing system that automatically selects the correct line/box drawing glyphs for intersections making drawing complex shapes easy. See @Terminal.Gui.LineCanvas.
 
 ## Thickness
 
-Describes the thickness of a frame around a rectangle. The thickness is specified for each side of the rectangle using a [Thickness](~/api/Terminal.Gui.Thickness.yml) object. The [Thickness](~/api/Terminal.Gui.Thickness.yml) object contains properties for the left, top, right, and bottom thickness. The [Adornment](~/api/Terminal.Gui.Adornment.yml) class uses [Thickness](~/api/Terminal.Gui.Thickness.yml) to support drawing the frame around a view. The `View` class contains three [Adornment](~/api/Terminal.Gui.Adornment.yml)-dervied properties: 
+Describes the thickness of a frame around a rectangle. The thickness is specified for each side of the rectangle using a @Terminal.Gui.Thickness object. The Thickness class contains properties for the left, top, right, and bottom thickness. The @Terminal.Gui.Adornment class uses @Terminal.Gui.Thickness to support drawing the frame around a view. The `View` class contains three Adornment-derived properties: 
 
-* [View.Margin.$2](~/api/Terminal.Gui.View.Margin.yml) - The space between the view and its peers (other views at the same level in the view hierarchy).
-* [View.Border.$2](~/api/Terminal.Gui.View.Border.yml) - The space between the view and its Padding. This is where the frame, title, and other "Adornments" are drawn.
-* [View.Padding.$2](~/api/Terminal.Gui.View.Padding.yml) - The space between the view and its content. This is where the text, images, and other content is drawn. The inner rectangle of `Padding` is the `Bounds` of a view. 
-
-See [View](~/api/Terminal.Gui.View.yml) for details.
+See [View Deep Dive](View.md) for details.
 

docfx/docs/getting-started.md

@@ -2,7 +2,7 @@
 
 Paste these commands into your favorite terminal on Windows, Mac, or Linux. This will install the [Terminal.Gui.Templates](https://github.com/gui-cs/Terminal.Gui.templates), create a new "Hello World" TUI app, and run it.
 
-(Press `CTRL-Q` to exit the app)
+(Press `Esc` to exit the app)
 
 ```ps1
 dotnet new --install Terminal.Gui.templates
@@ -25,79 +25,9 @@ Use the [Terminal.Gui.Templates](https://github.com/gui-cs/Terminal.Gui.template
 
 ## Sample Usage in C#
 
-The following example shows a basic Terminal.Gui application in C#:
-
-```csharp
-// A simple Terminal.Gui example in C# - using C# 9.0 Top-level statements
-
-using Terminal.Gui;
-
-Application.Run<ExampleWindow> ();
-
-System.Console.WriteLine ($"Username: {((ExampleWindow)Application.Top).usernameText.Text}");
-
-// Before the application exits, reset Terminal.Gui for clean shutdown
-Application.Shutdown ();
-
-// Defines a top-level window with border and title
-public class ExampleWindow : Window {
-	public TextField usernameText;
-	
-	public ExampleWindow ()
-	{
-		Title = "Example App (Ctrl+Q to quit)";
-
-		// Create input components and labels
-		var usernameLabel = new Label () { 
-			Text = "Username:" 
-		};
-
-		usernameText = new TextField ("") {
-			// Position text field adjacent to the label
-			X = Pos.Right (usernameLabel) + 1,
-
-			// Fill remaining horizontal space
-			Width = Dim.Fill (),
-		};
-
-		var passwordLabel = new Label () {
-			Text = "Password:",
-			X = Pos.Left (usernameLabel),
-			Y = Pos.Bottom (usernameLabel) + 1
-		};
-
-		var passwordText = new TextField ("") {
-			Secret = true,
-			// align with the text box above
-			X = Pos.Left (usernameText),
-			Y = Pos.Top (passwordLabel),
-			Width = Dim.Fill (),
-		};
-
-		// Create login button
-		var btnLogin = new Button () {
-			Text = "Login",
-			Y = Pos.Bottom(passwordLabel) + 1,
-			// center the login button horizontally
-			X = Pos.Center (),
-			IsDefault = true,
-		};
-
-		// When login button is clicked display a message popup
-		btnLogin.Clicked += () => {
-			if (usernameText.Text == "admin" && passwordText.Text == "password") {
-				MessageBox.Query ("Logging In", "Login Successful", "Ok");
-				Application.RequestStop ();
-			} else {
-				MessageBox.ErrorQuery ("Logging In", "Incorrect username or password", "Ok");
-			}
-		};
-
-		// Add the views to the Window
-		Add (usernameLabel, usernameText, passwordLabel, passwordText, btnLogin);
-	}
-}
-```
+The following example shows a basic Terminal.Gui application in C# (this is `./Example/Example.cs`):
+
+[!code-csharp[Program.cs](../../Example/Example.cs)]
 
 When run the application looks as follows:
 

docfx/docs/index.md

@@ -11,7 +11,7 @@
 * **[Extensible UI](https://gui-cs.github.io/Terminal.GuiV2Docs/api/Terminal.Gui.View.html)** - All visible UI elements are subclasses of the `View` class, and these in turn can contain an arbitrary number of sub-views. Dozens of [Built-in Views](views.md) are provided.
 * **[Keyboard](keyboard.md) and [Mouse](mouse.md) Input** - The library handles all the details of input processing and provides a simple event-based API for applications to consume.
 * **[Powerful Layout Engine](layout.md)** - The layout engine makes it easy to lay out controls relative to each other and enables dynamic terminal UIs. 
-* **[Machine, User, and App-Level Configuration](configuration.md)** - Persistent configuration settings, including overriding default look & feel with Themes, keyboard bindings, and more via the [`ConfigurationManager`](~/api/Terminal.Gui.ConfigurationManager.yml) class.
+* **[Machine, User, and App-Level Configuration](config.md)** - Persistent configuration settings, including overriding default look & feel with Themes, keyboard bindings, and more via the [`ConfigurationManager`](~/api/Terminal.Gui.ConfigurationManager.yml) class.
 * **[Clipboard support](https://gui-cs.github.io/Terminal.GuiV2Docs/api/Terminal.Gui.Clipboard.html)** - Cut, Copy, and Paste is provided through the [`Clipboard`] class.
 * **Multi-tasking** - The [Mainloop](https://gui-cs.github.io/Terminal.GuiV2Docs/api/Terminal.Gui.MainLoop.html) supports processing events, idle handlers, and timers. Most classes are safe for threading.
 * **[Reactive Extensions](https://github.com/dotnet/reactive)** - Use reactive extensions and benefit from increased code readability, and the ability to apply the MVVM pattern and [ReactiveUI](https://www.reactiveui.net/) data bindings. See the [source code](https://github.com/gui-cs/Terminal.GuiV2Docs/tree/master/ReactiveExample) of a sample app.
@@ -48,7 +48,7 @@ This example shows a prompt and returns an integer value depending on which valu
 
 More interesting user interfaces can be created by composing some of the various `View` classes that are included. 
 
-In the example above, [Applicaton.Init](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_Init_Terminal_Gui_ConsoleDriver_) sets up the environment, initializes the color schemes, and clears the screen to start the application.
+In the example above, [Application.Init()](xref:Terminal.Gui.Application.Init(Terminal.Gui.ConsoleDriver,System.String)) sets up the environment, initializes the color schemes, and clears the screen to start the application.
 
 The [Application](~/api/Terminal.Gui.Application.yml) class additionally creates an instance of the [Toplevel](~/api/Terminal.Gui.Toplevel.yml) View available in the `Application.Top` property, and can be used like this:
 
@@ -110,8 +110,7 @@ All visible elements in a Terminal.Gui application are implemented as
 
 See the full list of [Views provided by the Terminal.Gui library here](views.md).
 
-Every view can contain an arbitrary number of child views, called `SubViews`. Call the
-[View.Add](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_Add_Terminal_Gui_View_) method to add a couple of buttons to a UI:
+Every view can contain an arbitrary number of child views, called `SubViews`. Call @Terminal.Gui.View.Add(View) to add a couple of buttons to a UI:
 
 ```csharp
 void SetupMyView (View myView)

docfx/docs/keyboard.md

@@ -4,7 +4,7 @@
 
 Tenets higher in the list have precedence over tenets lower in the list.
 
-* **Users Have Control** - *Terminal.Gui* provides default key bindings consistent with these tenets, but those defaults are configurable by the user. For example, `ConfigurationManager` allows users to redefine key bindings for the system, a user, or an application.
+* **Users Have Control** - *Terminal.Gui* provides default key bindings consistent with these tenets, but those defaults are configurable by the user. For example, @Terminal.Gui.ConfigurationManager allows users to redefine key bindings for the system, a user, or an application.
 
 * **More Editor than Command Line** - Once a *Terminal.Gui* app starts, the user is no longer using the command line. Users expect keyboard idioms in TUI apps to be consistent with GUI apps (such as VS Code, Vim, and Emacs). For example, in almost all GUI apps, `Ctrl+V` is `Paste`. But the Linux shells often use `Shift+Insert`. *Terminal.Gui* binds `Ctrl+V` by default.
 
@@ -12,7 +12,7 @@ Tenets higher in the list have precedence over tenets lower in the list.
 
 * **The Source of Truth is Wikipedia** - We use this [Wikipedia article](https://en.wikipedia.org/wiki/Table_of_keyboard_shortcuts) as our guide for default key bindings.
 
-* **If It's Hot, It Works** - If a View with a [HotKey](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_HotKey) is visible, and the HotKey is visible, the user should be able to press that HotKey and whatever behavior is defined for it should work. For example, in v1, when a Modal view was active, the HotKeys on MenuBar continued to show "hot". In v2 we strive to ensure this doesn't happen.
+* **If It's Hot, It Works** - If a View with a @Terminal.Gui.View.HotKey is visible, and the HotKey is visible, the user should be able to press that HotKey and whatever behavior is defined for it should work. For example, in v1, when a Modal view was active, the HotKeys on MenuBar continued to show "hot". In v2 we strive to ensure this doesn't happen.
 
 
 ## Keyboard APIs
@@ -37,15 +37,15 @@ btn.KeyBindings.ReplaceKey (btn.KeyBindings.GetKeyFromCommands (Command.Accept))
 
 The [Command](~/api/Terminal.Gui.Command.yml) enum lists generic operations that are implemented by views. For example `Command.Accept` in a `Button` results in the `Clicked` event 
 firing while in `TableView` it is bound to `CellActivated`. Not all commands
-are implemented by all views (e.g. you cannot scroll in a `Button`). Use the `GetSupportedCommands()` method to determine which commands are implemented by a `View`. 
+are implemented by all views (e.g. you cannot scroll in a `Button`). Use the @Terminal.Gui.View.GetSupportedCommands() method to determine which commands are implemented by a `View`. 
 
-Key Bindings can be added at the `Application` or `View` level. For Application-scoped Key Bindings see [ApplicationNavigation](~/api/Terminal.Gui.ApplicationNavigation.yml). For View-scoped Key Bindings see [Key Bindings](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_KeyBinings).
+Key Bindings can be added at the `Application` or `View` level. For Application-scoped Key Bindings see @Terminal.Gui.Application.Navigation. For View-scoped Key Bindings see @Terminal.Gui.View.KeyBindings.
 
-### **[HotKey](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_HotKey)** 
+### **@"Terminal.Gui.View.HotKey"** 
 
 A **HotKey** is a key press that selects a visible UI item. For selecting items across `View`s (e.g. a `Button` in a `Dialog`) the key press must have the `Alt` modifier. For selecting items within a `View` that are not `View`s themselves, the key press can be key without the `Alt` modifier.  For example, in a `Dialog`, a `Button` with the text of "_Text" can be selected with `Alt+T`. Or, in a `Menu` with "_File _Edit", `Alt+F` will select (show) the "_File" menu. If the "_File" menu has a sub-menu of "_New" `Alt+N` or `N` will ONLY select the "_New" sub-menu if the "_File" menu is already opened.
 
-By default, the `Text` of a `View` is used to determine the `HotKey` by looking for the first occurrence of the [HotKeySpecifier](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_HotKeySpecifier) (which is underscore (`_`) by default). The character following the underscore is the `HotKey`. If the `HotKeySpecifier` is not found in `Text`, the first character of `Text` is used as the `HotKey`. The `Text` of a `View` can be changed at runtime, and the `HotKey` will be updated accordingly. [HotKey](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_HotKey) is `virtual` enabling this behavior to be customized.
+By default, the `Text` of a `View` is used to determine the `HotKey` by looking for the first occurrence of the @Terminal.Gui.View.HotKeySpecifier (which is underscore (`_`) by default). The character following the underscore is the `HotKey`. If the `HotKeySpecifier` is not found in `Text`, the first character of `Text` is used as the `HotKey`. The `Text` of a `View` can be changed at runtime, and the `HotKey` will be updated accordingly. @"Terminal.Gui.View.HotKey" is `virtual` enabling this behavior to be customized.
 
 ### **[Shortcut](~/api/Terminal.Gui.Shortcut.yml)**
 
@@ -57,28 +57,28 @@ The Command can be invoked even if the `View` that defines them is not focused o
 
 [MenuBar](~/api/Terminal.Gui.MenuBar.yml), [ContextMenu](~/api/Terminal.Gui.ContextMenu.yml), and [StatusBar](~/api/Terminal.Gui.StatusBar.yml) support `Shortcut`s. 
 
-### **[Handling Keyboard Events](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_KeyDown)**
+### **Handling Keyboard Events**
 
 Keyboard events are retrieved from [Console Drivers](drivers.md) and passed on 
 to the [Application](~/api/Terminal.Gui.Application.yml) class by the [Main Loop](mainloop.md). 
 
 [Application](~/api/Terminal.Gui.Application.yml) then determines the current [Toplevel](~/api/Terminal.Gui.Toplevel.yml) view
-(either the default created by calling `Application.Init`, or the one set by calling `Application.Run`). The mouse event, using [Bounds-relative coordinates](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_Bounds) is then passed to the [NewKeyDownEvent](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_NewKeyDownEvent_Terminal_Gui_Key_) method of the current [Toplevel](~/api/Terminal.Gui.Toplevel.yml) view. 
+(either the default created by calling @Terminal.Gui.Application.Init(Terminal.Gui.ConsoleDriver,System.String), or the one set by calling `Application.Run`). The mouse event, using [Viewport-relative coordinates](xref:Terminal.Gui.View.Viewport) is then passed to the @Terminal.Gui.View.NewKeyDownEvent(Terminal.Gui.Key) method of the current [Toplevel](~/api/Terminal.Gui.Toplevel.yml) view. 
 
-If the view is enabled, the [NewKeyDownEvent](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_NewKeyDownEvent_Terminal_Gui_Key_) method will do the following: 
+If the view is enabled, the @Terminal.Gui.View.NewKeyDownEvent(Terminal.Gui.Key) method will do the following: 
 
 1) If the view has a subview that has focus, 'ProcessKeyDown' on the focused view will be called. If the focused view handles the key press, processing stops.
-2) If there is no focused sub-view, or the focused sub-view does not handle the key press, [OnKeyDown](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_OnKeyDown_Terminal_Gui_Key_) will be called. If the view handles the key press, processing stops.
-3) If the view does not handle the key press, [OnInvokingKeyBindings](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_OnInvokingKeyBindings_Terminal_Gui_Key_) will be called. This method calls[InvokeKeyBindings](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_InvokeKeyBindings_Terminal_Gui_Key_) to invoke any keys bound to commands. If the key is bound and any of it's command handlers return true, processing stops.
-4) If the key is not bound, or the bound command handlers do not return true, [OnProcessKeyDow](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_OnProcessKeyDown_Terminal_Gui_Key_) is called. If the view handles the key press, processing stops.
+2) If there is no focused sub-view, or the focused sub-view does not handle the key press, @Terminal.Gui.View.OnKeyDown(Terminal.Gui.Key) will be called. If the view handles the key press, processing stops.
+3) If the view does not handle the key press, @Terminal.Gui.TextField.OnInvokingKeyBindings(Terminal.Gui.Key,Terminal.Gui.KeyBindingScope) will be called. This method calls @Terminal.Gui.View.InvokeKeyBindings(Terminal.Gui.Key,Terminal.Gui.KeyBindingScope) to invoke any keys bound to commands. If the key is bound and any of it's command handlers return true, processing stops.
+4) If the key is not bound, or the bound command handlers do not return true, @Terminal.Gui.View.OnProcessKeyDown(Terminal.Gui.Key) is called. If the view handles the key press, processing stops.
 
-## **[Application Key Handling](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_OnKeyDown_Terminal_Gui_Key_)**
+## **Application Key Handling**
 
 To define application key handling logic for an entire application in cases where the methods listed above are not suitable, use the `Application.OnKeyDown` event. 
 
-## **[Key Down/Up Events](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_KeyDown)**
+## **Key Down/Up Events**
 
-*Terminal.Gui* supports key up/down events with [OnKeyDown](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_OnKeyDown_Terminal_Gui_Key_) and [OnKeyUp](~/api/Terminal.Gui.View.yml#Terminal_Gui_View_OnKeyUp_Terminal_Gui_Key_), but not all [Console Drivers](drivers.md) do. To receive these key down and key up events, you must use a driver that supports them (e.g. `WindowsDriver`).
+*Terminal.Gui* supports key up/down events with @Terminal.Gui.View.OnKeyDown(Terminal.Gui.Key) and @Terminal.Gui.View.OnKeyUp(Terminal.Gui.Key), but not all [Console Drivers](drivers.md) do. To receive these key down and key up events, you must use a driver that supports them (e.g. `WindowsDriver`).
 
 # General input model
 
@@ -111,7 +111,7 @@ To define application key handling logic for an entire application in cases wher
 ## Application
 
 * Implements support for `KeyBindingScope.Application`.
-* Exposes [Application.KeyBindings](~/api/Terminal.Gui.Application.yml#Terminal_Gui_Application_KeyBindings_).
+* Exposes @Terminal.Gui.Application.KeyBindings.
 * Exposes cancelable `KeyDown/Up` events (via `Handled = true`). The `OnKey/Down/Up/` methods are public and can be used to simulate keyboard input.
 
 ## View

docfx/docs/layout.md

@@ -8,31 +8,31 @@ See [View Deep Dive](View.md) and [Arrangement Deep Dive](arrangement.md) for mo
 
 ### Coordinates
 
-* **Screen-Relative** - Describes the dimensions and characteristics of the underlying terminal. Currently Terminal.Gui only supports applications that run "full-screen", meaning they fill the entire terminal when running. As the user resizes their terminal, the [Screen](~/api/Terminal.Gui.Application.Screen.yml) changes size and the application will be resized to fit. *Screen-Relative* means an origin (`0, 0`) at the top-left corner of the terminal. [ConsoleDrivers](~/api/Terminal.Gui.ConsoleDriver.yml) s operate exclusively on *Screen-Relative* coordinates.
+* **Screen-Relative** - Describes the dimensions and characteristics of the underlying terminal. Currently Terminal.Gui only supports applications that run "full-screen", meaning they fill the entire terminal when running. As the user resizes their terminal, the @Terminal.Gui.Application.Screen changes size and the application will be resized to fit. *Screen-Relative* means an origin (`0, 0`) at the top-left corner of the terminal. @Terminal.Gui.ConsoleDriver s operate exclusively on *Screen-Relative* coordinates.
 
-* **Application-Relative** - The dimensions and characteristics of the application. Because only full-screen apps are currently supported, [Application](~/api/Terminal.Gui.Application.yml) is effectively the same as `Screen` from a layout perspective. *Application-Relative* currently means an origin (`0, 0`) at the top-left corner of the terminal. [Application.Top](~/api/Terminal.Gui.Application.Top.yml)  is a `View` with a top-left corner fixed at the *Application.Relative* coordinate of (`0, 0`) and is the size of `Screen`.
+* **Application-Relative** - The dimensions and characteristics of the application. Because only full-screen apps are currently supported, @Terminal.Gui.Application is effectively the same as `Screen` from a layout perspective. *Application-Relative* currently means an origin (`0, 0`) at the top-left corner of the terminal. @Terminal.Gui.Application.Top  is a `View` with a top-left corner fixed at the *Application.Relative* coordinate of (`0, 0`) and is the size of `Screen`.
 
-* **Frame-Relative**  - The [Frame](~/api/Terminal.Gui.View.Frame.yml) property of a `View` is a rectangle that describes the current location and size of the view relative to the `Superview`'s content area. *Frame-Relative* means a coordinate is relative to the top-left corner of the View in question. [View.FrameToScreen()](~/api/Terminal.Gui.View.FrameToScreen.yml) and [View.ScreenToFrame()](~/api/Terminal.Gui.View.ScreenToFrame.yml) are helper methods for translating a *Frame-Relative* coordinate to a *Screen-Relative* coordinate and vice-versa.
+* **Frame-Relative**  - The @Terminal.Gui.View.Frame property of a `View` is a rectangle that describes the current location and size of the view relative to the `Superview`'s content area. *Frame-Relative* means a coordinate is relative to the top-left corner of the View in question. @Terminal.Gui.View.FrameToScreen and @Terminal.Gui.View.ScreenToFrame are helper methods for translating a *Frame-Relative* coordinate to a *Screen-Relative* coordinate and vice-versa.
 
-* **Content-Relative** - A rectangle, with an origin of (`0, 0`) and size (defined by [View.GetContentSize()](~/api/Terminal.Gui.View.GetContentSize.yml)) where the View's content exists. *Content-Relative* means a coordinate is relative to the top-left corner of the content, which is always (`0,0`). [View.ContentToScreen()](~/api/Terminal.Gui.View.ContentToScreen.yml) and [View.ScreenToContent()](~/api/Terminal.Gui.View.ScreenToContent.yml) are helper methods for translating a *Content-Relative* coordinate to a *Screen-Relative* coordinate and vice-versa.
+* **Content-Relative** - A rectangle, with an origin of (`0, 0`) and size (defined by @Terminal.Gui.View.GetContentSize) where the View's content exists. *Content-Relative* means a coordinate is relative to the top-left corner of the content, which is always (`0,0`). @Terminal.Gui.View.ContentToScreen and @Terminal.Gui.View.ScreenToContent are helper methods for translating a *Content-Relative* coordinate to a *Screen-Relative* coordinate and vice-versa.
 
-* **Viewport-Relative** - A *Content-Relative* rectangle representing the subset of the View's content that is visible to the user: [Viewport](~/api/Terminal.Gui.View.Viewport.yml). 
+* **Viewport-Relative** - A *Content-Relative* rectangle representing the subset of the View's content that is visible to the user: @Terminal.Gui.View.Viewport. 
 
-    If [View.GetContentSize()](~/api/Terminal.Gui.View.GetContentSize.yml) is larger than the [Viewport](~/api/Terminal.Gui.View.Viewport.yml), scrolling is enabled. 
+    If @Terminal.Gui.View.GetContentSize is larger than the @Terminal.Gui.View.Viewport, scrolling is enabled. 
     
-    *Viewport-Relative* means a coordinate that is bound by (`0,0`) and the size of the inner-rectangle of the View's `Padding`. The View drawing primitives (e.g. `View.Move`) take *Viewport-Relative* coordinates; `Move (0, 0)` means the `Cell` in the top-left corner of the inner rectangle of `Padding`. `View.ViewportToScreen ()` and `View.ScreenToViewport ()` are helper methods for translating a *Viewport-Relative* coordinate to a *Screen-Relative* coordinate and vice-versa. To convert a *Viewport-Relative* coordinate to a *Content-Relative* coordinate, simply subtract `Viewport.X` and/or `Viewport.Y` from the *Content-Relative* coordinate. To convert a *Viewport-Relative* coordinate to a *Frame-Relative* coordinate, subtract the point returned by [View.GetViewportOffsetFromFrame()](~/api/Terminal.Gui.View.GetViewportOffsetFromFrame.yml).
+    *Viewport-Relative* means a coordinate that is bound by (`0,0`) and the size of the inner-rectangle of the View's `Padding`. The View drawing primitives (e.g. `View.Move`) take *Viewport-Relative* coordinates; `Move (0, 0)` means the `Cell` in the top-left corner of the inner rectangle of `Padding`. `View.ViewportToScreen ()` and `View.ScreenToViewport ()` are helper methods for translating a *Viewport-Relative* coordinate to a *Screen-Relative* coordinate and vice-versa. To convert a *Viewport-Relative* coordinate to a *Content-Relative* coordinate, simply subtract `Viewport.X` and/or `Viewport.Y` from the *Content-Relative* coordinate. To convert a *Viewport-Relative* coordinate to a *Frame-Relative* coordinate, subtract the point returned by @Terminal.Gui.View.GetViewportOffsetFromFrame.
 
 ### View Composition
 
-* *[Thickness](~/api/Terminal.Gui.Thickness.yml)* - A `record struct` describing a rectangle where each of the four sides can have a width. Valid width values are >= 0. The inner area of a Thickness is the sum of the widths of the four sides minus the size of the rectangle.
+* *@Terminal.Gui.Thickness* - A `record struct` describing a rectangle where each of the four sides can have a width. Valid width values are >= 0. The inner area of a Thickness is the sum of the widths of the four sides minus the size of the rectangle.
 
-* *[Frame](~/api/Terminal.Gui.View.Frame.yml)* - The `Rectangle` that defines the location and size of the [View](~/api/Terminal.Gui.View.yml) including all of the margin, border, padding, and content area. The coordinates are relative to the SuperView of the View (or, in the case of `Application.Top`, `ConsoleDriver.Row == 0; ConsoleDriver.Col == 0`). The Frame's location and size are controlled by the `.X`, `.Y`, `.Height`, and `.Width` properties of the View. 
+* *@Terminal.Gui.View.Frame* - The `Rectangle` that defines the location and size of the @Terminal.Gui.View including all of the margin, border, padding, and content area. The coordinates are relative to the SuperView of the View (or, in the case of `Application.Top`, `ConsoleDriver.Row == 0; ConsoleDriver.Col == 0`). The Frame's location and size are controlled by the `.X`, `.Y`, `.Height`, and `.Width` properties of the View. 
 
 * *Adornments* - The `Thickness`es that separate the `Frame` from the `ContentArea`. There are three Adornments, `Margin`, `Padding`, and `Border`. Adornments are not part of the View's content and are not clipped by the View's `ClipArea`. Examples of Adornments:
 
-* *[Margin](~/api/Terminal.Gui.View.Margin.yml)* - The `Adornment` that separates a View from other SubViews of the same SuperView. The Margin is not part of the View's content and is not clipped by the View's `ClipArea`. By default `Margin` is `{0,0,0,0}`. 
+* *@Terminal.Gui.View.Margin* - The `Adornment` that separates a View from other SubViews of the same SuperView. The Margin is not part of the View's content and is not clipped by the View's `ClipArea`. By default `Margin` is `{0,0,0,0}`. 
 
-    Enabling [View.ShadowStyle](~/api/Terminal.Gui.View.ShadowStyle.yml) will change the `Thickness` of the `Margin` to include the shadow.
+    Enabling @Terminal.Gui.View.ShadowStyle will change the `Thickness` of the `Margin` to include the shadow.
 
     `Margin` can be used instead of (or with) `Dim.Pos` to position a View relative to another View. 
 
@@ -48,11 +48,11 @@ See [View Deep Dive](View.md) and [Arrangement Deep Dive](arrangement.md) for mo
     view.Y = Pos.Bottom (otherView);
     ```
 
-* *[Border](~/api/Terminal.Gui.View.Border.yml)* - The `Adornment` where a visual border (drawn using line-drawing glyphs) and the [Title](~/api/Terminal.Gui.View.Title.yml) are drawn, and where the user can interact with the mouse/keyboard to adjust the Views' [Arrangement](arrangement.md). 
+* *@Terminal.Gui.View.Border* - The `Adornment` where a visual border (drawn using line-drawing glyphs) and the @Terminal.Gui.View.Title are drawn, and where the user can interact with the mouse/keyboard to adjust the Views' [Arrangement](arrangement.md). 
 
     The Border expands inward; in other words if `Border.Thickness.Top == 2` the border & title will take up the first row and the second row will be filled with spaces. The Border is not part of the View's content and is not clipped by the View's `Clip`.
 
-* *[Padding](~/api/Terminal.Gui.View.Padding.yml)*  - The `Adornment` that offsets the `ContentArea` from the `Border`. `Padding` is `{0, 0, 0, 0}` by default. Padding is not part of the View's content and is not clipped by the View's `Clip`. 
+* *@Terminal.Gui.View.Padding*  - The `Adornment` that offsets the `ContentArea` from the `Border`. `Padding` is `{0, 0, 0, 0}` by default. Padding is not part of the View's content and is not clipped by the View's `Clip`. 
 
     When, enabled, scroll bars reside within `Padding`. 
 
@@ -60,23 +60,23 @@ See [View Deep Dive](View.md) and [Arrangement Deep Dive](arrangement.md) for mo
 
 See [Arrangement Deep Dive](arrangement.md) for more.
 
-* *Tile*, *Tiled*, *Tiling* - Refer to a form of [Layout](layout.md) where SubViews of a [View](~/api/Terminal.Gui.View.yml) are visually arranged such that they abut each other and do not overlap. In a Tiled view arrangement, Z-ordering only comes into play when a developer intentionally causes views to be aligned such that they overlap. Borders that are drawn between the SubViews can optionally support resizing the SubViews (negating the need for `TileView`).
+* *Tile*, *Tiled*, *Tiling* - Refer to a form of @Terminal.Gui.View are visually arranged such that they abut each other and do not overlap. In a Tiled view arrangement, Z-ordering only comes into play when a developer intentionally causes views to be aligned such that they overlap. Borders that are drawn between the SubViews can optionally support resizing the SubViews (negating the need for `TileView`).
 
 * *Overlap*, *Overlapped*, *Overlapping* - Refers to a form [Layout](layout.md) where SubViews of a View are visually arranged such that their Frames overlap. In Overlap view arrangements there is a Z-axis (Z-order) in addition to the X and Y dimension. The Z-order indicates which Views are shown above other views.
 
 ## The Frame
 
-The [Frame](~/api/Terminal.Gui.View.Frame.yml) property of a `View` is a rectangle that describes the current location and size of the view relative to the `Superview`'s content area. The `Frame`  has a `Location` and `Size`. The `Location` describes the top-left corner of the view relative to the `SuperView`'s content area. The `Size` describes the width and height of the view. The `Frame` is used to determine where the view is drawn on the screen and is used to calculate the Viewport and content size.
+The @Terminal.Gui.View.Frame property of a `View` is a rectangle that describes the current location and size of the view relative to the `Superview`'s content area. The `Frame`  has a `Location` and `Size`. The `Location` describes the top-left corner of the view relative to the `SuperView`'s content area. The `Size` describes the width and height of the view. The `Frame` is used to determine where the view is drawn on the screen and is used to calculate the Viewport and content size.
 
 ## The Content Area
 
- The content area is the area where the view's content is drawn. Content can be any combination of the [View.Text](~/api/Terminal.Gui.View.Text.yml) property, `Subviews`, and other content drawn by the View. The [View.GetContentSize()](~/api/Terminal.Gui.View.GetContentSize.yml) method gets the size of the content area of the view. *Content Area* refers to the rectangle with a location of `0,0` with the size returned by [View.GetContentSize()](~/api/Terminal.Gui.View.GetContentSize.yml).
+ The content area is the area where the view's content is drawn. Content can be any combination of the @Terminal.Gui.View.Text property, `Subviews`, and other content drawn by the View. The @Terminal.Gui.View.GetContentSize method gets the size of the content area of the view. *Content Area* refers to the rectangle with a location of `0,0` with the size returned by @Terminal.Gui.View.GetContentSize.
 
- The Content Area size tracks the size of the [Viewport](~/api/Terminal.Gui.View.Viewport.yml) by default. If the content size is set via [View.SetContentSize()](~/api/Terminal.Gui.View.SetContentSize.yml), the content area is the provided size. If the content size is larger than the [Viewport](~/api/Terminal.Gui.View.Viewport.yml), scrolling is enabled. 
+ The Content Area size tracks the size of the @Terminal.Gui.View.Viewport by default. If the content size is set via @Terminal.Gui.View.SetContentSize, the content area is the provided size. If the content size is larger than the @Terminal.Gui.View.Viewport, scrolling is enabled. 
 
 ## The Viewport
 
-The Viewport ([Viewport](~/api/Terminal.Gui.View.Viewport.yml)) is a rectangle describing the portion of the *Content Area* that is currently visible to the user. It is a "portal" into the content. The `Viewport.Location` is relative to the top-left corner of the inner rectangle of `View.Padding`. If `Viewport.Size` is the same as `View.GetContentSize()`, `Viewport.Location` will be `0,0`. 
+The Viewport (@Terminal.Gui.View.Viewport) is a rectangle describing the portion of the *Content Area* that is currently visible to the user. It is a "portal" into the content. The `Viewport.Location` is relative to the top-left corner of the inner rectangle of `View.Padding`. If `Viewport.Size` is the same as `View.GetContentSize()`, `Viewport.Location` will be `0,0`. 
 
 To enable scrolling call `View.SetContentSize()` and then set `Viewport.Location` to positive values. Making `Viewport.Location` positive moves the Viewport down and to the right in the content. 
 
@@ -85,13 +85,13 @@ The `View.ViewportSettings` property controls how the Viewport is constrained. B
 The default `ViewportSettings` also constrains the Viewport to the size of the content, ensuring the right-most column or bottom-most row of the content will always be visible (in v1 the equivalent concept was `ScrollBarView.AlwaysKeepContentInViewport`). To allow the Viewport to be smaller than the content, set `ViewportSettings.AllowXGreaterThanContentWidth` and/or `ViewportSettings.AllowXGreaterThanContentHeight`.
 
 
-* *[Content Area](~/api/Terminal.Gui.View.GetContentSize().yml)* - The content area is the area where the view's content is drawn. Content can be any combination of the [View.Text](~/api/Terminal.Gui.View.Text.yml) property, `Subviews`, and other content drawn by the View. The [View.GetContentSize()](~/api/Terminal.Gui.View.GetContentSize.yml) method gets the size of the content area of the view. *Content Area* refers to the rectangle with a location of `0,0` with the size returned by [View.GetContentSize()](~/api/Terminal.Gui.View.GetContentSize.yml). The [Layout Deep Dive](layout.md) has more details on the Content Area.
+* *@Terminal.Gui.View.GetContentSize()* - The content area is the area where the view's content is drawn. Content can be any combination of the @Terminal.Gui.View.Text property, `Subviews`, and other content drawn by the View. The @Terminal.Gui.View.GetContentSize method gets the size of the content area of the view. *Content Area* refers to the rectangle with a location of `0,0` with the size returned by @Terminal.Gui.View.GetContentSize. The [Layout Deep Dive](layout.md) has more details on the Content Area.
 
-* *[Viewport](~/api/Terminal.Gui.View.Viewport.yml)* A rectangle describing the portion of the *Content Area* that is currently visible to the user. It is a "portal" into the content. The `Viewport.Location` is relative to the top-left corner of the inner rectangle of `View.Padding`. If `Viewport.Size` is the same as `View.GetContentSize()`, `Viewport.Location` will be `0,0`. 
+* *@Terminal.Gui.View.Viewport* A rectangle describing the portion of the *Content Area* that is currently visible to the user. It is a "portal" into the content. The `Viewport.Location` is relative to the top-left corner of the inner rectangle of `View.Padding`. If `Viewport.Size` is the same as `View.GetContentSize()`, `Viewport.Location` will be `0,0`. 
   
 ## Layout
 
-Terminal.Gui provides a rich system for how views are laid out relative to each other. The position of a view is set by setting the `X` and `Y` properties, which are of time [Pos](~/api/Terminal.Gui.Pos.yml). The size is set via `Width` and `Height`, which are of type [Dim](~/api/Terminal.Gui.Dim.yml).
+Terminal.Gui provides a rich system for how views are laid out relative to each other. The position of a view is set by setting the `X` and `Y` properties, which are of time @Terminal.Gui.Pos. The size is set via `Width` and `Height`, which are of type @Terminal.Gui.Dim.
 
 ```cs
 var label1 = new Label () { X = 1, Y = 2, Width = 3, Height = 4, Title = "Absolute")
@@ -109,15 +109,15 @@ The `Frame` property is a rectangle that provides the current location and size
 
 ## The `Pos` Type
 
-The [Pos](~/api/Terminal.Gui.Pos.yml) is the type of `View.X` and `View.Y` and supports the following sub-types:
+The @Terminal.Gui.Pos is the type of `View.X` and `View.Y` and supports the following sub-types:
 
-* Absolute position, by passing an integer - [Pos.Absolute](~/api/Terminal.Gui.Pos.Absolute.yml).
-* Percentage of the parent's view size - [Pos.Percent](~/api/Terminal.Gui.Pos.Percent.yml)
-* Anchored from the end of the dimension - [Pos.AnchorEnd](~/api/Terminal.Gui.Pos.AnchorEnd.yml)
-* Centered, using [Pos.Center](~/api/Terminal.Gui.Pos.Center.yml)
-* The [Pos.Left](~/api/Terminal.Gui.Pos.Left.yml), [Pos.Right](~/api/Terminal.Gui.Pos.Right.yml), [Pos.Top](~/api/Terminal.Gui.Pos.Top.yml), and [Pos.Bottom](~/api/Terminal.Gui.Pos.Bottom.yml) tracks the position of another view.
-* Aligned (left, right, center, etc...) with other views - [Pos.Align](~/api/Terminal.Gui.Pos.Align.yml).
-* An arbitrary function - [Pos.Func](~/api/Terminal.Gui.Pos.Func.yml)
+* Absolute position, by passing an integer - @Terminal.Gui.Pos.Absolute(System.Int32).
+* Percentage of the parent's view size - @Terminal.Gui.Pos.Percent(System.Int32)
+* Anchored from the end of the dimension - @Terminal.Gui.Pos.AnchorEnd(System.Int32)
+* Centered, using @Terminal.Gui.Pos.Center()
+* The @Terminal.Gui.Pos.Left(Terminal.Gui.View), @Terminal.Gui.Pos.Right(Terminal.Gui.View), @Terminal.Gui.Pos.Top(Terminal.Gui.View), and @Terminal.Gui.Pos.Bottom(Terminal.Gui.View) tracks the position of another view.
+* Aligned (left, right, center, etc...) with other views - @Terminal.Gui.Pos.Align(Terminal.Gui.Alignment,Terminal.Gui.AlignmentModes,System.Int32).
+* An arbitrary function - @Terminal.Gui.Pos.FuncTerminal.Gui.Pos.Func(System.Func{System.Int32})
 
 All `Pos` coordinates are relative to the SuperView's content area.
 
@@ -136,14 +136,14 @@ myView.Y = Pos.Bottom (anotherView) + 5;
 ```
 ## The `Dim` Type
 
-The [Dim](~/api/Terminal.Gui.Dim.yml) is the type of `View.Width` and `View.Height` and supports the following sub-types:
+The @Terminal.Gui.Dim is the type of `View.Width` and `View.Height` and supports the following sub-types:
 
-* Automatic size based on the View's content (either Subviews or Text) - [Dim.Auto](~/api/Terminal.Gui.Dim.Auto.yml) - See [Dim.Auto Deep Dive](dimauto.md).
-* Absolute size, by passing an integer - [Dim.Absolute](~/api/Terminal.Gui.Dim.Absolute.yml).
-* Percentage of the SuperView's Content Area  - [Dim.Percent](~/api/Terminal.Gui.Dim.Percent.yml).
-* Fill to the end of the SuperView's Content Area - [Dim.Fill](~/api/Terminal.Gui.Dim.Fill.yml).
-* Reference the Width or Height of another view - [Dim.Width](~/api/Terminal.Gui.Dim.Width.yml), [Dim.Height](~/api/Terminal.Gui.Dim.Height.yml).
-* An arbitrary function - [Dim.Func](~/api/Terminal.Gui.Dim.Func.yml).
+* Automatic size based on the View's content (either Subviews or Text) - @Terminal.Gui.Dim.Auto(Terminal.Gui.DimAutoStyle,Terminal.Gui.Dim,Terminal.Gui.Dim) - See [Dim.Auto Deep Dive](dimauto.md).
+* Absolute size, by passing an integer - @Terminal.Gui.Dim.Absolute(System.Int32).
+* Percentage of the SuperView's Content Area  - @Terminal.Gui.Dim.Percent(System.Int32).
+* Fill to the end of the SuperView's Content Area - @Terminal.Gui.Dim.Fill.
+* Reference the Width or Height of another view - @Terminal.Gui.Dim.Width(Terminal.Gui.View), @Terminal.Gui.Dim.Height(Terminal.Gui.View).
+* An arbitrary function - @Terminal.Gui.Dim.Func(System.Func{System.Int32}).
 
 All `Dim` dimensions are relative to the SuperView's content area.
 

docfx/docs/migratingfromv1.md

@@ -6,7 +6,7 @@ For detailed breaking change documentation check out this Discussion: https://gi
 
 ## View Constructors -> Initializers
 
-In v1, [View](~/api/Terminal.Gui.View.yml) and most sub-classes had multiple constructors that took a variety of parameters. In v2, the constructors have been replaced with initializers. This change was made to simplify the API and make it easier to use. In addition, the v1 constructors drove a false (and needlessly complex) distinction between "Absolute" and "Computed" layout. In v2, the layout system is much simpler and more intuitive.
+In v1, @Terminal.Gui.View and most sub-classes had multiple constructors that took a variety of parameters. In v2, the constructors have been replaced with initializers. This change was made to simplify the API and make it easier to use. In addition, the v1 constructors drove a false (and needlessly complex) distinction between "Absolute" and "Computed" layout. In v2, the layout system is much simpler and more intuitive.
 
 ### How to Fix
 
@@ -21,7 +21,7 @@ Replace the constructor calls with initializer calls.
 
 Terminal.Gui v2 now supports 24-bit color by default. This means that the colors you use in your application will be more accurate and vibrant. If you are using custom colors in your application, you may need to update them to use the new 24-bit color format.
 
-The [Attribute](~/api/Terminal.Gui.Attribute.yml) class has been simplified. Color names now match the ANSI standard ('Brown' is now called 'Yellow')
+The @Terminal.Gui.Attribute class has been simplified. Color names now match the ANSI standard ('Brown' is now called 'Yellow')
 
 ### How to Fix
 
@@ -83,23 +83,23 @@ When measuring the screen space taken up by a `string` you can use the extension
 
 ## `View Life Cycle Management
 
-In v1, [View](~/api/Terminal.Gui.View.yml) was derived from `Responder` which supported `IDisposable`. In v2, `Responder` has been removed and [View](~/api/Terminal.Gui.View.yml) is the base-class supporting `IDisposable`. 
+In v1, @Terminal.Gui.View was derived from `Responder` which supported `IDisposable`. In v2, `Responder` has been removed and @Terminal.Gui.View is the base-class supporting `IDisposable`. 
 
-In v1, [Application.Init](~/api/Terminal.Gui./Terminal.Gui.Application.Init) automatically created a toplevel view and set [Application.Top](~/api/Terminal.Gui.Application.Top.yml). In v2, [Application.Init](~/api/Terminal.Gui.Application.Init.yml) no longer automatically creates a toplevel or sets [Application.Top](~/api/Terminal.Gui.Application.Top.yml); app developers must explicitly create the toplevel view and pass it to [Application.Run](~/api/Terminal.Gui.Application.Run.yml) (or use `Application.Run<myTopLevel>`). Developers are responsible for calling `Dispose` on any toplevel they create before exiting. 
+In v1, @Terminal.Gui./Terminal.Gui.Application.Init) automatically created a toplevel view and set [Application.Top](~/api/Terminal.Gui.Application.Top. In v2, @Terminal.Gui.Application.Init no longer automatically creates a toplevel or sets @Terminal.Gui.Application.Top; app developers must explicitly create the toplevel view and pass it to @Terminal.Gui.Application.Run (or use `Application.Run<myTopLevel>`). Developers are responsible for calling `Dispose` on any toplevel they create before exiting. 
 
 ### How to Fix
 
-* Replace `Responder` with [View](~/api/Terminal.Gui.View.yml)
+* Replace `Responder` with @Terminal.Gui.View
 * Update any code that assumes `Application.Init` automatically created a toplevel view and set `Application.Top`.
 * Update any code that assumes `Application.Init` automatically disposed of the toplevel view when the application exited.
 
-## [Pos](~/api/Terminal.Gui.Pos.yml) and [Dim](~/api/Terminal.Gui.Dim.yml) types now adhere to standard C# idioms
+## @Terminal.Gui.Pos and @Terminal.Gui.Dim types now adhere to standard C# idioms
 
-* In v1, the [Pos](~/api/Terminal.Gui.Pos.yml) and [Dim](~/api/Terminal.Gui.Dim.yml) types (e.g. [Pos.PosView](~/api/Terminal.Gui.Pos.PosView.yml)) were nested classes and marked [internal](~/api/Terminal.Gui.internal.yml). In v2, they are no longer nested, and have appropriate public APIs. 
+* In v1, the @Terminal.Gui.Pos and @Terminal.Gui.Dim types (e.g. @Terminal.Gui.Pos.PosView) were nested classes and marked @Terminal.Gui.internal. In v2, they are no longer nested, and have appropriate public APIs. 
 * Nullabilty is enabled.
 * Methods & properties follow standards.
-* The static method that creates a [PosAbsolute](~/api/Terminal.Gui.PosAbsolute.yml), `Pos.At`, was renamed to [Pos.Absolute](~/api/Terminal.Gui.Pos.Absolute.yml) for consistency.
-* The static method that crates as [DimAbsoulte](~/api/Terminal.Gui.DimAbsoulte.yml), `Dim.Sized`, was renamed to [Dim.Absolute](~/api/Terminal.Gui.Dim.Absolute.yml) for consistency.
+* The static method that creates a @Terminal.Gui.PosAbsolute, `Pos.At`, was renamed to @Terminal.Gui.Pos.Absolute for consistency.
+* The static method that crates as @Terminal.Gui.DimAbsoulte, `Dim.Sized`, was renamed to @Terminal.Gui.Dim.Absolute for consistency.
 
 ### How to Fix
 
@@ -115,9 +115,9 @@ In v1, [Application.Init](~/api/Terminal.Gui./Terminal.Gui.Application.Init) aut
 In v2, the layout system has been improved to make it easier to create complex user interfaces. If you are using custom layouts in your application, you may need to update them to use the new layout system.
 
 * The distinction between `Absolute Layout` and `Computed Layout` has been removed, as has the `LayoutStyle` enum. v1 drew a false distinction between these styles. 
-* [View.Frame](~/api/Terminal.Gui.View.Frame.yml) now represents the position and size of the view in the superview's coordinate system. The `Frame` property is of type `Rectangle`.
-* [View.Bounds](~/api/Terminal.Gui.View.Bounds.yml) has been replaced by [View.Viewport](~/api/Terminal.Gui.View.Viewport.yml). The `Viewport` property represents the visible area of the view in its own coordinate system. The `Viewport` property is of type `Rectangle`.
-* [View.GetContentSize()](~/api/Terminal.Gui.View.GetContentSize.yml) represents the size of the view's content. This replaces `ScrollView` and `ScrollBarView` in v1. See more below.
+* @Terminal.Gui.View.Frame now represents the position and size of the view in the superview's coordinate system. The `Frame` property is of type `Rectangle`.
+* @Terminal.Gui.View.Bounds has been replaced by @Terminal.Gui.View.Viewport. The `Viewport` property represents the visible area of the view in its own coordinate system. The `Viewport` property is of type `Rectangle`.
+* @Terminal.Gui.View.GetContentSize represents the size of the view's content. This replaces `ScrollView` and `ScrollBarView` in v1. See more below.
 
 ### How to Fix
 
@@ -128,13 +128,13 @@ In v2, the layout system has been improved to make it easier to create complex u
 * Update any code that assumed `Bounds.Location` was always `Point.Empty`.
 * Update any code that used `Bounds` to refer to the size of the view's content. Use `GetContentSize()` instead.
 * Update any code that assumed `Bounds.Size` was the same as `Frame.Size`. `Frame.Size` defines the size of the view in the superview's coordinate system, while `Viewport.Size` defines the visible area of the view in its own coordinate system.
-* Use [View.GetAdornmentsThickness](~/api/Terminal.Gui.View.GetAdornmentsThickness.yml) to get the total thickness of the view's border, margin, and padding.
+* Use @Terminal.Gui.View.GetAdornmentsThickness to get the total thickness of the view's border, margin, and padding.
 * Not assume a View can draw outside of 'Viewport'. Use the 'Margin', 'Border', and 'Padding' Adornments to do things outside of `Viewport`. View subclasses should not implement their own concept of padding or margins but leverage these `Adornments` instead. 
 * Mouse and draw events now provide coordinates relative to the `Viewport` not the `Frame`.
 
-## `View.AutoSize` has been removed. Use [Dim.Auto](~/api/Terminal.Gui.Dim.Auto.yml) for width or height instead.
+## `View.AutoSize` has been removed. Use @Terminal.Gui.Dim.Auto for width or height instead.
 
-In v1, `View.AutoSize` was used to size a view to its `Text`. In v2, `View.AutoSize` has been removed. Use [Dim.Auto](~/api/Terminal.Gui.Dim.Auto.yml) for width or height instead.
+In v1, `View.AutoSize` was used to size a view to its `Text`. In v2, `View.AutoSize` has been removed. Use @Terminal.Gui.Dim.Auto for width or height instead.
 
 ### How to Fix
 
@@ -144,36 +144,36 @@ In v1, `View.AutoSize` was used to size a view to its `Text`. In v2, `View.AutoS
 
 In v2, the `Border`, `Margin`, and `Padding` properties have been added to all views. This simplifies view development and enables a sophisticated look and feel. If you are using custom borders, margins, or padding in your application, you may need to update them to use the new properties.
 
-* `View.Border` is now of type [Adornment](~/api/Terminal.Gui.Adornment.yml). [View.BorderStyle](~/api/Terminal.Gui.View.BorderStyle.yml) is provided as a convenience property to set the border style (`myView.BorderStyle = LineStyle.Double`).
+* `View.Border` is now of type @Terminal.Gui.Adornment. @Terminal.Gui.View.BorderStyle is provided as a convenience property to set the border style (`myView.BorderStyle = LineStyle.Double`).
 
 ### How to Fix
 
 ## Built-in Scrolling
 
-In v1, scrolling was enabled by using `ScrollView` or `ScrollBarView`. In v2, the base [View](~/api/Terminal.Gui.View.yml) class supports scrolling inherently. The area of a view visible to the user at a given moment was previously a rectangle called `Bounds`. `Bounds.Location` was always `Point.Empty`. In v2 the visible area is a rectangle called `Viewport` which is a protal into the Views content, which can be bigger (or smaller) than the area visible to the user. Causing a view to scroll is as simple as changing `View.Viewport.Location`. The View's content is described by [View.GetContentSize()](~/api/Terminal.Gui.View.GetContentSize.yml). See [Layout](layout.md) for details.
+In v1, scrolling was enabled by using `ScrollView` or `ScrollBarView`. In v2, the base @Terminal.Gui.View class supports scrolling inherently. The area of a view visible to the user at a given moment was previously a rectangle called `Bounds`. `Bounds.Location` was always `Point.Empty`. In v2 the visible area is a rectangle called `Viewport` which is a protal into the Views content, which can be bigger (or smaller) than the area visible to the user. Causing a view to scroll is as simple as changing `View.Viewport.Location`. The View's content is described by @Terminal.Gui.View.GetContentSize. See [Layout](layout.md) for details.
 
 ### How to Fix
 
-* Replace `ScrollView` with [View](~/api/Terminal.Gui.View.yml) and use `Viewport` and [View.GetContentSize()](~/api/Terminal.Gui.View.GetContentSize.yml) to control scrolling.
+* Replace `ScrollView` with @Terminal.Gui.View and use `Viewport` and @Terminal.Gui.View.GetContentSize to control scrolling.
 * Update any code that assumed `Bounds.Location` was always `Point.Empty`.
-* Update any code that used `Bounds` to refer to the size of the view's content. Use [View.GetContentSize()](~/api/Terminal.Gui.View.GetContentSize.yml) instead.
+* Update any code that used `Bounds` to refer to the size of the view's content. Use @Terminal.Gui.View.GetContentSize instead.
 * Update any code that assumed `Bounds.Size` was the same as `Frame.Size`. `Frame.Size` defines the size of the view in the superview's coordinate system, while `Viewport.Size` defines the visible area of the view in its own coordinate system.
 
 ## Updated Keyboard API
 
 The API for handling keyboard input is significantly improved. See [Keyboard API](keyboard.md).
 
-* The [Key](~/api/Terminal.Gui.Key.yml) class replaces the `KeyEvent` struct and provides a platform-independent abstraction for common keyboard operations. It is used for processing keyboard input and raising keyboard events. This class provides a high-level abstraction with helper methods and properties for common keyboard operations. Use this class instead of the low-level [KeyCode](~/api/Terminal.Gui.KeyCode.yml) enum when possible. See [Key](~/api/Terminal.Gui.Key.yml) for more details.
-* The preferred way to enable Application-wide or View-heirarchy-dependent keystrokes is to use the [Shortcut](~/api/Terminal.Gui.Shortcut.yml) View or the built-in View's that utilize it, such as the [Bar](~/api/Terminal.Gui.Bar.yml)-based views.
-* The preferred way to handle single keystrokes is to use **Key Bindings**. Key Bindings map a key press to a [Command](~/api/Terminal.Gui.Command.yml). A view can declare which commands it supports, and provide a lambda that implements the functionality of the command, using `View.AddCommand()`. Use the [View.Keybindings](~/api/Terminal.Gui.View.Keybindings.yml) to configure the key bindings.
+* The @Terminal.Gui.Key class replaces the `KeyEvent` struct and provides a platform-independent abstraction for common keyboard operations. It is used for processing keyboard input and raising keyboard events. This class provides a high-level abstraction with helper methods and properties for common keyboard operations. Use this class instead of the low-level @Terminal.Gui.KeyCode enum when possible. See @Terminal.Gui.Key for more details.
+* The preferred way to enable Application-wide or View-heirarchy-dependent keystrokes is to use the @Terminal.Gui.Shortcut View or the built-in View's that utilize it, such as the @Terminal.Gui.Bar-based views.
+* The preferred way to handle single keystrokes is to use **Key Bindings**. Key Bindings map a key press to a @Terminal.Gui.Command. A view can declare which commands it supports, and provide a lambda that implements the functionality of the command, using `View.AddCommand()`. Use the @Terminal.Gui.View.Keybindings to configure the key bindings.
 * For better consistency and user experience, the default key for closing an app or `Toplevel` is now `Esc` (it was previously `Ctrl+Q`).
 * The `Application.RootKeyEvent` method has been replaced with `Application.KeyDown`
 
 ### How to Fix
 
 * Replace `KeyEvent` with `Key`
-* Use [View.AddCommand](~/api/Terminal.Gui.View.AddCommand.yml) to define commands your view supports.
-* Use [View.Keybindings](~/api/Terminal.Gui.View.Keybindings.yml) to configure key bindings to `Command`s.
+* Use @Terminal.Gui.View.AddCommand to define commands your view supports.
+* Use @Terminal.Gui.View.Keybindings to configure key bindings to `Command`s.
 * It should be very uncommon for v2 code to override `OnKeyPressed` etc... 
 * Anywhere `Ctrl+Q` was hard-coded as the "quit key", replace with `Application.QuitKey`.
 * See *Navigation* below for more information on v2's navigation keys.
@@ -184,7 +184,7 @@ The API for handling keyboard input is significantly improved. See [Keyboard API
 + Application.KeyDown(object? sender, Key e)
 ```
 
-## [Command]((~/api/Terminal.Gui.Command.yml)) has been expanded and simplified
+## **@"Terminal.Gui.Command" has been expanded and simplified
 
 In v1, the `Command` enum had duplicate entries and inconsistent naming. In v2 it has been both expanded and simplified.
 
@@ -196,18 +196,18 @@ In v1, the `Command` enum had duplicate entries and inconsistent naming. In v2 i
 
 The API for mouse input is now internally consistent and easier to use.
 
-* The [MouseEvent](~/api/Terminal.Gui.MouseEvent.yml) class replaces `MouseEventEventArgs`.
+* The @Terminal.Gui.MouseEvent class replaces `MouseEventEventArgs`.
 * More granular APIs are provided to ease handling specific mouse actions. See [Mouse API](mouse.md).
-* Views can use the [View.Highlight](~/api/Terminal.Gui.View.Highlight.yml) event to have the view be visibly highlighted on various mouse events.
-* Views can set `View.WantContinousButtonPresses = true` to have their [Command.Accept](~/api/Terminal.Gui.Command.Accept.yml) command be invoked repeatedly as the user holds a mouse button down on the view.
+* Views can use the @Terminal.Gui.View.Highlight event to have the view be visibly highlighted on various mouse events.
+* Views can set `View.WantContinousButtonPresses = true` to have their @Terminal.Gui.Command.Accept command be invoked repeatedly as the user holds a mouse button down on the view.
 * Mouse and draw events now provide coordinates relative to the `Viewport` not the `Screen`.
 * The `Application.RootMouseEvent` method has been replaced with `Application.MouseEvent`
 
 ### How to Fix
 
 * Replace `MouseEventEventArgs` with `MouseEvent`
-* Use the [View.Highlight](~/api/Terminal.Gui.View.Highlight.yml) event to have the view be visibly highlighted on various mouse events.
-* Set `View.WantContinousButtonPresses = true` to have the [Command.Accept](~/api/Terminal.Gui.Command.Accept.yml) command be invoked repeatedly as the user holds a mouse button down on the view.
+* Use the @Terminal.Gui.View.Highlight event to have the view be visibly highlighted on various mouse events.
+* Set `View.WantContinousButtonPresses = true` to have the @Terminal.Gui.Command.Accept command be invoked repeatedly as the user holds a mouse button down on the view.
 * Update any code that assumed mouse events provided coordinates relative to the `Screen`.
 * Replace `Application.RootMouseEvent` with `Application.MouseEvent`.  
 
@@ -238,8 +238,8 @@ In v2, the API is (NOT YET IMPLEMENTED) simplified. A view simply reports the st
 
 #### How to Fix (Cursor API)
 
-* Use [View.CursorPosition](~/api/Terminal.Gui.View.CursorPosition.yml) to set the cursor position in a view. Set [View.CursorPosition](~/api/Terminal.Gui.View.CursorPosition.yml) to `null` to hide the cursor.
-* Set [View.CursorVisibility](~/api/Terminal.Gui.View.CursorVisibility.yml) to the cursor style you want to use.
+* Use @Terminal.Gui.View.CursorPosition to set the cursor position in a view. Set @Terminal.Gui.View.CursorPosition to `null` to hide the cursor.
+* Set @Terminal.Gui.View.CursorVisibility to the cursor style you want to use.
 * Remove any overrides of `OnEnter` and `OnLeave` that explicitly change the cursor.
 
 ### Focus
@@ -262,8 +262,8 @@ See also [Keyboard](keyboard.md) where HotKey is covered more deeply...
 
 ### How to Fix (Focus API)
 
-* Use [Application.Navigation.GetFocused()](~/api/Terminal.Gui.Application.Navigation.GetFocused.yml) to get the most focused view in the application.
-*  Use [Application.Navigation.AdvanceFocus()](~/api/Terminal.Gui.Application.Navigation.AdvanceFocus.yml) to cause focus to change.
+* Use @Terminal.Gui.Application.Navigation.GetFocused to get the most focused view in the application.
+*  Use @Terminal.Gui.Application.Navigation.AdvanceFocus to cause focus to change.
 
 ### Keyboard Navigation
 
@@ -371,19 +371,19 @@ Replace references to nested types with the new standalone version
 
 ## View and Text Alignment Changes
 
-In v1, both `TextAlignment` and `VerticalTextAlignment` enums were used to align text in views. In v2, these enums have been replaced with the [Alignment](~/api/Terminal.Gui.Alignment.yml) enum. The [View.TextAlignment](~/api/Terminal.Gui.View.TextAlignment.yml) property controls horizontal text alignment and the [View.VerticalTextAlignment](~/api/Terminal.Gui.View.VerticalTextAlignment.yml) property controls vertical text alignment.
+In v1, both `TextAlignment` and `VerticalTextAlignment` enums were used to align text in views. In v2, these enums have been replaced with the @Terminal.Gui.Alignment enum. The @Terminal.Gui.View.TextAlignment property controls horizontal text alignment and the @Terminal.Gui.View.VerticalTextAlignment property controls vertical text alignment.
 
-v2 now supports [Pos.Align](~/api/Terminal.Gui.Pos.Align.yml) which enables views to be easily aligned within their Superview. 
+v2 now supports @Terminal.Gui.Pos.Align which enables views to be easily aligned within their Superview. 
 
-The [Aligner](~/api/Terminal.Gui.Aligner.yml) class makes it easy to align elements (text, Views, etc...) within a container. 
+The @Terminal.Gui.Aligner class makes it easy to align elements (text, Views, etc...) within a container. 
 
 ### How to Fix
 
-* Replace `VerticalAlignment.Middle` is now [Alignment.Center](~/api/Terminal.Gui.Alignment.Center.yml). 
+* Replace `VerticalAlignment.Middle` is now @Terminal.Gui.Alignment.Center. 
 
 ## `StatusBar`- `StatusItem` is replaced by `Shortcut`
 
-[StatusBar](~/api/Terminal.Gui.StatusBar.yml) has been upgraded to utilize [Shortcut](~/api/Terminal.Gui.Shortcut.yml).
+@Terminal.Gui.StatusBar has been upgraded to utilize @Terminal.Gui.Shortcut.
 
 ### How to Fix
 
@@ -455,11 +455,11 @@ In v2, these methods have been named correctly.
 
 ## `Mdi` Replaced by `ViewArrangement.Overlapped`
 
-In v1, it apps with multiple overlapping views could be created using a set of APIs spread across `Application` (e.g. `Application.MdiTop`) and `Toplevel` (e.g. `IsMdiContainer`). This functionality has been replaced in v2 with [View.Arrangement](~/api/Terminal.Gui.View.Arrangement.yml). Specifically, overlapped views with [View.Arrangement](~/api/Terminal.Gui.View.Arrangement.yml) having the [ViewArrangement.Overlapped](~/api/Terminal.Gui.ViewArrangement.Overlapped.yml) flag set will be arranged in an overlapped fashion using the order in their SuperView's subview list as the Z-order. 
+In v1, it apps with multiple overlapping views could be created using a set of APIs spread across `Application` (e.g. `Application.MdiTop`) and `Toplevel` (e.g. `IsMdiContainer`). This functionality has been replaced in v2 with @Terminal.Gui.View.Arrangement. Specifically, overlapped views with @Terminal.Gui.View.Arrangement having the @Terminal.Gui.ViewArrangement.Overlapped flag set will be arranged in an overlapped fashion using the order in their SuperView's subview list as the Z-order. 
 
-Setting the [ViewArrangement.Movable](~/api/Terminal.Gui.ViewArrangement.Movable.yml) flag will enable the overlapped views to be movable with the mouse or keyboard (`Ctrl+F5` to activate).
+Setting the @Terminal.Gui.ViewArrangement.Movable flag will enable the overlapped views to be movable with the mouse or keyboard (`Ctrl+F5` to activate).
 
-Setting the [ViewArrangement.Sizable](~/api/Terminal.Gui.ViewArrangement.Sizable.yml) flag will enable the overlapped views to be resized with the mouse or keyboard (`Ctrl+F5` to activate).
+Setting the @Terminal.Gui.ViewArrangement.Sizable flag will enable the overlapped views to be resized with the mouse or keyboard (`Ctrl+F5` to activate).
 
 In v1, only Views derived from `Toplevel` could be overlapped. In v2, any view can be.
 
@@ -471,6 +471,6 @@ v1 conflated the concepts of
 
 * To simplify programming, any `View` added as a Subview another `View` will have it's lifecycle owned by the Superview; when a `View` is disposed, it will call `Dispose` on all the items in the `Subviews` property. Note this behavior is the same as it was in v1, just clarified.
 
-* In v1, [Application.End](~/api/Terminal.Gui.Application.Run.yml) called `Dispose ()` on [Application.Top](~/api/Terminal.Gui.Application.Top.yml) (via `Runstate.Toplevel`). This was incorrect as it meant that after `Application.Run` returned, `Application.Top` had been disposed, and any code that wanted to interrogate the results of `Run` by accessing `Application.Top` only worked by accident. This is because GC had not actually happened; if it had the application would have crashed. In v2 `Application.End` does NOT call `Dispose`, and it is the caller to `Application.Run` who is responsible for disposing the `Toplevel` that was either passed to `Application.Run (View)` or created by `Application.Run<T> ()`.
+* In v1, `Application.End` called `Dispose ()` on @Terminal.Gui.Application.Top (via `Runstate.Toplevel`). This was incorrect as it meant that after `Application.Run` returned, `Application.Top` had been disposed, and any code that wanted to interrogate the results of `Run` by accessing `Application.Top` only worked by accident. This is because GC had not actually happened; if it had the application would have crashed. In v2 `Application.End` does NOT call `Dispose`, and it is the caller to `Application.Run` who is responsible for disposing the `Toplevel` that was either passed to `Application.Run (View)` or created by `Application.Run<T> ()`.
 
 * Any code that creates a `Toplevel`, either by using `top = new()` or by calling either `top = Application.Run ()` or `top = ApplicationRun<T>()` must call `top.Dispose` when complete. The exception to this is if `top` is passed to `myView.Add(top)` making it a subview of `myView`. This is because the semantics of `Add` are that the `myView` takes over responsibility for the subviews lifetimes. Of course, if someone calls `myView.Remove(top)` to remove said subview, they then re-take responsbility for `top`'s lifetime and they must call `top.Dispose`.

docfx/docs/mouse.md

@@ -22,6 +22,6 @@ When the user does something with the mouse, the `ConsoleDriver` maps the platfo
 * **Clicked** - Indicates the user pressed then released the mouse button while over a particular View. 
 * **Moved** - Indicates the mouse moved to a new location since the last mouse event.
 
-## **[Global Mouse Handling](~/api/Terminal.Gui.Application.MouseEvent.yml)**
+## **Global Mouse Handling**
 
-The `Application.MouseEvent` event can be used if an application wishes to recieve all mouse events.
+The @Terminal.Gui.Application.MouseEvent event can be used if an application wishes to receive all mouse events.

docfx/docs/newinv2.md

@@ -16,23 +16,23 @@ Apps built with Terminal.Gui now feel modern thanks to these improvements:
 
 ## Simplified API
 
-The entire library has been reviewed and simplified. As a result, the API is more consistent and uses modern .NET API standards (e.g. for events). This refactoring resulted in the removal of thousands of lines of code, better unit tests, and higher performance than v1. See [Simplified API](overview.md#simplified-api) for details.
+The entire library has been reviewed and simplified. As a result, the API is more consistent and uses modern .NET API standards (e.g. for events). This refactoring resulted in the removal of thousands of lines of code, better unit tests, and higher performance than v1.
 
 ## [View](~/api/Terminal.Gui.View.yml) Improvements
-* *Improved!* View Lifetime Management is Now Deterministic - In v1 the rules ofr lifetime management of `View` objects was unclear and led to non-dterministic behavior and hard to diagnose bugs. This was particularly acute in the behavior of [Application.Run](~/api/Terminal.Gui.Application.Run.yml). In v2, the rules are clear and the code and unit test infrastructure tries to enforce them. See [Migrating From v1 To v2](migratingfromv1.md) for more details.
-* *New!* Adornments - Adornments are a special form of View that appear outside the `Viewport`: [Margin](~/api/Terminal.Gui.View.Margin.yml), [Border](~/api/Terminal.Gui.View.Border.yml), and [Padding](~/api/Terminal.Gui.View.Padding.yml).
+* *Improved!* View Lifetime Management is Now Deterministic - In v1 the rules ofr lifetime management of `View` objects was unclear and led to non-dterministic behavior and hard to diagnose bugs. This was particularly acute in the behavior of `Application.Run`. In v2, the rules are clear and the code and unit test infrastructure tries to enforce them. See [Migrating From v1 To v2](migratingfromv1.md) for more details.
+* *New!* Adornments - Adornments are a special form of View that appear outside the `Viewport`: @Terminal.Gui.View.Margin, @Terminal.Gui.View.Border, and @Terminal.Gui.View.Padding.
 * *New!* Built-in Scrolling/Virtual Content Area - In v1, to have a view a user could scroll required either a bespoke scrolling implementation, inheriting from `ScrollView`, or managing the complexity of `ScrollBarView` directly. In v2, the base-View class supports scrolling inherently. The area of a view visible to the user at a given moment was previously a rectangle called `Bounds`. `Bounds.Location` was always `Point.Empty`. In v2 the visible area is a rectangle called `Viewport` which is a protal into the Views content, which can be bigger (or smaller) than the area visible to the user. Causing a view to scroll is as simple as changing `View.Viewport.Location`. The View's content described by `View.GetContentSize()`. See [Layout](layout.md) for details.
-* *New!* [Dim.Auto](~/api/Terminal.Gui.Dim.Auto.yml) - Automatically sizes the view to fitthe view's Text, SubViews, or ContentArea.
-* *Improved!* [Pos.AnchorEnd](~/api/Terminal.Gui.Pos.AnchorEnd.yml) - New to v2 is `Pos.AnchorEnd ()` (with no parameters) which allows a view to be anchored to the right or bottom of the Superview. 
-* *New!* [Pos.Align](~/api/Terminal.Gui.Pos.Align.yml) - Aligns a set of views horizontally or vertically (left, rigth, center, etc...).
-* *New!* [View.Arrangement](~/api/Terminal.Gui.View.Arrangement.yml) enables tiled and overlapped view arrangement and moving/resizing Views with the keyboard and mouse. See [Arrangement](arrangement.md).
+* *New!* @Terminal.Gui.DimAuto - Automatically sizes the view to fit the view's Text, SubViews, or ContentArea.
+* *Improved!* @Terminal.Gui.PosAnchorEnd - New to v2 is `Pos.AnchorEnd ()` (with no parameters) which allows a view to be anchored to the right or bottom of the SuperView. 
+* *New!* @Terminal.Gui.PosAlign - Aligns a set of views horizontally or vertically (left, right, center, etc...).
+* *New!* @Terminal.Gui.View.Arrangement enables tiled and overlapped view arrangement and moving/resizing Views with the keyboard and mouse. See [Arrangement](arrangement.md).
 * *Improved!* Keyboard [Navigation](navigation.md) has been revamped to be more reliability and ensure TUI apps built with Terminal.Gui are accessible. 
 
 ## New and Improved Built-in Views
 
 * *[DatePicker](~/api/Terminal.Gui.DatePicker.yml)* - NEW! 
-* *[ScrollView](~/api/Terminal.Gui.ScrollView.yml)* - Replaced by built-in scrolling.
-* *[ScrollBar](~/api/Terminal.Gui.ScrollBar.yml)* - Replaces *ScrollBarView* with a much simpler view.
+* *ScrollView* - Replaced by built-in scrolling.
+* *@"Terminal.Gui.ScrollBar"* - Replaces *ScrollBarView* with a much simpler view.
 * *[Slider](~/api/Terminal.Gui.Slider.yml)* - NEW!
 * *[Shortcut](~/api/Terminal.Gui.Shortcut.yml)* - NEW! An opinionated (visually & API) View for displaying a command, helptext, key.
 * *[Bar](~/api/Terminal.Gui.Bar.yml)* - NEW! Building-block View for containing Shortcuts. Opinionated relative to Orientation but minimially so. The basis for the new StatusBar, MenuBar, and Menu views.
@@ -40,7 +40,7 @@ The entire library has been reviewed and simplified. As a result, the API is mor
 * *[MenuBar](~/api/Terminal.Gui.MenuBar.yml)* - COMING SOON! New implementation based on `Bar`
 * *[ContextMenu](~/api/Terminal.Gui.ContextMenu.yml)* - COMING SOON! New implementation based on `Bar`
 * *[FileDialog](~/api/Terminal.Gui.FileDialog.yml)* - The new, modern file dialog includes icons (in TUI!) for files/folders, search, and a `TreeView`. 
-* [ColorPicker](~/api/Terminal.Gui/ColorPicker.yml)* - Fully supports TrueColor with the ability to choose a color using HSV, RGB, or HSL as well as W3C standard color names.
+* *@"Terminal.Gui.ColorPicker"* - Fully supports TrueColor with the ability to choose a color using HSV, RGB, or HSL as well as W3C standard color names.
 
 ## Configuration Manager