Add Flex to views::BoxLayout.

ui/views/layout/box_layout.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/views/layout/box_layout.h"
 
 #include "ui/gfx/rect.h"
 #include "ui/views/view.h"
 
 namespace views {
 
 BoxLayout::BoxLayout(BoxLayout::Orientation orientation,
                      int inside_border_horizontal_spacing,
                      int inside_border_vertical_spacing,
                      int between_child_spacing)
     : orientation_(orientation),
       inside_border_insets_(inside_border_vertical_spacing,
                             inside_border_horizontal_spacing,
                             inside_border_vertical_spacing,
                             inside_border_horizontal_spacing),
       between_child_spacing_(between_child_spacing),
       main_axis_alignment_(MAIN_AXIS_ALIGNMENT_START),
-      cross_axis_alignment_(CROSS_AXIS_ALIGNMENT_STRETCH) {
+      cross_axis_alignment_(CROSS_AXIS_ALIGNMENT_STRETCH),
+      default_flex_(0) {
 }
 
 BoxLayout::~BoxLayout() {
 }
 
+void BoxLayout::SetFlexForViewAt(int index, int flex_weight) {
+  DCHECK(index >= 0);
+  DCHECK(flex_weight >= 0);
+  flex_map_[index] = flex_weight;
+}
+
+void BoxLayout::ClearFlexForViewAt(int index) {
+  DCHECK(index >= 0);
+  flex_map_.erase(index);
+}
+
+void BoxLayout::SetDefaultFlex(int default_flex) {
+  DCHECK(default_flex >= 0);
+  default_flex_ = default_flex;
+}
+
 void BoxLayout::Layout(View* host) {
   gfx::Rect child_area(host->GetLocalBounds());
   child_area.Inset(host->GetInsets());
   child_area.Inset(inside_border_insets_);
 
-  int padding = 0;
-  if (main_axis_alignment_ != MAIN_AXIS_ALIGNMENT_START) {
-    int total_main_axis_size = 0;
-    int num_visible = 0;
-    for (int i = 0; i < host->child_count(); ++i) {
-      View* child = host->child_at(i);
-      if (!child->visible())
-        continue;
-      total_main_axis_size += MainAxisSizeForView(child, child_area.width()) +
-                              between_child_spacing_;
-      ++num_visible;
-    }
+  int total_main_axis_size = 0;
+  int num_visible = 0;
+  int flex_sum = 0;
+  for (int i = 0; i < host->child_count(); ++i) {
+    View* child = host->child_at(i);
+    if (!child->visible())
+      continue;
+    total_main_axis_size +=
+        MainAxisSizeForView(child, child_area.width()) + between_child_spacing_;
+    ++num_visible;
+    flex_sum += GetFlexForViewAt(i);
+  }
+  total_main_axis_size -= between_child_spacing_;

[benwells, 2014/07/04 07:27:56]

Nit: this line can move after the if (!num_visible) check.

[calamity, 2014/07/07 05:11:17]

Done.

 
-    if (num_visible) {
-      total_main_axis_size -= between_child_spacing_;
-      int free_space = MainAxisSize(child_area) - total_main_axis_size;
-      int position = MainAxisPosition(child_area);
-      int size = MainAxisSize(child_area);
+  if (!num_visible)
+    return;
+
+  // Free space can be negative indicating that the views want to overflow.
+  int main_free_space = MainAxisSize(child_area) - total_main_axis_size;
+  {
+    int position = MainAxisPosition(child_area);
+    int size = MainAxisSize(child_area);
+    if (!flex_sum) {
       switch (main_axis_alignment_) {
-        case MAIN_AXIS_ALIGNMENT_FILL:
-          padding = std::max(free_space / num_visible, 0);
+        case MAIN_AXIS_ALIGNMENT_START:
           break;
         case MAIN_AXIS_ALIGNMENT_CENTER:
-          position += free_space / 2;
+          position += main_free_space / 2;
           size = total_main_axis_size;
           break;
         case MAIN_AXIS_ALIGNMENT_END:
-          position += free_space;
+          position += main_free_space;
           size = total_main_axis_size;
           break;
         default:
           NOTREACHED();
           break;
       }
-      gfx::Rect new_child_area(child_area);
-      SetMainAxisPosition(position, &new_child_area);
-      SetMainAxisSize(size, &new_child_area);
-      child_area.Intersect(new_child_area);
     }
+    gfx::Rect new_child_area(child_area);
+    SetMainAxisPosition(position, &new_child_area);
+    SetMainAxisSize(size, &new_child_area);
+    child_area.Intersect(new_child_area);
   }
 
   int main_position = MainAxisPosition(child_area);
+  int current_remainder = 0;
   for (int i = 0; i < host->child_count(); ++i) {
     View* child = host->child_at(i);
-    if (child->visible()) {
-      gfx::Rect bounds(child_area);
-      SetMainAxisPosition(main_position, &bounds);
-      if (cross_axis_alignment_ != CROSS_AXIS_ALIGNMENT_STRETCH) {
-        int free_space = CrossAxisSize(bounds) - CrossAxisSizeForView(child);
-        int position = CrossAxisPosition(bounds);
-        if (cross_axis_alignment_ == CROSS_AXIS_ALIGNMENT_CENTER) {
-          position += free_space / 2;
-        } else if (cross_axis_alignment_ == CROSS_AXIS_ALIGNMENT_END) {
-          position += free_space;
-        }
-        SetCrossAxisPosition(position, &bounds);
-        SetCrossAxisSize(CrossAxisSizeForView(child), &bounds);
+    if (!child->visible())
+      continue;
+
+    gfx::Rect bounds(child_area);
+    SetMainAxisPosition(main_position, &bounds);
+    if (cross_axis_alignment_ != CROSS_AXIS_ALIGNMENT_STRETCH) {
+      int free_space = CrossAxisSize(bounds) - CrossAxisSizeForView(child);
+      int position = CrossAxisPosition(bounds);
+      if (cross_axis_alignment_ == CROSS_AXIS_ALIGNMENT_CENTER) {
+        position += free_space / 2;
+      } else if (cross_axis_alignment_ == CROSS_AXIS_ALIGNMENT_END) {
+        position += free_space;
       }
-      int child_main_axis_size = MainAxisSizeForView(child, child_area.width());
-      SetMainAxisSize(child_main_axis_size + padding, &bounds);
-      if (MainAxisSize(bounds) > 0)
-        main_position += MainAxisSize(bounds) + between_child_spacing_;
+      SetCrossAxisPosition(position, &bounds);
+      SetCrossAxisSize(CrossAxisSizeForView(child), &bounds);
+    }
 
-      // Clamp child view bounds to |child_area|.
-      bounds.Intersect(child_area);
-      child->SetBoundsRect(bounds);
+    int current_padding = 0;
+    if (GetFlexForViewAt(i) > 0) {
+      current_padding = main_free_space * GetFlexForViewAt(i) / flex_sum;
+      current_remainder += main_free_space * GetFlexForViewAt(i);
+      current_remainder %= flex_sum;

[benwells, 2014/07/04 07:27:56]

As discussed today I'm worried this will leak pixels and the rounding isn't
always going to account for it. The rounding might also use extra pixels
sometimes.

This could be tested easily by DCHECKING that all the allocation padding sums to
the available padding and then laying out a bunch of scenarios.

[calamity, 2014/07/07 05:11:17]

Indeed it does. Reworked algorithm.

+      // Use the current remainder to round to the nearest pixel.
+      if (std::abs(current_remainder) * 2 >= flex_sum)
+        current_padding += main_free_space > 0 ? 1 : -1;
     }
+
+    int child_main_axis_size = MainAxisSizeForView(child, child_area.width());
+    SetMainAxisSize(child_main_axis_size + current_padding, &bounds);
+    if (MainAxisSize(bounds) > 0 || GetFlexForViewAt(i) > 0)
+      main_position += MainAxisSize(bounds) + between_child_spacing_;
+
+    // Clamp child view bounds to |child_area|.
+    bounds.Intersect(child_area);
+    child->SetBoundsRect(bounds);
   }
+  DCHECK_EQ(0, current_remainder);
 }
 
 gfx::Size BoxLayout::GetPreferredSize(const View* host) const {
   // Calculate the child views' preferred width.
   int width = 0;
   if (orientation_ == kVertical) {
     for (int i = 0; i < host->child_count(); ++i) {
       const View* child = host->child_at(i);
       if (!child->visible())
         continue;
 
       width = std::max(width, child->GetPreferredSize().width());
     }
   }
 
   return GetPreferredSizeForChildWidth(host, width);
 }
 
 int BoxLayout::GetPreferredHeightForWidth(const View* host, int width) const {
   int child_width = width - NonChildSize(host).width();
   return GetPreferredSizeForChildWidth(host, child_width).height();
 }
 
+int BoxLayout::GetFlexForViewAt(int index) {
+  std::map<int, int>::const_iterator it = flex_map_.find(index);
+  if (it == flex_map_.end())
+    return default_flex_;
+
+  return it->second;
+}
+
 int BoxLayout::MainAxisSize(const gfx::Rect& rect) const {
   return orientation_ == kHorizontal ? rect.width() : rect.height();
 }
 
 int BoxLayout::MainAxisPosition(const gfx::Rect& rect) const {
   return orientation_ == kHorizontal ? rect.x() : rect.y();
 }
 
 void BoxLayout::SetMainAxisSize(int size, gfx::Rect* rect) const {
   if (orientation_ == kHorizontal)
@@ skipping 94 matching lines @@
                    child_area_bounds.height() + non_child_size.height());
 }
 
 gfx::Size BoxLayout::NonChildSize(const View* host) const {
   gfx::Insets insets(host->GetInsets());
   return gfx::Size(insets.width() + inside_border_insets_.width(),
                    insets.height() + inside_border_insets_.height());
 }
 
 } // namespace views