300 lines
9.9 KiB
Rust
300 lines
9.9 KiB
Rust
use std::sync::Arc;
|
|
|
|
use crate::{mesher::Path, widgets::*, *};
|
|
|
|
#[derive(Clone, Copy, Debug)]
|
|
pub struct State {
|
|
/// 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.
|
|
title: String,
|
|
/// Put the window here the first time
|
|
default_pos: Option<Pos2>,
|
|
|
|
/// Size of the window first time
|
|
default_size: Option<Vec2>,
|
|
|
|
resizeable: bool,
|
|
|
|
// If true, won't allow you to make window so big that it creates spacing
|
|
shrink_width_to_fit_content: bool,
|
|
shrink_height_to_fit_content: bool,
|
|
|
|
// If true, won't allow you to resize smaller than that everything fits.
|
|
expand_width_to_fit_content: bool,
|
|
expand_height_to_fit_content: bool,
|
|
|
|
min_size: Vec2,
|
|
max_size: Option<Vec2>,
|
|
}
|
|
|
|
impl Default for Window {
|
|
fn default() -> Self {
|
|
Self {
|
|
title: "".to_owned(),
|
|
default_pos: None,
|
|
default_size: None,
|
|
resizeable: true,
|
|
shrink_width_to_fit_content: false,
|
|
shrink_height_to_fit_content: false,
|
|
expand_width_to_fit_content: true,
|
|
expand_height_to_fit_content: true,
|
|
min_size: Vec2::splat(16.0),
|
|
max_size: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Window {
|
|
pub fn new(title: impl Into<String>) -> Self {
|
|
Self {
|
|
title: title.into(),
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
pub fn default_pos(mut self, default_pos: Pos2) -> Self {
|
|
self.default_pos = Some(default_pos);
|
|
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_width_to_fit_content = false;
|
|
self.shrink_height_to_fit_content = false;
|
|
self.expand_width_to_fit_content = false;
|
|
self.expand_height_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
|
|
}
|
|
|
|
// pub fn shrink_to_fit_content(mut self, shrink_to_fit_content: bool) -> Self {
|
|
// self.shrink_to_fit_content = shrink_to_fit_content;
|
|
// self
|
|
// }
|
|
|
|
// pub fn expand_to_fit_content(mut self, expand_to_fit_content: bool) -> Self {
|
|
// self.expand_to_fit_content = expand_to_fit_content;
|
|
// self
|
|
// }
|
|
}
|
|
|
|
impl Window {
|
|
pub fn show(self, ctx: &Arc<Context>, add_contents: impl FnOnce(&mut Region)) {
|
|
let style = ctx.style();
|
|
let window_padding = style.window_padding;
|
|
|
|
let default_pos = self.default_pos.unwrap_or_else(|| pos2(100.0, 100.0)); // TODO
|
|
let default_inner_size = self.default_size.unwrap_or_else(|| vec2(250.0, 250.0));
|
|
|
|
let id = ctx.make_unique_id(&self.title, default_pos);
|
|
|
|
let (mut state, is_new) = match ctx.memory.lock().get_window(id) {
|
|
Some(state) => (state, false),
|
|
None => {
|
|
let state = State {
|
|
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)
|
|
}
|
|
};
|
|
|
|
state.outer_pos = state.outer_pos.round(); // TODO: round to pixel
|
|
|
|
let min_inner_size = self.min_size;
|
|
let max_inner_size = self
|
|
.max_size
|
|
.unwrap_or(Pos2::default() + ctx.input.screen_size - state.outer_pos);
|
|
|
|
let layer = Layer::Window(id);
|
|
let where_to_put_background = ctx.graphics.lock().layer(layer).len();
|
|
|
|
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
|
|
|
|
// Show top bar:
|
|
contents_region.add(Label::new(self.title).text_style(TextStyle::Heading));
|
|
contents_region.add(Separator::new().line_width(1.0).extra(window_padding.x)); // TODO: nicer way to split window title from contents
|
|
|
|
add_contents(&mut contents_region);
|
|
|
|
// TODO: handle the last item_spacing in a nicer way
|
|
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_width_to_fit_content {
|
|
new_inner_size.x = new_inner_size.x.min(desired_inner_size.x);
|
|
}
|
|
if self.shrink_height_to_fit_content {
|
|
new_inner_size.y = new_inner_size.y.min(desired_inner_size.y);
|
|
}
|
|
if self.expand_width_to_fit_content || is_new {
|
|
new_inner_size.x = new_inner_size.x.max(desired_inner_size.x);
|
|
}
|
|
if self.expand_height_to_fit_content || is_new {
|
|
new_inner_size.y = new_inner_size.y.max(desired_inner_size.y);
|
|
}
|
|
new_inner_size = new_inner_size.max(min_inner_size);
|
|
new_inner_size = new_inner_size.min(max_inner_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();
|
|
|
|
let corner_radius = style.window.corner_radius;
|
|
graphics.layer(layer).insert(
|
|
where_to_put_background,
|
|
(
|
|
Rect::everything(),
|
|
PaintCmd::Rect {
|
|
corner_radius,
|
|
fill_color: Some(style.background_fill_color()),
|
|
outline: Some(Outline::new(1.0, color::WHITE)),
|
|
rect: outer_rect,
|
|
},
|
|
),
|
|
);
|
|
|
|
let corner_interact = if self.resizeable {
|
|
// Resize-corner:
|
|
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")));
|
|
|
|
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, &outer_rect, Some(id.with("window")));
|
|
|
|
if corner_interact.active {
|
|
if let Some(mouse_pos) = ctx.input().mouse_pos {
|
|
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.outer_pos += ctx.input().mouse_move;
|
|
}
|
|
|
|
if corner_interact.hovered || corner_interact.active {
|
|
ctx.output.lock().cursor_icon = CursorIcon::ResizeNwSe;
|
|
}
|
|
|
|
state = State {
|
|
outer_pos: state.outer_pos,
|
|
inner_size: new_inner_size,
|
|
outer_rect,
|
|
};
|
|
|
|
// Constrain to screen:
|
|
let margin = 32.0;
|
|
state.outer_pos = state.outer_pos.max(pos2(margin - outer_rect.width(), 0.0));
|
|
state.outer_pos = state.outer_pos.min(pos2(
|
|
ctx.input.screen_size.x - margin,
|
|
ctx.input.screen_size.y - margin,
|
|
));
|
|
|
|
if win_interact.active || corner_interact.active || mouse_pressed_on_window(ctx, id) {
|
|
ctx.memory.lock().move_window_to_top(id);
|
|
}
|
|
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 {
|
|
if false {
|
|
// 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),
|
|
}
|
|
} else {
|
|
let offset = 3.0;
|
|
let center = center;
|
|
let radius = radius - offset;
|
|
let quadrant = 0.0; // Bottom-right
|
|
let mut path = Path::default();
|
|
path.add_circle_quadrant(center, radius, quadrant);
|
|
PaintCmd::Path {
|
|
path,
|
|
closed: false,
|
|
fill_color: None,
|
|
outline: Some(Outline::new(
|
|
style.interact_stroke_width(&interact),
|
|
style.interact_stroke_color(&interact),
|
|
)),
|
|
}
|
|
}
|
|
}
|