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