ui/views/controls/single_split_view.cc

   1 // Copyright (c) 2012 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 "ui/views/controls/single_split_view.h"
   6
   7 #include "skia/ext/skia_utils_win.h"
   8 #include "ui/accessibility/ax_view_state.h"
   9 #include "ui/base/cursor/cursor.h"
  10 #include "ui/gfx/canvas.h"
  11 #include "ui/views/background.h"
  12 #include "ui/views/controls/single_split_view_listener.h"
  13 #include "ui/views/native_cursor.h"
  14
  15 namespace views {
  16
  17 // static
  18 const char SingleSplitView::kViewClassName[] = "SingleSplitView";
  19
  20 // Size of the divider in pixels.
  21 static const int kDividerSize = 4;
  22
  23 SingleSplitView::SingleSplitView(View* leading,
  24                                  View* trailing,
  25                                  Orientation orientation,
  26                                  SingleSplitViewListener* listener)
  27     : is_horizontal_(orientation == HORIZONTAL_SPLIT),
  28       divider_offset_(-1),
  29       resize_leading_on_bounds_change_(true),
  30       resize_disabled_(false),
  31       listener_(listener) {
  32   AddChildView(leading);
  33   AddChildView(trailing);
  34 #if defined(OS_WIN)
  35   set_background(
  36       views::Background::CreateSolidBackground(
  37           skia::COLORREFToSkColor(GetSysColor(COLOR_3DFACE))));
  38 #endif
  39 }
  40
  41 void SingleSplitView::Layout() {
  42   gfx::Rect leading_bounds;
  43   gfx::Rect trailing_bounds;
  44   CalculateChildrenBounds(bounds(), &leading_bounds, &trailing_bounds);
  45
  46   if (has_children()) {
  47     if (child_at(0)->visible())
  48       child_at(0)->SetBoundsRect(leading_bounds);
  49     if (child_count() > 1) {
  50       if (child_at(1)->visible())
  51         child_at(1)->SetBoundsRect(trailing_bounds);
  52     }
  53   }
  54
  55   // Invoke super's implementation so that the children are layed out.
  56   View::Layout();
  57 }
  58
  59 const char* SingleSplitView::GetClassName() const {
  60   return kViewClassName;
  61 }
  62
  63 void SingleSplitView::GetAccessibleState(ui::AXViewState* state) {
  64   state->role = ui::AX_ROLE_GROUP;
  65   state->name = accessible_name_;
  66 }
  67
  68 gfx::Size SingleSplitView::GetPreferredSize() const {
  69   int width = 0;
  70   int height = 0;
  71   for (int i = 0; i < 2 && i < child_count(); ++i) {
  72     const View* view = child_at(i);
  73     gfx::Size pref = view->GetPreferredSize();
  74     if (is_horizontal_) {
  75       width += pref.width();
  76       height = std::max(height, pref.height());
  77     } else {
  78       width = std::max(width, pref.width());
  79       height += pref.height();
  80     }
  81   }
  82   if (is_horizontal_)
  83     width += GetDividerSize();
  84   else
  85     height += GetDividerSize();
  86   return gfx::Size(width, height);
  87 }
  88
  89 gfx::NativeCursor SingleSplitView::GetCursor(const ui::MouseEvent& event) {
  90   if (!IsPointInDivider(event.location()))
  91     return gfx::kNullCursor;
  92   return is_horizontal_ ? GetNativeEastWestResizeCursor()
  93                         : GetNativeNorthSouthResizeCursor();
  94 }
  95
  96 int SingleSplitView::GetDividerSize() const {
  97   bool both_visible = child_count() > 1 && child_at(0)->visible() &&
  98       child_at(1)->visible();
  99   return both_visible && !resize_disabled_ ? kDividerSize : 0;
 100 }
 101
 102 void SingleSplitView::CalculateChildrenBounds(
 103     const gfx::Rect& bounds,
 104     gfx::Rect* leading_bounds,
 105     gfx::Rect* trailing_bounds) const {
 106   bool is_leading_visible = has_children() && child_at(0)->visible();
 107   bool is_trailing_visible = child_count() > 1 && child_at(1)->visible();
 108
 109   if (!is_leading_visible && !is_trailing_visible) {
 110     *leading_bounds = gfx::Rect();
 111     *trailing_bounds = gfx::Rect();
 112     return;
 113   }
 114
 115   int divider_at;
 116
 117   if (!is_trailing_visible) {
 118     divider_at = GetPrimaryAxisSize(bounds.width(), bounds.height());
 119   } else if (!is_leading_visible) {
 120     divider_at = 0;
 121   } else {
 122     divider_at =
 123         CalculateDividerOffset(divider_offset_, this->bounds(), bounds);
 124     divider_at = NormalizeDividerOffset(divider_at, bounds);
 125   }
 126
 127   int divider_size = GetDividerSize();
 128
 129   if (is_horizontal_) {
 130     *leading_bounds = gfx::Rect(0, 0, divider_at, bounds.height());
 131     *trailing_bounds =
 132         gfx::Rect(divider_at + divider_size, 0,
 133                   std::max(0, bounds.width() - divider_at - divider_size),
 134                   bounds.height());
 135   } else {
 136     *leading_bounds = gfx::Rect(0, 0, bounds.width(), divider_at);
 137     *trailing_bounds =
 138         gfx::Rect(0, divider_at + divider_size, bounds.width(),
 139                   std::max(0, bounds.height() - divider_at - divider_size));
 140   }
 141 }
 142
 143 void SingleSplitView::SetAccessibleName(const base::string16& name) {
 144   accessible_name_ = name;
 145 }
 146
 147 bool SingleSplitView::OnMousePressed(const ui::MouseEvent& event) {
 148   if (!IsPointInDivider(event.location()))
 149     return false;
 150   drag_info_.initial_mouse_offset = GetPrimaryAxisSize(event.x(), event.y());
 151   drag_info_.initial_divider_offset =
 152       NormalizeDividerOffset(divider_offset_, bounds());
 153   return true;
 154 }
 155
 156 bool SingleSplitView::OnMouseDragged(const ui::MouseEvent& event) {
 157   if (child_count() < 2)
 158     return false;
 159
 160   int delta_offset = GetPrimaryAxisSize(event.x(), event.y()) -
 161       drag_info_.initial_mouse_offset;
 162   if (is_horizontal_ && base::i18n::IsRTL())
 163     delta_offset *= -1;
 164   // Honor the first child's minimum size when resizing.
 165   gfx::Size min = child_at(0)->GetMinimumSize();
 166   int new_size = std::max(GetPrimaryAxisSize(min.width(), min.height()),
 167                           drag_info_.initial_divider_offset + delta_offset);
 168
 169   // Honor the second child's minimum size, and don't let the view
 170   // get bigger than our width.
 171   min = child_at(1)->GetMinimumSize();
 172   new_size = std::min(GetPrimaryAxisSize() - kDividerSize -
 173       GetPrimaryAxisSize(min.width(), min.height()), new_size);
 174
 175   if (new_size != divider_offset_) {
 176     set_divider_offset(new_size);
 177     if (!listener_ || listener_->SplitHandleMoved(this))
 178       Layout();
 179   }
 180   return true;
 181 }
 182
 183 void SingleSplitView::OnMouseCaptureLost() {
 184   if (child_count() < 2)
 185     return;
 186
 187   if (drag_info_.initial_divider_offset != divider_offset_) {
 188     set_divider_offset(drag_info_.initial_divider_offset);
 189     if (!listener_ || listener_->SplitHandleMoved(this))
 190       Layout();
 191   }
 192 }
 193
 194 void SingleSplitView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
 195   divider_offset_ = CalculateDividerOffset(divider_offset_, previous_bounds,
 196                                            bounds());
 197 }
 198
 199 bool SingleSplitView::IsPointInDivider(const gfx::Point& p) {
 200   if (resize_disabled_)
 201     return false;
 202
 203   if (child_count() < 2)
 204     return false;
 205
 206   if (!child_at(0)->visible() || !child_at(1)->visible())
 207     return false;
 208
 209   int divider_relative_offset;
 210   if (is_horizontal_) {
 211     divider_relative_offset =
 212         p.x() - child_at(base::i18n::IsRTL() ? 1 : 0)->width();
 213   } else {
 214     divider_relative_offset = p.y() - child_at(0)->height();
 215   }
 216   return (divider_relative_offset >= 0 &&
 217       divider_relative_offset < GetDividerSize());
 218 }
 219
 220 int SingleSplitView::CalculateDividerOffset(
 221     int divider_offset,
 222     const gfx::Rect& previous_bounds,
 223     const gfx::Rect& new_bounds) const {
 224   if (resize_leading_on_bounds_change_ && divider_offset != -1) {
 225     // We do not update divider_offset on minimize (to zero) and on restore
 226     // (to largest value). As a result we get back to the original value upon
 227     // window restore.
 228     bool is_minimize_or_restore =
 229         previous_bounds.height() == 0 || new_bounds.height() == 0;
 230     if (!is_minimize_or_restore) {
 231       if (is_horizontal_)
 232         divider_offset += new_bounds.width() - previous_bounds.width();
 233       else
 234         divider_offset += new_bounds.height() - previous_bounds.height();
 235
 236       if (divider_offset < 0)
 237         divider_offset = GetDividerSize();
 238     }
 239   }
 240   return divider_offset;
 241 }
 242
 243 int SingleSplitView::NormalizeDividerOffset(int divider_offset,
 244                                             const gfx::Rect& bounds) const {
 245   int primary_axis_size = GetPrimaryAxisSize(bounds.width(), bounds.height());
 246   if (divider_offset < 0)
 247     // primary_axis_size may < GetDividerSize during initial layout.
 248     return std::max(0, (primary_axis_size - GetDividerSize()) / 2);
 249   return std::min(divider_offset,
 250                   std::max(primary_axis_size - GetDividerSize(), 0));
 251 }
 252
 253 }  // namespace views