Bugfixes (required_size & event propagation).

- Bugfix: Events are now properly propagated down the tree.
- Bugfix: The size is now once again properly calculated (not from the
  fixed layout anymore).
- Add example for event propagation.

Author: ThomasFrans

examples/clickable_items.rs

@@ -0,0 +1,71 @@
+use cursive::{
+    theme::{BorderStyle, Palette, Theme},
+    view::IntoBoxedView,
+    views::{Button, TextContent, TextView},
+    Cursive, CursiveExt,
+};
+
+use cursive_flexbox::prelude::*;
+
+fn main() {
+    // Create a cursive object. This is the basic object that handles the ui and event loop.
+    let mut cursive = Cursive::new();
+
+    cursive.add_global_callback('q', |cursive| cursive.quit());
+
+    cursive.set_theme(Theme {
+        shadow: false,
+        borders: BorderStyle::Simple,
+        palette: Palette::terminal_default(),
+    });
+
+    let content = TextContent::new("unset");
+    let textview = TextView::new_with_content(content.clone());
+
+    let content_clone = content.clone();
+    let button1 = Button::new_raw("Set text 'hello'.", move |_| {
+        content_clone.set_content("hello");
+    });
+
+    let button2 = Button::new_raw("Set text 'world'.", move |_| {
+        content.set_content("world");
+    });
+
+    // Create the flexbox and put some items in it.
+    let mut flexbox = Flexbox::from(vec![
+        button1.into_boxed_view(),
+        button2.into_boxed_view(),
+        textview.into_boxed_view(),
+    ]);
+
+    // Set a gap between the items on the main axis.
+    flexbox.set_main_axis_gap(2);
+
+    // Set a gap between the main axis (along the container cross axis).
+    flexbox.set_cross_axis_gap(2);
+
+    // Set item grow factors.
+    // flexbox.set_flex_grow(1, 1);
+    // flexbox.set_flex_grow(2, 2);
+
+    // Set the wrapping behavior of the main axes.
+    flexbox.set_flex_wrap(FlexWrap::Wrap);
+
+    // Set the algorithm to assign free space along the main axis.
+    flexbox.set_justify_content(JustifyContent::SpaceEvenly);
+
+    // Set the algorithm to assign free space along the cross axis for flex items.
+    flexbox.set_align_items(AlignItems::Center);
+
+    // Set the algorithm to assign free space along the cross axis in the container.
+    flexbox.set_align_content(AlignContent::FlexStart);
+
+    // Set the direction of the main axis.
+    flexbox.set_flex_direction(FlexDirection::Row);
+
+    // Add the flexbox to the ui.
+    cursive.add_fullscreen_layer(flexbox);
+
+    // Start running the eventloop.
+    cursive.run();
+}

src/layout.rs

@@ -32,22 +32,6 @@ impl<T> Layout<T> {
     pub fn iter(&self) -> Iter<'_, PlacedElement<T>> {
         self.into_iter()
     }
-
-    /// Return the size of this layout.
-    pub fn size(&self) -> XY<usize> {
-        let mut max_size = XY::from((0, 0));
-
-        self.iter().for_each(|item| {
-            if item.position.right() > max_size.x {
-                max_size.x = item.position.right() + 1;
-            }
-            if item.position.bottom() > max_size.y {
-                max_size.y = item.position.bottom() + 1;
-            }
-        });
-
-        max_size
-    }
 }
 
 impl<T> IntoIterator for Layout<T> {

src/lib.rs

@@ -488,27 +488,29 @@ impl MainAxis {
                 // Axis contains elements that want the free space. Give it to them, don't use
                 // justify-content.
 
-                let mut added_space = 0;
+                let mut current_item_assigned_space = 0;
                 let item_main_axis_size =
                     layout.flexitem_main_axis_size(&mut RefCell::borrow_mut(&item));
                 if remaining_grow_factor > 0 {
-                    added_space = (RefCell::borrow(&item).flex_grow as usize
-                        / remaining_grow_factor)
-                        * assignable_free_space;
+                    current_item_assigned_space =
+                        ((RefCell::borrow(&item).flex_grow as f64 / remaining_grow_factor as f64)
+                            * assignable_free_space as f64) as usize;
                 }
 
                 match layout.options.direction {
                     FlexDirection::Row => {
                         start_x = offset;
-                        width = item_main_axis_size + added_space;
+                        width = item_main_axis_size + current_item_assigned_space;
                     },
                     FlexDirection::Column => {
                         start_y = offset;
-                        height = item_main_axis_size + added_space;
+                        height = item_main_axis_size + current_item_assigned_space;
                     },
                 }
-                offset += item_main_axis_size + layout.options.main_axis_gap as usize + added_space;
-                assignable_free_space -= added_space;
+                offset += item_main_axis_size
+                    + layout.options.main_axis_gap as usize
+                    + current_item_assigned_space;
+                assignable_free_space -= current_item_assigned_space;
                 remaining_grow_factor -= RefCell::borrow(&item).flex_grow as usize;
             } else {
                 // Axis doesn't contain elements that want free space. Use justify-content property
@@ -957,40 +959,37 @@ impl View for Flexbox {
     fn required_size(&mut self, constraint: cursive_core::Vec2) -> cursive_core::Vec2 {
         // PERF: Cache the values that the previous layout was generated with and regenerate if
         // cached version is outdated.
-        let layout = self.generate_layout(constraint);
-        layout.size()
+        constraint
     }
 
     fn on_event(
         &mut self,
         mut event: cursive_core::event::Event,
     ) -> cursive_core::event::EventResult {
-        if let Some(active_child) = self.focused {
-            if let cursive_core::event::Event::Mouse {
-                ref mut offset,
-                ref mut position,
-                ..
-            } = event
-            {
-                if let Some(ref layout) = self.layout {
-                    if let Some(placed_element) =
-                        layout.element_at(global_to_view_coordinates(*position, *offset))
-                    {
-                        *offset = *offset + placed_element.position.top_left();
-                        RefCell::borrow_mut(&placed_element.element)
-                            .view
-                            .on_event(event)
-                    } else {
-                        EventResult::Ignored
-                    }
+        if let cursive_core::event::Event::Mouse {
+            ref mut offset,
+            ref mut position,
+            ..
+        } = event
+        {
+            if let Some(ref layout) = self.layout {
+                if let Some(placed_element) =
+                    layout.element_at(global_to_view_coordinates(*position, *offset))
+                {
+                    *offset = *offset + placed_element.position.top_left();
+                    RefCell::borrow_mut(&placed_element.element)
+                        .view
+                        .on_event(event)
                 } else {
                     EventResult::Ignored
                 }
             } else {
-                RefCell::borrow_mut(&self.content[active_child])
-                    .view
-                    .on_event(event)
+                EventResult::Ignored
             }
+        } else if let Some(active_child) = self.focused {
+            RefCell::borrow_mut(&self.content[active_child])
+                .view
+                .on_event(event)
         } else {
             EventResult::Ignored
         }