repository·master·Indexed 20 days ago
https://github.com/aui-framework/auiA cross-platform, high-performance, module-based framework for developing hardware-accelerated graphical desktop applications using modern C++20. AUI provides a retained-mode UI experience for building, styling, and dependency management without custom languages or external compilers. It supports cross-platform deployment on Windows, macOS, Linux, Android, and iOS, and allows for custom OpenGL shaders and GPU-friendly rendering via ITexture and AImage.
Building a user interface in AUI involves composing several key abstractions:
AButton, ALabel, ATextInput).signal-slot system that connects UI components directly to application data objects, ensuring the UI stays in sync with the underlying state.The CellsView class is used to visualize a grid by updating a texture whenever cell states change.
Key behaviors:
drawGrid lambda to compose grid lines, which are then passed to the renderer to perform a single draw call for the entire grid.AUI Assets is a feature provided by aui.toolbox that embeds external files (images, sounds, text, etc.) directly into your application or library's binary. This makes your application self-contained and avoids the need to manage platform-specific file paths or packaging.
To reference an embedded asset in your code, prefix the file path with a colon (:) character (e.g., ":background.png").
The Notes App example demonstrates how to manage application data using AListModel for collections and AProperty for individual state tracking.
AListModel to hold a list of data objects (e.g., a list of Note structs).AProperty to manage reactive state, such as the currently selected item (mCurrentNote) or application state flags like mDirty (indicating unsaved changes).mDirty is true).AUI uses a declarative syntax for building user interfaces. You can define a window by inheriting from AWindow and overriding its contents using setContents with layout containers and widgets.
Key Concepts:
Vertical, Horizontal, or Centered to structure elements.Label { "text" } or _new<AButton>("label") to create UI elements..connect(&AView::clicked, this, [] { ... }) to attach logic to widget events.APlatform::openUrl("url") to perform platform-level actions like opening a web browser.Example:
#include <AUI/Platform/AWindow.h>
#include <AUI/View/ALabel.h>
#include <AUI/View/AButton.h>
#include <AUI/Platform/APlatform.h>
using namespace declarative;
class MainWindow: public AWindow {
public:
MainWindow() : AWindow("App Title", 300_dp, 200_dp) {
setContents(
Vertical{
Label { "Hello!" },
_new<AButton>("Click Me").connect(&AView::clicked, this, [] {
APlatform::openUrl("https://example.com");
})
}
);
}
};MainWindow::MainWindow(): AWindow("Project template app", 300_dp, 200_dp) {
setContents(
Centered{
Vertical{
Centered { Label { "Hello world from AUI!" } },
_new<AButton>("Visit GitHub repo").connect(&AView::clicked, this, [] {
APlatform::openUrl("https://github.com/aui-framework/aui");
}),
}
}
);
}When developing AUI applications for Android, keep the following platform-specific behaviors in mind:
_dp.The aui_compile_assets command creates a build-time dependency on aui.toolbox. For every file found in the assets/ directory, the toolbox generates a corresponding *.cpp file. These generated files contain a byte array of the asset data, which is automatically registered to AUI's ABuiltinFiles filesystem during compilation.
Before being embedded, aui.toolbox performs two transformations:
.svg).AUI supports three distinct UI paradigms, though it is primarily designed as a hybrid/declarative framework to provide the best developer experience and performance.
AButton) are created as persistent objects in memory. You must manually manage their state (e.g., calling setText() when data changes) and maintain a link between business logic and the UI state.Recommendation: AUI strongly suggests using declarative mode for most use cases due to its dynamism and responsiveness.
AUI and Jetpack Compose represent different UI paradigms:
| Feature | AUI (Retained Mode) | Jetpack Compose (Immediate Mode) |
|---|---|---|
| State | Stored inside a class member | Local variable using remember |
| Vertical Layout | Vertical | Column |
| Horizontal Layout | Horizontal | Row |
| Display | Label { AUI_REACT("{}"_format(mCounter)) } | Text(text = "Counter $counter") |
| Increment | Button { .content = Label { "Count" }, .onClick = [this] { mCounter += 1; } } | Button(onClick = { counter++ }) |
Key Distinction: AUI is a retained mode UI, meaning the framework maintains a model of the UI hierarchy, whereas Jetpack Compose is an immediate mode UI.