* Add Glyphs.ReplacementChar config property
Introduced Glyphs.ReplacementChar to allow overriding the Unicode replacement character, defaulting to a space (' '). Updated both config.json and Glyphs.cs with this property, scoped to ThemeScope and documented as an override for Rune.ReplacementChar.
* Standardize to Glyphs.ReplacementChar for wide char invalidation
Replaced all uses of Rune.ReplacementChar.ToString() with Glyphs.ReplacementChar.ToString() in OutputBufferImpl and related tests. This ensures consistent use of the replacement character when invalidating or overwriting wide characters in the output buffer.
* Add configurable wide glyph replacement chars to OutputBuffer
Allows setting custom replacement characters for wide glyphs that cannot fit in the available space via IOutputBuffer.SetReplacementChars. Updated IDriver to expose GetOutputBuffer. All code paths and tests now use the configurable characters, improving testability and flexibility. Tests now use '①' and '②' for clarity instead of the default replacement character.
* Fixed warnings.
* Update IOutputBuffer.cs
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
* Add tests for wide char clipping edge cases in OutputBuffer
Added three unit tests to OutputBufferWideCharTests.cs to verify and document OutputBufferImpl's behavior when wide (double-width) characters are written at the edges of a clipping region. Tests cover cases where the first or second column of a wide character is outside the clip, as well as when both columns are inside. The tests assert correct use of replacement characters, dirty flags, and column advancement, and document that certain code paths are currently unreachable due to IsValidLocation checks.
* Clarify dead code path with explanatory comments
Added comments to mark a rarely executed code path as dead code, noting it is apparently never called. Referenced the related test scenario AddStr_WideChar_FirstColumnOutsideClip_SecondColumnInside_CurrentBehavior for context. No functional changes were made.
* Remove dead code for wide char partial clip handling
Removed unreachable code that handled the case where the first column of a wide character is outside the clipping region but the second column is inside. This logic was marked as dead code and never called. Now, only the cases where the second column is outside the clip or both columns are in bounds are handled. This simplifies the code and removes unnecessary checks.
* Replaces Glyphs.ReplacementChar with Glyphs.WideGlyphReplacement to clarify its use for clipped wide glyphs. Updates IOutputBuffer to use SetWideGlyphReplacement (single Rune) instead of SetReplacementChars (two Runes). Refactors OutputBufferImpl and all test code to use the new property and method. Removes second-column replacement logic, simplifying the API and improving consistency. Updates comments and test assertions to match the new naming and behavior.
* Update themes in config.json and add new UI Catalog props
Renamed "UI Catalog Theme" to "UI Catalog" and removed the
"Glyphs.ReplacementChar" property. Added several new properties
to the "UI Catalog" theme, including default shadow, highlight
states, button alignment, and separator line style. Also added
"Glyphs.WideGlyphReplacement" to the "Hot Dog Stand" theme.
---------
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Terminal.Gui UI Catalog
UI Catalog is a comprehensive sample library for Terminal.Gui. It attempts to satisfy the following goals:
- Be an easy-to-use showcase for Terminal.Gui concepts and features.
- Provide sample code that illustrates how to properly implement said concepts & features.
- Make it easy for contributors to add additional samples in a structured way.
Motivation
The original demo.cs sample app for Terminal.Gui is neither good to showcase, nor does it explain different concepts. In addition, because it is built on a single source file, it has proven to cause friction when multiple contributors are simultaneously working on different aspects of Terminal.Gui.
See Issue #368 for more background.
API Reference
How To Use
Build and run UI Catalog by typing dotnet run from the UI Catalog folder or by using the Terminal.Gui Visual Studio solution.
Program.cs is the main UI Catalog app and provides a UI for selecting and running Scenarios. Each *Scenario is implemented as a class derived from Scenario and Program.cs uses reflection to dynamically build the UI.
Scenarios are tagged with categories using the [ScenarioCategory] attribute. The left pane of the main screen lists the categories. Clicking on a category shows all the scenarios in that category.
Scenarios can be run either from the UICatalog.exe app UI or by being specified on the command line:
UICatalog.exe <Scenario Name>
e.g.
UICatalog.exe Buttons
Hitting ENTER on a selected Scenario or double-clicking on a Scenario runs that scenario as though it were a stand-alone Terminal.Gui app.
When a Scenario is run, it runs as though it were a standalone Terminal.Gui app. However, scaffolding is provided (in the Scenario base class) that (optionally) takes care of Terminal.Gui initialization.
Contributing by Adding Scenarios
To add a new Scenario simply:
- Create a new
.csfile in theScenariosdirectory that derives fromScenario. - Add a
[ScenarioMetaData]attribute to the class specifying the scenario's name and description. - Add one or more
[ScenarioCategory]attributes to the class specifying which categories the sceanrio belongs to. If you don't specify a category the sceanrio will show up in "All". - Implement the
Setupoverride which will be called when a user selects the scenario to run. - Optionally, implement the
Initand/orRunoverrides to provide a custom implementation.
The sample below is provided in the .\UICatalog\Scenarios directory as a generic sample that can be copied and re-named:
namespace UICatalog {
[ScenarioMetadata (Name: "Generic", Description: "Generic sample - A template for creating new Scenarios")]
[ScenarioCategory ("Controls")]
class MyScenario : Scenario {
public override void Setup ()
{
// Put your scenario code here, e.g.
Win.Add (new Button () {
Text = "Press me!",
X = Pos.Center (),
Y = Pos.Center (),
Clicked = () => MessageBox.Query (20, 7, "Hi", "Neat?", "Yes", "No")
});
}
}
}
Scenario provides Win, a Window object that provides a canvas for the Scenario to operate.
The default Window shows the Scenario name and supports exiting the Scenario through the Esc key.
To build a more advanced scenario, where control of the Runnable and Window is needed (e.g. for scenarios using MenuBar or StatusBar), simply use Application.Top per normal Terminal.Gui programming, as seen in the Notepad scenario.
For complete control, the Init and Run overrides can be implemented. The base.Init creates Win. The base.Run simply calls Application.Run(Application.Top).
Contribution Guidelines
- Provide a terse, descriptive
NameforScenarios. Keep them short. - Provide a clear
Description. - Comment
Scenariocode to describe to others why it's a usefulScenario. - Annotate
Scenarioswith[ScenarioCategory]attributes. Minimize the number of new categories created. - Use the
Bug RepoCategory forScenariosthat reproduce bugs.- Include the Github Issue # in the Description.
- Once the bug has been fixed in
developsubmit another PR to remove theScenario(or modify it to provide a good regression test/sample).
- Tag bugs or suggestions for
UI CatalogasTerminal.GuiGithub Issues with "UICatalog: ".

