Crate iced_native

source ·
Expand description

A renderer-agnostic native GUI runtime.

The native path of the Iced ecosystem

iced_native takes iced_core and builds a native runtime on top of it, featuring:

  • A custom layout engine, greatly inspired by druid
  • Event handling for all the built-in widgets
  • A renderer-agnostic API

To achieve this, it introduces a couple of reusable interfaces:

  • A Widget trait, which is used to implement new widgets: from layout requirements to event and drawing logic.
  • A bunch of Renderer traits, meant to keep the crate renderer-agnostic.

Usage

The strategy to use this crate depends on your particular use case. If you want to:

  • Implement a custom shell or integrate it in your own system, check out the UserInterface type.
  • Build a new renderer, see the renderer module.
  • Build a custom widget, start at the Widget trait.

Re-exports

pub use iced_futures::futures;
pub use executor::Executor;
pub use clipboard::Clipboard;
pub use command::Command;
pub use event::Event;
pub use layout::Layout;
pub use overlay::Overlay;
pub use program::Program;
pub use renderer::Renderer;
pub use subscription::Subscription;
pub use user_interface::UserInterface;
pub use widget::Widget;

Modules

Align and position widgets.
Change the appearance of an application.
Access the clipboard.
Run asynchronous actions.
Handle events of a user interface.
Choose your preferred executor to power a runtime.
Load and draw raster graphics.
Track keyboard events.
Position your widgets properly.
Track mouse events.
Display interactive elements on top of other widgets.
Build interactive programs using The Elm Architecture.
Write your own renderer.
Listen to external events in your application.
Load and draw vector graphics.
Access the native system.
Draw and interact with text.
Use the built-in theme and styles.
Keep track of time, both in native and web platforms!
Build touch events.
Implement your own event loop to drive a user interface.
Use the built-in widgets or create your own.
Build window-based GUI applications.

Macros

Creates a Color with shorter and cleaner syntax.
Creates a Column with the given children.
Creates a Row with the given children.

Structs

A color in the sRGB color space.
A bunch of time measurements for debugging purposes.
A generic Widget.
The hasher used to compare layouts.
An amount of space to pad for each side of a box
A 2D point.
A rectangle.
A connection to the state of a shell.
An amount of space in 2 dimensions.
A 2D vector.

Enums

Alignment on the axis of a container.
The background of some element.
The strategy used to fit the contents of a widget to its bounding box.
A font.
The strategy used to fill space in a specific dimension.
A built-in theme.

Type Definitions

A native runtime with a generic executor and receiver of results.