Struct FlexBox

pub struct FlexBox<T: Prop + 'static> {
    pub id: Arc<SourceID>,
    /* private fields */
}

Fields

id: Arc<SourceID>

Implementations

impl<T: Prop + 'static> FlexBox<T>

pub fn new( id: Arc<SourceID>, props: Rc<T>, children: Vector<Option<Box<ChildOf<dyn Prop>>>>, ) -> Self

Examples found in repository

examples/list-rs.rs (lines 261-270)

    fn call(
        &mut self,
        mut store: Self::Store,
        args: &CounterState,
    ) -> (Self::Store, im::HashMap<Arc<SourceID>, Option<Window>>) {
        if store.0 != *args {
            let button = {
                let text = Text::<FixedData> {
                    id: gen_id!(),
                    props: FixedData {
                        area: feather_ui::URect {
                            abs: AbsRect::new(10.0, 15.0, 10.0, 15.0),
                            rel: RelRect::new(0.0, 0.0, UNSIZED_AXIS, UNSIZED_AXIS),
                        }
                        .into(),
                        anchor: feather_ui::RelPoint(Vec2 { x: 0.0, y: 0.0 }).into(),
                        ..Default::default()
                    }
                    .into(),
                    text: format!("Boxes: {}", args.count),
                    font_size: 40.0,
                    line_height: 56.0,
                    ..Default::default()
                };

                let rect = Shape::<DRect, { ShapeKind::RoundRect as u8 }>::new(
                    gen_id!(),
                    feather_ui::FILL_DRECT.into(),
                    0.0,
                    0.0,
                    Vec4::broadcast(10.0),
                    sRGB::new(0.2, 0.7, 0.4, 1.0),
                    sRGB::transparent(),
                );

                Button::<FixedData>::new(
                    gen_id!(),
                    FixedData {
                        area: feather_ui::URect {
                            abs: AbsRect::new(0.0, 20.0, 0.0, 0.0),
                            rel: RelRect::new(0.5, 0.0, UNSIZED_AXIS, UNSIZED_AXIS),
                        }
                        .into(),
                        anchor: feather_ui::RelPoint(Vec2 { x: 0.5, y: 0.0 }).into(),
                        zindex: 0,
                    },
                    Slot(feather_ui::APP_SOURCE_ID.into(), 0),
                    feather_ui::children![fixed::Prop, rect, text],
                )
            };

            let rectlist = {
                let mut children: im::Vector<Option<Box<ChildOf<dyn list::Prop>>>> =
                    im::Vector::new();

                let rect_id = gen_id!();

                for i in 0..args.count {
                    children.push_back(Some(Box::new(Shape::<
                        ListChild,
                        { ShapeKind::RoundRect as u8 },
                    >::new(
                        rect_id.child(DataID::Int(i as i64)),
                        ListChild {
                            area: AbsRect::new(0.0, 0.0, 40.0, 40.0).into(),
                            margin: AbsRect::new(8.0, 8.0, 4.0, 4.0).into(),
                        }
                        .into(),
                        0.0,
                        0.0,
                        Vec4::broadcast(8.0),
                        sRGB::new(
                            (0.1 * i as f32) % 1.0,
                            (0.65 * i as f32) % 1.0,
                            (0.2 * i as f32) % 1.0,
                            1.0,
                        ),
                        sRGB::transparent(),
                    ))));
                }

                ListBox::<ListData>::new(
                    gen_id!(),
                    ListData {
                        area: feather_ui::URect {
                            abs: AbsRect::new(0.0, 200.0, 0.0, 0.0),
                            rel: RelRect::new(0.0, 0.0, UNSIZED_AXIS, 1.0),
                        }
                        .into(),
                        rlimits: feather_ui::RelLimits::new(
                            ZERO_POINT,
                            Vec2::new(1.0, f32::INFINITY),
                        ),
                        direction: feather_ui::RowDirection::BottomToTop,
                    }
                    .into(),
                    children,
                )
            };

            let flexlist = {
                let mut children: im::Vector<Option<Box<ChildOf<dyn flex::Prop>>>> =
                    im::Vector::new();

                let box_id = gen_id!();
                for i in 0..args.count {
                    children.push_back(Some(Box::new(Shape::<
                        FlexChild,
                        { ShapeKind::RoundRect as u8 },
                    >::new(
                        box_id.child(DataID::Int(i as i64)),
                        FlexChild {
                            area: feather_ui::URect {
                                abs: AbsRect::new(0.0, 0.0, 0.0, 40.0),
                                rel: RelRect::new(0.0, 0.0, 1.0, 0.0),
                            }
                            .into(),
                            margin: AbsRect::new(8.0, 8.0, 4.0, 4.0).into(),
                            basis: 40.0.into(),
                            grow: 0.0,
                            shrink: 0.0,
                        }
                        .into(),
                        0.0,
                        0.0,
                        Vec4::broadcast(8.0),
                        sRGB::new(
                            (0.1 * i as f32) % 1.0,
                            (0.65 * i as f32) % 1.0,
                            (0.2 * i as f32) % 1.0,
                            1.0,
                        ),
                        sRGB::transparent(),
                    ))));
                }

                FlexBox::<MinimalFlex>::new(
                    gen_id!(),
                    MinimalFlex {
                        area: (AbsRect::new(40.0, 40.0, 0.0, 200.0)
                            + RelRect::new(0.0, 0.0, 1.0, 0.0))
                        .into(),
                    }
                    .into(),
                    children,
                )
            };

            let region = Region::new(
                gen_id!(),
                FixedData {
                    area: FILL_DRECT,
                    zindex: 0,
                    ..Default::default()
                }
                .into(),
                feather_ui::children![fixed::Prop, button, flexlist, rectlist],
            );
            let window = Window::new(
                gen_id!(),
                feather_ui::winit::window::Window::default_attributes()
                    .with_title(env!("CARGO_CRATE_NAME"))
                    .with_resizable(true),
                Box::new(region),
            );

            store.1 = im::HashMap::new();
            store.1.insert(window.id.clone(), Some(window));
            store.0 = args.clone();
        }
        let windows = store.1.clone();
        (store, windows)
    }

Trait Implementations

impl<T: Prop + 'static> Clone for FlexBox<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Prop + 'static> Component for FlexBox<T>

type Props = T

fn layout( &self, manager: &mut StateManager, driver: &Driver, window: &Arc<SourceID>, ) -> Box<dyn Layout<T>>

impl<T: Prop + 'static> StateMachineChild for FlexBox<T>

fn id(&self) -> Arc<SourceID>

fn apply_children( &self, f: &mut dyn FnMut(&dyn StateMachineChild) -> Result<()>, ) -> Result<()>

fn init( &self, driver: &Weak<Driver>, ) -> Result<Box<dyn StateMachineWrapper>, Error>