Iced

https://docs.rs/iced/latest/iced/
Admin
Iced is a cross-platform GUI library focused on simplicity and type-safety, inspired by Elm.
Tokens:787,856
Snippets:11,169
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### setup

Source: https://docs.rs/iced/latest/iced/overlay/menu/type.StyleFn.html

Retrieves the setup information provided by the X11 server.

```APIDOC
## fn setup(&self) -> &Setup

### Description
Get the setup information sent by the X11 server.
```

--------------------------------

### Implementing a text editor

Source: https://docs.rs/iced/latest/iced/widget/fn.text_editor.html

Example showing the setup of a text editor widget, including state management, message handling, and view integration.

```rust
use iced::widget::text_editor;

struct State {
   content: text_editor::Content,
}

#[derive(Debug, Clone)]
enum Message {
    Edit(text_editor::Action)
}

fn view(state: &State) -> Element<'_, Message> {
    text_editor(&state.content)
        .placeholder("Type something here...")
        .on_action(Message::Edit)
        .into()
}

fn update(state: &mut State, message: Message) {
    match message {
        Message::Edit(action) => {
            state.content.perform(action);
        }
    }
}
```

--------------------------------

### Trim Start Matches Examples

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayString.html?search=

Demonstrates removing prefixes that match a specific pattern.

```rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");
```

--------------------------------

### Basic Application Example

Source: https://docs.rs/iced/latest/iced/application/fn.application.html

A minimal example demonstrating how to define state, update logic, and a view using the application function.

```rust
use iced::widget::{button, column, text, Column};

pub fn main() -> iced::Result {
    iced::application(u64::default, update, view).run()
}

#[derive(Debug, Clone)]
enum Message {
    Increment,
}

fn update(value: &mut u64, message: Message) {
    match message {
        Message::Increment => *value += 1,
    }
}

fn view(value: &u64) -> Column<Message> {
    column![
        text(value),
        button("+").on_press(Message::Increment),
    ]
}
```

--------------------------------

### Box Allocation Examples

Source: https://docs.rs/iced/latest/iced/widget/qr_code/type.StyleFn.html?search=std%3A%3Avec

Examples demonstrating the use of Box with custom allocators for uninitialized and zeroed memory.

```rust
let five = Box::try_new_in(5, System)?;
```

```rust
#![feature(allocator_api)]

use std::alloc::System;

let mut five = Box::<u32, _>::new_uninit_in(System);
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)
```

```rust
#![feature(allocator_api)]

use std::alloc::System;

let mut five = Box::<u32, _>::try_new_uninit_in(System)?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);
```

```rust
#![feature(allocator_api)]

use std::alloc::System;

let zero = Box::<u32, _>::new_zeroed_in(System);
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0)
```

```rust
#![feature(allocator_api)]

use std::alloc::System;

let zero = Box::<u32, _>::try_new_zeroed_in(System)?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);
```

--------------------------------

### Trim Start Examples

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayString.html?search=

Demonstrates trimming leading whitespace from strings, including handling of right-to-left languages.

```rust
let s = "  עברית  ";
assert!(Some('ע') == s.trim_start().chars().next());
```

--------------------------------

### Trim start matches example

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayString.html?search=

Demonstrates trimming characters from the start of a string slice.

```rust
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

--------------------------------

### Strip prefix examples

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayString.html?search=

Examples showing how to remove a prefix exactly once if it exists.

```rust
assert_eq!("foo:bar".strip_prefix("foo:"), Some("bar"));
assert_eq!("foo:bar".strip_prefix("bar"), None);
assert_eq!("foofoo".strip_prefix("foo"), Some("foo"));
```

--------------------------------

### Usage Example for right

Source: https://docs.rs/iced/latest/iced/widget/fn.right.html?search=std%3A%3Avec

Demonstrates the equivalent container configuration for right-alignment.

```rust
let right = container("Right!").align_right(Fill);
```

--------------------------------

### Building PathCommands

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/commands/struct.PathCommands.html

Example demonstrating how to use PathCommands::builder to construct a path.

```rust
use lyon_path::{EndpointId, PathCommands};

let mut cmds = PathCommands::builder();

cmds.begin(EndpointId(0));
cmds.line_to(EndpointId(1));
cmds.line_to(EndpointId(2));
cmds.end(true);

let cmds = cmds.build();
```

--------------------------------

### Strip suffix examples

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayString.html?search=

Examples showing how to remove a suffix exactly once if it exists.

```rust
assert_eq!("bar:foo".strip_suffix(":foo"), Some("bar"));
assert_eq!("bar:foo".strip_suffix("bar"), None);
assert_eq!("foofoo".strip_suffix("foo"), Some("foo"));
```

--------------------------------

### Create a new XcbWindowHandle

Source: https://docs.rs/iced/latest/iced/window/raw_window_handle/struct.XcbWindowHandle.html

Example usage of the new constructor to initialize an XcbWindowHandle.

```rust
let window: NonZeroU32;
let mut handle = XcbWindowHandle::new(window);
// Optionally set the visual ID.
handle.visual_id = None;
```

--------------------------------

### Create a new Win32WindowHandle

Source: https://docs.rs/iced/latest/iced/window/raw_window_handle/struct.Win32WindowHandle.html?search=

Example of creating a new handle and optionally setting the HINSTANCE.

```rust
let window: HWND;
let mut handle = Win32WindowHandle::new(NonZeroIsize::new(window.0).unwrap());
// Optionally set the GWLP_HINSTANCE.
let hinstance = NonZeroIsize::new(unsafe { GetWindowLongPtrW(window, GWLP_HINSTANCE) }).unwrap();
handle.hinstance = hinstance;
```

--------------------------------

### Radio Widget Usage Example

Source: https://docs.rs/iced/latest/iced/widget/fn.radio.html

An example demonstrating how to create multiple radio buttons within a column.

```rust
use iced::widget::{column, radio};

struct State {
   selection: Option<Choice>,
}

#[derive(Debug, Clone, Copy)]
enum Message {
    RadioSelected(Choice),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Choice {
    A,
    B,
    C,
    All,
}

fn view(state: &State) -> Element<'_, Message> {
    let a = radio(
        "A",
        Choice::A,
        state.selection,
        Message::RadioSelected,
    );

    let b = radio(
        "B",
        Choice::B,
        state.selection,
        Message::RadioSelected,
    );

    let c = radio(
        "C",
        Choice::C,
        state.selection,
        Message::RadioSelected,
    );

    let all = radio(
        "All of the above",
        Choice::All,
        state.selection,
        Message::RadioSelected
    );

    column![a, b, c, all].into()
}
```

--------------------------------

### Create a new XcbDisplayHandle

Source: https://docs.rs/iced/latest/iced/window/raw_window_handle/struct.XcbDisplayHandle.html

Example of how to instantiate a new XcbDisplayHandle using the new constructor.

```rust
let connection: NonNull<c_void>;
let screen;
let handle = XcbDisplayHandle::new(Some(connection), screen);
```

--------------------------------

### Creating a Tooltip

Source: https://docs.rs/iced/latest/iced/widget/fn.tooltip.html

An example of how to implement a tooltip within a view function.

```rust
use iced::widget::{container, tooltip};

enum Message {
    // ...
}

fn view(_state: &State) -> Element<'_, Message> {
    tooltip(
        "Hover me to display the tooltip!",
        container("This is the tooltip contents!")
            .padding(10)
            .style(container::rounded_box),
        tooltip::Position::Bottom,
    ).into()
}
```

--------------------------------

### Create a new OrbitalWindowHandle

Source: https://docs.rs/iced/latest/iced/window/raw_window_handle/struct.OrbitalWindowHandle.html

Example showing how to instantiate a new OrbitalWindowHandle using a pointer to a window.

```rust
let window: NonNull<Window>;
let mut handle = OrbitalWindowHandle::new(window.cast());
```

--------------------------------

### Creating a HaikuWindowHandle

Source: https://docs.rs/iced/latest/iced/window/raw_window_handle/struct.HaikuWindowHandle.html

Example showing how to instantiate a new HaikuWindowHandle using a BWindow pointer.

```rust
let b_window: NonNull<BWindow>;
let mut handle = HaikuWindowHandle::new(b_window.cast());
// Optionally set `b_direct_window`.
handle.b_direct_window = None;
```

--------------------------------

### Create a new WaylandDisplayHandle

Source: https://docs.rs/iced/latest/iced/window/raw_window_handle/struct.WaylandDisplayHandle.html

Example showing how to instantiate a new WaylandDisplayHandle using the new constructor.

```rust
let display: NonNull<c_void>;
let handle = WaylandDisplayHandle::new(display);
```

--------------------------------

### Create a new WaylandWindowHandle

Source: https://docs.rs/iced/latest/iced/window/raw_window_handle/struct.WaylandWindowHandle.html?search=

Example showing how to instantiate a new WaylandWindowHandle using a surface pointer.

```rust
let surface: NonNull<c_void>;
let handle = WaylandWindowHandle::new(surface);
```

--------------------------------

### Create a new WebOffscreenCanvasWindowHandle

Source: https://docs.rs/iced/latest/iced/window/raw_window_handle/struct.WebOffscreenCanvasWindowHandle.html

Example demonstrating how to create a new handle from a pointer to an OffscreenCanvas.

```rust
let canvas: &OffscreenCanvas;
let value: &JsValue = &canvas; // Deref to `JsValue`
let obj: NonNull<c_void> = NonNull::from(value).cast();
let mut handle = WebOffscreenCanvasWindowHandle::new(obj);
```

--------------------------------

### Preset::new

Source: https://docs.rs/iced/latest/iced/struct.Preset.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new Preset instance with a specified name and a boot function that returns the initial state and a Task.

```APIDOC
## fn new<State, Message>(name: impl Into<Cow<'static, str>>, boot: impl Fn() -> (State, Task<Message>) + 'static) -> Preset<State, Message>

### Description
Creates a new `Preset` with the given name and boot strategy.

### Parameters
- **name** (impl Into<Cow<'static, str>>) - The name of the preset.
- **boot** (impl Fn() -> (State, Task<Message>) + 'static) - A function that returns the initial state and a `Task` for concurrent booting.
```

--------------------------------

### Preset::new

Source: https://docs.rs/iced/latest/iced/struct.Preset.html

Creates a new Preset instance with a specified name and a boot function that returns the initial state and a task.

```APIDOC
## fn new<State, Message>(name: impl Into<Cow<'static, str>>, boot: impl Fn() -> (State, Task<Message>) + 'static) -> Preset<State, Message>

### Description
Creates a new `Preset` with the given name and boot strategy.

### Parameters
- **name** (impl Into<Cow<'static, str>>) - Required - The name of the preset.
- **boot** (impl Fn() -> (State, Task<Message>) + 'static) - Required - A function that returns the initial state and a `Task` for concurrent booting.
```

--------------------------------

### Deprecated Trim Right Examples

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayString.html?search=

Legacy examples for trim_right, which is superseded by trim_end.

```rust
let s = " Hello\tworld\t";

assert_eq!(" Hello\tworld", s.trim_right());
```

```rust
let s = "English  ";
assert!(Some('h') == s.trim_right().chars().rev().next());

let s = "עברית  ";
assert!(Some('ת') == s.trim_right().chars().rev().next());
```

--------------------------------

### Preset::new

Source: https://docs.rs/iced/latest/iced/struct.Preset.html?search=std%3A%3Avec

Creates a new Preset instance with a specified name and boot strategy function.

```APIDOC
### pub fn new<State, Message>(name: impl Into<Cow<'static, str>>, boot: impl Fn() -> (State, Task<Message>) + 'static) -> Preset<State, Message>

Creates a new `Preset` with the given name and boot strategy.
```

--------------------------------

### Deprecated Trim Left Examples

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayString.html?search=

Legacy examples for trim_left, which is superseded by trim_start.

```rust
let s = " Hello\tworld\t";

assert_eq!("Hello\tworld\t", s.trim_left());
```

```rust
let s = "  English";
assert!(Some('E') == s.trim_left().chars().next());

let s = "  עברית";
assert!(Some('ע') == s.trim_left().chars().next());
```

--------------------------------

### Usage examples for the text macro

Source: https://docs.rs/iced/latest/iced/widget/macro.text.html?search=

Demonstrates creating Text widgets with static strings, formatted arguments, and local variables.

```rust
use iced::widget::text;

enum Message {
    // ...
}

fn view(_state: &State) -> Element<Message> {
    let simple = text!("Hello, world!");

    let keyword = text!("Hello, {}", "world!");

    let planet = "Earth";
    let local_variable = text!("Hello, {planet}!");
    // ...
}
```

--------------------------------

### vertical_slider Usage Example

Source: https://docs.rs/iced/latest/iced/widget/fn.vertical_slider.html

A complete example demonstrating how to integrate a vertical_slider into an iced application state and view.

```rust
use iced::widget::vertical_slider;

struct State {
   value: f32,
}

#[derive(Debug, Clone)]
enum Message {
    ValueChanged(f32),
}

fn view(state: &State) -> Element<'_, Message> {
    vertical_slider(0.0..=100.0, state.value, Message::ValueChanged).into()
}

fn update(state: &mut State, message: Message) {
    match message {
        Message::ValueChanged(value) => {
            state.value = value;
        }
    }
}
```

--------------------------------

### Preset::boot

Source: https://docs.rs/iced/latest/iced/struct.Preset.html?search=std%3A%3Avec

Executes the boot strategy to initialize the program state and task.

```APIDOC
### pub fn boot(&self) -> (State, Task<Message>)

Boots the `Preset`, returning the initial `Program` state and a `Task` for concurrent booting.
```

--------------------------------

### Create a new AndroidNdkWindowHandle

Source: https://docs.rs/iced/latest/iced/window/raw_window_handle/struct.AndroidNdkWindowHandle.html

Example showing how to instantiate a new handle using a pointer to an ANativeWindow.

```rust
let ptr: NonNull<ANativeWindow>;
let handle = AndroidNdkWindowHandle::new(ptr.cast());
```

--------------------------------

### Create Settings with Style

Source: https://docs.rs/iced/latest/iced/widget/markdown/struct.Settings.html?search=

Initializes a new Settings instance with default text sizes and a specified style.

```rust
pub fn with_style(style: impl Into<Style>) -> Settings
```

--------------------------------

### Settings Constructor Methods

Source: https://docs.rs/iced/latest/iced/widget/markdown/struct.Settings.html

Methods for initializing Settings with specific styles or base text sizes.

```rust
pub fn with_style(style: impl Into<Style>) -> Settings
```

```rust
pub fn with_text_size( text_size: impl Into<Pixels>, style: impl Into<Style>, ) -> Settings
```

--------------------------------

### get

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/struct.IdIter.html

Returns an iterator over a subsection of the iterator.

```APIDOC
fn get<R>(self, index: R) -> <R as IteratorIndex<Self>>::Output
```

--------------------------------

### as_array

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayVec.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a reference to the underlying array.

```APIDOC
## pub fn as_array<const N: usize>(&self) -> Option<&[T; N]>

### Description
Gets a reference to the underlying array. Returns None if N is not equal to the length of the slice.
```

--------------------------------

### Preset Methods

Source: https://docs.rs/iced/latest/iced/struct.Preset.html?search=

Methods for creating, naming, and booting a Preset instance.

```rust
pub fn new( name: impl Into<Cow<'static, str>>, boot: impl Fn() -> (State, Task<Message>) + 'static, ) -> Preset<State, Message>
```

```rust
pub fn name(&self) -> &str
```

```rust
pub fn boot(&self) -> (State, Task<Message>)
```

--------------------------------

### get<I>(i: I)

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayString.html

Returns a subslice of the string safely.

```APIDOC
## pub fn get<I>(&self, i: I) -> Option<&<I as SliceIndex<str>>::Output>

### Description
Returns a subslice of the string. This is the non-panicking alternative to indexing.
```

--------------------------------

### Create and run an iced application

Source: https://docs.rs/iced/latest/iced/application/index.html

Demonstrates the basic structure of an iced application, including state initialization, update logic, and view construction.

```rust
use iced::widget::{button, column, text, Column};
use iced::Theme;

pub fn main() -> iced::Result {
    iced::application(u64::default, update, view)
        .theme(Theme::Dark)
        .centered()
        .run()
}

#[derive(Debug, Clone)]
enum Message {
    Increment,
}

fn update(value: &mut u64, message: Message) {
    match message {
        Message::Increment => *value += 1,
    }
}

fn view(value: &u64) -> Column<Message> {
    column![
        text(value),
        button("+").on_press(Message::Increment),
    ]
}
```

--------------------------------

### get()

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayString.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns a subslice of the string safely.

```APIDOC
## pub fn get<I>(&self, i: I) -> Option<&<I as SliceIndex<str>>::Output>

### Description
Returns a subslice of `str` based on the provided index range. Returns `None` if the index is out of bounds or not on a UTF-8 boundary.
```

--------------------------------

### Implementing a PaneGrid

Source: https://docs.rs/iced/latest/iced/widget/fn.pane_grid.html?search=

A complete example demonstrating how to define state, handle pane messages, and construct a PaneGrid with drag and resize capabilities.

```rust
use iced::widget::{pane_grid, text};

struct State {
    panes: pane_grid::State<Pane>,
}

enum Pane {
    SomePane,
    AnotherKindOfPane,
}

enum Message {
    PaneDragged(pane_grid::DragEvent),
    PaneResized(pane_grid::ResizeEvent),
}

fn view(state: &State) -> Element<'_, Message> {
    pane_grid(&state.panes, |pane, state, is_maximized| {
        pane_grid::Content::new(match state {
            Pane::SomePane => text("This is some pane"),
            Pane::AnotherKindOfPane => text("This is another kind of pane"),
        })
    })
    .on_drag(Message::PaneDragged)
    .on_resize(10, Message::PaneResized)
    .into()
}
```

--------------------------------

### starts_with

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayVec.html

Checks if the slice starts with the given needle.

```APIDOC
## starts_with(&self, needle: &[T]) -> bool

### Description
Returns true if needle is a prefix of the slice or equal to the slice.
```

--------------------------------

### get<T>

Source: https://docs.rs/iced/latest/iced/widget/shader/struct.Storage.html?search=std%3A%3Avec

Retrieves a reference to the data of type T.

```APIDOC
## pub fn get<T>(&self) -> Option<&(dyn Any + 'static)>

### Description
Returns a reference to the data with type T if it exists in Storage.

### Parameters
- **T** (Type) - The type to retrieve.
```

--------------------------------

### Content initialization methods

Source: https://docs.rs/iced/latest/iced/widget/text_editor/struct.Content.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to create a new Content instance, either empty or with initial text.

```rust
pub fn new() -> Content<R>
```

```rust
pub fn with_text(text: &str) -> Content<R>
```

--------------------------------

### get()

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/euclid/default/type.Scale.html

Returns the underlying scalar scale factor.

```APIDOC
### pub fn get(self) -> T

Returns the underlying scalar scale factor.
```

--------------------------------

### Convert Point3D to Untyped

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/euclid/default/type.Point3D.html

Example of dropping units from a Point3D.

```rust
enum Mm {}

let point: Point3D<_, Mm> = point3(1, -8, 0);

assert_eq!(point.x, point.to_untyped().x);
assert_eq!(point.y, point.to_untyped().y);
assert_eq!(point.z, point.to_untyped().z);
```

--------------------------------

### Grid creation methods

Source: https://docs.rs/iced/latest/iced/widget/struct.Grid.html?search=u32+-%3E+bool

Methods to initialize a new Grid instance.

```rust
pub fn new() -> Grid<'a, Message, Theme, Renderer>
```

```rust
pub fn with_capacity(capacity: usize) -> Grid<'a, Message, Theme, Renderer>
```

```rust
pub fn with_children( children: impl IntoIterator<Item = Element<'a, Message, Theme, Renderer>>, ) -> Grid<'a, Message, Theme, Renderer>
```

```rust
pub fn from_vec( children: Vec<Element<'a, Message, Theme, Renderer>>, ) -> Grid<'a, Message, Theme, Renderer>
```

--------------------------------

### Builder::move_to

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/struct.Builder.html?search=std%3A%3Avec

Moves the starting point of a new sub-path.

```APIDOC
## pub fn move_to(&mut self, point: Point)

### Description
Moves the starting point of a new sub-path to the specified `Point`.
```

--------------------------------

### relative_move_to

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/builder/trait.SvgPathBuilder.html?search=u32+-%3E+bool

Starts a new sub-path using relative coordinates.

```APIDOC
## fn relative_move_to(&mut self, to: Vector2D<f32, UnknownUnit>)

### Description
Equivalent to move_to in relative coordinates. Corresponds to the SVG 'm' command.
```

--------------------------------

### close

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/builder/trait.SvgPathBuilder.html?search=u32+-%3E+bool

Closes the current sub-path by drawing a line to the start.

```APIDOC
## fn close(&mut self)

### Description
Ends the current sub-path by connecting it back to its initial point. Corresponds to the SVG 'Z' command.
```

--------------------------------

### move_to

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/builder/trait.SvgPathBuilder.html?search=u32+-%3E+bool

Starts a new sub-path at the specified absolute position.

```APIDOC
## fn move_to(&mut self, to: Point2D<f32, UnknownUnit>)

### Description
Starts a new sub-path at the given position. This corresponds to the SVG 'M' command, establishing a new initial and current point.
```

--------------------------------

### Get slice length

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayVec.html

Returns the number of elements in the slice.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### pub fn open(settings: Settings) -> (Id, Task<Id>)

Source: https://docs.rs/iced/latest/iced/window/fn.open.html

Opens a new window with the given Settings; producing the Id of the new window on completion.

```APIDOC
## iced::window::open

### Description
Opens a new window with the provided settings. This function returns a tuple containing the unique identifier (Id) for the new window and a Task that resolves to the same Id once the window is successfully opened.

### Signature
`pub fn open(settings: Settings) -> (Id, Task<Id>)`

### Parameters
- **settings** (Settings) - Required - The configuration settings for the new window.
```

--------------------------------

### IntoBoot::into_boot

Source: https://docs.rs/iced/latest/iced/application/trait.IntoBoot.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The into_boot method is used to initialize an application by returning its starting state and an associated task.

```APIDOC
## fn into_boot(self) -> (State, Task<Message>)

### Description
Turns a type into the initial state of an `Application` and provides a `Task` to be executed upon startup.

### Signature
`fn into_boot(self) -> (State, Task<Message>)`

### Returns
- **State**: The initial state of the application.
- **Task<Message>**: A task to be performed during the application boot process.
```

--------------------------------

### Boot Preset

Source: https://docs.rs/iced/latest/iced/struct.Preset.html?search=std%3A%3Avec

Executes the boot strategy to return the initial state and a Task.

```rust
pub fn boot(&self) -> (State, Task<Message>)
```

--------------------------------

### Convert Point3D to Tuple

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/euclid/default/type.Point3D.html

Example of casting a Point3D into a tuple of its components.

```rust
enum Mm {}

let point: Point3D<_, Mm> = point3(1, -8, 0);

assert_eq!(point.to_tuple(), (1, -8, 0));
```

--------------------------------

### pub fn new(name: String, palette: Palette) -> Custom

Source: https://docs.rs/iced/latest/iced/theme/struct.Custom.html

Creates a new Custom theme instance using the provided name and palette.

```APIDOC
## pub fn new(name: String, palette: Palette) -> Custom

### Description
Creates a `Custom` theme from the given `Palette`.

### Parameters
- **name** (String) - The name of the custom theme.
- **palette** (Palette) - The palette configuration to apply to the theme.
```

--------------------------------

### Convert Point3D to Array

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/euclid/default/type.Point3D.html

Example of casting a Point3D into an array of its components.

```rust
enum Mm {}

let point: Point3D<_, Mm> = point3(1, -8, 0);

assert_eq!(point.to_array(), [1, -8, 0]);
```

--------------------------------

### Create a new XlibDisplayHandle

Source: https://docs.rs/iced/latest/iced/window/raw_window_handle/struct.XlibDisplayHandle.html?search=

Demonstrates how to instantiate a new XlibDisplayHandle using the new constructor.

```rust
let display: NonNull<c_void>;
let screen;
let handle = XlibDisplayHandle::new(Some(display), screen);
```

--------------------------------

### Experimental Duration Constants

Source: https://docs.rs/iced/latest/iced/time/struct.Duration.html?search=

Examples for nightly-only experimental duration constants.

```rust
#![feature(duration_constants)]
use std::time::Duration;

assert_eq!(Duration::SECOND, Duration::from_secs(1));
```

```rust
#![feature(duration_constants)]
use std::time::Duration;

assert_eq!(Duration::MILLISECOND, Duration::from_millis(1));
```

```rust
#![feature(duration_constants)]
use std::time::Duration;

assert_eq!(Duration::MICROSECOND, Duration::from_micros(1));
```

```rust
#![feature(duration_constants)]
use std::time::Duration;

assert_eq!(Duration::NANOSECOND, Duration::from_nanos(1));
```

--------------------------------

### Create a new GbmDisplayHandle

Source: https://docs.rs/iced/latest/iced/window/raw_window_handle/struct.GbmDisplayHandle.html?search=

Example showing how to instantiate a new GbmDisplayHandle using a pointer to a GBM device.

```rust
let ptr: NonNull<c_void>;
let handle = GbmDisplayHandle::new(ptr);
```

--------------------------------

### pub fn from(&self) -> Ep

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/type.PathEvent.html?search=std%3A%3Avec

Retrieves the starting endpoint of the event.

```APIDOC
## pub fn from(&self) -> Ep

### Description
Returns the starting endpoint (Ep) of the event.
```

--------------------------------

### Check prefix with starts_with

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayVec.html

Determines if a slice starts with a specific sequence.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

--------------------------------

### pub fn application

Source: https://docs.rs/iced/latest/iced/application/fn.application.html

Creates an iced Application given its boot, update, and view logic.

```APIDOC
## pub fn application<State, Message, Theme, Renderer>

### Description
Creates an iced `Application` given its boot, update, and view logic.

### Signature
```rust
pub fn application<State, Message, Theme, Renderer>(
    boot: impl BootFn<State, Message>,
    update: impl UpdateFn<State, Message>,
    view: impl for<'a> ViewFn<'a, State, Message, Theme, Renderer>,
) -> Application<impl Program<State = State, Message = Message, Theme = Theme>>
```

### Parameters
- **boot** (impl BootFn<State, Message>) - The function used to initialize the application state.
- **update** (impl UpdateFn<State, Message>) - The function used to handle messages and update the state.
- **view** (impl for<'a> ViewFn<'a, State, Message, Theme, Renderer>) - The function used to render the user interface based on the current state.
```

--------------------------------

### Create a QRCode widget

Source: https://docs.rs/iced/latest/iced/widget/fn.qr_code.html

Demonstrates initializing a QRCode widget using data stored in a state struct.

```rust
use iced::widget::qr_code;

struct State {
   data: qr_code::Data,
}

#[derive(Debug, Clone)]
enum Message {
    // ...
}

fn view(state: &State) -> Element<'_, Message> {
    qr_code(&state.data).into()
}
```

--------------------------------

### PathCommandsBuilder::begin

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/commands/struct.PathCommandsBuilder.html?search=

Starts a new path segment at the specified endpoint.

```APIDOC
### pub fn begin(&mut self, to: EndpointId) -> EventId

Starts a path at the given EndpointId.
```

--------------------------------

### Get String capacity

Source: https://docs.rs/iced/latest/iced/widget/markdown/type.Uri.html?search=

Returns the current capacity of the String in bytes.

```rust
let s = String::with_capacity(10);

assert!(s.capacity() >= 10);
```

--------------------------------

### Get default State

Source: https://docs.rs/iced/latest/iced/widget/overlay/menu/struct.State.html

Returns the default value for the State type.

```rust
fn default() -> State
```

--------------------------------

### Content Creation and Configuration

Source: https://docs.rs/iced/latest/iced/widget/pane_grid/struct.Content.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for initializing a new Content instance and configuring its properties like title bar and style.

```rust
pub fn new( body: impl Into<Element<'a, Message, Theme, Renderer>>, ) -> Content<'a, Message, Theme, Renderer>
```

```rust
pub fn title_bar( self, title_bar: TitleBar<'a, Message, Theme, Renderer>, ) -> Content<'a, Message, Theme, Renderer>
```

```rust
pub fn style( self, style: impl Fn(&Theme) -> Style + 'a, ) -> Content<'a, Message, Theme, Renderer>
where <Theme as Catalog>::Class<'a>: From<Box<dyn Fn(&Theme) -> Style + 'a>>,
```

```rust
pub fn class( self, class: impl Into<<Theme as Catalog>::Class<'a>>, ) -> Content<'a, Message, Theme, Renderer>
```

--------------------------------

### Create a new GbmWindowHandle

Source: https://docs.rs/iced/latest/iced/window/raw_window_handle/struct.GbmWindowHandle.html

Example showing how to instantiate a new GbmWindowHandle using a pointer to a GBM surface.

```rust
let ptr: NonNull<c_void>;
let handle = GbmWindowHandle::new(ptr);
```

--------------------------------

### as_array

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayVec.html?search=std%3A%3Avec

Gets a reference to the underlying array if the length matches N.

```APIDOC
## pub fn as_array<const N: usize>(&self) -> Option<&[T; N]>

### Description
Gets a reference to the underlying array. Returns None if N is not exactly equal to the length of the slice.
```

--------------------------------

### Create a Responsive Widget

Source: https://docs.rs/iced/latest/iced/widget/struct.Responsive.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a new Responsive widget using a closure that accepts a Size parameter.

```rust
pub fn new( view: impl Fn(Size) -> Element<'a, Message, Theme, Renderer> + 'a, ) -> Responsive<'a, Message, Theme, Renderer>
```

--------------------------------

### as_mut_array

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/arrayvec/struct.ArrayVec.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a mutable reference to the slice’s underlying array.

```APIDOC
## pub fn as_mut_array<const N: usize>(&mut self) -> Option<&mut [T; N]>

### Description
Gets a mutable reference to the slice’s underlying array. Returns None if N is not equal to the length of the slice.
```

--------------------------------

### Create New String

Source: https://docs.rs/iced/latest/iced/widget/markdown/type.Uri.html?search=

Initializes an empty String.

```rust
let s = String::new();
```

--------------------------------

### Getting current system time

Source: https://docs.rs/iced/latest/iced/time/struct.SystemTime.html

Retrieves the current system time.

```rust
use std::time::SystemTime;

let sys_time = SystemTime::now();
```

--------------------------------

### Menu construction and configuration methods

Source: https://docs.rs/iced/latest/iced/overlay/menu/struct.Menu.html

Methods for creating a new Menu instance and configuring its appearance and behavior.

```rust
pub fn new( state: &'a mut State, options: &'a [T], hovered_option: &'a mut Option<usize>, on_selected: impl FnMut(T) -> Message + 'a, on_option_hovered: Option<&'a dyn Fn(T) -> Message>, class: &'a <Theme as Catalog>::Class<'b>, ) -> Menu<'a, 'b, T, Message, Theme, Renderer>
```

```rust
pub fn width(self, width: f32) -> Menu<'a, 'b, T, Message, Theme, Renderer>
```

```rust
pub fn padding<P>(self, padding: P) -> Menu<'a, 'b, T, Message, Theme, Renderer>
where P: Into<Padding>,
```

```rust
pub fn text_size( self, text_size: impl Into<Pixels>, ) -> Menu<'a, 'b, T, Message, Theme, Renderer>
```

```rust
pub fn text_line_height( self, line_height: impl Into<LineHeight>, ) -> Menu<'a, 'b, T, Message, Theme, Renderer>
```

```rust
pub fn text_shaping( self, shaping: Shaping, ) -> Menu<'a, 'b, T, Message, Theme, Renderer>
```

```rust
pub fn font( self, font: impl Into<<Renderer as Renderer>::Font>, ) -> Menu<'a, 'b, T, Message, Theme, Renderer>
```

```rust
pub fn overlay( self, position: Point, viewport: Rectangle, target_height: f32, menu_height: Length, ) -> Element<'a, Message, Theme, Renderer>
```

--------------------------------

### Creating a keyed_column

Source: https://docs.rs/iced/latest/iced/widget/fn.keyed_column.html

An example demonstrating how to initialize a keyed_column using an iterator of items.

```rust
use iced::widget::{keyed_column, text};

enum Message {
    // ...
}

fn view(state: &State) -> Element<'_, Message> {
    keyed_column((0..=100).map(|i| {
        (i, text!("Item {i}").into())
    })).into()
}
```

--------------------------------

### Grid Initialization and Configuration

Source: https://docs.rs/iced/latest/iced/widget/grid/struct.Grid.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for creating and configuring a Grid widget.

```APIDOC
## Grid Initialization

### pub fn new() -> Grid
Creates an empty Grid.

### pub fn with_capacity(capacity: usize) -> Grid
Creates a Grid with the given capacity.

### pub fn with_children(children: impl IntoIterator<Item = Element>) -> Grid
Creates a Grid with the given elements.

### pub fn from_vec(children: Vec<Element>) -> Grid
Creates a Grid from an already allocated Vec.

## Grid Configuration

### pub fn spacing(self, amount: impl Into<Pixels>) -> Grid
Sets the spacing between cells in the Grid.

### pub fn width(self, width: impl Into<Pixels>) -> Grid
Sets the width of the Grid in Pixels.

### pub fn height(self, height: impl Into<Sizing>) -> Grid
Sets the height of the Grid.

### pub fn columns(self, column: usize) -> Grid
Sets the amount of columns in the Grid.

### pub fn fluid(self, max_width: impl Into<Pixels>) -> Grid
Makes the amount of columns dynamic in the Grid, never exceeding the provided max_width.

## Adding Elements

### pub fn push(self, child: impl Into<Element>) -> Grid
Adds an Element to the Grid.

### pub fn push_maybe(self, child: Option<impl Into<Element>>) -> Grid
Adds an element to the Grid, if Some.

### pub fn extend(self, children: impl IntoIterator<Item = Element>) -> Grid
Extends the Grid with the given children.
```

--------------------------------

### Basic Box Allocation

Source: https://docs.rs/iced/latest/iced/widget/checkbox/type.StyleFn.html?search=

Example of basic Box allocation using try_new_in.

```rust
let five = Box::try_new_in(5, System)?;
```

--------------------------------

### center_x usage example

Source: https://docs.rs/iced/latest/iced/widget/fn.center_x.html

Demonstrates the equivalent usage of center_x using the container builder pattern.

```rust
let center_x = container("Horizontal Center!").center_x(Fill);
```

--------------------------------

### AttributeStore Implementation for Unit Type

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/trait.AttributeStore.html

Example implementation of AttributeStore for the unit type ().

```rust
impl AttributeStore for () {
    fn get(&self, _: EndpointId) -> &[f32] { &[] }
    fn num_attributes(&self) -> usize { 0 }
}
```

--------------------------------

### Check Translation Identity

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/euclid/default/type.Translation2D.html?search=

Examples demonstrating how to create and verify identity translations.

```rust
use euclid::default::Translation2D;

assert_eq!(Translation2D::<f32>::identity().is_identity(), true);
assert_eq!(Translation2D::new(0, 0).is_identity(), true);
assert_eq!(Translation2D::new(1, 0).is_identity(), false);
assert_eq!(Translation2D::new(0, 1).is_identity(), false);
```

--------------------------------

### Flooring Size3D Components

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/euclid/default/type.Size3D.html?search=u32+-%3E+bool

Example usage of the floor method on a Size3D instance.

```rust
enum Mm {}

assert_eq!(size3::<_, Mm>(-0.1, -0.8, 0.4).floor(), size3::<_, Mm>(-1.0, -1.0, 0.0))
```

--------------------------------

### Create Custom theme instances

Source: https://docs.rs/iced/latest/iced/theme/struct.Custom.html?search=

Methods for initializing a Custom theme using either a standard palette or a custom generator function.

```rust
pub fn new(name: String, palette: Palette) -> Custom
```

```rust
pub fn with_fn( name: impl Into<Cow<'static, str>>, palette: Palette, generate: impl FnOnce(Palette) -> Extended, ) -> Custom
```

--------------------------------

### Ceiling Size3D Components

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/euclid/default/type.Size3D.html?search=u32+-%3E+bool

Example usage of the ceil method on a Size3D instance.

```rust
enum Mm {}

assert_eq!(size3::<_, Mm>(-0.1, -0.8, 0.4).ceil(), size3::<_, Mm>(0.0, 0.0, 1.0))
```

--------------------------------

### Scaling Application Screens with Iced

Source: https://docs.rs/iced/latest/iced/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to manage multiple screens using an enum state and a central update function that handles screen transitions via custom Actions.

```rust
use contacts::Contacts;
use conversation::Conversation;

use iced::{Element, Task};

struct State {
    screen: Screen,
}

enum Screen {
    Contacts(Contacts),
    Conversation(Conversation),
}

enum Message {
   Contacts(contacts::Message),
   Conversation(conversation::Message)
}

fn update(state: &mut State, message: Message) -> Task<Message> {
    match message {
        Message::Contacts(message) => {
            if let Screen::Contacts(contacts) = &mut state.screen {
                let action = contacts.update(message);

                match action {
                    contacts::Action::None => Task::none(),
                    contacts::Action::Run(task) => task.map(Message::Contacts),
                    contacts::Action::Chat(contact) => {
                        let (conversation, task) = Conversation::new(contact);

                        state.screen = Screen::Conversation(conversation);

                        task.map(Message::Conversation)
                    }
                 }
            } else {
                Task::none()    
            }
        }
        Message::Conversation(message) => {
            if let Screen::Conversation(conversation) = &mut state.screen {
                conversation.update(message).map(Message::Conversation)
            } else {
                Task::none()    
            }
        }
    }
}

fn view(state: &State) -> Element<'_, Message> {
    match &state.screen {
        Screen::Contacts(contacts) => contacts.view().map(Message::Contacts),
        Screen::Conversation(conversation) => conversation.view().map(Message::Conversation),
    }
}
```

--------------------------------

### Implementing a PickList in Iced

Source: https://docs.rs/iced/latest/iced/widget/fn.pick_list.html?search=

A complete example demonstrating how to define state, messages, and the view function for a pick_list component.

```rust
use iced::widget::pick_list;

struct State {
   favorite: Option<Fruit>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Fruit {
    Apple,
    Orange,
    Strawberry,
    Tomato,
}

#[derive(Debug, Clone)]
enum Message {
    FruitSelected(Fruit),
}

fn view(state: &State) -> Element<'_, Message> {
    let fruits = [
        Fruit::Apple,
        Fruit::Orange,
        Fruit::Strawberry,
        Fruit::Tomato,
    ];

    pick_list(
        fruits,
        state.favorite,
        Message::FruitSelected,
    )
    .placeholder("Select your favorite fruit...")
    .into()
}

fn update(state: &mut State, message: Message) {
    match message {
        Message::FruitSelected(fruit) => {
            state.favorite = Some(fruit);
        }
    }
}

impl std::fmt::Display for Fruit {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            Self::Apple => "Apple",
            Self::Orange => "Orange",
            Self::Strawberry => "Strawberry",
            Self::Tomato => "Tomato",
        })
    }
}
```

--------------------------------

### Rounding Size3D Components

Source: https://docs.rs/iced/latest/iced/widget/canvas/path/lyon_path/geom/euclid/default/type.Size3D.html?search=u32+-%3E+bool

Example usage of the round method on a Size3D instance.

```rust
enum Mm {}

assert_eq!(size3::<_, Mm>(-0.1, -0.8, 0.4).round(), size3::<_, Mm>(0.0, -1.0, 0.0))
```
Tokens:
Raw