TAG TECHNOLOGY

src/layout/ui.rs

@@ -1,46 +1,60 @@
 use crate::{
-    HashMap, Painter, Widget, WidgetId, WidgetLike,
+    HashMap, Painter, Vec2, Widget, WidgetId, WidgetLike,
     primitive::Primitives,
-    util::{ID, IDTracker},
+    util::{IDTracker, Id},
 };
 use std::{
     any::{Any, TypeId},
     ops::{Index, IndexMut},
 };
 
-#[derive(Default)]
-pub struct Ui {
+pub struct Ui<Ctx> {
     ids: IDTracker,
     base: Option<WidgetId>,
-    widgets: Widgets,
+    widgets: Widgets<Ctx>,
     updates: Vec<WidgetId>,
     primitives: Primitives,
     full_redraw: bool,
 }
 
-#[derive(Default)]
-pub struct Widgets(HashMap<ID, Box<dyn Widget>>);
+pub struct MouseState {
+    pos: Vec2,
+    primary: ButtonState,
+    secondary: ButtonState,
+}
 
-impl Ui {
-    pub fn add<W: Widget>(&mut self, w: impl WidgetLike<Widget = W>) -> WidgetId<W> {
+pub enum ButtonState {
+    JustPressed,
+    Pressed,
+    Released,
+}
+
+#[derive(Default)]
+pub struct Widgets<Ctx>(HashMap<Id, Box<dyn Widget<Ctx>>>);
+
+impl<Ctx> Ui<Ctx> {
+    pub fn add<W: Widget<Ctx>, Tag>(
+        &mut self,
+        w: impl WidgetLike<Ctx, Tag, Widget = W>,
+    ) -> WidgetId<W> {
         w.add(self)
     }
 
-    pub fn add_widget<W: Widget>(&mut self, w: W) -> WidgetId<W> {
+    pub fn add_widget<W: Widget<Ctx>>(&mut self, w: W) -> WidgetId<W> {
         self.push(w)
     }
 
-    pub fn push<W: Widget>(&mut self, w: W) -> WidgetId<W> {
+    pub fn push<W: Widget<Ctx>>(&mut self, w: W) -> WidgetId<W> {
         let id = self.ids.next();
         self.widgets.insert(id.duplicate(), w);
         WidgetId::new(id, TypeId::of::<W>())
     }
 
-    pub fn set<W: Widget>(&mut self, i: &WidgetId<W>, w: W) {
+    pub fn set<W: Widget<Ctx>>(&mut self, i: &WidgetId<W>, w: W) {
         self.widgets.insert(i.id.duplicate(), w);
     }
 
-    pub fn set_base(&mut self, w: impl WidgetLike) {
+    pub fn set_base<Tag>(&mut self, w: impl WidgetLike<Ctx, Tag>) {
         self.base = Some(w.add(self).erase_type());
         self.full_redraw = true;
     }
@@ -49,36 +63,42 @@ impl Ui {
         Self::default()
     }
 
-    pub fn get<W: Widget>(&self, id: &WidgetId<W>) -> Option<&W> {
+    pub fn get<W: Widget<Ctx>>(&self, id: &WidgetId<W>) -> Option<&W> {
         self.widgets.get(id)
     }
 
-    pub fn get_mut<W: Widget>(&mut self, id: &WidgetId<W>) -> Option<&mut W> {
+    pub fn get_mut<W: Widget<Ctx>>(&mut self, id: &WidgetId<W>) -> Option<&mut W> {
         self.widgets.get_mut(id)
     }
 
-    pub fn id<W: Widget>(&mut self) -> WidgetId<W> {
+    pub fn id<W: Widget<Ctx>>(&mut self) -> WidgetId<W> {
         WidgetId::new(self.ids.next(), TypeId::of::<W>())
     }
 
-    pub fn redraw_all(&mut self) {
-        let mut painter = Painter::new(&self.widgets);
+    pub fn redraw_all(&mut self, ctx: &mut Ctx)
+    where
+        Ctx: 'static,
+    {
+        let mut painter = Painter::new(&self.widgets, ctx);
         if let Some(base) = &self.base {
             painter.draw(base);
         }
         self.primitives = painter.finish();
     }
 
-    pub fn update(&mut self) -> Option<&Primitives> {
+    pub fn update(&mut self, ctx: &mut Ctx) -> Option<&Primitives>
+    where
+        Ctx: 'static,
+    {
         if self.full_redraw {
-            self.redraw_all();
+            self.redraw_all(ctx);
             self.full_redraw = false;
             return Some(&self.primitives);
         }
         if self.updates.is_empty() {
             return None;
         }
-        self.redraw_all();
+        self.redraw_all(ctx);
         self.updates.drain(..);
         Some(&self.primitives)
     }
@@ -86,9 +106,11 @@ impl Ui {
     pub fn needs_redraw(&self) -> bool {
         self.full_redraw || !self.updates.is_empty()
     }
+
+    pub fn set_mouse_pos(&mut self) {}
 }
 
-impl<W: Widget> Index<&WidgetId<W>> for Ui {
+impl<W: Widget<Ctx>, Ctx> Index<&WidgetId<W>> for Ui<Ctx> {
     type Output = W;
 
     fn index(&self, id: &WidgetId<W>) -> &Self::Output {
@@ -96,36 +118,40 @@ impl<W: Widget> Index<&WidgetId<W>> for Ui {
     }
 }
 
-impl<W: Widget> IndexMut<&WidgetId<W>> for Ui {
+impl<W: Widget<Ctx>, Ctx> IndexMut<&WidgetId<W>> for Ui<Ctx> {
     fn index_mut(&mut self, id: &WidgetId<W>) -> &mut Self::Output {
         self.updates.push(id.clone().erase_type());
         self.get_mut(id).unwrap()
     }
 }
 
-impl Widgets {
-    pub fn get_dyn(&self, id: &WidgetId) -> &dyn Widget {
+impl<Ctx> Widgets<Ctx> {
+    pub fn new() -> Self {
+        Self(HashMap::new())
+    }
+
+    pub fn get_dyn(&self, id: &WidgetId) -> &dyn Widget<Ctx> {
         self.0.get(&id.id).unwrap().as_ref()
     }
 
-    pub fn get<W: Widget>(&self, id: &WidgetId<W>) -> Option<&W> {
+    pub fn get<W: Widget<Ctx>>(&self, id: &WidgetId<W>) -> Option<&W> {
         self.0.get(&id.id).unwrap().as_any().downcast_ref()
     }
 
-    pub fn get_mut<W: Widget>(&mut self, id: &WidgetId<W>) -> Option<&mut W> {
+    pub fn get_mut<W: Widget<Ctx>>(&mut self, id: &WidgetId<W>) -> Option<&mut W> {
         self.0.get_mut(&id.id).unwrap().as_any_mut().downcast_mut()
     }
 
-    pub fn insert(&mut self, id: ID, widget: impl Widget) {
+    pub fn insert(&mut self, id: Id, widget: impl Widget<Ctx>) {
         self.0.insert(id, Box::new(widget));
     }
 
-    pub fn insert_any(&mut self, id: ID, widget: Box<dyn Widget>) {
+    pub fn insert_any(&mut self, id: Id, widget: Box<dyn Widget<Ctx>>) {
         self.0.insert(id, widget);
     }
 }
 
-impl dyn Widget {
+impl<Ctx> dyn Widget<Ctx> {
     pub fn as_any(&self) -> &dyn Any {
         self
     }
@@ -134,3 +160,16 @@ impl dyn Widget {
         self
     }
 }
+
+impl<Ctx> Default for Ui<Ctx> {
+    fn default() -> Self {
+        Self {
+            ids: Default::default(),
+            base: Default::default(),
+            widgets: Widgets::new(),
+            updates: Default::default(),
+            primitives: Default::default(),
+            full_redraw: Default::default(),
+        }
+    }
+}