reduce layout to one step. clean up code

Author: togglebyte

anathema-backend/src/lib.rs

@@ -9,8 +9,8 @@ use anathema_widgets::layout::{Constraints, LayoutCtx, LayoutFilter, PositionFil
 use anathema_widgets::paint::PaintFilter;
 use anathema_widgets::{GlyphMap, LayoutForEach, PaintChildren, PositionChildren, WidgetTreeView};
 
-pub mod tui;
 pub mod testing;
+pub mod tui;
 
 pub trait Backend {
     fn size(&self) -> Size;
@@ -55,54 +55,45 @@ impl<'rt, 'bp, T: Backend> WidgetCycle<'rt, 'bp, T> {
         }
     }
 
-    fn floating(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, needs_layout: bool) -> Result<()> {
+    fn fixed(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, needs_layout: bool) -> Result<()> {
         // -----------------------------------------------------------------------------
         //   - Layout -
         // -----------------------------------------------------------------------------
         if needs_layout {
-            let filter = LayoutFilter::floating();
+            let filter = LayoutFilter::all();
             self.layout(ctx, filter)?;
         }
 
         // -----------------------------------------------------------------------------
         //   - Position -
         // -----------------------------------------------------------------------------
-        self.position(ctx.attribute_storage, *ctx.viewport, PositionFilter::floating());
+        self.position(ctx.attribute_storage, *ctx.viewport, PositionFilter::fixed());
 
         // -----------------------------------------------------------------------------
         //   - Paint -
         // -----------------------------------------------------------------------------
-        self.paint(ctx, PaintFilter::floating());
+        self.paint(ctx, PaintFilter::fixed());
 
         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)?;
-        }
-
+    fn floating(&mut self, ctx: &mut LayoutCtx<'_, 'bp>) -> Result<()> {
         // -----------------------------------------------------------------------------
         //   - Position -
         // -----------------------------------------------------------------------------
-        self.position(ctx.attribute_storage, *ctx.viewport, PositionFilter::fixed());
+        self.position(ctx.attribute_storage, *ctx.viewport, PositionFilter::floating());
 
         // -----------------------------------------------------------------------------
         //   - Paint -
         // -----------------------------------------------------------------------------
-        self.paint(ctx, PaintFilter::fixed());
+        self.paint(ctx, PaintFilter::floating());
 
         Ok(())
     }
 
     pub fn run(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, needs_layout: bool) -> Result<()> {
         self.fixed(ctx, needs_layout)?;
-        self.floating(ctx, needs_layout)?;
-
+        self.floating(ctx)?;
         Ok(())
     }
 

anathema-backend/src/testing/mod.rs

@@ -4,7 +4,7 @@ use std::time::Duration;
 use anathema_geometry::Size;
 use anathema_value_resolver::AttributeStorage;
 use anathema_widgets::components::events::ComponentEvent;
-use anathema_widgets::paint::{paint, Glyph};
+use anathema_widgets::paint::{Glyph, paint};
 use anathema_widgets::{GlyphMap, PaintChildren};
 use surface::TestSurface;
 
@@ -21,7 +21,7 @@ impl<'a> GlyphSomething<'a> {
         let Some(glyph) = self.inner else { return false };
         match glyph {
             Glyph::Single(lhs, _) => *lhs == rhs,
-            Glyph::Cluster(glyph_index, _) => todo!(),
+            Glyph::Cluster(_glyph_index, _) => todo!(),
         }
     }
 }
@@ -51,7 +51,9 @@ impl TestBackend {
     }
 
     pub fn at(&self, x: usize, y: usize) -> GlyphSomething<'_> {
-        GlyphSomething { inner: self.surface.get(x, y) }
+        GlyphSomething {
+            inner: self.surface.get(x, y),
+        }
     }
 }
 
@@ -60,7 +62,7 @@ impl Backend for TestBackend {
         self.surface.size
     }
 
-    fn next_event(&mut self, timeout: Duration) -> Option<ComponentEvent> {
+    fn next_event(&mut self, _timeout: Duration) -> Option<ComponentEvent> {
         self.event_queue.pop_front()?
     }
 
@@ -77,10 +79,9 @@ impl Backend for TestBackend {
         paint(&mut self.surface, glyph_map, widgets, attribute_storage);
     }
 
-    fn render(&mut self, glyph_map: &mut GlyphMap) {
+    fn render(&mut self, _glyph_map: &mut GlyphMap) {
         // this does nothing here as everything written to the test buffer
     }
 
-    fn clear(&mut self) {
-    }
+    fn clear(&mut self) {}
 }

anathema-backend/src/testing/surface.rs

@@ -12,14 +12,13 @@ pub struct TestSurface {
 impl TestSurface {
     pub fn new(size: Size) -> Self {
         let len = size.width * size.height;
-        let mut lines = vec![Glyph::space(); len as usize];
-
+        let lines = vec![Glyph::space(); len as usize];
         Self { size, lines }
     }
 
-    pub(crate) fn resize(&mut self, new_size: Size, glyph_map: &mut GlyphMap) {
+    pub(crate) fn resize(&mut self, new_size: Size, _glyph_map: &mut GlyphMap) {
         self.size = new_size;
-        panic!("truncate and pop lines outside of the new size")
+        todo!("truncate and pop lines outside of the new size")
     }
 
     pub(crate) fn get(&self, x: usize, y: usize) -> Option<&Glyph> {
@@ -40,7 +39,7 @@ impl WidgetRenderer for TestSurface {
         self.set_style(style, local_pos)
     }
 
-    fn set_style(&mut self, style: Style, local_pos: Pos) {}
+    fn set_style(&mut self, _style: Style, _local_pos: Pos) {}
 
     fn size(&self) -> Size {
         self.size

anathema-backend/src/tui/buffer.rs

@@ -211,7 +211,7 @@ impl Buffer {
             // If this is a unicode char that is wider than one cell,
             // add a continuation cell if it fits, this way if we overwrite it
             // we can set the continuation cell to `Empty`.
-            if pos.x < self.size.width as u16 {
+            if pos.x < self.size.width {
                 if let 2.. = c.width() {
                     self.put(Cell::continuation(cell.style), LocalPos::new(pos.x + 1, pos.y));
                 }

anathema-backend/src/tui/events.rs

@@ -19,7 +19,7 @@ impl Events {
     pub fn poll(&self, timeout: Duration) -> Option<ComponentEvent> {
         match crossterm::event::poll(timeout).ok()? {
             true => {
-                let event = read().map(Into::into).ok()?;
+                let event = read().ok()?;
 
                 let event = match event {
                     CTEvent::Paste(_) => ComponentEvent::Noop,

anathema-backend/src/tui/mod.rs

@@ -3,8 +3,7 @@
 //! It uses two buffers and only draws the diffs from top left to bottom right, making it less
 //! likely to flicker when moving the cursor etc.
 #![deny(missing_docs)]
-use std::fs::File;
-use std::io::{BufWriter, Stdout, Write};
+use std::io::{Stdout, Write};
 use std::ops::Add;
 use std::time::Duration;
 

anathema-backend/src/tui/screen.rs

@@ -67,8 +67,8 @@ impl Screen {
     /// Erase a specific region.
     /// Will reset the styles for all the cells as well.
     pub(crate) fn erase_region(&mut self, pos: LocalPos, size: Size) {
-        let to_x = (size.width as u16 + pos.x).min(self.size().width as u16);
-        let to_y = (size.height as u16 + pos.y).min(self.size().height as u16);
+        let to_x = (size.width + pos.x).min(self.size().width);
+        let to_y = (size.height + pos.y).min(self.size().height);
 
         for x in pos.x.min(to_x)..to_x {
             for y in pos.y.min(to_y)..to_y {
@@ -169,7 +169,7 @@ mod test {
         for y in 0..size.height {
             let c = y.to_string().chars().next().unwrap();
             for x in 0..size.width {
-                screen.paint_glyph(Glyph::from_char(c, 1), LocalPos::new(x as u16, y as u16));
+                screen.paint_glyph(Glyph::from_char(c, 1), LocalPos::new(x, y));
             }
         }
 

anathema-default-widgets/src/border.rs

@@ -64,7 +64,7 @@ impl TryFrom<&ValueKind<'_>> for Sides {
     fn try_from(value: &ValueKind<'_>) -> Result<Self, Self::Error> {
         let mut sides = Sides::EMPTY;
         match value {
-            ValueKind::Str(cow) => Sides::from_str(&*cow),
+            ValueKind::Str(cow) => Sides::from_str(cow),
             ValueKind::List(list) => {
                 for x in list {
                     sides |= Sides::try_from(x)?;
@@ -85,7 +85,7 @@ impl TryFrom<&ValueKind<'_>> for Sides {
                 }
                 Ok(sides)
             }
-            _ => return Err(()),
+            _ => Err(()),
         }
     }
 }
@@ -259,16 +259,16 @@ impl BorderPainter {
             end_cap: (border_size.top_right > 0).then(|| Brush::new(glyphs[2], border_size.top_right)),
             start: LocalPos::ZERO,
             axis: Axis::Horizontal,
-            end: size.width as u16,
+            end: size.width,
         };
 
         let bottom = Line {
             start_cap: (border_size.bottom_left > 0).then(|| Brush::new(glyphs[6], border_size.bottom_left)),
             middle: (border_size.bottom > 0).then(|| Brush::new(glyphs[5], border_size.bottom)),
             end_cap: (border_size.bottom_right > 0).then(|| Brush::new(glyphs[4], border_size.bottom_right)),
-            start: LocalPos::new(0, height as u16 - 1),
+            start: LocalPos::new(0, height - 1),
             axis: Axis::Horizontal,
-            end: size.width as u16,
+            end: size.width,
         };
 
         if bottom.will_draw() {
@@ -286,7 +286,7 @@ impl BorderPainter {
             end_cap: None,
             start: LocalPos::new(0, offset),
             axis: Axis::Vertical,
-            end: height as u16,
+            end: height,
         };
 
         let right = Line {
@@ -295,7 +295,7 @@ impl BorderPainter {
             end_cap: None,
             start: LocalPos::new(size.width - border_size.right as u16, offset),
             axis: Axis::Vertical,
-            end: height as u16,
+            end: height,
         };
 
         Self {

anathema-default-widgets/src/layout/many.rs

@@ -80,7 +80,6 @@ impl Many {
         mut children: LayoutForEach<'_, 'bp>,
         constraints: Constraints,
         ctx: &mut LayoutCtx<'_, 'bp>,
-        offset: usize,
     ) -> Result<Size> {
         let max_constraints = constraints;
 
@@ -89,7 +88,7 @@ impl Many {
 
         let mut size = Size::ZERO;
 
-        _ = children.skip(offset).each(ctx, |ctx, node, children| {
+        _ = children.each(ctx, |ctx, node, children| {
             if ["spacer", "expand"].contains(&node.ident) {
                 return Ok(ControlFlow::Continue(()));
             }

anathema-default-widgets/src/overflow.rs

@@ -115,7 +115,6 @@ impl Widget for Overflow {
     ) -> Result<Size> {
         let attributes = ctx.attribute_storage.get(id);
         let axis = attributes.get_as(AXIS).unwrap_or(Axis::Vertical);
-        let offset = attributes.get_as::<usize>("offest").unwrap_or_default();
 
         let output_size: Size = (constraints.max_width(), constraints.max_height()).into();
 
@@ -144,7 +143,7 @@ impl Widget for Overflow {
         let mut many = Many::new(self.direction, axis, unconstrained);
 
         // NOTE: we use the inner size here from many.layout
-        _ = many.layout(children, constraints, ctx, offset)?;
+        _ = many.layout(children, constraints, ctx)?;
 
         self.inner_size = many.used_size.inner_size();