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) {
+  flex_map_[index] = flex_weight;
+}
+
+void BoxLayout::ClearFlexForViewAt(int index) {
+  flex_map_.erase(index);
+}
+
 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 padding_unit = 0;
+  int padding_remainder = 0;
+  int padding_sign = 0;
+  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) {
+    total_main_axis_size -= between_child_spacing_;
+    // Free space can be negative indicating that the views want to overflow.
+    int free_space = MainAxisSize(child_area) - total_main_axis_size;
+    int position = MainAxisPosition(child_area);
+    int size = MainAxisSize(child_area);
+    if (flex_sum) {
+      padding_sign = free_space > 0 ? 1 : -1;
+      padding_unit = free_space / flex_sum;
+      // If free space is negative, this will be negative.
+      padding_remainder = free_space % flex_sum;
+    } else {
       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;
           size = total_main_axis_size;
           break;
         case MAIN_AXIS_ALIGNMENT_END:
           position += 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);
       }
       int child_main_axis_size = MainAxisSizeForView(child, child_area.width());
-      SetMainAxisSize(child_main_axis_size + padding, &bounds);
-      if (MainAxisSize(bounds) > 0)
+      // The padding for the current view.
+      int current_padding = 0;
+      if (GetFlexForViewAt(i) > 0) {
+        current_padding = padding_unit * GetFlexForViewAt(i);
+        // Add any extra space due to multiple padding units being consumed.
+        int remainder_change = padding_remainder * GetFlexForViewAt(i);
+        current_padding += remainder_change / flex_sum;
+        // Use the current remainder to round to the nearest pixel.
+        current_remainder = (current_remainder + remainder_change) % flex_sum;
+        if (std::abs(current_remainder) > flex_sum / 2)
+          current_padding += padding_sign;
+      }
+
+      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);
     }
   }
 }
 
 gfx::Size BoxLayout::GetPreferredSize(const View* host) const {
@@ skipping 10 matching lines @@
   }
 
   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