155 lines
4.0 KiB
Rust
155 lines
4.0 KiB
Rust
use image::DynamicImage;
|
|
|
|
use crate::{
|
|
layout::{
|
|
IdLike, PainterData, PixelRegion, TextureHandle, Vec2, WidgetHandle, WidgetId,
|
|
WidgetInstance, WidgetLike, WidgetUpdate,
|
|
},
|
|
util::HashSet,
|
|
};
|
|
use std::sync::mpsc::{Receiver, channel};
|
|
|
|
pub struct Ui {
|
|
pub(crate) data: PainterData,
|
|
root: Option<WidgetHandle>,
|
|
updates: HashSet<WidgetId>,
|
|
free: Vec<WidgetId>,
|
|
recv: Receiver<WidgetUpdate>,
|
|
full_redraw: bool,
|
|
resized: bool,
|
|
}
|
|
|
|
impl Ui {
|
|
pub fn set_root<Tag>(&mut self, w: impl WidgetLike<Tag>) {
|
|
self.root = Some(w.add(self));
|
|
self.full_redraw = true;
|
|
}
|
|
|
|
pub fn new() -> Self {
|
|
Self::default()
|
|
}
|
|
|
|
pub fn add_texture(&mut self, image: DynamicImage) -> TextureHandle {
|
|
self.data.textures.add(image)
|
|
}
|
|
|
|
pub fn resize(&mut self, size: impl Into<Vec2>) {
|
|
self.data.output_size = size.into();
|
|
self.resized = true;
|
|
}
|
|
|
|
fn redraw_all(&mut self) {
|
|
for (_, inst) in self.data.active.drain() {
|
|
for m in self.data.modules.iter_mut() {
|
|
m.on_undraw(&inst);
|
|
}
|
|
}
|
|
// free before bc nothing should exist
|
|
self.free();
|
|
if let Some(root) = &self.root {
|
|
self.data.draw(root);
|
|
}
|
|
}
|
|
|
|
pub fn update(&mut self) -> bool {
|
|
for update in self.recv.try_iter() {
|
|
match update {
|
|
WidgetUpdate::Drop(id) => {
|
|
self.free.push(id);
|
|
}
|
|
WidgetUpdate::Mutate(id) => {
|
|
self.updates.insert(id);
|
|
}
|
|
}
|
|
}
|
|
if self.full_redraw {
|
|
self.redraw_all();
|
|
self.full_redraw = false;
|
|
true
|
|
} else if self.resized {
|
|
self.resized = false;
|
|
self.redraw_all();
|
|
true
|
|
} else if !self.updates.is_empty() {
|
|
self.redraw_updates();
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
fn redraw_updates(&mut self) {
|
|
self.data.redraw(std::mem::take(&mut self.updates));
|
|
self.free();
|
|
}
|
|
|
|
/// free any resources that don't have references anymore
|
|
fn free(&mut self) {
|
|
for id in self.free.drain(..) {
|
|
for m in self.data.modules.iter_mut() {
|
|
m.on_remove(&id);
|
|
}
|
|
}
|
|
self.data.textures.free();
|
|
}
|
|
|
|
pub fn needs_redraw(&self) -> bool {
|
|
self.full_redraw || !self.updates.is_empty()
|
|
}
|
|
|
|
pub fn active_widgets(&self) -> usize {
|
|
self.data.active.len()
|
|
}
|
|
|
|
pub fn debug_layers(&self) {
|
|
for ((idx, depth), primitives) in self.data.layers.iter_depth() {
|
|
let indent = " ".repeat(depth * 2);
|
|
let len = primitives.instances().len();
|
|
print!("{indent}{idx}: {len} primitives");
|
|
if len >= 1 {
|
|
print!(" ({})", primitives.instances()[0].binding);
|
|
}
|
|
println!();
|
|
}
|
|
}
|
|
|
|
pub fn window_region<W>(&self, id: &impl IdLike<W>) -> Option<PixelRegion> {
|
|
let region = self.data.active.get(&id.id())?.region;
|
|
Some(region.to_px(self.data.output_size))
|
|
}
|
|
|
|
pub fn debug(&self, label: &str) -> impl Iterator<Item = &WidgetInstance> {
|
|
self.data.active.iter().filter_map(move |(id, inst)| {
|
|
let widget = id.strong().unwrap();
|
|
if widget.get_label().as_str() == label {
|
|
Some(inst)
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
}
|
|
|
|
pub fn data(&self) -> &PainterData {
|
|
&self.data
|
|
}
|
|
|
|
pub fn data_mut(&mut self) -> &mut PainterData {
|
|
&mut self.data
|
|
}
|
|
}
|
|
|
|
impl Default for Ui {
|
|
fn default() -> Self {
|
|
let (send, recv) = channel();
|
|
Self {
|
|
data: PainterData::new(send),
|
|
root: Default::default(),
|
|
updates: Default::default(),
|
|
free: Default::default(),
|
|
full_redraw: false,
|
|
recv,
|
|
resized: false,
|
|
}
|
|
}
|
|
}
|