djkato/egui
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Make Region and some Layout members private

Browse source
This commit is contained in:
Emil Ernerfeldt 2021-01-06 13:36:06 +01:00
parent fe491c3b75
commit c969b8d9eb
2 changed files with 36 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

71
egui/src/layout.rs
View file

@ -5,7 +5,7 @@ use crate::{math::*, Align};
/// This describes the bounds and existing contents of an [`Ui`][`crate::Ui`]. /// This describes the bounds and existing contents of an [`Ui`][`crate::Ui`].
/// It is what is used and updated by [`Layout`] when adding new widgets. /// It is what is used and updated by [`Layout`] when adding new widgets.
#[derive(Clone, Copy, Debug)] #[derive(Clone, Copy, Debug)]
pub struct Region { pub(crate) struct Region {
/// This is the minimal size of the `Ui`. /// This is the minimal size of the `Ui`.
/// When adding new widgets, this will generally expand. /// When adding new widgets, this will generally expand.
/// ///
@ -129,6 +129,7 @@ impl Default for Layout {
} }
} }
/// ## Constructors
impl Layout { impl Layout {
pub fn left_to_right() -> Self { pub fn left_to_right() -> Self {
Self { Self {
@ -207,39 +208,40 @@ impl Layout {
..self ..self
} }
} }
}
// ------------------------------------------------------------------------ /// ## Inspectors
impl Layout {
pub fn main_dir(self) -> Direction { pub fn main_dir(&self) -> Direction {
self.main_dir self.main_dir
} }
pub fn main_wrap(self) -> bool { pub fn main_wrap(&self) -> bool {
self.main_wrap self.main_wrap
} }
pub fn cross_align(self) -> Align { pub fn cross_align(&self) -> Align {
self.cross_align self.cross_align
} }
pub fn cross_justify(self) -> bool { pub fn cross_justify(&self) -> bool {
self.cross_justify self.cross_justify
} }
pub fn is_horizontal(self) -> bool { pub fn is_horizontal(&self) -> bool {
self.main_dir().is_horizontal() self.main_dir().is_horizontal()
} }
pub fn is_vertical(self) -> bool { pub fn is_vertical(&self) -> bool {
self.main_dir().is_vertical() self.main_dir().is_vertical()
} }
pub fn prefer_right_to_left(self) -> bool { pub fn prefer_right_to_left(&self) -> bool {
self.main_dir == Direction::RightToLeft self.main_dir == Direction::RightToLeft
|| self.main_dir.is_vertical() && self.cross_align == Align::Max || self.main_dir.is_vertical() && self.cross_align == Align::Max
} }
fn horizontal_align(self) -> Align { fn horizontal_align(&self) -> Align {
match self.main_dir { match self.main_dir {
// Direction::LeftToRight => Align::left(), // Direction::LeftToRight => Align::left(),
// Direction::RightToLeft => Align::right(), // Direction::RightToLeft => Align::right(),
@ -249,7 +251,7 @@ impl Layout {
} }
} }
fn vertical_align(self) -> Align { fn vertical_align(&self) -> Align {
match self.main_dir { match self.main_dir {
// Direction::TopDown => Align::top(), // Direction::TopDown => Align::top(),
// Direction::BottomUp => Align::bottom(), // Direction::BottomUp => Align::bottom(),
@ -258,7 +260,10 @@ impl Layout {
Direction::LeftToRight | Direction::RightToLeft => self.cross_align, Direction::LeftToRight | Direction::RightToLeft => self.cross_align,
} }
} }
}
/// ## Doing layout
impl Layout {
pub fn align_size_within_rect(&self, size: Vec2, outer: Rect) -> Rect { pub fn align_size_within_rect(&self, size: Vec2, outer: Rect) -> Rect {
let x = match self.horizontal_align() { let x = match self.horizontal_align() {
Align::Min => outer.left(), Align::Min => outer.left(),
@ -274,9 +279,7 @@ impl Layout {
Rect::from_min_size(Pos2::new(x, y), size) Rect::from_min_size(Pos2::new(x, y), size)
} }
// ------------------------------------------------------------------------ fn initial_cursor(&self, max_rect: Rect) -> Pos2 {
fn initial_cursor(self, max_rect: Rect) -> Pos2 {
match self.main_dir { match self.main_dir {
Direction::LeftToRight => max_rect.left_top(), Direction::LeftToRight => max_rect.left_top(),
Direction::RightToLeft => max_rect.right_top(), Direction::RightToLeft => max_rect.right_top(),
@ -285,7 +288,7 @@ impl Layout {
} }
} }
pub fn region_from_max_rect(&self, max_rect: Rect) -> Region { pub(crate) fn region_from_max_rect(&self, max_rect: Rect) -> Region {
let cursor = self.initial_cursor(max_rect); let cursor = self.initial_cursor(max_rect);
let min_rect = Rect::from_min_size(cursor, Vec2::zero()); let min_rect = Rect::from_min_size(cursor, Vec2::zero());
Region { Region {
@ -299,7 +302,7 @@ impl Layout {
self.available_from_cursor_max_rect(region.cursor, region.max_rect) self.available_from_cursor_max_rect(region.cursor, region.max_rect)
} }
pub(crate) fn available_size_before_wrap(&self, region: &Region) -> Vec2 { fn available_size_before_wrap(&self, region: &Region) -> Vec2 {
self.available_rect_before_wrap(region).size() self.available_rect_before_wrap(region).size()
} }
@ -307,13 +310,13 @@ impl Layout {
self.available_from_cursor_max_rect(region.cursor, region.max_rect_finite()) self.available_from_cursor_max_rect(region.cursor, region.max_rect_finite())
} }
pub(crate) fn available_size_before_wrap_finite(&self, region: &Region) -> Vec2 { fn available_size_before_wrap_finite(&self, region: &Region) -> Vec2 {
self.available_rect_before_wrap_finite(region).size() self.available_rect_before_wrap_finite(region).size()
} }
/// Amount of space available for a widget. /// Amount of space available for a widget.
/// Wor wrapping layouts, this is the maximum (after wrap) /// For wrapping layouts, this is the maximum (after wrap).
pub fn available_size(&self, r: &Region) -> Vec2 { pub(crate) fn available_size(&self, r: &Region) -> Vec2 {
if self.main_wrap { if self.main_wrap {
if self.main_dir.is_horizontal() { if self.main_dir.is_horizontal() {
vec2(r.max_rect.width(), r.max_rect.bottom() - r.cursor.y) vec2(r.max_rect.width(), r.max_rect.bottom() - r.cursor.y)
@ -328,7 +331,7 @@ impl Layout {
/// Given the cursor in the region, how much space is available /// Given the cursor in the region, how much space is available
/// for the next widget? /// for the next widget?
fn available_from_cursor_max_rect(self, cursor: Pos2, max_rect: Rect) -> Rect { fn available_from_cursor_max_rect(&self, cursor: Pos2, max_rect: Rect) -> Rect {
let mut rect = max_rect; let mut rect = max_rect;
match self.main_dir { match self.main_dir {
@ -358,7 +361,12 @@ impl Layout {
/// This is what you then pass to `advance_after_outer_rect`. /// This is what you then pass to `advance_after_outer_rect`.
/// Use `justify_or_align` to get the inner `Rect`. /// Use `justify_or_align` to get the inner `Rect`.
#[allow(clippy::collapsible_if)] #[allow(clippy::collapsible_if)]
pub fn next_space(self, region: &Region, mut child_size: Vec2, item_spacing: Vec2) -> Rect { pub(crate) fn next_space(
&self,
region: &Region,
mut child_size: Vec2,
item_spacing: Vec2,
) -> Rect {
let mut cursor = region.cursor; let mut cursor = region.cursor;
if self.main_wrap { if self.main_wrap {
@ -423,7 +431,7 @@ impl Layout {
} }
/// Apply justify or alignment after calling `next_space`. /// Apply justify or alignment after calling `next_space`.
pub fn justify_or_align(self, mut rect: Rect, child_size: Vec2) -> Rect { pub(crate) fn justify_or_align(&self, mut rect: Rect, child_size: Vec2) -> Rect {
if self.main_dir.is_horizontal() { if self.main_dir.is_horizontal() {
debug_assert!((rect.width() - child_size.x).abs() < 0.1); debug_assert!((rect.width() - child_size.x).abs() < 0.1);
if self.cross_justify { if self.cross_justify {
@ -454,7 +462,7 @@ impl Layout {
} }
/// Advance the cursor by this many points. /// Advance the cursor by this many points.
pub fn advance_cursor(self, region: &mut Region, amount: f32) { pub(crate) fn advance_cursor(&self, region: &mut Region, amount: f32) {
match self.main_dir { match self.main_dir {
Direction::LeftToRight => region.cursor.x += amount, Direction::LeftToRight => region.cursor.x += amount,
Direction::RightToLeft => region.cursor.x -= amount, Direction::RightToLeft => region.cursor.x -= amount,
@ -463,20 +471,11 @@ impl Layout {
} }
} }
/// Advance the cursor by this spacing
pub fn advance_cursor2(self, region: &mut Region, amount: Vec2) {
if self.main_dir.is_horizontal() {
self.advance_cursor(region, amount.x)
} else {
self.advance_cursor(region, amount.y)
}
}
/// Advance cursor after a widget was added to a specific rectangle. /// Advance cursor after a widget was added to a specific rectangle.
/// `outer_rect` is a hack needed because the Vec2 cursor is not quite sufficient to keep track /// `outer_rect` is a hack needed because the Vec2 cursor is not quite sufficient to keep track
/// of what is happening when we are doing wrapping layouts. /// of what is happening when we are doing wrapping layouts.
pub fn advance_after_outer_rect( pub(crate) fn advance_after_outer_rect(
self, &self,
region: &mut Region, region: &mut Region,
outer_rect: Rect, outer_rect: Rect,
inner_rect: Rect, inner_rect: Rect,
@ -496,7 +495,7 @@ impl Layout {
/// ## Debug stuff /// ## Debug stuff
impl Layout { impl Layout {
/// Shows where the next widget is going to be placed /// Shows where the next widget is going to be placed
pub fn debug_paint_cursor(&self, region: &Region, painter: &crate::Painter) { pub(crate) fn debug_paint_cursor(&self, region: &Region, painter: &crate::Painter) {
use crate::paint::*; use crate::paint::*;
let cursor = region.cursor; let cursor = region.cursor;

2
egui/src/ui.rs
View file

@ -349,7 +349,7 @@ impl Ui {
/// In case of a wrapping layout, how much space is left on this row/column? /// In case of a wrapping layout, how much space is left on this row/column?
pub fn available_size_before_wrap(&self) -> Vec2 { pub fn available_size_before_wrap(&self) -> Vec2 {
self.layout.available_size_before_wrap(&self.region) self.layout.available_rect_before_wrap(&self.region).size()
} }
/// This is like `available_size_before_wrap()`, but will never be infinite. /// This is like `available_size_before_wrap()`, but will never be infinite.