OLD | NEW |
(Empty) | |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "ash/common/system/tray/three_view_layout.h" |
| 6 |
| 7 #include "ash/common/system/tray/size_range_layout.h" |
| 8 #include "base/logging.h" |
| 9 #include "ui/views/border.h" |
| 10 #include "ui/views/layout/box_layout.h" |
| 11 #include "ui/views/layout/fill_layout.h" |
| 12 |
| 13 namespace ash { |
| 14 namespace { |
| 15 |
| 16 // Converts ThreeViewLayout::Orientation values to |
| 17 // views::BoxLayout::Orientation values. |
| 18 views::BoxLayout::Orientation GetOrientation( |
| 19 ThreeViewLayout::Orientation orientation) { |
| 20 switch (orientation) { |
| 21 case ThreeViewLayout::Orientation::HORIZONTAL: |
| 22 return views::BoxLayout::kHorizontal; |
| 23 case ThreeViewLayout::Orientation::VERTICAL: |
| 24 return views::BoxLayout::kVertical; |
| 25 } |
| 26 // Required for some compilers. |
| 27 NOTREACHED(); |
| 28 return views::BoxLayout::kHorizontal; |
| 29 } |
| 30 |
| 31 } // namespace |
| 32 |
| 33 ThreeViewLayout::ThreeViewLayout() : ThreeViewLayout(0) {} |
| 34 |
| 35 ThreeViewLayout::ThreeViewLayout(int padding_between_containers) |
| 36 : ThreeViewLayout(Orientation::HORIZONTAL, padding_between_containers) {} |
| 37 |
| 38 ThreeViewLayout::ThreeViewLayout(Orientation orientation) |
| 39 : ThreeViewLayout(orientation, 0) {} |
| 40 |
| 41 ThreeViewLayout::ThreeViewLayout(Orientation orientation, |
| 42 int padding_between_containers) |
| 43 : box_layout_(new views::BoxLayout(GetOrientation(orientation), |
| 44 0, |
| 45 0, |
| 46 padding_between_containers)), |
| 47 start_container_(new views::View), |
| 48 start_container_layout_manager_(new SizeRangeLayout), |
| 49 center_container_(new views::View), |
| 50 center_container_layout_manager_(new SizeRangeLayout), |
| 51 end_container_(new views::View), |
| 52 end_container_layout_manager_(new SizeRangeLayout) { |
| 53 start_container_->SetLayoutManager(GetLayoutManager(Container::START)); |
| 54 center_container_->SetLayoutManager(GetLayoutManager(Container::CENTER)); |
| 55 end_container_->SetLayoutManager(GetLayoutManager(Container::END)); |
| 56 GetLayoutManager(Container::START) |
| 57 ->SetLayoutManager(CreateDefaultLayoutManager(orientation)); |
| 58 GetLayoutManager(Container::CENTER) |
| 59 ->SetLayoutManager(CreateDefaultLayoutManager(orientation)); |
| 60 GetLayoutManager(Container::END) |
| 61 ->SetLayoutManager(CreateDefaultLayoutManager(orientation)); |
| 62 } |
| 63 |
| 64 ThreeViewLayout::~ThreeViewLayout() { |
| 65 if (host_) { |
| 66 host_->RemoveChildView(GetContainer(Container::START)); |
| 67 host_->RemoveChildView(GetContainer(Container::CENTER)); |
| 68 host_->RemoveChildView(GetContainer(Container::END)); |
| 69 } |
| 70 } |
| 71 |
| 72 void ThreeViewLayout::SetMinCrossAxisSize(int min_size) { |
| 73 box_layout_->set_minimum_cross_axis_size(min_size); |
| 74 } |
| 75 |
| 76 void ThreeViewLayout::SetMinSize(Container container, const gfx::Size& size) { |
| 77 GetLayoutManager(container)->SetMinSize(size); |
| 78 } |
| 79 |
| 80 void ThreeViewLayout::SetMaxSize(Container container, const gfx::Size& size) { |
| 81 GetLayoutManager(container)->SetMaxSize(size); |
| 82 } |
| 83 |
| 84 void ThreeViewLayout::AddView(Container container, views::View* view) { |
| 85 GetContainer(container)->AddChildView(view); |
| 86 } |
| 87 |
| 88 void ThreeViewLayout::SetView(Container container, views::View* view) { |
| 89 views::View* container_view = GetContainer(container); |
| 90 container_view->RemoveAllChildViews(true); |
| 91 container_view->AddChildView(view); |
| 92 } |
| 93 |
| 94 void ThreeViewLayout::SetInsets(const gfx::Insets& insets) { |
| 95 box_layout_->set_inside_border_insets(insets); |
| 96 } |
| 97 |
| 98 void ThreeViewLayout::SetBorder(Container container, |
| 99 std::unique_ptr<views::Border> border) { |
| 100 GetContainer(container)->SetBorder(std::move(border)); |
| 101 } |
| 102 |
| 103 void ThreeViewLayout::SetContainerVisible(Container container, bool visible) { |
| 104 GetContainer(container)->SetVisible(visible); |
| 105 } |
| 106 |
| 107 void ThreeViewLayout::SetFlexForContainer(Container container, int flex) { |
| 108 box_layout_->SetFlexForView(GetContainer(container), flex); |
| 109 } |
| 110 |
| 111 void ThreeViewLayout::SetLayoutManager( |
| 112 Container container, |
| 113 std::unique_ptr<LayoutManager> layout_manager) { |
| 114 GetLayoutManager(container)->SetLayoutManager(std::move(layout_manager)); |
| 115 if (GetLayoutManager(container)) |
| 116 GetLayoutManager(container)->Installed(GetContainer(container)); |
| 117 } |
| 118 |
| 119 void ThreeViewLayout::Installed(views::View* host) { |
| 120 DCHECK(!host_); |
| 121 host_ = host; |
| 122 if (host_) { |
| 123 host_->AddChildView(GetContainer(Container::START)); |
| 124 host_->AddChildView(GetContainer(Container::CENTER)); |
| 125 host_->AddChildView(GetContainer(Container::END)); |
| 126 } |
| 127 box_layout_->Installed(host_); |
| 128 } |
| 129 |
| 130 void ThreeViewLayout::Layout(views::View* host) { |
| 131 box_layout_->Layout(host); |
| 132 } |
| 133 |
| 134 gfx::Size ThreeViewLayout::GetPreferredSize(const views::View* host) const { |
| 135 return box_layout_->GetPreferredSize(host); |
| 136 } |
| 137 |
| 138 int ThreeViewLayout::GetPreferredHeightForWidth(const views::View* host, |
| 139 int width) const { |
| 140 return box_layout_->GetPreferredHeightForWidth(host, width); |
| 141 } |
| 142 |
| 143 void ThreeViewLayout::ViewAdded(views::View* host, views::View* view) { |
| 144 box_layout_->ViewAdded(host, view); |
| 145 } |
| 146 |
| 147 void ThreeViewLayout::ViewRemoved(views::View* host, views::View* view) { |
| 148 box_layout_->ViewRemoved(host, view); |
| 149 } |
| 150 |
| 151 std::unique_ptr<views::LayoutManager> |
| 152 ThreeViewLayout::CreateDefaultLayoutManager(Orientation orientation) const { |
| 153 views::BoxLayout* box_layout = |
| 154 new views::BoxLayout(GetOrientation(orientation), 0, 0, 0); |
| 155 box_layout->set_main_axis_alignment( |
| 156 views::BoxLayout::MAIN_AXIS_ALIGNMENT_CENTER); |
| 157 box_layout->set_cross_axis_alignment( |
| 158 views::BoxLayout::CROSS_AXIS_ALIGNMENT_CENTER); |
| 159 return std::unique_ptr<views::LayoutManager>(box_layout); |
| 160 } |
| 161 |
| 162 views::View* ThreeViewLayout::GetContainer(Container container) const { |
| 163 switch (container) { |
| 164 case Container::START: |
| 165 return start_container_; |
| 166 case Container::CENTER: |
| 167 return center_container_; |
| 168 case Container::END: |
| 169 return end_container_; |
| 170 } |
| 171 // Required for some compilers. |
| 172 NOTREACHED(); |
| 173 return nullptr; |
| 174 } |
| 175 |
| 176 SizeRangeLayout* ThreeViewLayout::GetLayoutManager(Container container) const { |
| 177 switch (container) { |
| 178 case Container::START: |
| 179 return start_container_layout_manager_; |
| 180 case Container::CENTER: |
| 181 return center_container_layout_manager_; |
| 182 case Container::END: |
| 183 return end_container_layout_manager_; |
| 184 } |
| 185 // Required for some compilers. |
| 186 NOTREACHED(); |
| 187 return nullptr; |
| 188 } |
| 189 |
| 190 } // namespace ash |
OLD | NEW |