From 2aea11fc1573a88a8f0d8442aea61cf8e4f677be Mon Sep 17 00:00:00 2001 From: meloalright Date: Thu, 14 Nov 2024 01:24:49 +0800 Subject: [PATCH] feat(flex): add support of set min width and set align content and set justify content --- include/safe.h | 13 +--- src/lib.rs | 12 ++++ src/safe.cc | 86 +++++++++++++++++++++++++ src/safe.rs | 3 + tests/flex_wrap_test.rs | 139 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 243 insertions(+), 10 deletions(-) diff --git a/include/safe.h b/include/safe.h index 9dd3ed9..bfdb587 100644 --- a/include/safe.h +++ b/include/safe.h @@ -6,16 +6,6 @@ class TaitankSafeNode { public: TaitankSafeNode(); ~TaitankSafeNode(); -// void set_width(double width) const; -// void set_height(double height) const; -// -// void set_direction(int direction) const; -// -// void do_layout(double parent_width, double parent_height) const; -// double get_left() const; -// double get_top() const; -// double get_width() const; -// double get_height() const; public: taitank::TaitankNodeRef ptr; }; @@ -31,6 +21,9 @@ void set_flex_basis(std::unique_ptr & node, double flex_basis); void set_flex_direction(std::unique_ptr & node, int direction); void set_flex_wrap(std::unique_ptr & node, int flex_wrap_node); void set_align_items(std::unique_ptr & node, int flex_align); +void set_min_width(std::unique_ptr & node, double width); +void set_align_content(std::unique_ptr & node, int align_content); +void set_justify_content(std::unique_ptr & node, int justify_content); void insert_child(std::unique_ptr & node, std::unique_ptr & child, int index); void do_layout(std::unique_ptr & node, double parent_width, double parent_height, int direction); double get_width(std::unique_ptr & node); diff --git a/src/lib.rs b/src/lib.rs index 8c9f0c6..e22dcfe 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -82,6 +82,18 @@ pub fn set_align_items(node: &mut TaitankSafeNode, flex_align: FlexAlign) { ffi::set_align_items(&mut node.unique_ptr, flex_align as i32); } +pub fn set_min_width(node: &mut TaitankSafeNode, min_width: f64) { + ffi::set_min_width(&mut node.unique_ptr, min_width); +} + +pub fn set_align_content(node: &mut TaitankSafeNode, flex_align: FlexAlign) { + ffi::set_align_content(&mut node.unique_ptr, flex_align as i32); +} + +pub fn set_justify_content(node: &mut TaitankSafeNode, flex_align: FlexAlign) { + ffi::set_justify_content(&mut node.unique_ptr, flex_align as i32); +} + pub fn insert_child(node: &mut TaitankSafeNode, child: &mut TaitankSafeNode, index: i32) { ffi::insert_child(&mut node.unique_ptr, &mut child.unique_ptr, index); } diff --git a/src/safe.cc b/src/safe.cc index 23adca9..0dda7b0 100644 --- a/src/safe.cc +++ b/src/safe.cc @@ -160,6 +160,92 @@ void do_layout(std::unique_ptr & node, double parent_width, dou } } +void set_min_width(std::unique_ptr & node, double min_width) { + taitank::SetMinWidth(node->ptr, min_width); +} + +void set_align_content(std::unique_ptr & node, int flex_align) { + switch (flex_align) { + case 0: { + taitank::SetAlignContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_AUTO); + break; + } + case 1: { + taitank::SetAlignContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_START); + break; + } + case 2: { + taitank::SetAlignContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_CENTER); + break; + } + case 3: { + taitank::SetAlignContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_END); + break; + } + case 4: { + taitank::SetAlignContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_STRETCH); + break; + } + case 5: { + taitank::SetAlignContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_BASE_LINE); + break; + } + case 6: { + taitank::SetAlignContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_SPACE_BETWEEN); + break; + } + case 7: { + taitank::SetAlignContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_SPACE_AROUND); + break; + } + case 8: { + taitank::SetAlignContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_SPACE_EVENLY); + break; + } + } +} + +void set_justify_content(std::unique_ptr & node, int justify) { + switch (justify) { + case 0: { + taitank::SetJustifyContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_AUTO); + break; + } + case 1: { + taitank::SetJustifyContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_START); + break; + } + case 2: { + taitank::SetJustifyContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_CENTER); + break; + } + case 3: { + taitank::SetJustifyContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_END); + break; + } + case 4: { + taitank::SetJustifyContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_STRETCH); + break; + } + case 5: { + taitank::SetJustifyContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_BASE_LINE); + break; + } + case 6: { + taitank::SetJustifyContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_SPACE_BETWEEN); + break; + } + case 7: { + taitank::SetJustifyContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_SPACE_AROUND); + break; + } + case 8: { + taitank::SetJustifyContent(node->ptr, taitank::FlexAlign::FLEX_ALIGN_SPACE_EVENLY); + break; + } + } +} + double get_width(std::unique_ptr & node) { return taitank::GetWidth(node->ptr); } diff --git a/src/safe.rs b/src/safe.rs index 260402c..ce60ddc 100644 --- a/src/safe.rs +++ b/src/safe.rs @@ -16,6 +16,9 @@ pub mod ffi { fn set_flex_direction(node: &mut UniquePtr, flex_direction: i32); fn set_flex_wrap(node: &mut UniquePtr, flex_wrap_node: i32); fn set_align_items(node: &mut UniquePtr, flex_align: i32); + fn set_min_width(node: &mut UniquePtr, min_width: f64); + fn set_align_content(node: &mut UniquePtr, flex_align: i32); + fn set_justify_content(node: &mut UniquePtr, flex_align: i32); fn insert_child( node: &mut UniquePtr, child: &mut UniquePtr, diff --git a/tests/flex_wrap_test.rs b/tests/flex_wrap_test.rs index 10f1b10..7345b7f 100644 --- a/tests/flex_wrap_test.rs +++ b/tests/flex_wrap_test.rs @@ -251,4 +251,143 @@ mod tests { assert_eq!(30.0, get_height(&mut root_child3)); } + + #[test] + fn wrap_row_align_items_center() { + let mut root = node_create(); + set_flex_direction(&mut root, FlexDirection::FlexDirectionRow); + set_align_items(&mut root, FlexAlign::FlexAlignCenter); + set_flex_wrap(&mut root, FlexWrapNode::FlexWrap); + set_width(&mut root, 100.0); + + let mut root_child0 = node_create(); + set_width(&mut root_child0, 30.0); + set_height(&mut root_child0, 10.0); + insert_child(&mut root, &mut root_child0, 0); + + let mut root_child1 = node_create(); + set_width(&mut root_child1, 30.0); + set_height(&mut root_child1, 20.0); + insert_child(&mut root, &mut root_child1, 1); + + let mut root_child2 = node_create(); + set_width(&mut root_child2, 30.0); + set_height(&mut root_child2, 30.0); + insert_child(&mut root, &mut root_child2, 2); + + let mut root_child3 = node_create(); + set_width(&mut root_child3, 30.0); + set_height(&mut root_child3, 30.0); + insert_child(&mut root, &mut root_child3, 3); + + layout!(&mut root); + + assert_eq!(0.0, get_left(&mut root)); + assert_eq!(0.0, get_top(&mut root)); + assert_eq!(100.0, get_width(&mut root)); + assert_eq!(60.0, get_height(&mut root)); + + assert_eq!(0.0, get_left(&mut root_child0)); + assert_eq!(10.0, get_top(&mut root_child0)); + assert_eq!(30.0, get_width(&mut root_child0)); + assert_eq!(10.0, get_height(&mut root_child0)); + + assert_eq!(30.0, get_left(&mut root_child1)); + assert_eq!(5.0, get_top(&mut root_child1)); + assert_eq!(30.0, get_width(&mut root_child1)); + assert_eq!(20.0, get_height(&mut root_child1)); + + assert_eq!(60.0, get_left(&mut root_child2)); + assert_eq!(0.0, get_top(&mut root_child2)); + assert_eq!(30.0, get_width(&mut root_child2)); + assert_eq!(30.0, get_height(&mut root_child2)); + + assert_eq!(0.0, get_left(&mut root_child3)); + assert_eq!(30.0, get_top(&mut root_child3)); + assert_eq!(30.0, get_width(&mut root_child3)); + assert_eq!(30.0, get_height(&mut root_child3)); + + layout!(&mut root, std::f64::NAN, std::f64::NAN, Direction::RTL); + + assert_eq!(0.0, get_left(&mut root)); + assert_eq!(0.0, get_top(&mut root)); + assert_eq!(100.0, get_width(&mut root)); + assert_eq!(60.0, get_height(&mut root)); + + assert_eq!(70.0, get_left(&mut root_child0)); + assert_eq!(10.0, get_top(&mut root_child0)); + assert_eq!(30.0, get_width(&mut root_child0)); + assert_eq!(10.0, get_height(&mut root_child0)); + + assert_eq!(40.0, get_left(&mut root_child1)); + assert_eq!(5.0, get_top(&mut root_child1)); + assert_eq!(30.0, get_width(&mut root_child1)); + assert_eq!(20.0, get_height(&mut root_child1)); + + assert_eq!(10.0, get_left(&mut root_child2)); + assert_eq!(0.0, get_top(&mut root_child2)); + assert_eq!(30.0, get_width(&mut root_child2)); + assert_eq!(30.0, get_height(&mut root_child2)); + + assert_eq!(70.0, get_left(&mut root_child3)); + assert_eq!(30.0, get_top(&mut root_child3)); + assert_eq!(30.0, get_width(&mut root_child3)); + assert_eq!(30.0, get_height(&mut root_child3)); + + } + + #[test] + fn flex_wrap_children_with_min_main_overriding_flex_basis() { + let mut root = node_create(); + set_flex_direction(&mut root, FlexDirection::FlexDirectionRow); + set_flex_wrap(&mut root, FlexWrapNode::FlexWrap); + set_width(&mut root, 100.0); + + let mut root_child0 = node_create(); + set_flex_basis(&mut root_child0, 50.0); + set_min_width(&mut root_child0, 55.0); + set_height(&mut root_child0, 50.0); + insert_child(&mut root, &mut root_child0, 0); + + let mut root_child1 = node_create(); + set_flex_basis(&mut root_child0, 50.0); + set_min_width(&mut root_child1, 55.0); + set_height(&mut root_child1, 50.0); + insert_child(&mut root, &mut root_child1, 1); + + layout!(&mut root); + + assert_eq!(0.0, get_left(&mut root)); + assert_eq!(0.0, get_top(&mut root)); + assert_eq!(100.0, get_width(&mut root)); + assert_eq!(100.0, get_height(&mut root)); + + assert_eq!(0.0, get_left(&mut root_child0)); + assert_eq!(0.0, get_top(&mut root_child0)); + assert_eq!(55.0, get_width(&mut root_child0)); + assert_eq!(50.0, get_height(&mut root_child0)); + + assert_eq!(0.0, get_left(&mut root_child1)); + assert_eq!(50.0, get_top(&mut root_child1)); + assert_eq!(55.0, get_width(&mut root_child1)); + assert_eq!(50.0, get_height(&mut root_child1)); + + layout!(&mut root, std::f64::NAN, std::f64::NAN, Direction::RTL); + + assert_eq!(0.0, get_left(&mut root)); + assert_eq!(0.0, get_top(&mut root)); + assert_eq!(100.0, get_width(&mut root)); + assert_eq!(100.0, get_height(&mut root)); + + assert_eq!(45.0, get_left(&mut root_child0)); + assert_eq!(0.0, get_top(&mut root_child0)); + assert_eq!(55.0, get_width(&mut root_child0)); + assert_eq!(50.0, get_height(&mut root_child0)); + + assert_eq!(45.0, get_left(&mut root_child1)); + assert_eq!(50.0, get_top(&mut root_child1)); + assert_eq!(55.0, get_width(&mut root_child1)); + assert_eq!(50.0, get_height(&mut root_child1)); + + } }