diff --git a/emigui/src/memory.rs b/emigui/src/memory.rs index b83be15b..a91adb56 100644 --- a/emigui/src/memory.rs +++ b/emigui/src/memory.rs @@ -44,10 +44,11 @@ impl Memory { } } + /// TODO: call once at the start of the frame for the current mouse pos pub fn layer_at(&self, pos: Pos2) -> Layer { for window_id in self.window_order.iter().rev() { if let Some(state) = self.windows.get(window_id) { - if state.rect.contains(pos) { + if state.outer_rect.contains(pos) { return Layer::Window(*window_id); } } diff --git a/emigui/src/window.rs b/emigui/src/window.rs index 0c570eab..fdce2f9f 100644 --- a/emigui/src/window.rs +++ b/emigui/src/window.rs @@ -4,12 +4,15 @@ use crate::{mesher::Path, widgets::*, *}; #[derive(Clone, Copy, Debug)] pub struct WindowState { - /// Last known pos/size - /// TODO: replace with outer_pos and inner_rect - /// so we can change style without content resizing. - pub rect: Rect, + /// Last known pos + pub outer_pos: Pos2, + pub inner_size: Vec2, + + /// used for catching clicks: + pub outer_rect: Rect, } +// TODO: separate out resizing into a contained and reusable Resize-region. #[derive(Clone, Debug)] pub struct Window { /// The title of the window and by default the source of its identity. @@ -17,6 +20,9 @@ pub struct Window { /// Put the window here the first time default_pos: Option, + /// Size of the window first time + default_size: Option, + resizeable: bool, // If true, won't allow you to make window so big that it creates spacing @@ -24,6 +30,9 @@ pub struct Window { // If true, won't allow you to resize smaller than that everything fits. expand_to_fit_content: bool, + + min_size: Vec2, + max_size: Option, } impl Default for Window { @@ -31,9 +40,12 @@ impl Default for Window { Self { title: "".to_owned(), default_pos: None, + default_size: None, resizeable: true, shrink_to_fit_content: false, // Normally you want this when resizable = false expand_to_fit_content: true, + min_size: Vec2::splat(16.0), + max_size: None, } } } @@ -51,6 +63,33 @@ impl Window { self } + pub fn default_size(mut self, default_size: Vec2) -> Self { + self.default_size = Some(default_size); + self + } + + pub fn min_size(mut self, min_size: Vec2) -> Self { + self.min_size = min_size; + self + } + + pub fn max_size(mut self, max_size: Vec2) -> Self { + self.max_size = Some(max_size); + self + } + + pub fn fixed_size(mut self, size: Vec2) -> Self { + self.shrink_to_fit_content = false; + self.shrink_to_fit_content = false; + self.expand_to_fit_content = false; + self.default_size = Some(size); + self.min_size = size; + self.max_size = Some(size); + self + } + + /// Can you resize it with the mouse? + /// Note that a window can still auto-resize pub fn resizeable(mut self, resizeable: bool) -> Self { self.resizeable = resizeable; self @@ -65,21 +104,37 @@ impl Window { self.expand_to_fit_content = expand_to_fit_content; self } +} +impl Window { pub fn show(self, ctx: &Arc, add_contents: F) where F: FnOnce(&mut Region), { + let style = ctx.style(); + let window_padding = style.window_padding; + + let min_inner_size = self.min_size; + let max_inner_size = self + .max_size + .unwrap_or(ctx.input.screen_size - 2.0 * window_padding); + let default_pos = self.default_pos.unwrap_or(pos2(100.0, 100.0)); // TODO - let default_size = vec2(200.0, 50.0); // TODO - let default_rect = Rect::from_min_size(default_pos, default_size); + let default_inner_size = self.default_size.unwrap_or(vec2(200.0, 200.0)); let id = ctx.make_unique_id(&self.title, default_pos); let (mut state, is_new_window) = match ctx.memory.lock().get_window(id) { Some(state) => (state, false), None => { - let state = WindowState { rect: default_rect }; + let state = WindowState { + outer_pos: default_pos, + inner_size: default_inner_size, + outer_rect: Rect::from_min_size( + default_pos, + default_inner_size + 2.0 * window_padding, + ), + }; (state, true) } }; @@ -87,13 +142,7 @@ impl Window { let layer = Layer::Window(id); let where_to_put_background = ctx.graphics.lock().layer(layer).len(); - let style = ctx.style(); - let window_padding = style.window_padding; - - let inner_rect = Rect::from_min_size( - state.rect.min() + window_padding, - state.rect.size() - 2.0 * window_padding, - ); + let inner_rect = Rect::from_min_size(state.outer_pos + window_padding, state.inner_size); let mut contents_region = Region::new(ctx.clone(), layer, id, inner_rect); // TODO: handle contents_region.clip_rect while resizing @@ -103,23 +152,23 @@ impl Window { add_contents(&mut contents_region); - // Now insert window background: - // TODO: handle the last item_spacing in a nicer way - let inner_size = contents_region.bounding_size - style.item_spacing; - let inner_size = inner_size.ceil(); // Avoid rounding errors in math - let desired_outer_size = inner_size + 2.0 * window_padding; - let mut new_outer_size = state.rect.size(); + let desired_inner_size = contents_region.bounding_size - style.item_spacing; + let desired_inner_size = desired_inner_size.ceil(); // Avoid rounding errors in math + let mut new_inner_size = state.inner_size; if self.shrink_to_fit_content { - new_outer_size = new_outer_size.min(desired_outer_size); + new_inner_size = new_inner_size.min(desired_inner_size); } - if self.expand_to_fit_content || is_new_window { - new_outer_size = new_outer_size.max(desired_outer_size); + new_inner_size = new_inner_size.max(desired_inner_size); } + new_inner_size = new_inner_size.max(min_inner_size); + new_inner_size = new_inner_size.min(max_inner_size); - state.rect = Rect::from_min_size(state.rect.min(), new_outer_size); + let new_outer_size = new_inner_size + 2.0 * window_padding; + + let outer_rect = Rect::from_min_size(state.outer_pos, new_outer_size); let mut graphics = ctx.graphics.lock(); @@ -132,64 +181,84 @@ impl Window { corner_radius, fill_color: Some(style.background_fill_color()), outline: Some(Outline::new(1.0, color::WHITE)), - rect: state.rect, + rect: outer_rect, }, ), ); let corner_interact = if self.resizeable { // Resize-corner: - let mut path = Path::default(); - let quadrant = 0.0; // Bottom-right - let corner_center = state.rect.max() - Vec2::splat(corner_radius); + let corner_center = outer_rect.max() - Vec2::splat(corner_radius); let corner_rect = Rect::from_min_size(corner_center, Vec2::splat(corner_radius)); - let corner_interact = ctx.interact(layer, corner_rect, Some(id.with(&"corner"))); + let corner_interact = ctx.interact(layer, corner_rect, Some(id.with("corner"))); - // TODO: Path::circle_sector() or something - path.add_point(corner_center, vec2(0.0, -1.0)); - path.add_point(corner_center + vec2(corner_radius, 0.0), vec2(0.0, -1.0)); - path.add_circle_quadrant(corner_center, corner_radius, quadrant); - path.add_point(corner_center + vec2(0.0, corner_radius), vec2(-1.0, 0.0)); - path.add_point(corner_center, vec2(-1.0, 0.0)); - graphics.layer(layer).insert( - where_to_put_background + 1, - ( - Rect::everything(), - PaintCmd::Path { - path, - closed: true, - fill_color: style.interact_fill_color(&corner_interact), - outline: style.interact_outline(&corner_interact), - }, - ), - ); + graphics.layer(layer).push(( + Rect::everything(), + paint_resize_corner(corner_center, corner_radius, &style, &corner_interact), + )); corner_interact } else { InteractInfo::default() }; - let win_interact = ctx.interact(layer, state.rect, Some(id.with(&"window"))); + let win_interact = ctx.interact(layer, outer_rect, Some(id.with("window"))); if corner_interact.active { if let Some(mouse_pos) = ctx.input().mouse_pos { - let new_size = mouse_pos - state.rect.min() + 0.5 * corner_interact.rect.size(); - let min_size = 2.0 * window_padding + Vec2::splat(16.0); // TODO - let new_size = new_size.max(min_size); - state.rect = Rect::from_min_size(state.rect.min(), new_size); + let new_outer_size = + mouse_pos - state.outer_pos + 0.5 * corner_interact.rect.size(); + new_inner_size = new_outer_size - 2.0 * window_padding; + new_inner_size = new_inner_size.max(min_inner_size); + new_inner_size = new_inner_size.min(max_inner_size); } } else if win_interact.active { - state.rect = state.rect.translate(ctx.input().mouse_move); + state.outer_pos += ctx.input().mouse_move; } + state = WindowState { + outer_pos: state.outer_pos, + inner_size: new_inner_size, + outer_rect: outer_rect, + }; + if corner_interact.hovered || corner_interact.active { *ctx.cursor_icon.lock() = CursorIcon::ResizeNorthWestSouthEast; } - let mut memory = ctx.memory.lock(); - if win_interact.active || corner_interact.active { - memory.move_window_to_top(id); + if win_interact.active || corner_interact.active || mouse_pressed_on_window(ctx, id) { + ctx.memory.lock().move_window_to_top(id); } - memory.set_window_state(id, state); + ctx.memory.lock().set_window_state(id, state); + } +} + +fn mouse_pressed_on_window(ctx: &Context, id: Id) -> bool { + if let Some(mouse_pos) = ctx.input.mouse_pos { + ctx.input.mouse_pressed && ctx.memory.lock().layer_at(mouse_pos) == Layer::Window(id) + } else { + false + } +} + +fn paint_resize_corner( + center: Pos2, + radius: f32, + style: &Style, + interact: &InteractInfo, +) -> PaintCmd { + // TODO: Path::circle_sector() or something + let quadrant = 0.0; // Bottom-right + let mut path = Path::default(); + path.add_point(center, vec2(0.0, -1.0)); + path.add_point(center + vec2(radius, 0.0), vec2(0.0, -1.0)); + path.add_circle_quadrant(center, radius, quadrant); + path.add_point(center + vec2(0.0, radius), vec2(-1.0, 0.0)); + path.add_point(center, vec2(-1.0, 0.0)); + PaintCmd::Path { + path, + closed: true, + fill_color: style.interact_fill_color(&interact), + outline: style.interact_outline(&interact), } }