7 files changed, 75 insertions(+), 60 deletions(-)

M .gitignore
M examples/empty_container.rs
D src/elements/.container.rs.swp
D src/elements/.element.rs.swp
M src/elements/container.rs
A src/elements/macros.rs
M src/elements/mod.rs

@@ 1,1 1,3 @@
 /target
+*.swp
+*~

@@ 2,18 2,12 @@ extern crate lintuini;
 use lintuini::elements::Element;
 use lintuini::elements::Container;
 
-use ratatui::style::{Color, Style};
-use ratatui::widgets::BorderType;
-
 use crossterm::event;
 
 fn main() -> std::io::Result<()> {
-    let fill = Style::default().bg(Color::Blue);
-    let bord_style = Style::default().bg(Color::Green).fg(Color::Black);
-    let bord_type = BorderType::Double;
-    let cont = lintuini::elements::Container::new();
+    let cont = Container::new();
 
-    ratatui::run(|mut terminal| {
+    ratatui::run(|terminal| {
         loop {
             terminal.draw(|mut frame| {
                 let area = frame.area();

@@ 1,12 1,11 @@
 use ratatui_core::layout;
-use ratatui_core::style::Style;
 use ratatui_core::terminal::Frame;
 
 use ratatui_widgets::block;
-use ratatui_widgets::borders;
 
-use super::element::{Element, ElementWithChildren};
 use crate::error;
+use crate::elements::{Element, ElementWithChildren};
+use crate::elements::macros::*;
 
 #[derive(Default)]
 pub struct Container<'a> {


@@ 16,24 15,14 @@ pub struct Container<'a> {
     widgets: ContainerWidgets<'a>,
 }
 
-impl ElementWithChildren for Container<'_> {
-    #[inline(always)]
-    fn add_child(&mut self, child: impl Into<Box<dyn Element>>) -> Result<(), error::LintuiniError>{
-        self.children.push(child.into());
-        
-
-        Ok(())
-    }
-    #[inline(always)]
-    fn children(&self) -> &[Box<dyn Element>] {
-        self.children.as_slice()
-    }
-    #[inline(always)]
-    fn children_mut(&mut self) -> &mut [Box<dyn Element>] {
-        self.children.as_mut_slice()
-    }
+#[derive(Clone, Default)]
+struct ContainerWidgets<'a> {
+    block0: block::Block<'a>,
 }
 
+basic_config_methods!(Container<'_>);
+element_with_children!(Container<'_>);
+
 impl Element for Container<'_> {
     #[inline(always)]
     fn constraint(&self) -> layout::Constraint {


@@ 44,42 33,10 @@ impl Element for Container<'_> {
         frm.render_widget(&self.widgets.block0, rect);
 
         for (el, r) in self.children.iter().zip(&*self.layout.split(rect)) {
-            el.render(frm, *r);
+            el.render(frm, *r)?;
         }
 
         Ok(())
     }
 }
 
-impl Container<'_> {
-    #[inline(always)]
-    pub fn new() -> Self {
-        Container::default()
-    }
-
-    #[inline(always)]
-    pub fn constraint(mut self, constraint: layout::Constraint) -> Self {
-        self.constraint = constraint;
-        self
-    }
-
-    #[inline(always)]
-    pub fn direction(mut self, direction: layout::Direction) -> Self {
-        self.layout = self.layout.direction(direction);
-        self.regenerate_layout()
-    }
-
-    fn regenerate_layout(mut self) -> Self {
-        if self.children.len() == 0 { return self; }
-        self.layout = self.layout.constraints(
-            self.children
-                .iter()
-                .map(|el| el.constraint())
-        );
-        self
-    }
-}
-#[derive(Clone, Default)]
-struct ContainerWidgets<'a> {
-    block0: block::Block<'a>,
-}

@@ 0,0 1,59 @@
+macro_rules! element_with_children {
+    ($el:ty) => {
+        impl ElementWithChildren for $el {
+            #[inline(always)]
+            fn add_child(&mut self, child: impl Into<Box<dyn Element>>) -> Result<(), crate::error::LintuiniError>{
+                self.children.push(child.into());
+                self.regenerate_layout();
+                Ok(())
+            }
+
+            #[inline(always)]
+            fn children(&self) -> &[Box<dyn Element>] {
+                self.children.as_slice()
+            }
+
+            #[inline(always)]
+            fn children_mut(&mut self) -> &mut [Box<dyn Element>] {
+                self.children.as_mut_slice()
+            }
+        }
+    }
+}
+pub(crate) use element_with_children;
+
+macro_rules! basic_config_methods {
+    ($el:ty) => {    
+        impl $el {
+            #[inline(always)]
+            pub fn new() -> Self {
+                <$el>::default()
+            }
+
+            #[inline(always)]
+            pub fn constraint(&mut self, constraint: ratatui_core::layout::Constraint) -> &mut Self {
+                self.constraint = constraint;
+                self
+            }
+
+            // beware the owned self!
+            #[inline(always)]
+            pub fn direction(mut self, direction: ratatui_core::layout::Direction) -> Self {
+                self.layout = self.layout.direction(direction);
+                self.regenerate_layout();
+                self
+            }
+
+            pub fn regenerate_layout(&mut self) -> &mut Self {
+                if self.children.len() == 0 { return self; }
+                self.layout = self.layout.clone().constraints(
+                    self.children
+                        .iter()
+                        .map(|el| el.constraint())
+                );
+                self
+            }
+        }
+    }
+}
+pub(crate) use basic_config_methods;

@@ 3,3 3,6 @@ pub use container::*;
 
 pub mod element;
 pub use element::*;
+
+pub mod macros;
+