505 lines
15 KiB
Rust
505 lines
15 KiB
Rust
use std::collections::HashSet;
|
|
|
|
use crate::{font::Font, math::*, types::*};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#[derive(Clone, Copy, Debug, Serialize)]
|
|
pub struct LayoutOptions {
|
|
/// The width and height of a single character (including any spacing).
|
|
/// All text is monospace!
|
|
pub char_size: Vec2,
|
|
|
|
/// Horizontal and vertical padding within a window frame.
|
|
pub window_padding: Vec2,
|
|
|
|
/// Horizontal and vertical spacing between widgets
|
|
pub item_spacing: Vec2,
|
|
|
|
/// Indent foldable regions etc by this much.
|
|
pub indent: f32,
|
|
|
|
/// Default width of sliders, foldout categories etc. TODO: percentage of parent?
|
|
pub width: f32,
|
|
|
|
/// Button size is text size plus this on each side
|
|
pub button_padding: Vec2,
|
|
|
|
/// Checkboxed, radio button and foldables have an icon at the start.
|
|
/// The text starts after this many pixels.
|
|
pub start_icon_width: f32,
|
|
}
|
|
|
|
impl Default for LayoutOptions {
|
|
fn default() -> Self {
|
|
LayoutOptions {
|
|
char_size: vec2(7.2, 14.0),
|
|
item_spacing: vec2(8.0, 4.0),
|
|
window_padding: vec2(6.0, 6.0),
|
|
indent: 21.0,
|
|
width: 250.0,
|
|
button_padding: vec2(5.0, 3.0),
|
|
start_icon_width: 20.0,
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// TODO: rename
|
|
pub struct GuiResponse<'a> {
|
|
/// The mouse is hovering above this
|
|
pub hovered: bool,
|
|
|
|
/// The mouse went got pressed on this thing this frame
|
|
pub clicked: bool,
|
|
|
|
/// The mouse is interacting with this thing (e.g. dragging it)
|
|
pub active: bool,
|
|
|
|
layout: &'a mut Layout,
|
|
}
|
|
|
|
impl<'a> GuiResponse<'a> {
|
|
/// Show some stuff if the item was hovered
|
|
pub fn tooltip<F>(self, add_contents: F) -> Self
|
|
where
|
|
F: FnOnce(&mut Layout),
|
|
{
|
|
if self.hovered {
|
|
let window_pos = self.layout.input.mouse_pos + vec2(16.0, 16.0);
|
|
self.layout.show_popup(window_pos, add_contents);
|
|
}
|
|
self
|
|
}
|
|
|
|
/// Show this text if the item was hovered
|
|
pub fn tooltip_text<S: Into<String>>(self, text: S) -> Self {
|
|
self.tooltip(|popup| {
|
|
popup.label(text);
|
|
})
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#[derive(Clone, Debug, Default)]
|
|
struct Memory {
|
|
/// The widget being interacted with (e.g. dragged, in case of a slider).
|
|
active_id: Option<Id>,
|
|
|
|
/// Which foldable regions are open.
|
|
open_foldables: HashSet<Id>,
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
struct TextFragment {
|
|
/// The start of each character, starting at zero.
|
|
x_offsets: Vec<f32>,
|
|
/// 0 for the first line, n * line_spacing for the rest
|
|
y_offset: f32,
|
|
text: String,
|
|
}
|
|
|
|
type TextFragments = Vec<TextFragment>;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
enum Direction {
|
|
Horizontal,
|
|
Vertical,
|
|
}
|
|
|
|
impl Default for Direction {
|
|
fn default() -> Direction {
|
|
Direction::Vertical
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// TODO: give this a better name
|
|
#[derive(Clone, Debug, Default)]
|
|
struct Layouter {
|
|
/// Doesn't change.
|
|
dir: Direction,
|
|
|
|
/// Changes only along self.dir
|
|
cursor: Vec2,
|
|
|
|
/// We keep track of our max-size along the orthogonal to self.dir
|
|
size: Vec2,
|
|
}
|
|
|
|
impl Layouter {
|
|
/// Reserve this much space and move the cursor.
|
|
fn reserve_space(&mut self, size: Vec2) {
|
|
if self.dir == Direction::Horizontal {
|
|
self.cursor.x += size.x;
|
|
self.size.x += size.x;
|
|
self.size.y = self.size.y.max(size.y);
|
|
} else {
|
|
self.cursor.y += size.y;
|
|
self.size.y += size.y;
|
|
self.size.x = self.size.x.max(size.x);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
type Id = u64;
|
|
|
|
#[derive(Clone)]
|
|
pub struct Layout {
|
|
options: LayoutOptions,
|
|
font: Font, // TODO: Arc?
|
|
input: GuiInput,
|
|
memory: Memory,
|
|
id: Id,
|
|
layouter: Layouter,
|
|
graphics: Vec<GuiCmd>,
|
|
hovering_graphics: Vec<GuiCmd>,
|
|
}
|
|
|
|
impl Layout {
|
|
pub fn new() -> Layout {
|
|
Layout {
|
|
options: Default::default(),
|
|
font: Font::new(13),
|
|
input: Default::default(),
|
|
memory: Default::default(),
|
|
id: Default::default(),
|
|
layouter: Default::default(),
|
|
graphics: Default::default(),
|
|
hovering_graphics: Default::default(),
|
|
}
|
|
}
|
|
|
|
pub fn input(&self) -> &GuiInput {
|
|
&self.input
|
|
}
|
|
|
|
pub fn gui_commands(&self) -> impl Iterator<Item = &GuiCmd> {
|
|
self.graphics.iter().chain(self.hovering_graphics.iter())
|
|
}
|
|
|
|
pub fn options(&self) -> &LayoutOptions {
|
|
&self.options
|
|
}
|
|
|
|
pub fn set_options(&mut self, options: LayoutOptions) {
|
|
self.options = options;
|
|
}
|
|
|
|
// TODO: move
|
|
pub fn new_frame(&mut self, gui_input: GuiInput) {
|
|
self.graphics.clear();
|
|
self.hovering_graphics.clear();
|
|
self.layouter = Default::default();
|
|
self.input = gui_input;
|
|
if !gui_input.mouse_down {
|
|
self.memory.active_id = None;
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
pub fn button<S: Into<String>>(&mut self, text: S) -> GuiResponse {
|
|
let text: String = text.into();
|
|
let id = self.get_id(&text);
|
|
let (text, text_size) = self.layout_text(&text);
|
|
let text_cursor = self.layouter.cursor + self.options.button_padding;
|
|
let (rect, interact) =
|
|
self.reserve_space(text_size + 2.0 * self.options.button_padding, Some(id));
|
|
self.graphics.push(GuiCmd::Button { interact, rect });
|
|
self.add_text(text_cursor, text);
|
|
self.response(interact)
|
|
}
|
|
|
|
pub fn checkbox<S: Into<String>>(&mut self, text: S, checked: &mut bool) -> GuiResponse {
|
|
let text: String = text.into();
|
|
let id = self.get_id(&text);
|
|
let (text, text_size) = self.layout_text(&text);
|
|
let text_cursor = self.layouter.cursor
|
|
+ self.options.button_padding
|
|
+ vec2(self.options.start_icon_width, 0.0);
|
|
let (rect, interact) = self.reserve_space(
|
|
self.options.button_padding
|
|
+ vec2(self.options.start_icon_width, 0.0)
|
|
+ text_size
|
|
+ self.options.button_padding,
|
|
Some(id),
|
|
);
|
|
if interact.clicked {
|
|
*checked = !*checked;
|
|
}
|
|
self.graphics.push(GuiCmd::Checkbox {
|
|
checked: *checked,
|
|
interact,
|
|
rect,
|
|
});
|
|
self.add_text(text_cursor, text);
|
|
self.response(interact)
|
|
}
|
|
|
|
pub fn label<S: Into<String>>(&mut self, text: S) -> GuiResponse {
|
|
let text: String = text.into();
|
|
let (text, text_size) = self.layout_text(&text);
|
|
self.add_text(self.layouter.cursor, text);
|
|
let (_, interact) = self.reserve_space(text_size, None);
|
|
self.response(interact)
|
|
}
|
|
|
|
/// A radio button
|
|
pub fn radio<S: Into<String>>(&mut self, text: S, checked: bool) -> GuiResponse {
|
|
let text: String = text.into();
|
|
let id = self.get_id(&text);
|
|
let (text, text_size) = self.layout_text(&text);
|
|
let text_cursor = self.layouter.cursor
|
|
+ self.options.button_padding
|
|
+ vec2(self.options.start_icon_width, 0.0);
|
|
let (rect, interact) = self.reserve_space(
|
|
self.options.button_padding
|
|
+ vec2(self.options.start_icon_width, 0.0)
|
|
+ text_size
|
|
+ self.options.button_padding,
|
|
Some(id),
|
|
);
|
|
self.graphics.push(GuiCmd::RadioButton {
|
|
checked,
|
|
interact,
|
|
rect,
|
|
});
|
|
self.add_text(text_cursor, text);
|
|
self.response(interact)
|
|
}
|
|
|
|
pub fn slider_f32<S: Into<String>>(
|
|
&mut self,
|
|
text: S,
|
|
value: &mut f32,
|
|
min: f32,
|
|
max: f32,
|
|
) -> GuiResponse {
|
|
debug_assert!(min <= max);
|
|
let text: String = text.into();
|
|
let id = self.get_id(&text);
|
|
let (text, text_size) = self.layout_text(&format!("{}: {:.3}", text, value));
|
|
self.add_text(self.layouter.cursor, text);
|
|
self.layouter.reserve_space(text_size);
|
|
let (slider_rect, interact) = self.reserve_space(
|
|
Vec2 {
|
|
x: self.options.width,
|
|
y: self.options.char_size.y,
|
|
},
|
|
Some(id),
|
|
);
|
|
|
|
if interact.active {
|
|
*value = remap_clamp(
|
|
self.input.mouse_pos.x,
|
|
slider_rect.min().x,
|
|
slider_rect.max().x,
|
|
min,
|
|
max,
|
|
);
|
|
}
|
|
|
|
self.graphics.push(GuiCmd::Slider {
|
|
interact,
|
|
max,
|
|
min,
|
|
rect: slider_rect,
|
|
value: *value,
|
|
});
|
|
|
|
self.response(interact)
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Areas:
|
|
|
|
pub fn foldable<S, F>(&mut self, text: S, add_contents: F) -> GuiResponse
|
|
where
|
|
S: Into<String>,
|
|
F: FnOnce(&mut Layout),
|
|
{
|
|
assert!(
|
|
self.layouter.dir == Direction::Vertical,
|
|
"Horizontal foldable is unimplemented"
|
|
);
|
|
let text: String = text.into();
|
|
let id = self.get_id(&text);
|
|
let (text, text_size) = self.layout_text(&text);
|
|
let text_cursor = self.layouter.cursor + self.options.button_padding;
|
|
let (rect, interact) = self.reserve_space(
|
|
vec2(
|
|
self.options.width,
|
|
text_size.y + 2.0 * self.options.button_padding.y,
|
|
),
|
|
Some(id),
|
|
);
|
|
|
|
if interact.clicked {
|
|
if self.memory.open_foldables.contains(&id) {
|
|
self.memory.open_foldables.remove(&id);
|
|
} else {
|
|
self.memory.open_foldables.insert(id);
|
|
}
|
|
}
|
|
let open = self.memory.open_foldables.contains(&id);
|
|
|
|
self.graphics.push(GuiCmd::FoldableHeader {
|
|
interact,
|
|
rect,
|
|
open,
|
|
});
|
|
self.add_text(text_cursor + vec2(self.options.start_icon_width, 0.0), text);
|
|
|
|
if open {
|
|
let old_id = self.id;
|
|
self.id = id;
|
|
let old_x = self.layouter.cursor.x;
|
|
self.layouter.cursor.x += self.options.indent;
|
|
add_contents(self);
|
|
self.layouter.cursor.x = old_x;
|
|
self.id = old_id;
|
|
}
|
|
|
|
self.response(interact)
|
|
}
|
|
|
|
/// Start a region with horizontal layout
|
|
pub fn horizontal<F>(&mut self, add_contents: F)
|
|
where
|
|
F: FnOnce(&mut Layout),
|
|
{
|
|
let horizontal_layouter = Layouter {
|
|
dir: Direction::Horizontal,
|
|
cursor: self.layouter.cursor,
|
|
..Default::default()
|
|
};
|
|
let old_layouter = std::mem::replace(&mut self.layouter, horizontal_layouter);
|
|
add_contents(self);
|
|
let horizontal_layouter = std::mem::replace(&mut self.layouter, old_layouter);
|
|
self.layouter.reserve_space(horizontal_layouter.size);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Free painting. It is up to the caller to make sure there is room for these.
|
|
pub fn add_paint_command(&mut self, cmd: GuiCmd) {
|
|
self.graphics.push(cmd);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
/// Show a pop-over window
|
|
pub fn show_popup<F>(&mut self, window_pos: Vec2, add_contents: F)
|
|
where
|
|
F: FnOnce(&mut Layout),
|
|
{
|
|
// TODO: less copying
|
|
let mut popup_layout = Layout {
|
|
options: self.options,
|
|
input: self.input,
|
|
font: self.font.clone(),
|
|
memory: self.memory.clone(), // TODO: Arc
|
|
id: self.id,
|
|
layouter: Default::default(),
|
|
graphics: vec![],
|
|
hovering_graphics: vec![],
|
|
};
|
|
popup_layout.layouter.cursor = window_pos + self.options.window_padding;
|
|
|
|
add_contents(&mut popup_layout);
|
|
|
|
// TODO: handle the last item_spacing in a nicer way
|
|
let inner_size = popup_layout.layouter.size - self.options.item_spacing;
|
|
let outer_size = inner_size + 2.0 * self.options.window_padding;
|
|
|
|
let rect = Rect::from_min_size(window_pos, outer_size);
|
|
self.hovering_graphics.push(GuiCmd::Window { rect });
|
|
self.hovering_graphics
|
|
.extend(popup_layout.gui_commands().cloned());
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
fn reserve_space(&mut self, size: Vec2, interaction_id: Option<Id>) -> (Rect, InteractInfo) {
|
|
let rect = Rect {
|
|
pos: self.layouter.cursor,
|
|
size,
|
|
};
|
|
self.layouter
|
|
.reserve_space(size + self.options.item_spacing);
|
|
let hovered = rect.contains(self.input.mouse_pos);
|
|
let clicked = hovered && self.input.mouse_clicked;
|
|
let active = if interaction_id.is_some() {
|
|
if clicked {
|
|
self.memory.active_id = interaction_id;
|
|
}
|
|
self.memory.active_id == interaction_id
|
|
} else {
|
|
false
|
|
};
|
|
|
|
let interact = InteractInfo {
|
|
hovered,
|
|
clicked,
|
|
active,
|
|
};
|
|
(rect, interact)
|
|
}
|
|
|
|
fn get_id(&self, id_str: &str) -> Id {
|
|
use std::hash::Hasher;
|
|
let mut hasher = std::collections::hash_map::DefaultHasher::new();
|
|
hasher.write_u64(self.id);
|
|
hasher.write(id_str.as_bytes());
|
|
hasher.finish()
|
|
}
|
|
|
|
fn layout_text(&self, text: &str) -> (TextFragments, Vec2) {
|
|
let char_size = self.options.char_size;
|
|
let mut cursor_y = 0.0;
|
|
let mut max_width = 0.0;
|
|
let mut text_fragments = Vec::new();
|
|
for line in text.split('\n') {
|
|
let x_offsets = self.font.layout_single_line(&line);
|
|
let line_width = *x_offsets.last().unwrap();
|
|
text_fragments.push(TextFragment {
|
|
x_offsets,
|
|
y_offset: cursor_y,
|
|
text: line.into(),
|
|
});
|
|
|
|
cursor_y += char_size.y;
|
|
max_width = line_width.max(max_width);
|
|
}
|
|
let bounding_size = vec2(max_width, cursor_y);
|
|
(text_fragments, bounding_size)
|
|
}
|
|
|
|
fn add_text(&mut self, pos: Vec2, text: Vec<TextFragment>) {
|
|
for fragment in text {
|
|
self.graphics.push(GuiCmd::Text {
|
|
pos: pos + vec2(0.0, fragment.y_offset),
|
|
style: TextStyle::Label,
|
|
text: fragment.text,
|
|
x_offsets: fragment.x_offsets,
|
|
});
|
|
}
|
|
}
|
|
|
|
fn response(&mut self, interact: InteractInfo) -> GuiResponse {
|
|
GuiResponse {
|
|
hovered: interact.hovered,
|
|
clicked: interact.clicked,
|
|
active: interact.active,
|
|
layout: self,
|
|
}
|
|
}
|
|
}
|