Struct YoleckUi

pub struct YoleckUi(pub Ui);

An handle for the egui UI frame used in editing systems.

Tuple Fields

0: Ui

Methods from Deref<Target = Ui>

pub fn child_ui( &mut self, max_rect: Rect, layout: Layout, ui_stack_info: Option<UiStackInfo>, ) -> Ui

👎Deprecated: Use ui.new_child() instead

Create a new [Ui] at a specific region.

Note: calling this function twice from the same [Ui] will create a conflict of id. Use [Self::scope] if needed.

When in doubt, use None for the UiStackInfo argument.

pub fn child_ui_with_id_source( &mut self, max_rect: Rect, layout: Layout, id_salt: impl Hash, ui_stack_info: Option<UiStackInfo>, ) -> Ui

👎Deprecated: Use ui.new_child() instead

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

When in doubt, use None for the UiStackInfo argument.

pub fn new_child(&mut self, ui_builder: UiBuilder) -> Ui

Create a child Ui with the properties of the given builder.

This is a very low-level function. Usually you are better off using [Self::scope_builder].

Note that calling this does not allocate any space in the parent Ui, so after adding widgets to the child Ui you probably want to allocate the [Ui::min_rect] of the child in the parent Ui using e.g. [Ui::advance_cursor_after_rect].

pub fn set_sizing_pass(&mut self)

👎Deprecated: Use UiBuilder.sizing_pass().invisible()

Set to true in special cases where we do one frame where we size up the contents of the Ui, without actually showing it.

This will also turn the Ui invisible. Should be called right after [Self::new], if at all.

pub fn is_sizing_pass(&self) -> bool

Set to true in special cases where we do one frame where we size up the contents of the Ui, without actually showing it.

pub fn id(&self) -> Id

Generated based on id of parent ui together with an optional id salt.

This should be stable 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).

However, it is not necessarily globally unique. For instance, sibling Uis share the same [Self::id] unless they where explicitly given different id salts using [UiBuilder::id_salt].

pub fn unique_id(&self) -> Id

This is a globally unique ID of this Ui, based on where in the hierarchy of widgets this Ui is in.

This means it is not stable, as it can change if new widgets are added or removed prior to this one. It should therefore only be used for transient interactions (clicks etc), not for storing state over time.

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].

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_of].

Example:

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

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_of].

pub fn reset_style(&mut self)

Reset to the default style set in [Context].

pub fn spacing(&self) -> &Spacing

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

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

pub fn visuals(&self) -> &Visuals

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

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_of].

Example:

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

pub fn stack(&self) -> &Arc<UiStack>

Get a reference to this [Ui]’s [UiStack].

pub fn ctx(&self) -> &Context

Get a reference to the parent [Context].

pub fn painter(&self) -> &Painter

Use this to paint stuff within this [Ui].

pub fn pixels_per_point(&self) -> f32

Number of physical pixels for each logical UI point.

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.

pub fn disable(&mut self)

Calling disable() 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].

Note that once disabled, there is no way to re-enable the [Ui].

Example

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

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

👎Deprecated: Use disable(), add_enabled_ui(), or add_enabled() instead

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

pub fn is_visible(&self) -> bool

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

This is false if any parent had [UiBuilder::invisible] or if [Context::will_discard].

pub fn set_invisible(&mut self)

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

The widgets will not be interactive (set_invisible() implies disable()).

Once invisible, there is no way to make the [Ui] visible again.

Usually it is more convenient to use [Self::add_visible_ui] or [Self::add_visible].

Example

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

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

👎Deprecated: Use set_invisible(), add_visible_ui(), or add_visible() instead

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

pub fn set_opacity(&mut self, opacity: f32)

Make the widget in this [Ui] semi-transparent.

opacity must be between 0.0 and 1.0, where 0.0 means fully transparent (i.e., invisible) and 1.0 means fully opaque.

Example

ui.group(|ui| {
    ui.set_opacity(0.5);
    if ui.button("Half-transparent button").clicked() {
        /* … */
    }
});

See also: [Self::opacity] and [Self::multiply_opacity].

pub fn multiply_opacity(&mut self, opacity: f32)

Like [Self::set_opacity], but multiplies the given value with the current opacity.

See also: [Self::set_opacity] and [Self::opacity].

pub fn opacity(&self) -> f32

Read the current opacity of the underlying painter.

See also: [Self::set_opacity] and [Self::multiply_opacity].

pub fn layout(&self) -> &Layout

Read the [Layout].

pub fn wrap_mode(&self) -> TextWrapMode

Which wrap mode should the text use in this [Ui]?

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

pub fn wrap_text(&self) -> bool

👎Deprecated: Use wrap_mode instead

Should text wrap in this [Ui]?

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

pub fn text_valign(&self) -> Align

How to vertically align text

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].

pub fn layer_id(&self) -> LayerId

Use this to paint stuff within this [Ui].

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

The height of text of this text style.

Returns a value rounded to [emath::GUI_ROUNDING].

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.

pub fn shrink_clip_rect(&mut self, new_clip_rect: Rect)

Constrain the rectangle in which we can paint.

Short for ui.set_clip_rect(ui.clip_rect().intersect(new_clip_rect)).

See also: [Self::clip_rect] and [Self::set_clip_rect].

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.

Warning: growing the clip rect might cause unexpected results! When in doubt, use [Self::shrink_clip_rect] instead.

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.

This is false if the whole Ui is invisible (see [UiBuilder::invisible]) or if [Context::will_discard] is true.

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

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

Read-write access to the shared [InputState].

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

Read-only access to the shared [Memory].

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

Read-write access to the shared [Memory].

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

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

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.

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

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

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

Read-only access to [Fonts].

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.

pub fn min_size(&self) -> Vec2

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

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.

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.

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.

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.

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.

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.

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.

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.

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 taller than previous widgets.

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.

pub fn set_width_range(&mut self, width: impl Into<Rangef>)

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

pub fn set_height_range(&mut self, height: impl Into<Rangef>)

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

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

Set both the minimum and maximum width.

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

Set both the minimum and maximum height.

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 a ui to stretch to a certain place.

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 a ui to stretch to a certain place.

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”.

pub fn available_width(&self) -> f32

The available width at the moment, given the current cursor.

See [Self::available_size] for more information.

pub fn available_height(&self) -> f32

The available height at the moment, given the current cursor.

See [Self::available_size] for more information.

pub fn available_size_before_wrap(&self) -> Vec2

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

If the layout does not wrap, this will return the same value as [Self::available_size].

pub fn available_rect_before_wrap(&self) -> Rect

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

If the layout does not wrap, this will return the same value as [Self::available_size].

pub fn make_persistent_id<IdSource>(&self, id_salt: IdSource) -> Id

where IdSource: Hash,

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

pub fn next_auto_id(&self) -> Id

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

pub fn auto_id_with<IdSource>(&self, id_salt: IdSource) -> Id

where IdSource: Hash,

Same as ui.next_auto_id().with(id_salt)

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

Pretend like count widgets have been allocated.

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].

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

👎Deprecated: The contains_pointer argument is ignored. Use ui.interact instead.

Deprecated: use [Self::interact] instead.

pub fn response(&self) -> Response

Read the [Ui]s background [Response]. It’s [Sense] will be based on the [UiBuilder::sense] used to create this [Ui].

The rectangle of the [Response] (and interactive area) will be [Self::min_rect] of the last pass.

The very first time when the [Ui] is created, this will return a [Response] with a [Rect] of [Rect::NOTHING].

pub fn interact_bg(&self, sense: Sense) -> Response

👎Deprecated: Use UiBuilder::sense with Ui::response instead

Interact with the background of this [Ui], i.e. behind all the widgets.

The rectangle of the [Response] (and interactive area) will be [Self::min_rect].

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.

However, this will NOT check if any other widget in the same layer is covering this widget. For that, use [Response::contains_pointer] instead.

pub fn ui_contains_pointer(&self) -> bool

Is the pointer (mouse/touch) above the current [Ui]?

Equivalent to ui.rect_contains_pointer(ui.min_rect())

Note that this tests against the current [Ui::min_rect]. If you want to test against the final min_rect, use [Self::response] instead.

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), egui::StrokeKind::Inside);

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].

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.

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());

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.

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

Allocate a rect without interacting with it.

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.

pub fn next_widget_position(&self) -> Pos2

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

pub fn allocate_ui<R>( &mut self, desired_size: Vec2, add_contents: impl FnOnce(&mut Ui) -> 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.

pub fn allocate_ui_with_layout<R>( &mut self, desired_size: Vec2, layout: Layout, add_contents: impl FnOnce(&mut Ui) -> 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.

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

👎Deprecated: Use allocate_new_ui instead

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.

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

Allocated space (UiBuilder::max_rect) and then add content to it.

If the contents overflow, more space will be allocated. When finished, the amount of space actually used (min_rect) will be allocated in the parent. So you can request a lot of space and then use less.

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

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

Adjust the scroll position of any parent [crate::ScrollArea] so that the given [Rect] becomes visible.

If align is [Align::TOP] it means “put the top of the rect at the top of the scroll area”, etc. 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));
    }
});

pub fn scroll_to_rect_animation( &self, rect: Rect, align: Option<Align>, animation: ScrollAnimation, )

Same as [Self::scroll_to_rect], but allows you to specify the [style::ScrollAnimation].

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

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

If align is [Align::TOP] it means “put the top of the rect at the top of the scroll area”, etc. 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));
    }
});

pub fn scroll_to_cursor_animation( &self, align: Option<Align>, animation: ScrollAnimation, )

Same as [Self::scroll_to_cursor], but allows you to specify the [style::ScrollAnimation].

pub fn scroll_with_delta(&self, delta: Vec2)

Scroll this many points in the given direction, in the parent [crate::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.

If this is called multiple times per frame for the same [crate::ScrollArea], the deltas will be summed.

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));
    }
});

pub fn scroll_with_delta_animation( &self, delta: Vec2, animation: ScrollAnimation, )

Same as [Self::scroll_with_delta], but allows you to specify the [style::ScrollAnimation].

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!");

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

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].

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"));

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

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!"));

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

👎Deprecated: Use ‘ui.scope_builder’ instead

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!");
});

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] that is always added, but item_spacing won’t be added again by add_space.

[Self::min_rect] will expand to contain the space.

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

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))

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

Show large text.

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

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

Show monospace (fixed width) text.

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

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())

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

Show small text.

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

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())

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())

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

Looks like a hyperlink.

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

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

See also [Link].

pub fn hyperlink(&mut self, url: impl ToString) -> Response

Link to a web page.

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

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

See also [Hyperlink].

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

Shortcut for add(Hyperlink::from_label_and_url(label, url)).

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

See also [Hyperlink].

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

where S: TextBuffer,

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

See also [TextEdit].

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

where S: TextBuffer,

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

See also [TextEdit].

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

where S: TextBuffer,

A [TextEdit] for code editing.

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

See also [TextEdit::code_editor].

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

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())

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

Show a checkbox.

See also [Self::toggle_value].

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].

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

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

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

where Value: PartialEq,

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
}

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].

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

where Value: PartialEq,

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].

pub fn separator(&mut self) -> Response

Shortcut for add(Separator::default())

See also [Separator].

pub fn spinner(&mut self) -> Response

Shortcut for add(Spinner::new())

See also [Spinner].

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π

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°)

pub fn image<'a>(&mut self, source: impl Into<ImageSource<'a>>) -> Response

Show an image available at the given uri.

⚠ This will do nothing unless you install some image loaders first! The easiest way to do this is via egui_extras::install_image_loaders.

The loaders handle caching image data, sampled textures, etc. across frames, so calling this is immediate-mode safe.

ui.image("https://picsum.photos/480");
ui.image("file://assets/ferris.png");
ui.image(egui::include_image!("../assets/ferris.png"));
ui.add(
    egui::Image::new(egui::include_image!("../assets/ferris.png"))
        .max_width(200.0)
        .corner_radius(10),
);

Using [crate::include_image] is often the most ergonomic, and the path will be resolved at compile-time and embedded in the binary. When using a “file://” url on the other hand, you need to make sure the files can be found in the right spot at runtime!

See also [crate::Image], [crate::ImageSource].

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.

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.

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.

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.

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

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.

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

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.

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");
});

See also [Self::scope].

pub fn push_id<R>( &mut self, id_salt: 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!
    });
}

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

👎Deprecated: Use ‘ui.scope_builder’ instead

Push another level onto the [UiStack].

You can use this, for instance, to tag a group of widgets.

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

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

Create a child, add content to it, and then allocate only what was used in the parent Ui.

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

Create a child, add content to it, and then allocate only what was used in the parent Ui.

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

👎Deprecated: Use ui.scope_builder(UiBuilder::new().layer_id(…), …) instead

Redirect shapes to another paint layer.

let layer_id = LayerId::new(Order::Tooltip, Id::new("my_floating_ui"));
ui.with_layer_id(layer_id, |ui| {
    ui.label("This is now in a different layer");
});

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.

The name must be unique within the current parent, or you need to use [CollapsingHeader::id_salt].

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

Create a child ui which is indented to the right.

The id_salt here be anything at all.

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 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.

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.

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

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

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 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.

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.

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");
});

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");
});

pub fn with_layout<R>( &mut self, layout: Layout, add_contents: impl FnOnce(&mut Ui) -> 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.

pub fn centered_and_justified<R>( &mut self, add_contents: impl FnOnce(&mut Ui) -> 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!

pub fn end_row(&mut self)

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

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

Set row height in horizontal wrapping layout.

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

Temporarily split a [Ui] into several columns.

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

pub fn columns_const<const NUM_COL: usize, R>( &mut self, add_contents: impl FnOnce(&mut [Ui; NUM_COL]) -> R, ) -> R

Temporarily split a [Ui] into several columns.

The same as [Self::columns()], but uses a constant for the column count. This allows for compile-time bounds checking, and makes the compiler happy.

ui.columns_const(|[col_1, col_2]| {
    col_1.label("First column");
    col_2.label("Second column");
});

pub fn dnd_drag_source<Payload, R>( &mut self, id: Id, payload: Payload, add_contents: impl FnOnce(&mut Ui) -> R, ) -> InnerResponse<R>

where Payload: Any + Send + Sync,

Create something that can be drag-and-dropped.

The id needs to be globally unique. The payload is what will be dropped if the user starts dragging.

In contrast to [Response::dnd_set_drag_payload], this function will paint the widget at the mouse cursor while the user is dragging.

pub fn dnd_drop_zone<Payload, R>( &mut self, frame: Frame, add_contents: impl FnOnce(&mut Ui) -> R, ) -> (InnerResponse<R>, Option<Arc<Payload>>)

where Payload: Any + Send + Sync,

Surround the given ui with a frame which changes colors when you can drop something onto it.

Returns the dropped item, if it was released this frame.

The given frame is used for its margins, but it color is ignored.

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

Create a new Scope and transform its contents via a [emath::TSTransform]. This only affects visuals, inputs will not be transformed. So this is mostly useful to create visual effects on interactions, e.g. scaling a button on hover / click.

Check out [Context::set_transform_layer] for a persistent transform that also affects inputs.

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].

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].

pub fn menu_image_button<'a, R>( &mut self, image: impl Into<Image<'a>>, 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.

let img = egui::include_image!("../assets/ferris.png");

ui.menu_image_button(title, img, |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].

pub fn menu_image_text_button<'a, R>( &mut self, image: impl Into<Image<'a>>, title: impl Into<WidgetText>, add_contents: impl FnOnce(&mut Ui) -> R, ) -> InnerResponse<Option<R>>

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

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

let img = egui::include_image!("../assets/ferris.png");
let title = "My Menu";

ui.menu_image_text_button(img, title, |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].

pub fn debug_paint_cursor(&self)

Shows where the next widget is going to be placed

Trait Implementations

impl Deref for YoleckUi

type Target = Ui

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for YoleckUi

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Resource for YoleckUi

where Self: Send + Sync + 'static,