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);
+  }
 
-    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;
+
+  total_main_axis_size -= between_child_spacing_;
+  // 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 total_padding = 0;
+  int current_flex = 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_flex += GetFlexForViewAt(i);
+      int quot = (main_free_space * current_flex) / flex_sum;
+      int rem = (main_free_space * current_flex) % flex_sum;
+      current_padding = quot - total_padding;
+      // Use the current remainder to round to the nearest pixel.
+      if (std::abs(rem) * 2 >= flex_sum)
+        current_padding += main_free_space > 0 ? 1 : -1;
+      total_padding += current_padding;
     }
+
+    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);
+  }
+
+  if (flex_sum) {
+    DCHECK_LE(MainAxisPosition(child_area) + MainAxisSize(child_area),

[benwells, 2014/07/18 02:52:25]

I think DCHECK_EQ(total_padding, main_free_space) would be clearer. I'm not sure
what this DCHECK is testing.

[calamity, 2014/07/18 03:20:03]

Done.

+              main_position - between_child_spacing_);
   }
 }
 
 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