Add between_child_spacing to FlexLayout

Change-Id: Ia62b8b0376012143db82661c50437f17cfdab2bf
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1809602
Commit-Queue: Allen Bauer <kylixrd@chromium.org>
Reviewed-by: Peter Kasting <pkasting@chromium.org>
Cr-Commit-Position: refs/heads/master@{#698483}

ui/views/examples/flex_layout_example.cc

@@ -45,6 +45,9 @@ void FlexLayoutExample::CreateAdditionalControls(int vertical_pos) {
   cross_axis_alignment_ = CreateCombobox(base::ASCIIToUTF16("Cross axis"),
                                          cross_axis_values, 4, &vertical_pos);
 
+  between_child_spacing_ =
+      CreateTextfield(base::ASCIIToUTF16("Child spacing"), &vertical_pos);
+
   CreateMarginsTextFields(base::ASCIIToUTF16("Interior margin"),
                           &interior_margin_, &vertical_pos);
 
@@ -54,6 +57,9 @@ void FlexLayoutExample::CreateAdditionalControls(int vertical_pos) {
   collapse_margins_ =
       CreateCheckbox(base::ASCIIToUTF16("Collapse margins"), &vertical_pos);
 
+  ignore_default_main_axis_margins_ = CreateCheckbox(
+      base::ASCIIToUTF16("Ignore main axis margins"), &vertical_pos);
+
   layout_ = layout_panel()->SetLayoutManager(std::make_unique<FlexLayout>());
 }
 
@@ -84,12 +90,21 @@ void FlexLayoutExample::ContentsChanged(Textfield* sender,
       LayoutExampleBase::TextfieldsToInsets(interior_margin_));
   layout_->SetDefault(views::kMarginsKey, LayoutExampleBase::TextfieldsToInsets(
                                               default_child_margins_));
+  if (sender == between_child_spacing_) {
+    int spacing;
+    if (base::StringToInt(between_child_spacing_->GetText(), &spacing))
+      layout_->SetBetweenChildSpacing(spacing);
+  }
   RefreshLayoutPanel(false);
 }
 
 void FlexLayoutExample::ButtonPressedImpl(Button* sender) {
-  if (sender == collapse_margins_)
+  if (sender == collapse_margins_) {
     layout_->SetCollapseMargins(collapse_margins_->GetChecked());
+  } else if (sender == ignore_default_main_axis_margins_) {
+    layout_->SetIgnoreDefaultMainAxisMargins(
+        ignore_default_main_axis_margins_->GetChecked());
+  }
   RefreshLayoutPanel(false);
 }
 

ui/views/examples/flex_layout_example.h

@@ -45,9 +45,11 @@ class VIEWS_EXAMPLES_EXPORT FlexLayoutExample : public LayoutExampleBase {
   Combobox* orientation_ = nullptr;
   Combobox* main_axis_alignment_ = nullptr;
   Combobox* cross_axis_alignment_ = nullptr;
+  Textfield* between_child_spacing_ = nullptr;
   Checkbox* collapse_margins_ = nullptr;
   InsetTextfields interior_margin_;
   InsetTextfields default_child_margins_;
+  Checkbox* ignore_default_main_axis_margins_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(FlexLayoutExample);
 };

ui/views/layout/flex_layout.cc

@@ -326,6 +326,14 @@ FlexLayout& FlexLayout::SetMinimumCrossAxisSize(int size) {
   return *this;
 }
 
+FlexLayout& FlexLayout::SetBetweenChildSpacing(int between_child_spacing) {
+  if (between_child_spacing_ != between_child_spacing) {
+    between_child_spacing_ = between_child_spacing;
+    InvalidateHost(true);
+  }
+  return *this;
+}
+
 LayoutManagerBase::ProposedLayout FlexLayout::CalculateProposedLayout(
     const SizeBounds& size_bounds) const {
   FlexLayoutData data;
@@ -492,9 +500,10 @@ Inset1D FlexLayout::GetCrossAxisMargins(const FlexLayoutData& layout,
 
 int FlexLayout::CalculateMargin(int margin1,
                                 int margin2,
-                                int internal_padding) const {
-  const int result =
-      collapse_margins() ? std::max(margin1, margin2) : margin1 + margin2;
+                                int internal_padding,
+                                int spacing) const {
+  const int result = collapse_margins() ? std::max({margin1, margin2, spacing})
+                                        : margin1 + margin2 + spacing;
   return std::max(0, result - internal_padding);
 }
 
@@ -539,7 +548,8 @@ int FlexLayout::CalculateChildSpacing(
       child2 ? child2->internal_padding.main_leading() : 0;
 
   return CalculateMargin(left_margin, right_margin,
-                         left_padding + right_padding);
+                         left_padding + right_padding,
+                         (child1 && child2) ? between_child_spacing() : 0);
 }
 
 void FlexLayout::UpdateLayoutFromChildren(

ui/views/layout/flex_layout.h

@@ -89,6 +89,7 @@ class VIEWS_EXPORT FlexLayout : public LayoutManagerBase {
   FlexLayout& SetIncludeHostInsetsInLayout(bool include_host_insets_in_layout);
   FlexLayout& SetIgnoreDefaultMainAxisMargins(
       bool ignore_default_main_axis_margins);
+  FlexLayout& SetBetweenChildSpacing(int between_child_spacing);
 
   LayoutOrientation orientation() const { return orientation_; }
   bool collapse_margins() const { return collapse_margins_; }
@@ -102,6 +103,7 @@ class VIEWS_EXPORT FlexLayout : public LayoutManagerBase {
   bool ignore_default_main_axis_margins() const {
     return ignore_default_main_axis_margins_;
   }
+  int between_child_spacing() const { return between_child_spacing_; }
 
   // Moves and uses |value| as the default value for layout property |key|.
   template <class T, class U>
@@ -149,10 +151,14 @@ class VIEWS_EXPORT FlexLayout : public LayoutManagerBase {
   Inset1D GetCrossAxisMargins(const FlexLayoutData& layout,
                               size_t child_index) const;
 
-  // Calculates a margin between two child views based on each's margin and any
-  // internal padding present in one or both elements. Uses properties of the
-  // layout, like whether adjacent margins should be collapsed.
-  int CalculateMargin(int margin1, int margin2, int internal_padding) const;
+  // Calculates a margin between two child views based on each's margin,
+  // inter-child spacing, and any internal padding present in one or both
+  // elements. Uses properties of the layout, like whether adjacent margins
+  // should be collapsed.
+  int CalculateMargin(int margin1,
+                      int margin2,
+                      int internal_padding,
+                      int spacing = 0) const;
 
   // Calculates the cross-layout space available to a view based on the
   // available space and margins.
@@ -263,6 +269,11 @@ class VIEWS_EXPORT FlexLayout : public LayoutManagerBase {
   // trailing edge of the host view.
   bool ignore_default_main_axis_margins_ = false;
 
+  // The spacing between the children along the main axis. This is irrespective
+  // of any margins which are set. If |collapse_margins_| is true, then the max
+  // between this value and the margins is used.
+  int between_child_spacing_ = 0;
+
   // Default properties for any views that don't have them explicitly set for
   // this layout.
   PropertyHandler layout_defaults_{this};

ui/views/layout/flex_layout_unittest.cc

@@ -2008,6 +2008,46 @@ TEST_F(FlexLayoutTest, Layout_OnlyCallsSetViewVisibilityWhenNecessary) {
   EXPECT_EQ(0, child2->GetSetVisibleCount());
 }
 
+TEST_F(FlexLayoutTest, Between_Child_Spacing) {
+  layout_->SetOrientation(LayoutOrientation::kHorizontal);
+  layout_->SetInteriorMargin(Insets(7));
+  layout_->SetBetweenChildSpacing(8);
+  View* v1 = AddChild(gfx::Size(10, 20));
+  View* v2 = AddChild(gfx::Size(10, 20));
+  EXPECT_EQ(gfx::Size(42, 34), layout_->GetPreferredSize(host_.get()));
+  host_->SetBounds(0, 0, 100, 100);
+  host_->Layout();
+  EXPECT_EQ(gfx::Rect(7, 7, 10, 86), v1->bounds());
+  EXPECT_EQ(gfx::Rect(25, 7, 10, 86), v2->bounds());
+}
+
+TEST_F(FlexLayoutTest, Between_Child_Spacing_With_Margins) {
+  layout_->SetOrientation(LayoutOrientation::kHorizontal);
+  layout_->SetDefault(views::kMarginsKey, Insets(7));
+  layout_->SetBetweenChildSpacing(8);
+  View* v1 = AddChild(gfx::Size(10, 20));
+  View* v2 = AddChild(gfx::Size(10, 20));
+  EXPECT_EQ(gfx::Size(56, 34), layout_->GetPreferredSize(host_.get()));
+  host_->SetBounds(0, 0, 100, 100);
+  host_->Layout();
+  EXPECT_EQ(gfx::Rect(7, 7, 10, 86), v1->bounds());
+  EXPECT_EQ(gfx::Rect(39, 7, 10, 86), v2->bounds());
+}
+
+TEST_F(FlexLayoutTest, Between_Child_Spacing_With_Margins_Collapsed) {
+  layout_->SetOrientation(LayoutOrientation::kHorizontal);
+  layout_->SetDefault(views::kMarginsKey, Insets(7));
+  layout_->SetBetweenChildSpacing(8);
+  layout_->SetCollapseMargins(true);
+  View* v1 = AddChild(gfx::Size(10, 20));
+  View* v2 = AddChild(gfx::Size(10, 20));
+  EXPECT_EQ(gfx::Size(42, 34), layout_->GetPreferredSize(host_.get()));
+  host_->SetBounds(0, 0, 100, 100);
+  host_->Layout();
+  EXPECT_EQ(gfx::Rect(7, 7, 10, 86), v1->bounds());
+  EXPECT_EQ(gfx::Rect(25, 7, 10, 86), v2->bounds());
+}
+
 // Cross-axis Fit Tests --------------------------------------------------------
 
 // Tests for cross-axis alignment that checks three different conditions: