Egui

https://docs.rs/egui/latest/
Admin
Egui is an easy-to-use, immediate mode GUI library written in pure Rust, designed for highly...
Tokens:3,049,739
Snippets:27,407
Trust Score:9.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Quick start example with common egui widgets

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

A comprehensive example showing common egui widgets: labels, hyperlinks, text editing, buttons, sliders, drag values, checkboxes, radio buttons, separators, images, and collapsing sections. The code is wrapped in a test harness (egui::__run_test_ui) and includes hidden setup lines for variables and types.

```rust
# egui::__run_test_ui(|ui| {
# let mut my_string = String::new();
# let mut my_boolean = true;
# let mut my_f32 = 42.0;
ui.label("This is a label");
ui.hyperlink("https://github.com/emilk/egui");
ui.text_edit_singleline(&mut my_string);
if ui.button("Click me").clicked() { }
ui.add(egui::Slider::new(&mut my_f32, 0.0..=100.0));
ui.add(egui::DragValue::new(&mut my_f32));

ui.checkbox(&mut my_boolean, "Checkbox");

#[derive(PartialEq)]
enum Enum { First, Second, Third }
# let mut my_enum = Enum::First;
ui.horizontal(|ui| {
    ui.radio_value(&mut my_enum, Enum::First, "First");
    ui.radio_value(&mut my_enum, Enum::Second, "Second");
    ui.radio_value(&mut my_enum, Enum::Third, "Third");
});

ui.separator();

# let my_image = egui::TextureId::default();
ui.image((my_image, egui::Vec2::new(640.0, 480.0)));

ui.collapsing("Click to see what is hidden!", |ui| {
    ui.label("Not much, as it turns out");
});
# });
```

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

### Minimal egui application setup

Source: https://docs.rs/egui/latest/src/egui/lib.rs.html?search=

Shows the minimal egui application structure: create the context, run the UI closure, handle platform output, tessellate shapes, and paint. The example is from the crate-level documentation and is meant to be used as a starting point for integrating egui into a custom application.

```rust
//! ```
//! # egui::__run_test_ui(|ui| {
//! ui.label("Hello world!");
//! if ui.button("Click me").clicked() {
//!     // take some action here
//! }
//! # });
//! # }
//! ```
```

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

### Common egui widgets quick start

Source: https://docs.rs/egui/latest/egui/index.html

Quick-start examples of common egui widgets: label, hyperlink, text edit, button, slider, drag value, checkbox, radio buttons, separator, image, and collapsing section. Use these to get familiar with the immediate-mode API.

```rust
ui.label("This is a label");
ui.hyperlink("https://github.com/emilk/egui");
ui.text_edit_singleline(&mut my_string);
if ui.button("Click me").clicked() { }
ui.add(egui::Slider::new(&mut my_f32, 0.0..=100.0));
ui.add(egui::DragValue::new(&mut my_f32));

ui.checkbox(&mut my_boolean, "Checkbox");

#[derive(PartialEq)]
enum Enum { First, Second, Third }
ui.horizontal(|ui| {
    ui.radio_value(&mut my_enum, Enum::First, "First");
    ui.radio_value(&mut my_enum, Enum::Second, "Second");
    ui.radio_value(&mut my_enum, Enum::Third, "Third");
});

ui.separator();

ui.image((my_image, egui::Vec2::new(640.0, 480.0)));

ui.collapsing("Click to see what is hidden!", |ui| {
    ui.label("Not much, as it turns out");
});

```

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

### Initialize egui Context for debug painter example

Source: https://docs.rs/egui/latest/src/egui/context.rs.html?search=std%3A%3Avec

Example setup for using `debug_painter` or similar context methods; creates a default `egui::Context` and a boolean state variable.

```rust
# let ctx = egui::Context::default();
# let state = true;
```

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

### run_ui example with full_output handling

Source: https://docs.rs/egui/latest/src/egui/context.rs.html

Example usage of Context::run_ui, showing how to create a Ui and handle the returned FullOutput by dropping it without applying deltas.

```rust
///     ui.label("Hello egui!");
/// });
/// // handle full_output
/// # full_output.drop_without_applying_deltas();
/// ```
```

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

### Range::is_empty examples

Source: https://docs.rs/egui/latest/egui/text/type.ByteRange.html?search=

Examples for the is_empty method on Range, showing that a range is empty when start >= end.

```rust
assert!(!(3..5).is_empty());
assert!( (3..3).is_empty());
assert!( (3..2).is_empty());
```

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

### link example

Source: https://docs.rs/egui/latest/egui/struct.Ui.html

Shows how to create a hyperlink-like button and handle clicks.

```rust
if ui.link("Documentation").clicked() {
    // …
}
```

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

### Basic Grid usage example

Source: https://docs.rs/egui/latest/egui/struct.Grid.html?search=

Shows how to create and populate a Grid with rows and columns using egui::Grid::new and ui.end_row(). Demonstrates grouping multiple widgets in one cell with ui.horizontal.

```rust
egui::Grid::new("some_unique_id").show(ui, |ui| {
    ui.label("First row, first column");
    ui.label("First row, second column");
    ui.end_row();

    ui.label("Second row, first column");
    ui.label("Second row, second column");
    ui.label("Second row, third column");
    ui.end_row();

    ui.horizontal(|ui| { ui.label("Same"); ui.label("cell"); });
    ui.label("Third row, second column");
    ui.end_row();
});
```

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

### BTreeMap::len() example

Source: https://docs.rs/egui/latest/egui/viewport/type.OrderedViewportIdMap.html

Example for BTreeMap::len() showing how to get the number of elements. The example asserts the length is 0 initially and 1 after inserting one entry.

```rust
use std::collections::BTreeMap;

let mut a = BTreeMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);
```

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

### BTreeMap::entry example

Source: https://docs.rs/egui/latest/egui/viewport/type.OrderedViewportIdMap.html

Gets the given key's corresponding entry in the map for in-place manipulation. The example counts occurrences of letters in a vector.

```rust
use std::collections::BTreeMap;

let mut count: BTreeMap<&str, usize> = BTreeMap::new();

// count the number of occurrences of letters in the vec
for x in ["a", "b", "a", "c", "a", "b"] {
    count.entry(x).and_modify(|curr| *curr += 1).or_insert(1);
}

assert_eq!(count["a"], 3);
assert_eq!(count["b"], 2);
assert_eq!(count["c"], 1);
```

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

### Window struct definition with usage example

Source: https://docs.rs/egui/latest/src/egui/containers/window.rs.html

Documentation and struct definition for the Window builder. Includes a usage example showing egui::Window::new("My Window").show(ctx, |ui| { ui.label("Hello World!"); }); and notes that it is not a native OS window.

```rust
/// Builder for a floating window which can be dragged, closed, collapsed, resized and scrolled (off by default).
///
/// You can customize:
/// * title
/// * default, minimum, maximum and/or fixed size, collapsed/expanded
/// * if the window has a scroll area (off by default)
/// * if the window can be collapsed (minimized) to just the title bar (yes, by default)
/// * if there should be a close button (none by default)
///
/// ```
/// # egui::__run_test_ctx(|ctx| {
/// egui::Window::new("My Window").show(ctx, |ui| {
///    ui.label("Hello World!");
/// });
/// # });
/// ```
///
/// The previous rectangle used by this window can be obtained through [`crate::Memory::area_rect()`].
///
/// Note that this is NOT a native OS window.
/// To create a new native OS window, use [`crate::Context::show_viewport_deferred`].
#[must_use = "You should call .show()"]
pub struct Window<'a> {
    title: Atoms<'a>,
    open: Option<&'a mut bool>,
    area: Area,
    frame: Option<Frame>,
    title_frame: Option<Frame>,
    resize: Resize,
    scroll: ScrollArea,
    collapsible: bool,
    default_open: bool,
    with_title_bar: bool,
    fade_out: bool,
    auto_sized: bool,
    drag_area: WindowDrag,
}
```

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

### Widget usage examples

Source: https://docs.rs/egui/latest/src/egui/widgets/mod.rs.html?search=std%3A%3Avec

Shows how to add widgets to a UI using `ui.add` and handle button clicks.

```rust
ui.add(Label::new("Text").text_color(color::red));
```

```rust
if ui.add(Button::new("Click me")).clicked() { … }
```

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

### BTreeMap::range example

Source: https://docs.rs/egui/latest/egui/viewport/type.OrderedViewportIdMap.html

Constructs a double-ended iterator over a sub-range of elements. Panics if range start > end, or if start == end and both bounds are Excluded.

```rust
use std::collections::BTreeMap;
use std::ops::Bound::Included;

let mut map = BTreeMap::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");
for (&key, &value) in map.range((Included(&4), Included(&8))) {
    println!("{key}: {value}");
}
assert_eq!(Some((&5, &"b")), map.range(4..).next());
```

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

### Quick start: common egui widgets

Source: https://docs.rs/egui/latest/egui/index.html?search=std%3A%3Avec

Quick-start examples of common egui widgets: label, hyperlink, text edit, button, slider, drag value, checkbox, radio buttons, separator, image, and collapsing section. Assumes variables like my_string, my_f32, my_boolean, my_enum, and my_image are already defined.

```rust
ui.label("This is a label");
ui.hyperlink("https://github.com/emilk/egui");
ui.text_edit_singleline(&mut my_string);
if ui.button("Click me").clicked() { }
ui.add(egui::Slider::new(&mut my_f32, 0.0..=100.0));
ui.add(egui::DragValue::new(&mut my_f32));

ui.checkbox(&mut my_boolean, "Checkbox");

#[derive(PartialEq)]
enum Enum { First, Second, Third }
ui.horizontal(|ui| {
    ui.radio_value(&mut my_enum, Enum::First, "First");
    ui.radio_value(&mut my_enum, Enum::Second, "Second");
    ui.radio_value(&mut my_enum, Enum::Third, "Third");
});

ui.separator();

ui.image((my_image, egui::Vec2::new(640.0, 480.0)));

ui.collapsing("Click to see what is hidden!", |ui| {
    ui.label("Not much, as it turns out");
});
```

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

### BTreeMap::range_mut example

Source: https://docs.rs/egui/latest/egui/viewport/type.OrderedViewportIdMap.html

Constructs a mutable double-ended iterator over a sub-range of elements. Panics if range start > end, or if start == end and both bounds are Excluded.

```rust
use std::collections::BTreeMap;

let mut map: BTreeMap<&str, i32> =
    [("Alice", 0), ("Bob", 0), ("Carol", 0), ("Cheryl", 0)].into();
for (_, balance) in map.range_mut("B".."Cheryl") {
    *balance += 100;
}
for (name, balance) in &map {
    println!("{name} => {balance}");
}
```

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

### substr_range example

Source: https://docs.rs/egui/latest/egui/struct.Galley.html?search=

Uses substr_range with split to get the byte ranges of each substring.

```rust
use core::range::Range;

let data = "a, b, b, a";
let mut iter = data.split(", ").map(|s| data.substr_range(s).unwrap());

assert_eq!(iter.next(), Some(Range { start: 0, end: 1 }));
assert_eq!(iter.next(), Some(Range { start: 3, end: 4 }));
assert_eq!(iter.next(), Some(Range { start: 6, end: 7 }));
assert_eq!(iter.next(), Some(Range { start: 9, end: 10 }));
```

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

### Ui usage example with add, label, and horizontal

Source: https://docs.rs/egui/latest/src/egui/ui.rs.html

Shows how to create a Ui and add widgets: a label, a shorthand label, and a horizontal row with a label and button. The example is wrapped in egui::__run_test_ui for testing.

```rust
# egui::__run_test_ui(|ui| {
ui.add(egui::Label::new("Hello World!"));
ui.label("A shorter and more convenient way to add a label.");
ui.horizontal(|ui| {
    ui.label("Add widgets");
    if ui.button("on the same row!").clicked() {
        /* … */
    }
});
});
```

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

### button example

Source: https://docs.rs/egui/latest/egui/struct.Ui.html

Shows how to create buttons with plain text and with RichText styling, and handle clicks.

```rust
if ui.button("Click me!").clicked() {
    // …
}

if ui.button(RichText::new("delete").color(Color32::RED)).clicked() {
    // …
}
```

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

### total_drag_delta()

Source: https://docs.rs/egui/latest/egui/struct.AtomLayoutResponse.html

Method to get the total drag delta since the start of the drag.

```APIDOC
## total_drag_delta()

### Description
Returns how many points the widget has been dragged since the start of the drag, if dragged.

### Method
total_drag_delta

### Signature
pub fn total_drag_delta(&self) -> Option<Vec2>

### Returns
- **Option<Vec2>** - The total drag delta in points since the start of the drag, or None if not dragged.
```

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

### BTreeMap::lower_bound() example (nightly)

Source: https://docs.rs/egui/latest/egui/viewport/type.OrderedViewportIdMap.html

Example for BTreeMap::lower_bound() showing how to get a cursor at the gap before the smallest key greater than the given bound. This is a nightly-only experimental API (btree_cursors). The example demonstrates Included, Excluded, and Unbounded bounds.

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

use std::collections::BTreeMap;
use std::ops::Bound;

let map = BTreeMap::from([
    (1, "a"),
    (2, "b"),
    (3, "c"),
    (4, "d"),
]);

let cursor = map.lower_bound(Bound::Included(&2));
assert_eq!(cursor.peek_prev(), Some((&1, &"a")));
assert_eq!(cursor.peek_next(), Some((&2, &"b")));

let cursor = map.lower_bound(Bound::Excluded(&2));
assert_eq!(cursor.peek_prev(), Some((&2, &"b")));
assert_eq!(cursor.peek_next(), Some((&3, &"c")));

let cursor = map.lower_bound(Bound::Unbounded);
assert_eq!(cursor.peek_prev(), None);
assert_eq!(cursor.peek_next(), Some((&1, &"a")));
```

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

### RichText creation example

Source: https://docs.rs/egui/latest/egui/widget_text/struct.RichText.html?search=u32+-%3E+bool

Shows how to create RichText instances with various style options. The example uses the builder methods color, size, and underline.

```rust
use egui::{RichText, Color32};

RichText::new("Plain");
RichText::new("colored").color(Color32::RED);
RichText::new("Large and underlined").size(20.0).underline();
```

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

### Arc::try_unwrap example

Source: https://docs.rs/egui/latest/egui/plugin/type.ContextCallback.html

Shows how to use Arc::try_unwrap to get the inner value when there is exactly one strong reference, and to get an Err when there are multiple strong references.

```rust
use std::sync::Arc;

let x = Arc::new(3);
assert_eq!(Arc::try_unwrap(x), Ok(3));

let x = Arc::new(4);
let _y = Arc::clone(&x);
assert_eq!(*Arc::try_unwrap(x).unwrap_err(), 4);
```

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

### as_rchunks_mut example

Source: https://docs.rs/egui/latest/egui/struct.AllocatedAtomLayout.html

Splits a mutable slice into N-element arrays starting from the end, returning a remainder slice. The example modifies the remainder and each chunk. Panics if N is zero.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

let (remainder, chunks) = v.as_rchunks_mut();
remainder[0] = 9;
for chunk in chunks {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[9, 1, 1, 2, 2]);
```

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

### hyperlink_to example

Source: https://docs.rs/egui/latest/egui/struct.Ui.html

Shows how to create a hyperlink with custom label and URL.

```rust
ui.hyperlink_to("egui on GitHub", "https://www.github.com/emilk/egui/");
```

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

### as_chunks_mut example

Source: https://docs.rs/egui/latest/egui/struct.AllocatedAtomLayout.html

Splits a mutable slice into N-element arrays starting from the beginning, returning a remainder slice. The example modifies the remainder and each chunk. Panics if N is zero.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

let (chunks, remainder) = v.as_chunks_mut();
remainder[0] = 9;
for chunk in chunks {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 9]);
```

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

### parse::<F> examples: basic, turbofish, failing

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

Three examples: basic parse with type annotation, turbofish syntax without annotation, and a failing parse returning Result::Err.

```rust
let four: u32 = "4".parse().unwrap();

assert_eq!(4, four);
```

```rust
let four = "4".parse::<u32>();

assert_eq!(Ok(4), four);
```

```rust
let nope = "j".parse::<u32>();

assert!(nope.is_err());
```

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

### len example

Source: https://docs.rs/egui/latest/egui/load/enum.Bytes.html?search=u32+-%3E+bool

Shows how to use the `len` method to get the number of elements in a slice.

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

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

### egui viewport module documentation and example

Source: https://docs.rs/egui/latest/src/egui/viewport.rs.html

Module-level documentation for egui viewports, covering viewport classes (root, deferred, immediate, embedded), usage patterns, and integration notes. Includes a code example showing how to access the current viewport and all viewports via `ctx.input`.

```rust
//! egui supports multiple viewports, corresponding to multiple native windows.
//!
//! Not all egui backends support multiple viewports, but `eframe` native does
//! (but not on web).
//!
//! You can spawn a new viewport using [`Context::show_viewport_deferred`] and [`Context::show_viewport_immediate`].
//! These needs to be called every frame the viewport should be visible.
//!
//! This is implemented by the native `eframe` backend, but not the web one.
//!
//! ## Viewport classes
//! The viewports form a tree of parent-child relationships.
//!
//! There are different classes of viewports.
//!
//! ### Root viewport
//! The root viewport is the original viewport, and cannot be closed without closing the application.
//!
//! ### Deferred viewports
//! These are created with [`Context::show_viewport_deferred`].
//! Deferred viewports take a closure that is called by the integration at a later time, perhaps multiple times.
//! Deferred viewports are repainted independently of the parent viewport.
//! This means communication with them needs to be done via channels, or `Arc/Mutex`.
//!
//! This is the most performant type of child viewport, though a bit more cumbersome to work with compared to immediate viewports.
//!
//! ### Immediate viewports
//! These are created with [`Context::show_viewport_immediate`].
//! Immediate viewports take a `FnOnce` closure, similar to other egui functions, and is called immediately.
//! This makes communication with them much simpler than with deferred viewports, but this simplicity comes at a cost: whenever the parent viewports needs to be repainted, so will the child viewport, and vice versa.
//! This means that if you have `N` viewports you are potentially doing `N` times as much CPU work. However, if all your viewports are showing animations, and thus are repainting constantly anyway, this doesn't matter.
//!
//! In short: immediate viewports are simpler to use, but can waste a lot of CPU time.
//!
//! ### Embedded viewports
//! These are not real, independent viewports, but is a fallback mode for when the integration does not support real viewports.
//! In your callback is called with [`ViewportClass::EmbeddedWindow`] it means the viewport is embedded inside of
//! a regular [`crate::Window`], trapped in the parent viewport.
//!
//!
//! ## Using the viewports
//! Only one viewport is active at any one time, identified with [`Context::viewport_id`].
//! You can modify the current (change the title, resize the window, etc) by sending
//! a [`ViewportCommand`] to it using [`Context::send_viewport_cmd`].
//! You can interact with other viewports using [`Context::send_viewport_cmd_to`].
//!
//! There is an example in <https://github.com/emilk/egui/tree/main/examples/multiple_viewports/src/main.rs>.
//!
//! You can find all available viewports in [`crate::RawInput::viewports`] and the active viewport in
//! [`crate::InputState::viewport`]:
//!
//! ```no_run
//! # let ctx = &egui::Context::default();
//! ctx.input(|i| {
//!     dbg!(&i.viewport()); // Current viewport
//!     dbg!(&i.raw.viewports); // All viewports
//! });
//! ```
//!
//! ## For integrations
//! * There is a [`crate::InputState::viewport`] with information about the current viewport.
//! * There is a [`crate::RawInput::viewports`] with information about all viewports.
//! * The repaint callback set by [`Context::set_request_repaint_callback`] points to which viewport should be repainted.
//! * [`crate::FullOutput::viewport_output`] is a list of viewports which should result in their own independent windows.
//! * To support immediate viewports you need to call [`Context::set_immediate_viewport_renderer`].
//! * If you support viewports, you need to call [`Context::set_embed_viewports`] with `false`, or all new viewports will be embedded (the default behavior).
//!
//! ## Future work
//! There are several more things related to viewports that we want to add.
//! Read more at <https://github.com/emilk/egui/issues/3556>.

use std::sync::Arc;

use crate::{AsId, Context, Id, Ui};
use epaint::{Pos2, Vec2};

// ----------------------------------------------------------------------------

/// The different types of viewports supported by egui.
#[derive(Clone, Copy, Default, Hash, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
pub enum ViewportClass {
    /// The root viewport; i.e. the original window.
    #[default]
    Root,

    /// A viewport run independently from the parent viewport.
    ///
    /// This is the preferred type of viewport from a performance perspective.
    ///

```

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

### FontDefinitions

Source: https://docs.rs/egui/latest/egui/struct.FontDefinitions.html

Documentation for the FontDefinitions struct, including its fields and a usage example for installing custom fonts.

```APIDOC
## Struct FontDefinitions

### Description
Describes the font data and the sizes to use. Often you would start with `FontDefinitions::default()` and then add/change the contents.

### Fields
- **font_data** (`BTreeMap<String, Arc<FontData>>`) - List of font names and their definitions. `epaint` has built-in-default for these, but you can override them if you like.
- **families** (`BTreeMap<FontFamily, Vec<String>>`) - Which fonts (names) to use for each `FontFamily`. The list should be a list of keys into `Self::font_data`. When looking for a character glyph `epaint` will start with the first font and then move to the second, and so on. So the first font is the primary, and then comes a list of fallbacks in order of priority.

### Usage Example
```rust
let mut fonts = FontDefinitions::default();

// Install my own font (maybe supporting non-latin characters):
fonts.font_data.insert("my_font".to_owned(),
   std::sync::Arc::new(
       // .ttf and .otf supported
       FontData::from_static(include_bytes!("../../../epaint_default_fonts/fonts/Ubuntu-Light.ttf"))
   )
);

// Put my font first (highest priority):
fonts.families.get_mut(&FontFamily::Proportional).unwrap()
    .insert(0, "my_font".to_owned());

// Put my font as last fallback for monospace:
fonts.families.get_mut(&FontFamily::Monospace).unwrap()
    .push("my_font".to_owned());

egui_ctx.set_fonts(fonts);
```
```

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

### egui library documentation and integration example

Source: https://docs.rs/egui/latest/src/egui/lib.rs.html

The complete source of the egui library documentation page, including the module-level doc comment, feature flags, usage examples, and integration notes. It shows the required Rust version (1.95.0), the basic structure for integrating egui with a custom backend, and the coordinate system details.

```rust
//! `egui`:  an easy-to-use GUI in pure Rust!
//!
//! Try the live web demo: <https://www.egui.rs/#demo>. Read more about egui at <https://github.com/emilk/egui>.
//!
//! `egui` is in heavy development, with each new version having breaking changes.
//! You need to have rust 1.95.0 or later to use `egui`.
//!
//! To quickly get started with egui, you can take a look at [`eframe_template`](https://github.com/emilk/eframe_template)
//! which uses [`eframe`](https://docs.rs/eframe).
//!
//! To create a GUI using egui you first need a [`Context`] (by convention referred to by `ctx`).
//! Then you add a [`Window`] or a [`Panel`] to get a [`Ui`], which is what you'll be using to add all the buttons and labels that you need.
//!
//!
//! ## Feature flags
#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
//!
//!
//! # Using egui
//!
//! To see what is possible to build with egui you can check out the online demo at <https://www.egui.rs/#demo>.
//!
//! If you like the "learning by doing" approach, clone <https://github.com/emilk/eframe_template> and get started using egui right away.
//!
//! ### A simple example
//!
//! Here is a simple counter that can be incremented and decremented using two buttons:
//! ```
//! fn ui_counter(ui: &mut egui::Ui, counter: &mut i32) {
//!     // Put the buttons and label on the same row:
//!     ui.horizontal(|ui| {
//!         if ui.button("−").clicked() {
//!             *counter -= 1;
//!         }
//!         ui.label(counter.to_string());
//!         if ui.button("+").clicked() {
//!             *counter += 1;
//!         }
//!     });
//! }
//! ```
//!
//! In some GUI frameworks this would require defining multiple types and functions with callbacks or message handlers,
//! but thanks to `egui` being immediate mode everything is one self-contained function!
//!
//! ### Quick start
//!
//! ```
//! # egui::__run_test_ui(|ui| {
//! # let mut my_string = String::new();
//! # let mut my_boolean = true;
//! # let mut my_f32 = 42.0;
//! ui.label("This is a label");
//! ui.hyperlink("https://github.com/emilk/egui");
//! ui.text_edit_singleline(&mut my_string);
//! if ui.button("Click me").clicked() { }
//! ui.add(egui::Slider::new(&mut my_f32, 0.0..=100.0));
//! ui.add(egui::DragValue::new(&mut my_f32));
//!
//! ui.checkbox(&mut my_boolean, "Checkbox");
//!
//! #[derive(PartialEq)]
//! enum Enum { First, Second, Third }
//! # let mut my_enum = Enum::First;
//! ui.horizontal(|ui| {
//!     ui.radio_value(&mut my_enum, Enum::First, "First");
//!     ui.radio_value(&mut my_enum, Enum::Second, "Second");
//!     ui.radio_value(&mut my_enum, Enum::Third, "Third");
//! });
//!
//! ui.separator();
//!
//! # let my_image = egui::TextureId::default();
//! ui.image((my_image, egui::Vec2::new(640.0, 480.0)));
//!
//! ui.collapsing("Click to see what is hidden!", |ui| {
//!     ui.label("Not much, as it turns out");
//! });
//! # });
//! ```
//!
//! ## Viewports
//! Some egui backends support multiple _viewports_, which is what egui calls the native OS windows it resides in.
//! See [`crate::viewport`] for more information.
//!
//! ## Coordinate system
//! The left-top corner of the screen is `(0.0, 0.0)`,
//! with X increasing to the right and Y increasing downwards.
//!
//! `egui` uses logical _points_ as its coordinate system.
//! Those related to physical _pixels_ by the `pixels_per_point` scale factor.
//! For example, a high-dpi screen can have `pixels_per_point = 2.0`,
//! meaning there are two physical screen pixels for each logical point.
//!
//! Angles are in radians, and are measured clockwise from the X-axis, which has angle=0.
//!
//! # Integrating with egui
//!
//! Most likely you are using an existing `egui` backend/integration such as [`eframe`](https://docs.rs/eframe), [`bevy_egui`](https://docs.rs/bevy_egui),
//! or [`egui-miniquad`](https://github.com/not-fl3/egui-miniquad),
//! but if you want to integrate `egui` into a new game engine or graphics backend, this is the section for you.
//!
//! You need to collect [`RawInput`] and handle [`FullOutput`]. The basic structure is this:
//!
//! ``` no_run
//! # fn handle_platform_output(_: egui::PlatformOutput) {}
//! # fn gather_input() -> egui::RawInput { egui::RawInput::default() }
//! # fn paint(textures_delta: egui::TexturesDelta, _: Vec<egui::ClippedPrimitive>) {}
//! let mut ctx = egui::Context::default();
//!
//! // Game loop:
//! loop {
//!     let raw_input: egui::RawInput = gather_input();
//!
//!     let full_output = ctx.run_ui(raw_input, |ui| {
```

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

### MenuBar example with File menu

Source: https://docs.rs/egui/latest/src/egui/containers/menu.rs.html?search=

Example usage of `egui::MenuBar` with a menu button that sends a close command when clicked. The `#` lines are hidden in documentation but are part of the test harness.

```rust
# egui::__run_test_ui(|ui| {
 egui::MenuBar::new().ui(ui, |ui| {
     ui.menu_button("File", |ui| {
         if ui.button("Quit").clicked() {
             ui.send_viewport_cmd(egui::ViewportCommand::Close);
         }
     });
 });
# });
```

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

### strip_prefix example

Source: https://docs.rs/egui/latest/egui/load/enum.Bytes.html?search=u32+-%3E+bool

Demonstrates the `strip_prefix` method on slices. It returns `Some` with the subslice after the prefix if the slice starts with the prefix, otherwise `None`. The example includes cases with empty prefix, full match, and no match.

```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```

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

### Use `InnerResponse` to get inner result and response

Source: https://docs.rs/egui/latest/src/egui/response.rs.html

Shows how to use `InnerResponse` to get both the inner result of a closure and the response of the wrapping UI area. The example uses `ui.horizontal` and accesses `inner_resp.response` and `inner_resp.inner`.

```rust
# egui::__run_test_ui(|ui| {
let inner_resp = ui.horizontal(|ui| {
    ui.label("Blah blah");
    42
});
inner_resp.response.on_hover_text("You hovered the horizontal layout");
assert_eq!(inner_resp.inner, 42);
# });
```

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

### hyperlink example

Source: https://docs.rs/egui/latest/egui/struct.Ui.html

Shows how to link to a web page using a URL.

```rust
ui.hyperlink("https://www.egui.rs/");
```

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

### egui::debug_text::print usage example

Source: https://docs.rs/egui/latest/src/egui/debug_text.rs.html?search=

Shows how to call `egui::debug_text::print` to display debug text. The example is a doc test with hidden setup lines. The function only works when compiled with `debug_assertions`.

```rust
/// ```
/// # let ctx = &egui::Context::default();
/// # let state = true;
/// egui::debug_text::print(ctx, format!("State: {state:?}"));
/// ```
```

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

### ComboBox usage example

Source: https://docs.rs/egui/latest/src/egui/containers/combo_box.rs.html?search=std%3A%3Avec

Documentation example for the ComboBox type. Shows how to create a combo box with a label, display the selected text, and handle selection changes by comparing the value before and after showing the UI.

```rust
/// A drop-down selection menu with a descriptive label.
///
/// ```
/// # egui::__run_test_ui(|ui| {
/// # #[derive(Debug, PartialEq, Copy, Clone)]
/// # enum Enum { First, Second, Third }
/// # let mut selected = Enum::First;
/// let before = selected;
/// egui::ComboBox::from_label("Select one!")
///     .selected_text(format!("{:?}", selected))
///     .show_ui(ui, |ui| {
///         ui.selectable_value(&mut selected, Enum::First, "First");
///         ui.selectable_value(&mut selected, Enum::Second, "Second");
///         ui.selectable_value(&mut selected, Enum::Third, "Third");
///     }
/// );
///
/// if selected != before {
///     // Handle selection change
/// }
/// # });
/// ```
```

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

### as_simd example

Source: https://docs.rs/egui/latest/egui/struct.AllocatedAtomLayout.html

Demonstrates splitting a slice into SIMD-aligned parts and computing a sum.

```rust
#![feature(portable_simd)]
use core::simd::prelude::*;

let short = &[1, 2, 3];
let (prefix, middle, suffix) = short.as_simd::<4>();
assert_eq!(middle, []); // Not enough elements for anything in the middle

// They might be split in any possible way between prefix and suffix
let it = prefix.iter().chain(suffix).copied();
assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);

fn basic_simd_sum(x: &[f32]) -> f32 {
    use std::ops::Add;
    let (prefix, middle, suffix) = x.as_simd();
    let sums = f32x4::from_array([
        prefix.iter().copied().sum(),
        0.0,
        0.0,
        suffix.iter().copied().sum(),
    ]);
    let sums = middle.iter().copied().fold(sums, f32x4::add);
    sums.reduce_sum()
}
```

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

### as_mut_ptr example

Source: https://docs.rs/egui/latest/egui/struct.AllocatedAtomLayout.html

Shows how to get a mutable raw pointer to the slice's buffer and modify elements through it.

```rust
let x = &mut [1, 2, 4];
let x_ptr = x.as_mut_ptr();

unsafe {
    for i in 0..x.len() {
        *x_ptr.add(i) += 2;
    }
}
assert_eq!(x, &[3, 4, 6]);
```

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

### get example

Source: https://docs.rs/egui/latest/egui/load/enum.Bytes.html?search=u32+-%3E+bool

Returns a reference to an element or subslice depending on the index type. Returns None if out of bounds.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

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

### windows example

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

Demonstrates `windows` returning overlapping contiguous windows of length `size`. Panics if `size` is zero; returns no values if the slice is shorter than `size`.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.windows(3);
assert_eq!(iter.next().unwrap(), &['l', 'o', 'r']);
assert_eq!(iter.next().unwrap(), &['o', 'r', 'e']);
assert_eq!(iter.next().unwrap(), &['r', 'e', 'm']);
assert!(iter.next().is_none());
```

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

### Button usage example

Source: https://docs.rs/egui/latest/src/egui/widgets/button.rs.html

Documentation example for the Button widget showing how to create a clickable button and a disabled button using ui.add and ui.add_enabled.

```rust
/// Clickable button with text.
///
/// See also [`Ui::button`].
///
/// ```
/// # egui::__run_test_ui(|ui| {
/// # fn do_stuff() {}
///
/// if ui.add(egui::Button::new("Click me")).clicked() {
///     do_stuff();
/// }
///
/// // A greyed-out and non-interactive button:
/// if ui.add_enabled(false, egui::Button::new("Can't click this")).clicked() {
///     unreachable!();
/// }
/// # });
/// ```
```

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

### starts_with example

Source: https://docs.rs/egui/latest/egui/load/enum.Bytes.html

Checks if the slice starts with the given prefix. Returns `true` if the needle is a prefix or equal to the slice.

```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]));

```

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

### strip_circumfix example

Source: https://docs.rs/egui/latest/egui/load/enum.Bytes.html?search=u32+-%3E+bool

Demonstrates the `strip_circumfix` method on slices. It returns `Some` with the subslice after the prefix and before the suffix if the slice starts with the prefix, ends with the suffix, and they don't overlap; otherwise `None`. The example includes cases with empty prefix/suffix and overlapping prefix/suffix.

```rust
let v = &[10, 50, 40, 30];
assert_eq!(v.strip_circumfix(&[10], &[30]), Some(&[50, 40][..]));
assert_eq!(v.strip_circumfix(&[10], &[40, 30]), Some(&[50][..]));
assert_eq!(v.strip_circumfix(&[10, 50], &[40, 30]), Some(&[][..]));
assert_eq!(v.strip_circumfix(&[50], &[30]), None);
assert_eq!(v.strip_circumfix(&[10], &[40]), None);
assert_eq!(v.strip_circumfix(&[], &[40, 30]), Some(&[10, 50][..]));
assert_eq!(v.strip_circumfix(&[10, 50], &[]), Some(&[40, 30][..]));
assert_eq!(v.strip_circumfix(&[10, 50, 40], &[50, 40, 30]), None);
```

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

### Creating a clickable link with ui.link and egui::Link::new

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

Shows two equivalent ways to create a clickable link in egui: using `ui.link` and using `egui::Link::new` with `ui.add`. Both return a `Response` that can be checked with `.clicked()`.

```rust
// These are equivalent:
if ui.link("Documentation").clicked() {
    // …
}

if ui.add(egui::Link::new("Documentation")).clicked() {
    // …
}
```

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

### Minimal egui application loop

Source: https://docs.rs/egui/latest/src/egui/lib.rs.html

Shows the core loop of an egui application: create the context, run the UI, handle platform output, tessellate shapes, and paint. This is the minimal setup required to render a UI with egui.

```rust
//!         egui::CentralPanel::default().show(ui, |ui| {
//!             ui.label("Hello world!");
//!             if ui.button("Click me").clicked() {
//!                 // take some action here
//!             }
//!         });
//!     });
//!     handle_platform_output(full_output.platform_output);
//!     let clipped_primitives = ctx.tessellate(full_output.shapes, full_output.pixels_per_point);
//!     paint(full_output.textures_delta, clipped_primitives);
//! }
```
Tokens:
Raw