Create Direction enum

examples/app.rs

@@ -22,9 +22,9 @@ impl Component for Counter {
     }
 
     fn view<'a>(&mut self, bump: &'a Bump) -> impl View<'a, Self::Message> {
-        LinearLayout::new((
+        LinearLayout::column((
             format_in!(bump, "High five count: {}", self.count),
-            LinearLayout::new((
+            LinearLayout::row((
                 Text::new("Up high!").on_click(|_| Message::Increment),
                 Text::new("Down low!").on_click(|_| Message::Decrement),
             )),

src/element/linear_layout.rs

@@ -1,27 +1,49 @@
-use crate::{Element, Node, WindowMessage};
+use crate::{Direction, Element, Node, WindowMessage};
 use kurbo::Point;
 use skia_safe::surfaces;
 use taffy::geometry::Size;
 
 pub struct LinearLayoutElement {
     pub(crate) nodes: Vec<Node>,
     pub(crate) points: Vec<(Point, Size<f64>)>,
+    pub(crate) direction: Direction,
 }
 
 impl Element for LinearLayoutElement {
     fn layout(&mut self) -> taffy::prelude::Size<f64> {
-        let mut y = 0.;
+        let mut pos = Point::default();
+        let mut max = 0f64;
         self.points.clear();
         for node in &mut self.nodes {
             let size = node.element.as_element_mut().layout();
-            let point = Point::new(0., y);
+            let point = match self.direction {
+                Direction::Row => {
+                    let point = pos;
+                    pos.x += size.width;
+                    max = max.max(size.height);
+                    point
+                }
+                Direction::Column => {
+                    let point = pos;
+                    pos.y += size.height;
+                    max = max.max(size.width);
+                    point
+                }
+                _ => todo!(),
+            };
             self.points.push((point, size));
-            y += size.height;
         }
-        Size {
-            width: 1000.,
-            height: y,
+        let mut width = pos.x;
+        let mut height = pos.y;
+        match self.direction {
+            Direction::Row => {
+                height = max;
+            }
+            Direction::RowReverse => todo!(),
+            Direction::Column => width = max,
+            Direction::ColumnReverse => todo!(),
         }
+        Size { width, height }
     }
 
     fn handle(&mut self, msg: crate::WindowMessage, output: &mut Vec<Box<dyn std::any::Any>>) {
@@ -35,7 +57,7 @@ impl Element for LinearLayoutElement {
                     {
                         node.element.as_element_mut().handle(
                             WindowMessage::Click {
-                                position: Point::new(point.x, position.y - point.y),
+                                position: Point::new(position.x - point.x, position.y - point.y),
                             },
                             output,
                         );
@@ -54,7 +76,11 @@ impl Element for LinearLayoutElement {
             .unwrap();
             node.element.as_element_mut().render(surface.canvas());
             let image = surface.image_snapshot();
-            canvas.draw_image(image, skia_safe::Point::new(0., point.y as _), None);
+            canvas.draw_image(
+                image,
+                skia_safe::Point::new(point.x as _, point.y as _),
+                None,
+            );
         }
     }
 }

src/lib.rs

@@ -13,7 +13,7 @@ pub use element::Element;
 mod view;
 use kurbo::Point;
 
-pub use view::{LinearLayout, Text, View};
+pub use view::{Direction, LinearLayout, Text, View};
 
 mod view_group;
 pub use view_group::ViewGroup;

src/view/linear_layout.rs

@@ -1,12 +1,29 @@
 use crate::{element::LinearLayoutElement, View, ViewGroup};
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Direction {
+    Row,
+    RowReverse,
+    Column,
+    ColumnReverse,
+}
+
 pub struct LinearLayout<V> {
     view: V,
+    direction: Direction,
 }
 
 impl<V> LinearLayout<V> {
-    pub fn new(view: V) -> Self {
-        Self { view }
+    pub fn new(direction: Direction, view: V) -> Self {
+        Self { view, direction }
+    }
+
+    pub fn row(view: V) -> Self {
+        Self::new(Direction::Row, view)
+    }
+
+    pub fn column(view: V) -> Self {
+        Self::new(Direction::Column, view)
     }
 }
 
@@ -19,6 +36,7 @@ impl<'a, M, V: ViewGroup<'a, M>> View<'a, M> for LinearLayout<V> {
         LinearLayoutElement {
             nodes,
             points: Vec::new(),
+            direction: self.direction,
         }
     }
 

src/view/mod.rs

@@ -1,7 +1,7 @@
 use crate::{element::TextElement, Element};
 
 mod linear_layout;
-pub use linear_layout::LinearLayout;
+pub use linear_layout::{Direction, LinearLayout};
 
 mod text;
 pub use text::Text;