| // 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) { |
| } |
| |
| BoxLayout::~BoxLayout() { |
| } |
| |
| 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; |
| if (orientation_ == kHorizontal) { |
| total_main_axis_size += |
| child->GetPreferredSize().width() + between_child_spacing_; |
| } else { |
| total_main_axis_size += child->GetHeightForWidth(child_area.width()) + |
| between_child_spacing_; |
| } |
| ++num_visible; |
| } |
| |
| 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); |
| switch (main_axis_alignment_) { |
| case MAIN_AXIS_ALIGNMENT_FILL: |
| padding = std::max(free_space / num_visible, 0); |
| 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); |
| } |
| } |
| |
| int x = child_area.x(); |
| int y = child_area.y(); |
| for (int i = 0; i < host->child_count(); ++i) { |
| View* child = host->child_at(i); |
| if (child->visible()) { |
| gfx::Rect bounds(x, y, child_area.width(), child_area.height()); |
| if (orientation_ == kHorizontal) { |
| bounds.set_width(child->GetPreferredSize().width() + padding); |
| if (bounds.width() > 0) |
| x += bounds.width() + between_child_spacing_; |
| } else { |
| bounds.set_height(child->GetHeightForWidth(bounds.width()) + padding); |
| if (bounds.height() > 0) |
| y += bounds.height() + 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 { |
| // 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::MainAxisSize(const gfx::Rect& child_area) const { |
| return orientation_ == kHorizontal ? child_area.width() : child_area.height(); |
| } |
| |
| int BoxLayout::MainAxisPosition(const gfx::Rect& child_area) const { |
| return orientation_ == kHorizontal ? child_area.x() : child_area.y(); |
| } |
| |
| void BoxLayout::SetMainAxisSize(int size, gfx::Rect* child_area) const { |
| if (orientation_ == kHorizontal) |
| child_area->set_width(size); |
| else |
| child_area->set_height(size); |
| } |
| |
| void BoxLayout::SetMainAxisPosition(int position, gfx::Rect* child_area) const { |
| if (orientation_ == kHorizontal) |
| child_area->set_x(position); |
| else |
| child_area->set_y(position); |
| } |
| |
| gfx::Size BoxLayout::GetPreferredSizeForChildWidth(const View* host, |
| int child_area_width) const { |
| gfx::Rect child_area_bounds; |
| |
| if (orientation_ == kHorizontal) { |
| // Horizontal layouts ignore |child_area_width|, meaning they mimic the |
| // default behavior of GridLayout::GetPreferredHeightForWidth(). |
| // TODO(estade): fix this if it ever becomes a problem. |
| int position = 0; |
| for (int i = 0; i < host->child_count(); ++i) { |
| const View* child = host->child_at(i); |
| if (!child->visible()) |
| continue; |
| |
| gfx::Size size(child->GetPreferredSize()); |
| if (size.IsEmpty()) |
| continue; |
| |
| gfx::Rect child_bounds(position, 0, size.width(), size.height()); |
| child_area_bounds.Union(child_bounds); |
| position += size.width() + between_child_spacing_; |
| } |
| } else { |
| int height = 0; |
| for (int i = 0; i < host->child_count(); ++i) { |
| const View* child = host->child_at(i); |
| if (!child->visible()) |
| continue; |
| |
| int extra_height = child->GetHeightForWidth(child_area_width); |
| // Only add |between_child_spacing_| if this is not the only child. |
| if (height != 0 && extra_height > 0) |
| height += between_child_spacing_; |
| height += extra_height; |
| } |
| |
| child_area_bounds.set_width(child_area_width); |
| child_area_bounds.set_height(height); |
| } |
| |
| gfx::Size non_child_size = NonChildSize(host); |
| return gfx::Size(child_area_bounds.width() + non_child_size.width(), |
| 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 |