repository·master·Indexed 27 days ago
https://github.com/linebender/druidA data-oriented, Rust-native UI design toolkit for high-performance desktop applications. Druid utilizes a widget-based architecture and a two-way dataflow system centered around the Data, Widget, and Lens traits. It integrates with piet for 2D graphics and kurbo for geometry. Note: The project is currently unmaintained and discontinued, with development having moved to Xilem.
The Env represents the application environment, used for managing and accessing resources like color schemes, localized strings, and other application-specific state. It is created at launch and passed down to all widgets.
Key behaviors:
Env are inherited by all child widgets. If a value is overridden at a specific level in the widget tree, that new value applies to all children of that widget.Env once set.Env uses typed keys. You must ensure the type used to set a value matches the type used to retrieve it via a Key to avoid runtime panics.Druid is a data-oriented framework for building cross-platform desktop applications. It is composed of several specialized libraries:
druid: An opinionated set of high-level APIs for building applications.druid-shell: A low-level library providing abstractions for interacting with the OS and window manager.piet: An abstraction for 2D graphics.kurbo: A library for 2D geometry.The Widget trait defines the components of a Druid UI. A UI is structured as a widget tree starting from a single root widget. The Widget trait is generic over T, which represents the [Data] handled by the widget.
Druid operates through a specific lifecycle of method calls:
Event (e.g., key press, mouse movement). This method provides mutable access to your application model and is the only place where the model can be changed. Events are delivered recursively down the tree.layout or paint calls.Druid relies on several foundational libraries for graphics, curves, and text layout. If you need to extend Druid's capabilities or understand its low-level primitives, explore these projects:
Druid's architecture is built around three primary concepts:
Data trait: Used to represent your application's model.Widget trait: Used to represent the user interface elements.Lens trait: Used to associate specific parts of your model with specific parts of your UI.The druid-shell architecture is split into two layers:
src/backend. The implementation for the active backend is re-exported via druid-shell::backend.To maintain a consistent API, druid-shell uses wrapper structs that define a common interface. When you call methods on these wrappers, they internally invoke the corresponding methods on the concrete backend-specific type.
The Controller trait is used to create widgets that handle events, updates, or lifecycle changes without performing layout or drawing. This is useful for adding logic to existing widgets (e.g., intercepting keypresses in a textbox).
Key characteristics:
event, update, and lifecycle methods (all are optional).paint or layout.Example: A controller that triggers an action after a delay following a keypress:
// Conceptual example of a Controller implementation
impl<W: Widget<T>, T> Controller<T, W> for MyController {
fn event(&mut self, child: &mut W, ctx: &mut EventCtx, event: &Event, data: &mut T, env: &Env) {
// Handle event and potentially modify child or data
child.event(ctx, event, data, env);
}
// ... other optional methods
}To use Druid, you need:
Druid requires GTK-3's development kit on Linux and OpenBSD platforms.
apt-get.dnf.pkg_add.# Ubuntu
sudo apt-get install libgtk-3-dev
# Fedora
sudo dnf install gtk3-devel glib2-devel
# OpenBSD
pkg_add gtk+3To start a new project, create a new Rust binary crate and add druid as a dependency using cargo.
cargo new my-druid-app
cd my-druid-app
cargo add druidDruid widgets are designed to be modular and composable rather than monolithic. Instead of a single widget handling its own alignment or padding, you should wrap specialized widgets in layout or decorator widgets.
For example, to add padding to a Label, you do not configure the label itself; instead, you wrap the label in a widget that provides padding.