Struct egui::Ui

pub struct Ui { /* fields omitted */ }

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

Implementations

impl Ui

pub fn new(ctx: Arc<Context>, layer: Layer, id: Id, rect: Rect) -> Self

pub fn child_ui(&self, child_rect: Rect) -> Self

pub fn round_to_pixel(&self, point: f32) -> f32

pub fn round_vec_to_pixels(&self, vec: Vec2) -> Vec2

pub fn round_pos_to_pixels(&self, pos: Pos2) -> Pos2

pub fn id(&self) -> Id

pub fn style(&self) -> &Style

Options for this ui, and any child uis we may spawn.

pub fn set_style(&mut self, style: Style)

pub fn ctx(&self) -> &Arc<Context>

pub fn input(&self) -> &InputState

pub fn memory(&self) -> MutexGuard<Memory>

pub fn output(&self) -> MutexGuard<Output>

pub fn fonts(&self) -> &Fonts

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 set_clip_rect(&mut self, clip_rect: Rect)

pub fn top_left(&self) -> Pos2

Screen-space position of this Ui. This may have moved from its original if a child overflowed to the left or up (rare).

pub fn bottom_right(&self) -> Pos2

Screen-space position of the current bottom right corner of this Ui. This may move when we add children that overflow our desired rectangle bounds. This position may be at inifnity if the desired rect is initinite, which mappens when a parent widget says "be as big as you want to be".

pub fn rect(&self) -> Rect

Position and current size of the ui. The size is the maximum of the origional (minimum/desired) size and the size of the containted children.

pub fn rect_finite(&self) -> Rect

This is like rect(), but will never be infinite. If the desired rect is infinite ("be as big as you want") this will be bounded by child bounds.

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

Set the width of the ui. You won't be able to shrink it beyond its current child bounds.

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

Set the height of the ui. You won't be able to shrink it beyond its current child bounds.

pub fn bounding_size(&self) -> Vec2

Size of content

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

Expand the bounding rect of this ui to include a child at the given rect.

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

pub fn child_bounds(&self) -> Rect

Bounding box of all contained children

pub fn force_set_child_bounds(&mut self, child_bounds: Rect)

pub fn available(&self) -> Rect

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 rectangle should be intepreted as "as little as possible". An infinite rectangle should be interpred as "as much as you want". In most layouts the next widget will be put in the top left corner of this Rect.

pub fn available_finite(&self) -> Rect

This is like available(), but will never be infinite. Use this for components that want to grow without bounds (but shouldn't). In most layouts the next widget will be put in the top left corner of this Rect.

pub fn layout(&self) -> &Layout

pub fn set_layout(&mut self, layout: Layout)

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

pub fn has_kb_focus(&self, id: Id) -> bool

pub fn request_kb_focus(&self, id: Id)

pub fn make_unique_child_id<IdSource>(&self, id_source: IdSource) -> Id where
    IdSource: Hash + Debug, 

Will warn if the returned id is not guaranteed unique. Use this to generate widget ids for widgets that have persistent state in Memory. If the id_source is not unique within this ui then an error will be printed at the current cursor position.

pub fn make_position_id(&self) -> Id

Make an Id that is unique to this positon. Can be used for widgets that do NOT persist state in Memory but you still need to interact with (e.g. buttons, sliders).

pub fn make_child_id(&self, id_seed: impl Hash) -> Id

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

pub fn interact_hover(&self, rect: Rect) -> InteractInfo

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

#[must_use]pub fn response(&mut self, interact: InteractInfo) -> GuiResponse

pub fn allocate_space(&mut self, child_size: Vec2) -> 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 you minimum, and don't ask for more than you need. If you want to fill the space, ask about available().size() and use that.

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

You may get LESS space than you asked for if the current layout won't fit what you asked for.

pub fn add_paint_cmd(&mut self, paint_cmd: PaintCmd)

It is up to the caller to make sure there is room for this. Can be used for free painting. NOTE: all coordinates are screen coordinates!

pub fn add_paint_cmds(&mut self, cmds: Vec<PaintCmd>)

pub fn insert_paint_cmd(&mut self, pos: usize, paint_cmd: PaintCmd)

Insert a paint cmd before existing ones

pub fn paint_list_len(&self) -> usize

pub fn debug_text(&self, text: impl Into<String>)

Paint some debug text at current cursor

pub fn debug_text_at(&self, pos: Pos2, text: impl Into<String>)

pub fn debug_rect(&mut self, rect: Rect, text: impl Into<String>)

pub fn floating_text(
    &mut self,
    pos: Pos2,
    text: impl Into<String>,
    text_style: TextStyle,
    align: (Align, Align),
    text_color: Option<Color>
) -> Rect

Show some text anywhere in the ui. To center the text at the given position, use align: (Center, Center). If you want to draw text floating on top of everything, consider using Context.floating_text instead.

pub fn add_galley(
    &mut self,
    pos: Pos2,
    galley: Galley,
    text_style: TextStyle,
    color: Option<Color>
)

Already layed out text.

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

pub fn label(&mut self, label: impl Into<Label>) -> GuiResponse

pub fn hyperlink(&mut self, url: impl Into<String>) -> GuiResponse

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

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

pub fn radio(&mut self, text: impl Into<String>, checked: bool) -> GuiResponse

pub fn separator(&mut self) -> GuiResponse

pub fn collapsing<R>(
    &mut self,
    text: impl Into<String>,
    add_contents: impl FnOnce(&mut Ui) -> R
) -> Option<R>

pub fn add_custom_contents(
    &mut self,
    size: Vec2,
    add_contents: impl FnOnce(&mut Ui)
) -> Rect

Create a child ui at the current cursor. size is the desired size. Actual size may be much smaller if avilable_size() is not enough. Set size to Vec::infinity() to get as much space as possible. Just because you ask for a lot of space does not mean you have to use it! After add_contents is called the contents of bounding_size will decide how much space will be used in the parent ui.

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

Create a child ui

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

Create a child ui which is indented to the right

pub fn left_column(&mut self, width: f32) -> Ui

pub fn centered_column(&mut self, width: f32) -> Ui

pub fn right_column(&mut self, width: f32) -> Ui

pub fn column(&mut self, column_position: Align, width: f32) -> Ui

A column ui with a given width.

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

Start a ui with horizontal layout

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

Start a ui with vertical layout

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

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

Temporarily split split an Ui into several columns.

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