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 )
Warning
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).
Chevron is released under the GNU Affero GPLv3 license. See LICENSE for the full text.
| 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.
Note
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.
/*!
* @file main.cpp
*
* @brief
* Conceptual portable GUI application launch sequence.
*/
#include <chevron/entry.hpp> // Entry point helpers and macros
#include <chevron/process.hpp> // Application process-level constructs
#include <chevron/wx/runtime.hpp> // wxWidgets GUI framework engine
using chevron::AppProcess;
using WxEngine = chevron::wx::Engine;
using chevron::WindowFactory;
using chevron::ProcessMemoryConfig;
using chevron::ProcessThreadConfig;
using chevron::ProcessExitReport;
// Note:
// `ENTRY_POINT_METHOD_SIGNATURE` and `ENTRY_POINT_ARG_VARS` are
// Chevron defined macros from <chevron/entry.hpp>.
/*!
* @brief
* Application entry point (main method)
*/
ENTRY_POINT_METHOD_SIGNATURE {
ProcessMemoryConfig memoryConfig{ /*Configure process memory*/ };
ProcessThreadConfig threadConfig{ /*Configure process threads*/ };
AppProcess proc{memoryConfig, threadConfig};
WxEngine::Configuration runtimeConfig;
runtimeConfig.forwardCmdlArgs(ENTRY_POINT_ARG_VARS);
auto guiEngine = std::make_unique<WxEngine>(runtimeConfig);
guiEngine->windowing().registerFactory(
WindowFactory{
/*Callable that returns new wxFrame pointer*/,
/*Window dispatch descriptor*/
}
);
proc.commitGUIEngine(std::move(guiEngine));
proc.initializeGUIEngine();
proc.mainloopEntry();
ProcessExitReport report = proc.shutdown();
return report.exitCode;
}