677 lines
23 KiB
Rust
677 lines
23 KiB
Rust
use std::{hash::Hash, sync::Arc};
|
|
|
|
use crate::{color::*, containers::*, layout::*, paint::*, widgets::*, *};
|
|
|
|
/// Represents a region of the screen
|
|
/// with a type of layout (horizontal or vertical).
|
|
pub struct Ui {
|
|
/// How we access input, output and memory
|
|
ctx: Arc<Context>,
|
|
|
|
/// 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.
|
|
/// Hopefully unique.
|
|
id: Id,
|
|
|
|
/// Where to put the graphics output of this Ui
|
|
layer: Layer,
|
|
|
|
/// Everything painted in this ui will be clipped against this.
|
|
/// This means nothing outside of this rectangle will be visible on screen.
|
|
clip_rect: Rect,
|
|
|
|
/// The `rect` represents where in screen-space the ui is
|
|
/// and its max size (original available_space).
|
|
/// Note that the size may be infinite in one or both dimensions.
|
|
/// The widgets will TRY to fit within the rect,
|
|
/// but may overflow (which you will see in child_bounds).
|
|
/// Some widgets (like separator lines) will try to fill the full desired width of the ui.
|
|
/// If the desired size is zero, it is a signal that child widgets should be as small as possible.
|
|
/// If the desired size is initie, it is a signal that child widgets should take up as much room as they want.
|
|
desired_rect: Rect, // TODO: rename as max_rect ?
|
|
|
|
/// Bounding box of all children.
|
|
/// This is used to see how large a ui actually
|
|
/// needs to be after all children has been added.
|
|
/// You can think of this as the minimum size.
|
|
child_bounds: Rect, // TODO: rename as min_rect ?
|
|
|
|
/// Overide default style in this ui
|
|
style: Style,
|
|
|
|
layout: Layout,
|
|
|
|
/// Where the next widget will be put.
|
|
/// Progresses along self.dir.
|
|
/// Initially set to rect.min
|
|
/// If something has already been added, this will point ot style.item_spacing beyond the latest child.
|
|
/// The cursor can thus be style.item_spacing pixels outside of the child_bounds.
|
|
cursor: Pos2, // TODO: move into Layout?
|
|
}
|
|
|
|
impl Ui {
|
|
// ------------------------------------------------------------------------
|
|
// Creation:
|
|
|
|
pub fn new(ctx: Arc<Context>, layer: Layer, id: Id, rect: Rect) -> Self {
|
|
let style = ctx.style();
|
|
Ui {
|
|
ctx,
|
|
id,
|
|
layer,
|
|
clip_rect: rect.expand(style.clip_rect_margin),
|
|
desired_rect: rect,
|
|
child_bounds: Rect::from_min_size(rect.min, Vec2::zero()), // TODO: Rect::nothing() ?
|
|
style,
|
|
layout: Default::default(),
|
|
cursor: rect.min,
|
|
}
|
|
}
|
|
|
|
pub fn child_ui(&self, child_rect: Rect) -> Self {
|
|
// let clip_rect = self
|
|
// .clip_rect
|
|
// .intersect(&child_rect.expand(self.style().clip_rect_margin));
|
|
let clip_rect = self.clip_rect(); // Keep it unless the child explciitly desires differently
|
|
Ui {
|
|
ctx: self.ctx.clone(),
|
|
id: self.id,
|
|
layer: self.layer,
|
|
clip_rect,
|
|
desired_rect: child_rect,
|
|
child_bounds: Rect::from_min_size(child_rect.min, Vec2::zero()), // TODO: Rect::nothing() ?
|
|
style: self.style,
|
|
layout: self.layout,
|
|
cursor: child_rect.min,
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------
|
|
|
|
pub fn round_to_pixel(&self, point: f32) -> f32 {
|
|
self.ctx.round_to_pixel(point)
|
|
}
|
|
|
|
pub fn round_vec_to_pixels(&self, vec: Vec2) -> Vec2 {
|
|
self.ctx.round_vec_to_pixels(vec)
|
|
}
|
|
|
|
pub fn round_pos_to_pixels(&self, pos: Pos2) -> Pos2 {
|
|
self.ctx.round_pos_to_pixels(pos)
|
|
}
|
|
|
|
pub fn id(&self) -> Id {
|
|
self.id
|
|
}
|
|
|
|
/// Options for this ui, and any child uis we may spawn.
|
|
pub fn style(&self) -> &Style {
|
|
&self.style
|
|
}
|
|
|
|
pub fn set_style(&mut self, style: Style) {
|
|
self.style = style
|
|
}
|
|
|
|
pub fn ctx(&self) -> &Arc<Context> {
|
|
&self.ctx
|
|
}
|
|
|
|
pub fn input(&self) -> &InputState {
|
|
self.ctx.input()
|
|
}
|
|
|
|
pub fn memory(&self) -> parking_lot::MutexGuard<'_, Memory> {
|
|
self.ctx.memory()
|
|
}
|
|
|
|
pub fn output(&self) -> parking_lot::MutexGuard<'_, Output> {
|
|
self.ctx.output()
|
|
}
|
|
|
|
pub fn fonts(&self) -> &Fonts {
|
|
self.ctx.fonts()
|
|
}
|
|
|
|
/// 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 clip_rect(&self) -> Rect {
|
|
self.clip_rect
|
|
}
|
|
|
|
pub fn set_clip_rect(&mut self, clip_rect: Rect) {
|
|
self.clip_rect = clip_rect;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
/// 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 top_left(&self) -> Pos2 {
|
|
// If a child doesn't fit in desired_rect, we have effectively expanded:
|
|
self.desired_rect.min.min(self.child_bounds.min)
|
|
}
|
|
|
|
/// 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 bottom_right(&self) -> Pos2 {
|
|
// If a child doesn't fit in desired_rect, we have effectively expanded:
|
|
self.desired_rect.max.max(self.child_bounds.max)
|
|
}
|
|
|
|
/// 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(&self) -> Rect {
|
|
Rect::from_min_max(self.top_left(), self.bottom_right())
|
|
}
|
|
|
|
/// 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 rect_finite(&self) -> Rect {
|
|
let mut bottom_right = self.child_bounds.max;
|
|
if self.desired_rect.max.x.is_finite() {
|
|
bottom_right.x = bottom_right.x.max(self.desired_rect.max.x);
|
|
}
|
|
if self.desired_rect.max.y.is_finite() {
|
|
bottom_right.y = bottom_right.y.max(self.desired_rect.max.y);
|
|
}
|
|
|
|
Rect::from_min_max(self.top_left(), bottom_right)
|
|
}
|
|
|
|
/// Set the width of the ui.
|
|
/// You won't be able to shrink it beyond its current child bounds.
|
|
pub fn set_desired_width(&mut self, width: f32) {
|
|
let min_width = self.child_bounds.max.x - self.top_left().x;
|
|
let width = width.max(min_width);
|
|
self.desired_rect.max.x = self.top_left().x + width;
|
|
}
|
|
|
|
/// Set the height 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) {
|
|
let min_height = self.child_bounds.max.y - self.top_left().y;
|
|
let height = height.max(min_height);
|
|
self.desired_rect.max.y = self.top_left().y + height;
|
|
}
|
|
|
|
/// Size of content
|
|
pub fn bounding_size(&self) -> Vec2 {
|
|
self.child_bounds.size()
|
|
}
|
|
|
|
/// Expand the bounding rect of this ui to include a child at the given rect.
|
|
pub fn expand_to_include_child(&mut self, rect: Rect) {
|
|
self.child_bounds.extend_with(rect.min);
|
|
self.child_bounds.extend_with(rect.max);
|
|
}
|
|
|
|
pub fn expand_to_size(&mut self, size: Vec2) {
|
|
self.child_bounds.extend_with(self.top_left() + size);
|
|
}
|
|
|
|
/// Bounding box of all contained children
|
|
pub fn child_bounds(&self) -> Rect {
|
|
self.child_bounds
|
|
}
|
|
|
|
pub fn force_set_child_bounds(&mut self, child_bounds: Rect) {
|
|
self.child_bounds = child_bounds;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Layout related measures:
|
|
|
|
/// 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(&self) -> Rect {
|
|
self.layout.available(self.cursor, 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 available_finite(&self) -> Rect {
|
|
self.layout.available(self.cursor, self.rect_finite())
|
|
}
|
|
|
|
pub fn layout(&self) -> &Layout {
|
|
&self.layout
|
|
}
|
|
|
|
// TODO: remove
|
|
pub fn set_layout(&mut self, layout: Layout) {
|
|
self.layout = layout;
|
|
|
|
// TODO: remove this HACK:
|
|
if layout.is_reversed() {
|
|
self.cursor = self.rect_finite().max;
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
pub fn contains_mouse(&self, rect: Rect) -> bool {
|
|
self.ctx.contains_mouse(self.layer, self.clip_rect, rect)
|
|
}
|
|
|
|
pub fn has_kb_focus(&self, id: Id) -> bool {
|
|
self.memory().kb_focus_id == Some(id)
|
|
}
|
|
|
|
pub fn request_kb_focus(&self, id: Id) {
|
|
self.memory().kb_focus_id = Some(id);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
/// 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_unique_id<IdSource>(&self, id_source: IdSource) -> Id
|
|
where
|
|
IdSource: Hash + std::fmt::Debug,
|
|
{
|
|
let id = self.id.with(&id_source);
|
|
// TODO: clip name clash error messages to clip rect
|
|
self.ctx.register_unique_id(id, id_source, self.cursor)
|
|
}
|
|
|
|
/// 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_position_id(&self) -> Id {
|
|
self.id.with(&Id::from_pos(self.cursor))
|
|
}
|
|
|
|
pub fn make_child_id(&self, id_seed: impl Hash) -> Id {
|
|
self.id.with(id_seed)
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Interaction
|
|
|
|
pub fn interact(&self, rect: Rect, id: Id, sense: Sense) -> InteractInfo {
|
|
self.ctx
|
|
.interact(self.layer, self.clip_rect, rect, Some(id), sense)
|
|
}
|
|
|
|
pub fn interact_hover(&self, rect: Rect) -> InteractInfo {
|
|
self.ctx
|
|
.interact(self.layer, self.clip_rect, rect, None, Sense::nothing())
|
|
}
|
|
|
|
pub fn hovered(&self, rect: Rect) -> bool {
|
|
self.interact_hover(rect).hovered
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn response(&mut self, interact: InteractInfo) -> GuiResponse {
|
|
// TODO: unify GuiResponse and InteractInfo. They are the same thing!
|
|
GuiResponse {
|
|
hovered: interact.hovered,
|
|
clicked: interact.clicked,
|
|
active: interact.active,
|
|
rect: interact.rect,
|
|
ctx: self.ctx.clone(),
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Stuff that moves the cursor, i.e. allocates space in this ui!
|
|
|
|
/// 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 allocate_space(&mut self, child_size: Vec2) -> Rect {
|
|
let child_size = self.round_vec_to_pixels(child_size);
|
|
self.cursor = self.round_pos_to_pixels(self.cursor);
|
|
|
|
// For debug rendering
|
|
let too_wide = child_size.x > self.available().width();
|
|
let too_high = child_size.x > self.available().height();
|
|
|
|
let rect = self.reserve_space_impl(child_size);
|
|
|
|
if self.style().debug_widget_rects {
|
|
self.add_paint_cmd(PaintCmd::Rect {
|
|
rect,
|
|
corner_radius: 0.0,
|
|
outline: Some(Outline::new(1.0, LIGHT_BLUE)),
|
|
fill_color: None,
|
|
});
|
|
|
|
let color = color::srgba(200, 0, 0, 255);
|
|
let width = 2.5;
|
|
|
|
let mut paint_line_seg =
|
|
|a, b| self.add_paint_cmd(PaintCmd::line_segment([a, b], color, width));
|
|
|
|
if too_wide {
|
|
paint_line_seg(rect.left_top(), rect.left_bottom());
|
|
paint_line_seg(rect.left_center(), rect.right_center());
|
|
paint_line_seg(rect.right_top(), rect.right_bottom());
|
|
}
|
|
|
|
if too_high {
|
|
paint_line_seg(rect.left_top(), rect.right_top());
|
|
paint_line_seg(rect.center_top(), rect.center_bottom());
|
|
paint_line_seg(rect.left_bottom(), rect.right_bottom());
|
|
}
|
|
}
|
|
|
|
rect
|
|
}
|
|
|
|
/// Reserve this much space and move the cursor.
|
|
/// Returns where to put the widget.
|
|
fn reserve_space_impl(&mut self, child_size: Vec2) -> Rect {
|
|
let available_size = self.available_finite().size();
|
|
let child_rect =
|
|
self.layout
|
|
.allocate_space(&mut self.cursor, &self.style, available_size, child_size);
|
|
self.child_bounds = self.child_bounds.union(child_rect);
|
|
child_rect
|
|
}
|
|
|
|
// ------------------------------------------------
|
|
// Painting related stuff
|
|
|
|
/// 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_cmd(&mut self, paint_cmd: PaintCmd) {
|
|
self.ctx
|
|
.graphics()
|
|
.layer(self.layer)
|
|
.push((self.clip_rect(), paint_cmd))
|
|
}
|
|
|
|
pub fn add_paint_cmds(&mut self, mut cmds: Vec<PaintCmd>) {
|
|
let clip_rect = self.clip_rect();
|
|
self.ctx
|
|
.graphics()
|
|
.layer(self.layer)
|
|
.extend(cmds.drain(..).map(|cmd| (clip_rect, cmd)));
|
|
}
|
|
|
|
/// Insert a paint cmd before existing ones
|
|
pub fn insert_paint_cmd(&mut self, pos: usize, paint_cmd: PaintCmd) {
|
|
self.ctx
|
|
.graphics()
|
|
.layer(self.layer)
|
|
.insert(pos, (self.clip_rect(), paint_cmd));
|
|
}
|
|
|
|
pub fn paint_list_len(&self) -> usize {
|
|
self.ctx.graphics().layer(self.layer).len()
|
|
}
|
|
|
|
/// Paint some debug text at current cursor
|
|
pub fn debug_text(&self, text: impl Into<String>) {
|
|
self.debug_text_at(self.cursor, text);
|
|
}
|
|
|
|
// TODO: AsRef<str>
|
|
pub fn debug_text_at(&self, pos: Pos2, text: impl Into<String>) {
|
|
self.ctx.debug_text(pos, text);
|
|
}
|
|
|
|
pub fn debug_rect(&mut self, rect: Rect, text: impl Into<String>) {
|
|
self.add_paint_cmd(PaintCmd::Rect {
|
|
corner_radius: 0.0,
|
|
fill_color: None,
|
|
outline: Some(Outline::new(1.0, color::RED)),
|
|
rect,
|
|
});
|
|
let align = (Align::Min, Align::Min);
|
|
let text_style = TextStyle::Monospace;
|
|
self.floating_text(rect.min, text.into(), text_style, align, Some(color::RED));
|
|
}
|
|
|
|
/// 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 floating_text(
|
|
&mut self,
|
|
pos: Pos2,
|
|
text: impl Into<String>,
|
|
text_style: TextStyle,
|
|
align: (Align, Align),
|
|
text_color: Option<Color>,
|
|
) -> Rect {
|
|
let font = &self.fonts()[text_style];
|
|
let galley = font.layout_multiline(text.into(), f32::INFINITY);
|
|
let rect = align_rect(Rect::from_min_size(pos, galley.size), align);
|
|
self.add_galley(rect.min, galley, text_style, text_color);
|
|
rect
|
|
}
|
|
|
|
/// Already layed out text.
|
|
pub fn add_galley(
|
|
&mut self,
|
|
pos: Pos2,
|
|
galley: font::Galley,
|
|
text_style: TextStyle,
|
|
color: Option<Color>,
|
|
) {
|
|
let color = color.unwrap_or_else(|| self.style().text_color);
|
|
self.add_paint_cmd(PaintCmd::Text {
|
|
pos,
|
|
galley,
|
|
text_style,
|
|
color,
|
|
});
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Addding Widgets
|
|
|
|
pub fn add(&mut self, widget: impl Widget) -> GuiResponse {
|
|
widget.ui(self)
|
|
}
|
|
|
|
// Convenience functions:
|
|
|
|
pub fn add_label(&mut self, text: impl Into<String>) -> GuiResponse {
|
|
self.add(Label::new(text))
|
|
}
|
|
|
|
pub fn button(&mut self, text: impl Into<String>) -> bool {
|
|
self.add(Button::new(text)).clicked
|
|
}
|
|
|
|
pub fn add_hyperlink(&mut self, url: impl Into<String>) -> GuiResponse {
|
|
self.add(Hyperlink::new(url))
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Addding Containers / Sub-uis:
|
|
|
|
pub fn collapsing<R>(
|
|
&mut self,
|
|
text: impl Into<String>,
|
|
add_contents: impl FnOnce(&mut Ui) -> R,
|
|
) -> Option<R> {
|
|
CollapsingHeader::new(text).show(self, add_contents)
|
|
}
|
|
|
|
/// 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_contents(&mut self, size: Vec2, add_contents: impl FnOnce(&mut Ui)) -> Rect {
|
|
let size = size.min(self.available().size());
|
|
let child_rect = Rect::from_min_size(self.cursor, size);
|
|
let mut child_ui = self.child_ui(child_rect);
|
|
add_contents(&mut child_ui);
|
|
self.allocate_space(child_ui.bounding_size())
|
|
}
|
|
|
|
/// Create a child ui
|
|
pub fn add_custom<R>(&mut self, add_contents: impl FnOnce(&mut Ui) -> R) -> (R, Rect) {
|
|
let child_rect = self.available();
|
|
let mut child_ui = self.child_ui(child_rect);
|
|
let r = add_contents(&mut child_ui);
|
|
let size = child_ui.bounding_size();
|
|
(r, self.allocate_space(size))
|
|
}
|
|
|
|
/// Create a child ui which is indented to the right
|
|
pub fn indent<R>(
|
|
&mut self,
|
|
id_source: impl Hash,
|
|
add_contents: impl FnOnce(&mut Ui) -> R,
|
|
) -> (R, Rect) {
|
|
assert!(
|
|
self.layout().dir() == Direction::Vertical,
|
|
"You can only indent vertical layouts"
|
|
);
|
|
let indent = vec2(self.style.indent, 0.0);
|
|
let child_rect = Rect::from_min_max(self.cursor + indent, self.bottom_right());
|
|
let mut child_ui = Ui {
|
|
id: self.id.with(id_source),
|
|
..self.child_ui(child_rect)
|
|
};
|
|
let ret = add_contents(&mut child_ui);
|
|
let size = child_ui.bounding_size();
|
|
|
|
// draw a grey line on the left to mark the indented section
|
|
let line_start = child_rect.min - indent * 0.5;
|
|
let line_start = line_start.round(); // TODO: round to pixel instead
|
|
let line_end = pos2(line_start.x, line_start.y + size.y - 2.0);
|
|
self.add_paint_cmd(PaintCmd::line_segment(
|
|
[line_start, line_end],
|
|
gray(150, 255),
|
|
self.style.line_width,
|
|
));
|
|
|
|
(ret, self.allocate_space(indent + size))
|
|
}
|
|
|
|
pub fn left_column(&mut self, width: f32) -> Ui {
|
|
self.column(Align::Min, width)
|
|
}
|
|
|
|
pub fn centered_column(&mut self, width: f32) -> Ui {
|
|
self.column(Align::Center, width)
|
|
}
|
|
|
|
pub fn right_column(&mut self, width: f32) -> Ui {
|
|
self.column(Align::Max, width)
|
|
}
|
|
|
|
/// A column ui with a given width.
|
|
pub fn column(&mut self, column_position: Align, width: f32) -> Ui {
|
|
let x = match column_position {
|
|
Align::Min => 0.0,
|
|
Align::Center => self.available().width() / 2.0 - width / 2.0,
|
|
Align::Max => self.available().width() - width,
|
|
};
|
|
self.child_ui(Rect::from_min_size(
|
|
self.cursor + vec2(x, 0.0),
|
|
vec2(width, self.available().height()),
|
|
))
|
|
}
|
|
|
|
/// Start a ui with horizontal layout
|
|
pub fn horizontal<R>(&mut self, add_contents: impl FnOnce(&mut Ui) -> R) -> (R, Rect) {
|
|
self.inner_layout(Layout::horizontal(Align::Min), add_contents)
|
|
}
|
|
|
|
/// Start a ui with vertical layout
|
|
pub fn vertical<R>(&mut self, add_contents: impl FnOnce(&mut Ui) -> R) -> (R, Rect) {
|
|
self.inner_layout(Layout::vertical(Align::Min), add_contents)
|
|
}
|
|
|
|
pub fn inner_layout<R>(
|
|
&mut self,
|
|
layout: Layout,
|
|
add_contents: impl FnOnce(&mut Self) -> R,
|
|
) -> (R, Rect) {
|
|
let child_rect = Rect::from_min_max(self.cursor, self.bottom_right());
|
|
let mut child_ui = Self {
|
|
..self.child_ui(child_rect)
|
|
};
|
|
child_ui.set_layout(layout); // HACK: need a separate call right now
|
|
let ret = add_contents(&mut child_ui);
|
|
let size = child_ui.bounding_size();
|
|
let rect = self.allocate_space(size);
|
|
(ret, rect)
|
|
}
|
|
|
|
/// Temporarily split split an Ui into several columns.
|
|
///
|
|
/// ``` ignore
|
|
/// ui.columns(2, |columns| {
|
|
/// columns[0].add(emigui::widgets::label!("First column"));
|
|
/// columns[1].add(emigui::widgets::label!("Second column"));
|
|
/// });
|
|
/// ```
|
|
pub fn columns<F, R>(&mut self, num_columns: usize, add_contents: F) -> R
|
|
where
|
|
F: FnOnce(&mut [Self]) -> R,
|
|
{
|
|
// TODO: ensure there is space
|
|
let spacing = self.style.item_spacing.x;
|
|
let total_spacing = spacing * (num_columns as f32 - 1.0);
|
|
let column_width = (self.available().width() - total_spacing) / (num_columns as f32);
|
|
|
|
let mut columns: Vec<Self> = (0..num_columns)
|
|
.map(|col_idx| {
|
|
let pos = self.cursor + vec2((col_idx as f32) * (column_width + spacing), 0.0);
|
|
let child_rect =
|
|
Rect::from_min_max(pos, pos2(pos.x + column_width, self.bottom_right().y));
|
|
|
|
Self {
|
|
id: self.make_child_id(&("column", col_idx)),
|
|
..self.child_ui(child_rect)
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
let result = add_contents(&mut columns[..]);
|
|
|
|
let mut sum_width = total_spacing;
|
|
for column in &columns {
|
|
sum_width += column.child_bounds.width();
|
|
}
|
|
|
|
let mut max_height = 0.0;
|
|
for ui in columns {
|
|
let size = ui.bounding_size();
|
|
max_height = size.y.max(max_height);
|
|
}
|
|
|
|
let size = vec2(self.available().width().max(sum_width), max_height);
|
|
self.allocate_space(size);
|
|
result
|
|
}
|
|
|
|
// ------------------------------------------------
|
|
}
|