Make widgets generic over global state

showbits-common/src/node.rs

@@ -5,15 +5,15 @@ use taffy::{
     TaffyTree, TrackSizingFunction,
 };
 
-use crate::Widget;
+use crate::{BoxedWidget, Widget};
 
-pub struct Node {
+pub struct Node<C> {
     layout: Style,
     children: Vec<NodeId>,
-    widget: Option<Box<dyn Widget>>,
+    widget: Option<BoxedWidget<C>>,
 }
 
-impl Node {
+impl<C> Node<C> {
     pub fn empty() -> Self {
         Self {
             layout: Style::default(),
@@ -27,12 +27,12 @@ impl Node {
         self
     }
 
-    pub fn widget<W: Widget + 'static>(mut self, widget: W) -> Self {
+    pub fn widget<W: Widget<C> + 'static>(mut self, widget: W) -> Self {
         self.widget = Some(Box::new(widget));
         self
     }
 
-    pub fn register(self, tree: &mut TaffyTree<Box<dyn Widget>>) -> TaffyResult<NodeId> {
+    pub fn register(self, tree: &mut TaffyTree<BoxedWidget<C>>) -> TaffyResult<NodeId> {
         let id = tree.new_with_children(self.layout, &self.children)?;
         tree.set_node_context(id, self.widget)?;
         Ok(id)
@@ -170,7 +170,7 @@ macro_rules! layout_setter_rect {
     };
 }
 
-impl Node {
+impl<C> Node<C> {
     layout_setter!(display: Display);
 
     layout_setter!(overflow: Point<Overflow>);

showbits-common/src/render.rs

@@ -1,7 +1,7 @@
 use image::RgbImage;
 use taffy::{AvailableSpace, NodeId, Point, Size, TaffyResult, TaffyTree};
 
-use crate::{Rect, Vec2, View, Widget};
+use crate::{BoxedWidget, Rect, Vec2, View};
 
 fn point_to_vec2(point: Point<f32>) -> Vec2 {
     Vec2::new(point.x as i32, point.y as i32)
@@ -11,23 +11,25 @@ fn size_to_vec2(size: Size<f32>) -> Vec2 {
     Vec2::new(size.width as i32, size.height as i32)
 }
 
-fn layout(
-    tree: &mut TaffyTree<Box<dyn Widget>>,
+fn layout<C>(
+    tree: &mut TaffyTree<BoxedWidget<C>>,
+    ctx: &mut C,
     root: NodeId,
     available: Size<AvailableSpace>,
 ) -> TaffyResult<()> {
     tree.enable_rounding(); // Just to make sure
     tree.compute_layout_with_measure(root, available, |known, available, _node, context| {
         if let Some(widget) = context {
-            widget.size(known, available)
+            widget.size(ctx, known, available)
         } else {
             Size::ZERO
         }
     })
 }
 
-fn render_to_view(
-    tree: &mut TaffyTree<Box<dyn Widget>>,
+fn render_to_view<C>(
+    tree: &mut TaffyTree<BoxedWidget<C>>,
+    ctx: &mut C,
     node: NodeId,
     view: &mut View<'_>,
 ) -> anyhow::Result<()> {
@@ -36,8 +38,8 @@ fn render_to_view(
     let mut view = view.dup().zoom(area);
 
     // First pass
-    if let Some(ctx) = tree.get_node_context_mut(node) {
-        ctx.draw_below(&mut view)?;
+    if let Some(widget) = tree.get_node_context_mut(node) {
+        widget.draw_below(ctx, &mut view)?;
     }
 
     // Render children
@@ -48,23 +50,24 @@ fn render_to_view(
     }
     children.sort_unstable_by_key(|(order, _)| *order);
     for (_, child) in children {
-        render_to_view(tree, child, &mut view)?;
+        render_to_view(tree, ctx, child, &mut view)?;
     }
 
     // Second pass
-    if let Some(ctx) = tree.get_node_context_mut(node) {
-        ctx.draw_above(&mut view)?;
+    if let Some(widget) = tree.get_node_context_mut(node) {
+        widget.draw_above(ctx, &mut view)?;
     }
 
     Ok(())
 }
 
-pub fn render(
-    tree: &mut TaffyTree<Box<dyn Widget>>,
+pub fn render<C>(
+    tree: &mut TaffyTree<BoxedWidget<C>>,
+    ctx: &mut C,
     root: NodeId,
     available: Size<AvailableSpace>,
 ) -> anyhow::Result<RgbImage> {
-    layout(tree, root, available)?;
+    layout(tree, ctx, root, available)?;
 
     let layout = tree.layout(root)?;
     assert_eq!(layout.location.x, 0.0);
@@ -73,7 +76,7 @@ pub fn render(
 
     let (width, height) = size_to_vec2(layout.size).to_u32();
     let mut image = RgbImage::new(width, height);
-    render_to_view(tree, root, &mut View::new(&mut image))?;
+    render_to_view(tree, ctx, root, &mut View::new(&mut image))?;
 
     Ok(image)
 }

showbits-common/src/widget.rs

@@ -2,22 +2,29 @@ use taffy::{AvailableSpace, Size};
 
 use crate::{Node, View};
 
-pub trait Widget {
+pub trait Widget<C> {
     #[allow(unused_variables)]
-    fn size(&mut self, known: Size<Option<f32>>, available: Size<AvailableSpace>) -> Size<f32> {
+    fn size(
+        &mut self,
+        ctx: &mut C,
+        known: Size<Option<f32>>,
+        available: Size<AvailableSpace>,
+    ) -> Size<f32> {
         Size::ZERO
     }
 
-    fn draw_below(&mut self, view: &mut View<'_>) -> anyhow::Result<()>;
-    fn draw_above(&mut self, view: &mut View<'_>) -> anyhow::Result<()>;
+    fn draw_below(&mut self, ctx: &mut C, view: &mut View<'_>) -> anyhow::Result<()>;
+    fn draw_above(&mut self, ctx: &mut C, view: &mut View<'_>) -> anyhow::Result<()>;
 }
 
-pub trait WidgetExt {
-    fn node(self) -> Node;
+pub type BoxedWidget<C> = Box<dyn Widget<C>>;
+
+pub trait WidgetExt<C> {
+    fn node(self) -> Node<C>;
 }
 
-impl<W: Widget + 'static> WidgetExt for W {
-    fn node(self) -> Node {
+impl<C, W: Widget<C> + 'static> WidgetExt<C> for W {
+    fn node(self) -> Node<C> {
         Node::empty().widget(self)
     }
 }