Big push: rewrote how state are handled in templates

Author: togglebyte

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "anathema"
-edition = "2021"
+edition = "2024"
 version = "0.2.0"
 license = "MIT"
 description = "Create beautiful, easily customisable terminal applications"
@@ -22,13 +22,20 @@ anathema-store = { path = "./anathema-store" }
 anathema-templates = { path = "./anathema-templates" }
 anathema-widgets = { path = "./anathema-widgets" }
 anathema-geometry = { path = "./anathema-geometry" }
+anathema-strings = { path = "./anathema-strings" }
+anathema-value-resolver = { path = "./anathema-value-resolver" }
+
+[features]
+default = []
+profile = ["anathema-runtime/profile", "anathema-widgets/profile", "anathema-backend/profile"]
+debuggy = ["anathema-widgets/debuggy"]
 
 [lints]
 workspace = true
 
 [workspace.package]
 version = "0.2.0"
-edition = "2021"
+edition = "2024"
 
 [workspace.dependencies]
 bitflags = "2.4.1"
@@ -47,8 +54,10 @@ members = [
     "anathema-state",
     "anathema-state-derive",
     "anathema-store",
+    "anathema-strings",
     "anathema-templates", 
     "anathema-widgets", 
+    "anathema-value-resolver", 
 ]
 
 [workspace.lints.rust]

anathema-backend/Cargo.toml

@@ -7,11 +7,18 @@ edition.workspace = true
 anathema-geometry = { path = "../anathema-geometry" }
 anathema-state = { path = "../anathema-state" }
 anathema-store = { path = "../anathema-store" }
-anathema-widgets = { path = "../anathema-widgets" }
+anathema-strings = { path = "../anathema-strings" }
 anathema-templates = { path = "../anathema-templates" }
+anathema-value-resolver = { path = "../anathema-value-resolver" }
+anathema-widgets = { path = "../anathema-widgets" }
 crossterm = { workspace = true }
 unicode-width = { workspace = true }
 bitflags = { workspace = true }
+puffin = { version = "0.19.1", optional = true }
+
+[features]
+default = []
+profile = ["puffin"]
 
 [lints]
 workspace = true

anathema-backend/src/lib.rs

@@ -1,12 +1,14 @@
+use std::ops::ControlFlow;
 use std::time::Duration;
 
 use anathema_geometry::{Pos, Size};
-use anathema_store::tree::{AsNodePath, Node, TreeValues};
+use anathema_value_resolver::{AttributeStorage, Scope};
 use anathema_widgets::components::events::Event;
-use anathema_widgets::layout::{layout_widget, position_widget, Constraints, LayoutCtx, LayoutFilter, Viewport};
-use anathema_widgets::{AttributeStorage, Element, FloatingWidgets, GlyphMap, WidgetKind, WidgetTree};
+use anathema_widgets::error::Result;
+use anathema_widgets::layout::{Constraints, LayoutCtx, LayoutFilter, PositionFilter, Viewport};
+use anathema_widgets::paint::PaintFilter;
+use anathema_widgets::{GlyphMap, LayoutForEach, PaintChildren, PositionChildren, WidgetTreeView};
 
-pub mod test;
 pub mod tui;
 
 pub trait Backend {
@@ -20,11 +22,8 @@ pub trait Backend {
     fn paint<'bp>(
         &mut self,
         glyph_map: &mut GlyphMap,
-        element: &mut Element<'bp>,
-        children: &[Node],
-        values: &mut TreeValues<WidgetKind<'bp>>,
+        widgets: PaintChildren<'_, 'bp>,
         attribute_storage: &AttributeStorage<'bp>,
-        ignore_floats: bool,
     );
 
     /// Called by the runtime at the end of the frame.
@@ -42,93 +41,101 @@ pub trait Backend {
 // a less silly name
 pub struct WidgetCycle<'rt, 'bp, T> {
     backend: &'rt mut T,
-    tree: &'rt mut WidgetTree<'bp>,
-    glyph_map: &'rt mut GlyphMap,
+    tree: WidgetTreeView<'rt, 'bp>,
     constraints: Constraints,
-    attribute_storage: &'rt AttributeStorage<'bp>,
-    floating_widgets: &'rt FloatingWidgets,
-    viewport: Viewport,
 }
 
 impl<'rt, 'bp, T: Backend> WidgetCycle<'rt, 'bp, T> {
-    pub fn new(
-        backend: &'rt mut T,
-        tree: &'rt mut WidgetTree<'bp>,
-        glyph_map: &'rt mut GlyphMap,
-        constraints: Constraints,
-        attribute_storage: &'rt AttributeStorage<'bp>,
-        floating_widgets: &'rt FloatingWidgets,
-        viewport: Viewport,
-    ) -> Self {
+    pub fn new(backend: &'rt mut T, tree: WidgetTreeView<'rt, 'bp>, constraints: Constraints) -> Self {
         Self {
             backend,
             tree,
-            glyph_map,
             constraints,
-            attribute_storage,
-            floating_widgets,
-            viewport,
         }
     }
 
-    fn floating(&mut self) {
-        // Floating widgets
-        for widget_id in self.floating_widgets.iter() {
-            // Find the parent widget and get the position
-            // If no parent element is found assume Pos::ZERO
-            let mut parent = self.tree.path_ref(*widget_id).parent();
-            let (pos, constraints) = loop {
-                match parent {
-                    None => break (Pos::ZERO, self.constraints),
-                    Some(p) => match self.tree.get_ref_by_path(p) {
-                        Some(WidgetKind::Element(el)) => {
-                            let bounds = el.inner_bounds();
-                            break (bounds.from, Constraints::from(bounds));
-                        }
-                        _ => parent = p.parent(),
-                    },
-                }
-            };
-
-            self.tree.with_nodes_and_values(*widget_id, |widget, children, values| {
-                let WidgetKind::Element(el) = widget else { unreachable!("this is always a floating widget") };
-                let mut layout_ctx = LayoutCtx::new(self.attribute_storage, &self.viewport, self.glyph_map);
-
-                layout_widget(el, children, values, constraints, &mut layout_ctx, true);
-
-                // Position
-                position_widget(pos, el, children, values, self.attribute_storage, true, self.viewport);
-
-                // Paint
-                self.backend
-                    .paint(self.glyph_map, el, children, values, self.attribute_storage, true);
-            });
+    fn floating(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, needs_layout: bool) -> Result<()> {
+        // -----------------------------------------------------------------------------
+        //   - Layout -
+        // -----------------------------------------------------------------------------
+        if needs_layout {
+            let filter = LayoutFilter::floating();
+            self.layout(ctx, filter)?;
         }
+
+        // -----------------------------------------------------------------------------
+        //   - Position -
+        // -----------------------------------------------------------------------------
+        self.position(ctx.attribute_storage, *ctx.viewport, PositionFilter::floating());
+
+        // -----------------------------------------------------------------------------
+        //   - Paint -
+        // -----------------------------------------------------------------------------
+        self.paint(ctx, PaintFilter::floating());
+
+        Ok(())
+    }
+
+    fn fixed(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, needs_layout: bool) -> Result<()> {
+        // -----------------------------------------------------------------------------
+        //   - Layout -
+        // -----------------------------------------------------------------------------
+        if needs_layout {
+            let filter = LayoutFilter::fixed();
+            self.layout(ctx, filter)?;
+        }
+
+        // -----------------------------------------------------------------------------
+        //   - Position -
+        // -----------------------------------------------------------------------------
+        self.position(ctx.attribute_storage, *ctx.viewport, PositionFilter::fixed());
+
+        // -----------------------------------------------------------------------------
+        //   - Paint -
+        // -----------------------------------------------------------------------------
+        self.paint(ctx, PaintFilter::fixed());
+
+        Ok(())
     }
 
-    pub fn run(&mut self) {
-        let mut filter = LayoutFilter::new(true, self.attribute_storage);
-        self.tree.for_each(&mut filter).first(&mut |widget, children, values| {
-            // Layout
-            let mut layout_ctx = LayoutCtx::new(self.attribute_storage, &self.viewport, self.glyph_map);
-            layout_widget(widget, children, values, self.constraints, &mut layout_ctx, true);
-
-            // Position
-            position_widget(
-                Pos::ZERO,
-                widget,
-                children,
-                values,
-                self.attribute_storage,
-                true,
-                self.viewport,
-            );
-
-            // Paint
-            self.backend
-                .paint(self.glyph_map, widget, children, values, self.attribute_storage, true);
+    pub fn run(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, needs_layout: bool) -> Result<()> {
+        self.fixed(ctx, needs_layout)?;
+        self.floating(ctx, needs_layout)?;
+
+        Ok(())
+    }
+
+    fn layout(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, filter: LayoutFilter) -> Result<()> {
+        #[cfg(feature = "profile")]
+        puffin::profile_function!();
+        let tree = self.tree.view_mut();
+
+        let scope = Scope::root();
+        let mut for_each = LayoutForEach::new(tree, &scope, filter, None);
+        let constraints = self.constraints;
+        _ = for_each.each(ctx, |ctx, widget, children| {
+            let _ = widget.layout(children, constraints, ctx)?;
+            Ok(ControlFlow::Break(()))
+        })?;
+        Ok(())
+    }
+
+    fn position(&mut self, attributes: &AttributeStorage<'bp>, viewport: Viewport, filter: PositionFilter) {
+        #[cfg(feature = "profile")]
+        puffin::profile_function!();
+
+        let mut for_each = PositionChildren::new(self.tree.view_mut(), attributes, filter);
+        _ = for_each.each(|widget, children| {
+            widget.position(children, Pos::ZERO, attributes, viewport);
+            ControlFlow::Break(())
         });
+    }
+
+    fn paint(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, filter: PaintFilter) {
+        #[cfg(feature = "profile")]
+        puffin::profile_function!();
 
-        self.floating();
+        let for_each = PaintChildren::new(self.tree.view_mut(), ctx.attribute_storage, filter);
+        self.backend.paint(ctx.glyph_map, for_each, ctx.attribute_storage);
     }
 }