Struct egui::Ui

source ·
pub struct Ui {
    id: Id,
    next_auto_id_source: u64,
    painter: Painter,
    style: Arc<Style>,
    placer: Placer,
    enabled: bool,
    menu_state: Option<Arc<RwLock<MenuState>>>,
}
Expand description

This is what you use to place widgets.

Represents a region of the screen with a type of layout (horizontal or vertical).

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() {
        /* … */
    }
});

Fields§

§id: Id

ID of this ui. Generated based on id of parent ui together with another source of child identity (e.g. window title). Acts like a namespace for child uis. Should be unique and persist predictably from one frame to next so it can be used as a source for storing state (e.g. window position, or if a collapsing header is open).

§next_auto_id_source: u64

This is used to create a unique interact ID for some widgets. This value is based on where in the hierarchy of widgets this Ui is in, and the value is increment with each added child widget. This works as an Id source only as long as new widgets aren’t added or removed. They are therefore only good for Id:s that has no state.

§painter: Painter

Specifies paint layer, clip rectangle and a reference to Context.

§style: Arc<Style>

The Style (visuals, spacing, etc) of this ui. Commonly many Ui:s share the same Style. The Ui implements copy-on-write for this.

§placer: Placer

Handles the Ui size and the placement of new widgets.

§enabled: bool

If false we are unresponsive to input, and all widgets will assume a gray style.

§menu_state: Option<Arc<RwLock<MenuState>>>

Indicates whether this Ui belongs to a Menu.

Implementations§

source§

impl Ui

source

pub fn new( ctx: Context, layer_id: LayerId, id: Id, max_rect: Rect, clip_rect: Rect ) -> Self

Create a new Ui.

Normally you would not use this directly, but instead use SidePanel, TopBottomPanel, CentralPanel, Window or Area.

source

pub fn child_ui(&mut self, max_rect: Rect, layout: Layout) -> Self

Create a new Ui at a specific region.

source

pub fn child_ui_with_id_source( &mut self, max_rect: Rect, layout: Layout, id_source: impl Hash ) -> Self

Create a new Ui at a specific region with a specific id.

source

pub fn id(&self) -> Id

A unique identity of this Ui.

source

pub fn style(&self) -> &Arc<Style>

Style options for this Ui and its children.

Note that this may be a different Style than that of Context::style.

source

pub fn style_mut(&mut self) -> &mut Style

Mutably borrow internal Style. Changes apply to this Ui and its subsequent children.

To set the style of all Ui:s, use Context::set_style.

Example:

ui.style_mut().override_text_style = Some(egui::TextStyle::Heading);
source

pub fn set_style(&mut self, style: impl Into<Arc<Style>>)

Changes apply to this Ui and its subsequent children.

To set the visuals of all Ui:s, use Context::set_visuals.

source

pub fn reset_style(&mut self)

Reset to the default style set in Context.

source

pub fn spacing(&self) -> &Spacing

The current spacing options for this Ui. Short for ui.style().spacing.

source

pub fn spacing_mut(&mut self) -> &mut Spacing

Mutably borrow internal Spacing. Changes apply to this Ui and its subsequent children.

Example:

ui.spacing_mut().item_spacing = egui::vec2(10.0, 2.0);
source

pub fn visuals(&self) -> &Visuals

The current visuals settings of this Ui. Short for ui.style().visuals.

source

pub fn visuals_mut(&mut self) -> &mut Visuals

Mutably borrow internal visuals. Changes apply to this Ui and its subsequent children.

To set the visuals of all Ui:s, use Context::set_visuals.

Example:

ui.visuals_mut().override_text_color = Some(egui::Color32::RED);
source

pub fn ctx(&self) -> &Context

Get a reference to the parent Context.

source

pub fn painter(&self) -> &Painter

Use this to paint stuff within this Ui.

source

pub fn is_enabled(&self) -> bool

If false, the Ui does not allow any interaction and the widgets in it will draw with a gray look.

source

pub fn set_enabled(&mut self, enabled: bool)

Calling set_enabled(false) will cause the Ui to deny all future interaction and all the widgets will draw with a gray look.

Usually it is more convenient to use Self::add_enabled_ui or Self::add_enabled.

Calling set_enabled(true) has no effect - it will NOT re-enable the Ui once disabled.

Example
ui.group(|ui| {
    ui.checkbox(&mut enabled, "Enable subsection");
    ui.set_enabled(enabled);
    if ui.button("Button that is not always clickable").clicked() {
        /* … */
    }
});
source

pub fn is_visible(&self) -> bool

If false, any widgets added to the Ui will be invisible and non-interactive.

source

pub fn visible(&self) -> bool

👎Deprecated: Renamed is_visible
source

pub fn set_visible(&mut self, visible: bool)

Calling set_visible(false) will cause all further widgets to be invisible, yet still allocate space.

The widgets will not be interactive (set_visible(false) implies set_enabled(false)).

Calling set_visible(true) has no effect.

Example
ui.group(|ui| {
    ui.checkbox(&mut visible, "Show subsection");
    ui.set_visible(visible);
    if ui.button("Button that is not always shown").clicked() {
        /* … */
    }
});
source

pub fn layout(&self) -> &Layout

source

pub fn wrap_text(&self) -> bool

Should text wrap in this Ui?

This is determined first by Style::wrap, and then by the layout of this Ui.

source

pub fn painter_at(&self, rect: Rect) -> Painter

Create a painter for a sub-region of this Ui.

The clip-rect of the returned Painter will be the intersection of the given rectangle and the clip_rect() of this Ui.

source

pub fn layer_id(&self) -> LayerId

Use this to paint stuff within this Ui.

source

pub fn text_style_height(&self, style: &TextStyle) -> f32

The height of text of this text style

source

pub fn clip_rect(&self) -> Rect

Screen-space rectangle for clipping what we paint in this ui. This is used, for instance, to avoid painting outside a window that is smaller than its contents.

source

pub fn set_clip_rect(&mut self, clip_rect: Rect)

Screen-space rectangle for clipping what we paint in this ui. This is used, for instance, to avoid painting outside a window that is smaller than its contents.

source

pub fn is_rect_visible(&self, rect: Rect) -> bool

Can be used for culling: if false, then no part of rect will be visible on screen.

source§

impl Ui

Helpers for accessing the underlying Context.

These functions all lock the Context owned by this Ui. Please see the documentation of Context for how locking works!

source

pub fn input<R>(&self, reader: impl FnOnce(&InputState) -> R) -> R

Read-only access to the shared InputState.

if ui.input(|i| i.key_pressed(egui::Key::A)) {
    // …
}
source

pub fn input_mut<R>(&self, writer: impl FnOnce(&mut InputState) -> R) -> R

Read-write access to the shared InputState.

source

pub fn memory<R>(&self, reader: impl FnOnce(&Memory) -> R) -> R

Read-only access to the shared Memory.

source

pub fn memory_mut<R>(&self, writer: impl FnOnce(&mut Memory) -> R) -> R

Read-write access to the shared Memory.

source

pub fn data<R>(&self, reader: impl FnOnce(&IdTypeMap) -> R) -> R

Read-only access to the shared IdTypeMap, which stores superficial widget state.

source

pub fn data_mut<R>(&self, writer: impl FnOnce(&mut IdTypeMap) -> R) -> R

Read-write access to the shared IdTypeMap, which stores superficial widget state.

source

pub fn output<R>(&self, reader: impl FnOnce(&PlatformOutput) -> R) -> R

Read-only access to the shared PlatformOutput.

This is what egui outputs each frame.

ctx.output_mut(|o| o.cursor_icon = egui::CursorIcon::Progress);
source

pub fn output_mut<R>(&self, writer: impl FnOnce(&mut PlatformOutput) -> R) -> R

Read-write access to the shared PlatformOutput.

This is what egui outputs each frame.

ctx.output_mut(|o| o.cursor_icon = egui::CursorIcon::Progress);
source

pub fn fonts<R>(&self, reader: impl FnOnce(&Fonts) -> R) -> R

Read-only access to Fonts.

source§

impl Ui

source

pub fn min_rect(&self) -> Rect

Where and how large the Ui is already. All widgets that have been added to this Ui fits within this rectangle.

No matter what, the final Ui will be at least this large.

This will grow as new widgets are added, but never shrink.

source

pub fn min_size(&self) -> Vec2

Size of content; same as min_rect().size()

source

pub fn max_rect(&self) -> Rect

New widgets will try to fit within this rectangle.

Text labels will wrap to fit within max_rect. Separator lines will span the max_rect.

If a new widget doesn’t fit within the max_rect then the Ui will make room for it by expanding both min_rect and max_rect.

source

pub(crate) fn force_set_min_rect(&mut self, min_rect: Rect)

Used for animation, kind of hacky

source

pub fn set_max_size(&mut self, size: Vec2)

Set the maximum size of the ui. You won’t be able to shrink it below the current minimum size.

source

pub fn set_max_width(&mut self, width: f32)

Set the maximum width of the ui. You won’t be able to shrink it below the current minimum size.

source

pub fn set_max_height(&mut self, height: f32)

Set the maximum height of the ui. You won’t be able to shrink it below the current minimum size.

source

pub fn set_min_size(&mut self, size: Vec2)

Set the minimum size of the ui. This can’t shrink the ui, only make it larger.

source

pub fn set_min_width(&mut self, width: f32)

Set the minimum width of the ui. This can’t shrink the ui, only make it larger.

source

pub fn set_min_height(&mut self, height: f32)

Set the minimum height of the ui. This can’t shrink the ui, only make it larger.

source

pub fn shrink_width_to_current(&mut self)

Helper: shrinks the max width to the current width, so further widgets will try not to be wider than previous widgets. Useful for normal vertical layouts.

source

pub fn shrink_height_to_current(&mut self)

Helper: shrinks the max height to the current height, so further widgets will try not to be wider than previous widgets.

source

pub fn expand_to_include_rect(&mut self, rect: Rect)

Expand the min_rect and max_rect of this ui to include a child at the given rect.

source

pub fn set_width_range(&mut self, width: RangeInclusive<f32>)

ui.set_width_range(min..=max); is equivalent to ui.set_min_width(min); ui.set_max_width(max);.

source

pub fn set_height_range(&mut self, height: RangeInclusive<f32>)

ui.set_height_range(min..=max); is equivalent to ui.set_min_height(min); ui.set_max_height(max);.

source

pub fn set_width(&mut self, width: f32)

Set both the minimum and maximum width.

source

pub fn set_height(&mut self, height: f32)

Set both the minimum and maximum height.

source

pub fn expand_to_include_x(&mut self, x: f32)

Ensure we are big enough to contain the given x-coordinate. This is sometimes useful to expand an ui to stretch to a certain place.

source

pub fn expand_to_include_y(&mut self, y: f32)

Ensure we are big enough to contain the given y-coordinate. This is sometimes useful to expand an ui to stretch to a certain place.

source

pub fn available_size(&self) -> Vec2

The available space at the moment, given the current cursor. This how much more space we can take up without overflowing our parent. Shrinks as widgets allocate space and the cursor moves. A small size should be interpreted as “as little as possible”. An infinite size should be interpreted as “as much as you want”.

source

pub fn available_width(&self) -> f32

source

pub fn available_height(&self) -> f32

source

pub fn available_size_before_wrap(&self) -> Vec2

In case of a wrapping layout, how much space is left on this row/column?

source

pub fn available_rect_before_wrap(&self) -> Rect

source§

impl Ui

source

pub fn make_persistent_id<IdSource>(&self, id_source: IdSource) -> Idwhere IdSource: Hash,

Use this to generate widget ids for widgets that have persistent state in Memory.

source

pub fn next_auto_id(&self) -> Id

This is the Id that will be assigned to the next widget added to this Ui.

source

pub fn auto_id_with<IdSource>(&self, id_source: IdSource) -> Idwhere IdSource: Hash,

source

pub fn skip_ahead_auto_ids(&mut self, count: usize)

source§

impl Ui

source

pub fn interact(&self, rect: Rect, id: Id, sense: Sense) -> Response

Check for clicks, drags and/or hover on a specific region of this Ui.

source

pub fn interact_with_hovered( &self, rect: Rect, hovered: bool, id: Id, sense: Sense ) -> Response

Check for clicks, and drags on a specific region that is hovered. This can be used once you have checked that some shape you are painting has been hovered, and want to check for clicks and drags on hovered items this frame. The given Rect should approximately be where the thing is, as it is just where warnings will be painted if there is an Id clash.

source

pub fn rect_contains_pointer(&self, rect: Rect) -> bool

Is the pointer (mouse/touch) above this rectangle in this Ui?

The clip_rect and layer of this Ui will be respected, so, for instance, if this Ui is behind some other window, this will always return false.

source

pub fn ui_contains_pointer(&self) -> bool

Is the pointer (mouse/touch) above this Ui? Equivalent to ui.rect_contains_pointer(ui.min_rect())

source§

impl Ui

source

pub fn allocate_response( &mut self, desired_size: Vec2, sense: Sense ) -> Response

Allocate space for a widget and check for interaction in the space. Returns a Response which contains a rectangle, id, and interaction info.

How sizes are negotiated

Each widget should have a minimum desired size and a desired size. When asking for space, ask AT LEAST for your minimum, and don’t ask for more than you need. If you want to fill the space, ask about Ui::available_size and use that.

You may get MORE space than you asked for, for instance for justified layouts, like in menus.

You will never get a rectangle that is smaller than the amount of space you asked for.

let response = ui.allocate_response(egui::vec2(100.0, 200.0), egui::Sense::click());
if response.clicked() { /* … */ }
ui.painter().rect_stroke(response.rect, 0.0, (1.0, egui::Color32::WHITE));
source

pub fn allocate_exact_size( &mut self, desired_size: Vec2, sense: Sense ) -> (Rect, Response)

Returns a Rect with exactly what you asked for.

The response rect will be larger if this is part of a justified layout or similar. This means that if this is a narrow widget in a wide justified layout, then the widget will react to interactions outside the returned Rect.

source

pub fn allocate_at_least( &mut self, desired_size: Vec2, sense: Sense ) -> (Rect, Response)

Allocate at least as much space as needed, and interact with that rect.

The returned Rect will be the same size as Response::rect.

source

pub fn allocate_space(&mut self, desired_size: Vec2) -> (Id, Rect)

Reserve this much space and move the cursor. Returns where to put the widget.

How sizes are negotiated

Each widget should have a minimum desired size and a desired size. When asking for space, ask AT LEAST for your minimum, and don’t ask for more than you need. If you want to fill the space, ask about Ui::available_size and use that.

You may get MORE space than you asked for, for instance for justified layouts, like in menus.

You will never get a rectangle that is smaller than the amount of space you asked for.

Returns an automatic Id (which you can use for interaction) and the Rect of where to put your widget.

let (id, rect) = ui.allocate_space(egui::vec2(100.0, 200.0));
let response = ui.interact(rect, id, egui::Sense::click());
source

fn allocate_space_impl(&mut self, desired_size: Vec2) -> Rect

Reserve this much space and move the cursor. Returns where to put the widget.

source

pub fn allocate_rect(&mut self, rect: Rect, sense: Sense) -> Response

Allocate a specific part of the Ui.

Ignore the layout of the Ui: just put my widget here! The layout cursor will advance to past this rect.

source

pub(crate) fn advance_cursor_after_rect(&mut self, rect: Rect) -> Id

source

pub(crate) fn placer(&self) -> &Placer

source

pub fn cursor(&self) -> Rect

Where the next widget will be put.

One side of this will always be infinite: the direction in which new widgets will be added. The opposing side is what is incremented. The crossing sides are initialized to max_rect.

So one can think of cursor as a constraint on the available region.

If something has already been added, this will point to style.spacing.item_spacing beyond the latest child. The cursor can thus be style.spacing.item_spacing pixels outside of the min_rect.

source

pub(crate) fn set_cursor(&mut self, cursor: Rect)

source

pub fn next_widget_position(&self) -> Pos2

Where do we expect a zero-sized widget to be placed?

source

pub fn allocate_ui<R>( &mut self, desired_size: Vec2, add_contents: impl FnOnce(&mut Self) -> R ) -> InnerResponse<R>

Allocated the given space and then adds content to that space. If the contents overflow, more space will be allocated. When finished, the amount of space actually used (min_rect) will be allocated. So you can request a lot of space and then use less.

source

pub fn allocate_ui_with_layout<R>( &mut self, desired_size: Vec2, layout: Layout, add_contents: impl FnOnce(&mut Self) -> R ) -> InnerResponse<R>

Allocated the given space and then adds content to that space. If the contents overflow, more space will be allocated. When finished, the amount of space actually used (min_rect) will be allocated. So you can request a lot of space and then use less.

source

fn allocate_ui_with_layout_dyn<'c, R>( &mut self, desired_size: Vec2, layout: Layout, add_contents: Box<dyn FnOnce(&mut Self) -> R + 'c> ) -> InnerResponse<R>

source

pub fn allocate_ui_at_rect<R>( &mut self, max_rect: Rect, add_contents: impl FnOnce(&mut Self) -> R ) -> InnerResponse<R>

Allocated the given rectangle and then adds content to that rectangle. If the contents overflow, more space will be allocated. When finished, the amount of space actually used (min_rect) will be allocated. So you can request a lot of space and then use less.

source

pub fn allocate_painter( &mut self, desired_size: Vec2, sense: Sense ) -> (Response, Painter)

Convenience function to get a region to paint on.

Note that egui uses screen coordinates for everything.

let size = Vec2::splat(16.0);
let (response, painter) = ui.allocate_painter(size, Sense::hover());
let rect = response.rect;
let c = rect.center();
let r = rect.width() / 2.0 - 1.0;
let color = Color32::from_gray(128);
let stroke = Stroke::new(1.0, color);
painter.circle_stroke(c, r, stroke);
painter.line_segment([c - vec2(0.0, r), c + vec2(0.0, r)], stroke);
painter.line_segment([c, c + r * Vec2::angled(TAU * 1.0 / 8.0)], stroke);
painter.line_segment([c, c + r * Vec2::angled(TAU * 3.0 / 8.0)], stroke);
source

pub fn scroll_to_rect(&self, rect: Rect, align: Option<Align>)

Adjust the scroll position of any parent ScrollArea so that the given Rect becomes visible.

If align is None, it’ll scroll enough to bring the cursor into view.

See also: Response::scroll_to_me, Ui::scroll_to_cursor. Ui::scroll_with_delta..

egui::ScrollArea::vertical().show(ui, |ui| {
    // …
    let response = ui.button("Center on me.");
    if response.clicked() {
        ui.scroll_to_rect(response.rect, Some(Align::Center));
    }
});
source

pub fn scroll_to_cursor(&self, align: Option<Align>)

Adjust the scroll position of any parent ScrollArea so that the cursor (where the next widget goes) becomes visible.

If align is not provided, it’ll scroll enough to bring the cursor into view.

See also: Response::scroll_to_me, Ui::scroll_to_rect. Ui::scroll_with_delta.

egui::ScrollArea::vertical().show(ui, |ui| {
    let scroll_bottom = ui.button("Scroll to bottom.").clicked();
    for i in 0..1000 {
        ui.label(format!("Item {}", i));
    }

    if scroll_bottom {
        ui.scroll_to_cursor(Some(Align::BOTTOM));
    }
});
source

pub fn scroll_with_delta(&self, delta: Vec2)

Scroll this many points in the given direction, in the parent ScrollArea.

The delta dictates how the content (i.e. this UI) should move.

A positive X-value indicates the content is being moved right, as when swiping right on a touch-screen or track-pad with natural scrolling.

A positive Y-value indicates the content is being moved down, as when swiping down on a touch-screen or track-pad with natural scrolling.

/// See also: Response::scroll_to_me, Ui::scroll_to_rect, Ui::scroll_to_cursor

let mut scroll_delta = Vec2::ZERO;
if ui.button("Scroll down").clicked() {
    scroll_delta.y -= 64.0; // move content up
}
egui::ScrollArea::vertical().show(ui, |ui| {
    ui.scroll_with_delta(scroll_delta);
    for i in 0..1000 {
        ui.label(format!("Item {}", i));
    }
});
source§

impl Ui

source

pub fn add(&mut self, widget: impl Widget) -> Response

Add a Widget to this Ui at a location dependent on the current Layout.

The returned Response can be used to check for interactions, as well as adding tooltips using Response::on_hover_text.

See also Self::add_sized and Self::put.

let response = ui.add(egui::Slider::new(&mut my_value, 0..=100));
response.on_hover_text("Drag me!");
source

pub fn add_sized( &mut self, max_size: impl Into<Vec2>, widget: impl Widget ) -> Response

Add a Widget to this Ui with a given size. The widget will attempt to fit within the given size, but some widgets may overflow.

To fill all remaining area, use ui.add_sized(ui.available_size(), widget);

See also Self::add and Self::put.

ui.add_sized([40.0, 20.0], egui::DragValue::new(&mut my_value));
source

pub fn put(&mut self, max_rect: Rect, widget: impl Widget) -> Response

Add a Widget to this Ui at a specific location (manual layout).

See also Self::add and Self::add_sized.

source

pub fn add_enabled(&mut self, enabled: bool, widget: impl Widget) -> Response

Add a single Widget that is possibly disabled, i.e. greyed out and non-interactive.

If you call add_enabled from within an already disabled Ui, the widget will always be disabled, even if the enabled argument is true.

See also Self::add_enabled_ui and Self::is_enabled.

ui.add_enabled(false, egui::Button::new("Can't click this"));
source

pub fn add_enabled_ui<R>( &mut self, enabled: bool, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Add a section that is possibly disabled, i.e. greyed out and non-interactive.

If you call add_enabled_ui from within an already disabled Ui, the result will always be disabled, even if the enabled argument is true.

See also Self::add_enabled and Self::is_enabled.

Example
ui.checkbox(&mut enabled, "Enable subsection");
ui.add_enabled_ui(enabled, |ui| {
    if ui.button("Button that is not always clickable").clicked() {
        /* … */
    }
});
source

pub fn add_visible(&mut self, visible: bool, widget: impl Widget) -> Response

Add a single Widget that is possibly invisible.

An invisible widget still takes up the same space as if it were visible.

If you call add_visible from within an already invisible Ui, the widget will always be invisible, even if the visible argument is true.

See also Self::add_visible_ui, Self::set_visible and Self::is_visible.

ui.add_visible(false, egui::Label::new("You won't see me!"));
source

pub fn add_visible_ui<R>( &mut self, visible: bool, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Add a section that is possibly invisible, i.e. greyed out and non-interactive.

An invisible ui still takes up the same space as if it were visible.

If you call add_visible_ui from within an already invisible Ui, the result will always be invisible, even if the visible argument is true.

See also Self::add_visible, Self::set_visible and Self::is_visible.

Example
ui.checkbox(&mut visible, "Show subsection");
ui.add_visible_ui(visible, |ui| {
    ui.label("Maybe you see this, maybe you don't!");
});
source

pub fn add_space(&mut self, amount: f32)

Add extra space before the next widget.

The direction is dependent on the layout. This will be in addition to the crate::style::Spacing::item_spacing.

Self::min_rect will expand to contain the space.

source

pub fn label(&mut self, text: impl Into<WidgetText>) -> Response

Show some text.

Shortcut for add(Label::new(text))

See also Label.

Example
use egui::{RichText, FontId, Color32};
ui.label("Normal text");
ui.label(RichText::new("Large text").font(FontId::proportional(40.0)));
ui.label(RichText::new("Red text").color(Color32::RED));
source

pub fn colored_label( &mut self, color: impl Into<Color32>, text: impl Into<RichText> ) -> Response

Show colored text.

Shortcut for ui.label(RichText::new(text).color(color))

source

pub fn heading(&mut self, text: impl Into<RichText>) -> Response

Show large text.

Shortcut for ui.label(RichText::new(text).heading())

source

pub fn monospace(&mut self, text: impl Into<RichText>) -> Response

Show monospace (fixed width) text.

Shortcut for ui.label(RichText::new(text).monospace())

source

pub fn code(&mut self, text: impl Into<RichText>) -> Response

Show text as monospace with a gray background.

Shortcut for ui.label(RichText::new(text).code())

source

pub fn small(&mut self, text: impl Into<RichText>) -> Response

Show small text.

Shortcut for ui.label(RichText::new(text).small())

source

pub fn strong(&mut self, text: impl Into<RichText>) -> Response

Show text that stand out a bit (e.g. slightly brighter).

Shortcut for ui.label(RichText::new(text).strong())

source

pub fn weak(&mut self, text: impl Into<RichText>) -> Response

Show text that is weaker (fainter color).

Shortcut for ui.label(RichText::new(text).weak())

Looks like a hyperlink.

Shortcut for add(Link::new(text)).

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

See also Link.

Link to a web page.

Shortcut for add(Hyperlink::new(url)).

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

See also Hyperlink.

Shortcut for add(Hyperlink::new(url).text(label)).

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

See also Hyperlink.

source

pub fn text_edit_singleline<S: TextBuffer>(&mut self, text: &mut S) -> Response

No newlines (\n) allowed. Pressing enter key will result in the TextEdit losing focus (response.lost_focus).

See also TextEdit.

source

pub fn text_edit_multiline<S: TextBuffer>(&mut self, text: &mut S) -> Response

A TextEdit for multiple lines. Pressing enter key will create a new line.

See also TextEdit.

source

pub fn code_editor<S: TextBuffer>(&mut self, text: &mut S) -> Response

A TextEdit for code editing.

This will be multiline, monospace, and will insert tabs instead of moving focus.

See also TextEdit::code_editor.

source

pub fn button(&mut self, text: impl Into<WidgetText>) -> Response

Usage: if ui.button("Click me").clicked() { … }

Shortcut for add(Button::new(text))

See also Button.

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

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

pub fn small_button(&mut self, text: impl Into<WidgetText>) -> Response

A button as small as normal body text.

Usage: if ui.small_button("Click me").clicked() { … }

Shortcut for add(Button::new(text).small())

source

pub fn checkbox( &mut self, checked: &mut bool, text: impl Into<WidgetText> ) -> Response

Show a checkbox.

See also Self::toggle_value.

source

pub fn toggle_value( &mut self, selected: &mut bool, text: impl Into<WidgetText> ) -> Response

Acts like a checkbox, but looks like a SelectableLabel.

Click to toggle to bool.

See also Self::checkbox.

source

pub fn radio(&mut self, selected: bool, text: impl Into<WidgetText>) -> Response

Show a RadioButton. Often you want to use Self::radio_value instead.

source

pub fn radio_value<Value: PartialEq>( &mut self, current_value: &mut Value, alternative: Value, text: impl Into<WidgetText> ) -> Response

Show a RadioButton. It is selected if *current_value == selected_value. If clicked, selected_value is assigned to *current_value.


#[derive(PartialEq)]
enum Enum { First, Second, Third }
let mut my_enum = Enum::First;

ui.radio_value(&mut my_enum, Enum::First, "First");

// is equivalent to:

if ui.add(egui::RadioButton::new(my_enum == Enum::First, "First")).clicked() {
    my_enum = Enum::First
}
source

pub fn selectable_label( &mut self, checked: bool, text: impl Into<WidgetText> ) -> Response

Show a label which can be selected or not.

See also SelectableLabel and Self::toggle_value.

source

pub fn selectable_value<Value: PartialEq>( &mut self, current_value: &mut Value, selected_value: Value, text: impl Into<WidgetText> ) -> Response

Show selectable text. It is selected if *current_value == selected_value. If clicked, selected_value is assigned to *current_value.

Example: ui.selectable_value(&mut my_enum, Enum::Alternative, "Alternative").

See also SelectableLabel and Self::toggle_value.

source

pub fn separator(&mut self) -> Response

Shortcut for add(Separator::default())

See also Separator.

source

pub fn spinner(&mut self) -> Response

Shortcut for add(Spinner::new())

See also Spinner.

source

pub fn drag_angle(&mut self, radians: &mut f32) -> Response

Modify an angle. The given angle should be in radians, but is shown to the user in degrees. The angle is NOT wrapped, so the user may select, for instance 720° = 2𝞃 = 4π

source

pub fn drag_angle_tau(&mut self, radians: &mut f32) -> Response

Modify an angle. The given angle should be in radians, but is shown to the user in fractions of one Tau (i.e. fractions of one turn). The angle is NOT wrapped, so the user may select, for instance 2𝞃 (720°)

source

pub fn image( &mut self, texture_id: impl Into<TextureId>, size: impl Into<Vec2> ) -> Response

Show an image here with the given size.

In order to display an image you must first acquire a TextureHandle. This is best done with egui_extras::RetainedImage or Context::load_texture.

struct MyImage {
    texture: Option<egui::TextureHandle>,
}

impl MyImage {
    fn ui(&mut self, ui: &mut egui::Ui) {
        let texture: &egui::TextureHandle = self.texture.get_or_insert_with(|| {
            // Load the texture only once.
            ui.ctx().load_texture(
                "my-image",
                egui::ColorImage::example(),
                Default::default()
            )
        });

        // Show the image:
        ui.image(texture, texture.size_vec2());
    }
}

See also crate::Image and crate::ImageButton.

source§

impl Ui

source

pub fn color_edit_button_srgba(&mut self, srgba: &mut Color32) -> Response

Shows a button with the given color. If the user clicks the button, a full color picker is shown.

source

pub fn color_edit_button_hsva(&mut self, hsva: &mut Hsva) -> Response

Shows a button with the given color. If the user clicks the button, a full color picker is shown.

source

pub fn color_edit_button_srgb(&mut self, srgb: &mut [u8; 3]) -> Response

Shows a button with the given color. If the user clicks the button, a full color picker is shown. The given color is in sRGB space.

source

pub fn color_edit_button_rgb(&mut self, rgb: &mut [f32; 3]) -> Response

Shows a button with the given color. If the user clicks the button, a full color picker is shown. The given color is in linear RGB space.

source

pub fn color_edit_button_srgba_premultiplied( &mut self, srgba: &mut [u8; 4] ) -> Response

Shows a button with the given color. If the user clicks the button, a full color picker is shown. The given color is in sRGBA space with premultiplied alpha

source

pub fn color_edit_button_srgba_unmultiplied( &mut self, srgba: &mut [u8; 4] ) -> Response

Shows a button with the given color. If the user clicks the button, a full color picker is shown. The given color is in sRGBA space without premultiplied alpha. If unsure, what “premultiplied alpha” is, then this is probably the function you want to use.

source

pub fn color_edit_button_rgba_premultiplied( &mut self, rgba_premul: &mut [f32; 4] ) -> Response

Shows a button with the given color. If the user clicks the button, a full color picker is shown. The given color is in linear RGBA space with premultiplied alpha

source

pub fn color_edit_button_rgba_unmultiplied( &mut self, rgba_unmul: &mut [f32; 4] ) -> Response

Shows a button with the given color. If the user clicks the button, a full color picker is shown. The given color is in linear RGBA space without premultiplied alpha. If unsure, what “premultiplied alpha” is, then this is probably the function you want to use.

source§

impl Ui

source

pub fn group<R>( &mut self, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Put into a Frame::group, visually grouping the contents together

ui.group(|ui| {
    ui.label("Within a frame");
});

Se also Self::scope.

source

pub fn push_id<R>( &mut self, id_source: impl Hash, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Create a child Ui with an explicit Id.

for i in 0..10 {
    // ui.collapsing("Same header", |ui| { }); // this will cause an ID clash because of the same title!

    ui.push_id(i, |ui| {
        ui.collapsing("Same header", |ui| { }); // this is fine!
    });
}
source

pub fn scope<R>( &mut self, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Create a scoped child ui.

You can use this to temporarily change the Style of a sub-region, for instance:

ui.scope(|ui| {
    ui.spacing_mut().slider_width = 200.0; // Temporary change
    // …
});
source

fn scope_dyn<'c, R>( &mut self, add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>, id_source: Id ) -> InnerResponse<R>

source

pub fn with_layer_id<R>( &mut self, layer_id: LayerId, add_contents: impl FnOnce(&mut Self) -> R ) -> InnerResponse<R>

Redirect shapes to another paint layer.

source

pub fn collapsing<R>( &mut self, heading: impl Into<WidgetText>, add_contents: impl FnOnce(&mut Ui) -> R ) -> CollapsingResponse<R>

A CollapsingHeader that starts out collapsed.

source

pub fn indent<R>( &mut self, id_source: impl Hash, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Create a child ui which is indented to the right.

The id_source here be anything at all.

source

fn indent_dyn<'c, R>( &mut self, id_source: impl Hash, add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c> ) -> InnerResponse<R>

source

pub fn horizontal<R>( &mut self, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Start a ui with horizontal layout. After you have called this, the function registers the contents as any other widget.

Elements will be centered on the Y axis, i.e. adjusted up and down to lie in the center of the horizontal layout. The initial height is style.spacing.interact_size.y. Centering is almost always what you want if you are planning to to mix widgets or use different types of text.

If you don’t want the contents to be centered, use Self::horizontal_top instead.

The returned Response will only have checked for mouse hover but can be used for tooltips (on_hover_text). It also contains the Rect used by the horizontal layout.

ui.horizontal(|ui| {
    ui.label("Same");
    ui.label("row");
});

See also Self::with_layout for more options.

source

pub fn horizontal_centered<R>( &mut self, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Like Self::horizontal, but allocates the full vertical height and then centers elements vertically.

source

pub fn horizontal_top<R>( &mut self, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Like Self::horizontal, but aligns content with top.

source

pub fn horizontal_wrapped<R>( &mut self, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Start a ui with horizontal layout that wraps to a new row when it reaches the right edge of the max_size. After you have called this, the function registers the contents as any other widget.

Elements will be centered on the Y axis, i.e. adjusted up and down to lie in the center of the horizontal layout. The initial height is style.spacing.interact_size.y. Centering is almost always what you want if you are planning to to mix widgets or use different types of text.

The returned Response will only have checked for mouse hover but can be used for tooltips (on_hover_text). It also contains the Rect used by the horizontal layout.

See also Self::with_layout for more options.

source

fn horizontal_with_main_wrap_dyn<'c, R>( &mut self, main_wrap: bool, add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c> ) -> InnerResponse<R>

source

pub fn vertical<R>( &mut self, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Start a ui with vertical layout. Widgets will be left-justified.

ui.vertical(|ui| {
    ui.label("over");
    ui.label("under");
});

See also Self::with_layout for more options.

source

pub fn vertical_centered<R>( &mut self, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Start a ui with vertical layout. Widgets will be horizontally centered.

ui.vertical_centered(|ui| {
    ui.label("over");
    ui.label("under");
});
source

pub fn vertical_centered_justified<R>( &mut self, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<R>

Start a ui with vertical layout. Widgets will be horizontally centered and justified (fill full width).

ui.vertical_centered_justified(|ui| {
    ui.label("over");
    ui.label("under");
});
source

pub fn with_layout<R>( &mut self, layout: Layout, add_contents: impl FnOnce(&mut Self) -> R ) -> InnerResponse<R>

The new layout will take up all available space.

ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
    ui.label("world!");
    ui.label("Hello");
});

If you don’t want to use up all available space, use Self::allocate_ui_with_layout.

See also the helpers Self::horizontal, Self::vertical, etc.

source

fn with_layout_dyn<'c, R>( &mut self, layout: Layout, add_contents: Box<dyn FnOnce(&mut Self) -> R + 'c> ) -> InnerResponse<R>

source

pub fn centered<R>( &mut self, add_contents: impl FnOnce(&mut Self) -> R ) -> InnerResponse<R>

👎Deprecated: Use ui.vertical_centered or ui.centered_and_justified
source

pub fn centered_and_justified<R>( &mut self, add_contents: impl FnOnce(&mut Self) -> R ) -> InnerResponse<R>

This will make the next added widget centered and justified in the available space.

Only one widget may be added to the inner Ui!

source

pub(crate) fn set_grid(&mut self, grid: GridLayout)

source

pub(crate) fn save_grid(&mut self)

source

pub(crate) fn is_grid(&self) -> bool

source

pub fn end_row(&mut self)

Move to the next row in a grid layout or wrapping layout. Otherwise does nothing.

source

pub fn set_row_height(&mut self, height: f32)

Set row height in horizontal wrapping layout.

source

pub fn columns<R>( &mut self, num_columns: usize, add_contents: impl FnOnce(&mut [Self]) -> R ) -> R

Temporarily split a Ui into several columns.

ui.columns(2, |columns| {
    columns[0].label("First column");
    columns[1].label("Second column");
});
source

fn columns_dyn<'c, R>( &mut self, num_columns: usize, add_contents: Box<dyn FnOnce(&mut [Self]) -> R + 'c> ) -> R

source

pub fn close_menu(&mut self)

Close the menu we are in (including submenus), if any.

See also: Self::menu_button and Response::context_menu.

source

pub(crate) fn menu_state(&self) -> Option<Arc<RwLock<MenuState>>>

source

pub(crate) fn set_menu_state( &mut self, menu_state: Option<Arc<RwLock<MenuState>>> )

source

pub fn menu_button<R>( &mut self, title: impl Into<WidgetText>, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<Option<R>>

Create a menu button that when clicked will show the given menu.

If called from within a menu this will instead create a button for a sub-menu.

ui.menu_button("My menu", |ui| {
    ui.menu_button("My sub-menu", |ui| {
        if ui.button("Close the menu").clicked() {
            ui.close_menu();
        }
    });
});

See also: Self::close_menu and Response::context_menu.

source

pub fn menu_image_button<R>( &mut self, texture_id: TextureId, image_size: impl Into<Vec2>, add_contents: impl FnOnce(&mut Ui) -> R ) -> InnerResponse<Option<R>>

Create a menu button with an image that when clicked will show the given menu.

If called from within a menu this will instead create a button for a sub-menu.

use egui_extras;

let img = egui_extras::RetainedImage::from_svg_bytes_with_size(
    "rss",
    include_bytes!("rss.svg"),
    egui_extras::image::FitTo::Size(24, 24),
);

ui.menu_image_button(img.texture_id(ctx), img.size_vec2(), |ui| {
    ui.menu_button("My sub-menu", |ui| {
        if ui.button("Close the menu").clicked() {
            ui.close_menu();
        }
    });
});

See also: Self::close_menu and Response::context_menu.

source§

impl Ui

source

pub fn debug_paint_cursor(&self)

Shows where the next widget is going to be placed

source

pub fn trace_location(&self, text: impl ToString)

Shows the given text where the next widget is to be placed if when Context::set_debug_on_hover has been turned on and the mouse is hovering the Ui.

Auto Trait Implementations§

§

impl !RefUnwindSafe for Ui

§

impl !Send for Ui

§

impl !Sync for Ui

§

impl Unpin for Ui

§

impl !UnwindSafe for Ui

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.