+ Every C++ GUI application has to settle the same foundational details before it can really begin: how memory is structured, how concurrent threads of execution are managed, + how windows are handled, how UI views change at runtime, and more. None of this is the application itself, yet it is crucial to the applications functionality. +
++ + Chevron is a C++20 GUI application infrastructure library that owns the mechanics of a modern GUI application (process lifetime, window scaffolding, dynamic view handling, + thread infrastructure, etc.) so user code can focus on the application itself, written directly against the GUI framework the user chose. + +
+( diagram showcasing components Chevron provides downstream applications )
++ It does NOT unify GUI frameworks behind a portable interface and it does NOT introduce an explicit widget layer of its own. A Chevron user + picks exactly one GUI framework, includes it directly, and writes GUI code similar to how they typically would. What changes is the structural environment that code lives + inside (the parts of the application that aren't about the GUI but are around it). +
+| Subsystem | +Status | +Notes | +
|---|---|---|
| Process Lifecycle | +Design | +AppProcess design still pending further library development |
+
| GUI Runtime | +Design | +GUIEngine design still pending further library development |
+
| Memory Infrastructure | +Design | ++ Process-level memory construct designs/implementations complete; Broader memory hierarchy still in-progress + | +
| Thread Infrastructure | +Design | +ThreadCore and related entity designs still incomplete |
+
| Host System Services | +Not Started | +N/a | +
| Logging System | +Not Started | +N/a | +
| Windowing System | +Design | +
+ WindowCoordinator and WindowDispatcher designs nearly complete; WindowEnvelope and WindowingSubsystem still
+ pending further design
+ |
+
| Window Component System | +Design | +Incomplete design; Pending further window facilities design and development | +
| Dynamic View System | +Design | +Incomplete design; Pending further window facilities design and development | +
| Event Routing System | +Not Started | +N/a | +
| Messaging Infrastructure | +Not Started | +N/a | +
| Telemetry Infrastructure | +Not Started | +N/a | +
+ Chevron is organized as three nested lifetime tiers, each owned and bounded by the one above it. AppProcess opens the process lifetime and lives for the full
+ duration of the application. Inside it, GUIEngine opens the GUI lifetime, governing framework initialization, the mainloop, and teardown. Inside that, each
+ live window is represented by a WindowEnvelope, created when a window is dispatched and destroyed when that window closes. Nothing in a tier may exist before
+ its enclosing tier has opened, and nothing may outlive its close. Every other piece of infrastructure in the library (memory, threading, windowing, dynamic views)
+ lives somewhere inside this nesting.
+
( diagram showcasing major system component lifetime tiers )
+
+ Every Chevron application is structured around a single AppProcess at its root. AppProcess owns the GUIEngine, an abstraction whose
+ concrete implementation matches the user's chosen GUI framework. The GUI engine hosts Chevron's windowing infrastructure: a dispatcher that creates windows, a coordinator
+ that manages them once they exist, and a windowing subsystem that surfaces these components together as a coherent user-facing API. Live windows are represented by
+ WindowEnvelope instances held by the coordinator, each carrying its own per-window infrastructure (PWI). The application's behavior
+ lives inside those windows, where the user writes code against the chosen GUI framework directly.
+
+ Chevron applications are bootstrapped from the users own main() entry point. During this stage, the process is tailor configured to the applications profile, a GUI
+ engine is prepared for the users chosen framework, and window factories are registered to declare window intent. Once setup work is complete on the established GUI engine, it
+ can then be handed off to AppProcess to enter application runtime under Chevron's direction. The bootstrapping phase is also the ideal opportunity to conduct any
+ necessary pre-launch work.
+
+> The main method is always tasked with handling process-wide setup, it is not application code. The application itself lives downstream of this stage, in the windows +> and infrastructure that come online during runtime. +>
+ +```cpp +/*! + * @file main.cpp + * + * @brief + * Conceptual portable GUI application launch sequence. + */ + +#include+ Every C++ GUI application has to settle the same foundational details before it can really begin: how memory is structured, how concurrent threads of execution are managed, + how windows are handled, how UI views change at runtime, and more. None of this is the application itself, yet it is crucial to the applications functionality. +
++ + Chevron is a C++20 GUI application infrastructure library that owns the mechanics of a modern GUI application (process lifetime, window scaffolding, dynamic view handling, + thread infrastructure, etc.) so user code can focus on the application itself, written directly against the GUI framework the user chose. + +
+( diagram showcasing components Chevron provides downstream applications )
++ It does NOT unify GUI frameworks behind a portable interface and it does NOT introduce an explicit widget layer of its own. A Chevron user + picks exactly one GUI framework, includes it directly, and writes GUI code similar to how they typically would. What changes is the structural environment that code lives + inside (the parts of the application that aren't about the GUI but are around it). +
+| Subsystem | +Status | +Notes | +
|---|---|---|
| Process Lifecycle | +Design | +AppProcess design still pending further library development |
+
| GUI Runtime | +Design | +GUIEngine design still pending further library development |
+
| Memory Infrastructure | +Design | ++ Process-level memory construct designs/implementations complete; Broader memory hierarchy still in-progress + | +
| Thread Infrastructure | +Design | +ThreadCore and related entity designs still incomplete |
+
| Host System Services | +Not Started | +N/a | +
| Logging System | +Not Started | +N/a | +
| Windowing System | +Design | +
+ WindowCoordinator and WindowDispatcher designs nearly complete; WindowEnvelope and WindowingSubsystem still
+ pending further design
+ |
+
| Window Component System | +Design | +Incomplete design; Pending further window facilities design and development | +
| Dynamic View System | +Design | +Incomplete design; Pending further window facilities design and development | +
| Event Routing System | +Not Started | +N/a | +
| Messaging Infrastructure | +Not Started | +N/a | +
| Telemetry Infrastructure | +Not Started | +N/a | +
+ Chevron is organized as three nested lifetime tiers, each owned and bounded by the one above it. AppProcess opens the process lifetime and lives for the full
+ duration of the application. Inside it, GUIEngine opens the GUI lifetime, governing framework initialization, the mainloop, and teardown. Inside that, each
+ live window is represented by a WindowEnvelope, created when a window is dispatched and destroyed when that window closes. Nothing in a tier may exist before
+ its enclosing tier has opened, and nothing may outlive its close. Every other piece of infrastructure in the library (memory, threading, windowing, dynamic views)
+ lives somewhere inside this nesting.
+
( diagram showcasing major system component lifetime tiers )
+
+ Every Chevron application is structured around a single AppProcess at its root. AppProcess owns the GUIEngine, an abstraction whose
+ concrete implementation matches the user's chosen GUI framework. The GUI engine hosts Chevron's windowing infrastructure: a dispatcher that creates windows, a coordinator
+ that manages them once they exist, and a windowing subsystem that surfaces these components together as a coherent user-facing API. Live windows are represented by
+ WindowEnvelope instances held by the coordinator, each carrying its own per-window infrastructure (PWI). The application's behavior
+ lives inside those windows, where the user writes code against the chosen GUI framework directly.
+
+ Chevron applications are bootstrapped from the users own main() entry point. During this stage, the process is tailor configured to the applications profile, a GUI
+ engine is prepared for the users chosen framework, and window factories are registered to declare window intent. Once setup work is complete on the established GUI engine, it
+ can then be handed off to AppProcess to enter application runtime under Chevron's direction. The bootstrapping phase is also the ideal opportunity to conduct any
+ necessary pre-launch work.
+
+> The main method is always tasked with handling process-wide setup, it is not application code. The application itself lives downstream of this stage, in the windows +> and infrastructure that come online during runtime. +>
+ +```cpp +/*! + * @file main.cpp + * + * @brief + * Conceptual portable GUI application launch sequence. + */ + +#include