ash/wm/workspace/snap_sizer.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 "ash/wm/workspace/snap_sizer.h"
   6
   7 #include <cmath>
   8
   9 #include "ash/screen_ash.h"
  10 #include "ash/wm/property_util.h"
  11 #include "ash/wm/window_resizer.h"
  12 #include "ash/wm/window_util.h"
  13 #include "ui/aura/window.h"
  14 #include "ui/gfx/screen.h"
  15
  16 namespace ash {
  17 namespace internal {
  18
  19 namespace {
  20
  21 // A list of ideal window width in pixel which will be used to populate the
  22 // |usable_width_| list.
  23 const int kIdealWidth[] = { 1280, 1024, 768, 640 };
  24
  25 // Windows are initially snapped to the size in |usable_width_| at index 0.
  26 // The index into |usable_width_| is changed if any of the following happen:
  27 // . The user stops moving the mouse for |kDelayBeforeIncreaseMS| and then
  28 //   moves the mouse again.
  29 // . The mouse moves |kPixelsBeforeAdjust| horizontal pixels.
  30 // . The mouse is against the edge of the screen and the mouse is moved
  31 //   |kMovesBeforeAdjust| times.
  32 const int kDelayBeforeIncreaseMS = 500;
  33 const int kMovesBeforeAdjust = 25;
  34 const int kPixelsBeforeAdjust = 100;
  35
  36 // When the smallest resolution does not fit on the screen, we take this
  37 // fraction of the available space.
  38 const int kMinimumScreenPercent = 90;
  39
  40 // Create the list of possible width for the current screen configuration:
  41 // Fill the |usable_width_| list with items from |kIdealWidth| which fit on
  42 // the screen and supplement it with the 'half of screen' size. Furthermore,
  43 // add an entry for 90% of the screen size if it is smaller then the biggest
  44 // value in the |kIdealWidth| list (to get a step between the values).
  45 std::vector<int> BuildIdealWidthList(aura::Window* window) {
  46   std::vector<int> ideal_width_list;
  47   gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window));
  48   int half_size = work_area.width() / 2;
  49   int maximum_width = (kMinimumScreenPercent * work_area.width()) / 100;
  50   for (size_t i = 0; i < arraysize(kIdealWidth); i++) {
  51     if (maximum_width >= kIdealWidth[i]) {
  52       if (i && !ideal_width_list.size() && maximum_width != kIdealWidth[i])
  53         ideal_width_list.push_back(maximum_width);
  54       if (half_size > kIdealWidth[i])
  55         ideal_width_list.push_back(half_size);
  56       if (half_size >= kIdealWidth[i])
  57         half_size = 0;
  58       ideal_width_list.push_back(kIdealWidth[i]);
  59     }
  60   }
  61   if (half_size)
  62     ideal_width_list.push_back(half_size);
  63
  64   return ideal_width_list;
  65 }
  66
  67 }  // namespace
  68
  69 SnapSizer::SnapSizer(aura::Window* window,
  70                      const gfx::Point& start,
  71                      Edge edge,
  72                      InputType input_type)
  73     : window_(window),
  74       edge_(edge),
  75       time_last_update_(base::TimeTicks::Now()),
  76       size_index_(0),
  77       resize_disabled_(false),
  78       num_moves_since_adjust_(0),
  79       last_adjust_x_(start.x()),
  80       last_update_x_(start.x()),
  81       start_x_(start.x()),
  82       input_type_(input_type),
  83       usable_width_(BuildIdealWidthList(window)) {
  84   DCHECK(!usable_width_.empty());
  85   target_bounds_ = GetTargetBounds();
  86 }
  87
  88 SnapSizer::~SnapSizer() {
  89 }
  90
  91 void SnapSizer::SnapWindow(aura::Window* window, SnapSizer::Edge edge) {
  92   if (!wm::CanSnapWindow(window))
  93     return;
  94   internal::SnapSizer sizer(window, gfx::Point(), edge,
  95       internal::SnapSizer::OTHER_INPUT);
  96   if (wm::IsWindowFullscreen(window) || wm::IsWindowMaximized(window)) {
  97     // Before we can set the bounds we need to restore the window.
  98     // Restoring the window will set the window to its restored bounds.
  99     // To avoid an unnecessary bounds changes (which may have side effects)
 100     // we set the restore bounds to the bounds we want, restore the window,
 101     // then reset the restore bounds. This way no unnecessary bounds
 102     // changes occurs and the original restore bounds is remembered.
 103     gfx::Rect restore = *GetRestoreBoundsInScreen(window);
 104     SetRestoreBoundsInParent(window, sizer.GetSnapBounds(window->bounds()));
 105     wm::RestoreWindow(window);
 106     SetRestoreBoundsInScreen(window, restore);
 107   } else {
 108     window->SetBounds(sizer.GetSnapBounds(window->bounds()));
 109   }
 110 }
 111
 112 void SnapSizer::Update(const gfx::Point& location) {
 113   // See description above for details on this behavior.
 114   num_moves_since_adjust_++;
 115   if ((base::TimeTicks::Now() - time_last_update_).InMilliseconds() >
 116       kDelayBeforeIncreaseMS) {
 117     ChangeBounds(location.x(),
 118                  CalculateIncrement(location.x(), last_update_x_));
 119   } else {
 120     bool along_edge = AlongEdge(location.x());
 121     int pixels_before_adjust = kPixelsBeforeAdjust;
 122     if (input_type_ == TOUCH_MAXIMIZE_BUTTON_INPUT) {
 123       const gfx::Rect& workspace_bounds = window_->parent()->bounds();
 124       if (start_x_ > location.x()) {
 125         pixels_before_adjust =
 126             std::min(pixels_before_adjust, start_x_ / 10);
 127       } else {
 128         pixels_before_adjust =
 129             std::min(pixels_before_adjust,
 130                      (workspace_bounds.width() - start_x_) / 10);
 131       }
 132     }
 133     if (std::abs(location.x() - last_adjust_x_) >= pixels_before_adjust ||
 134         (along_edge && num_moves_since_adjust_ >= kMovesBeforeAdjust)) {
 135       ChangeBounds(location.x(),
 136                    CalculateIncrement(location.x(), last_adjust_x_));
 137     }
 138   }
 139   last_update_x_ = location.x();
 140   time_last_update_ = base::TimeTicks::Now();
 141 }
 142
 143 gfx::Rect SnapSizer::GetSnapBounds(const gfx::Rect& bounds) {
 144   int current = 0;
 145   if (!resize_disabled_) {
 146     for (current = usable_width_.size() - 1; current >= 0; current--) {
 147       gfx::Rect target = GetTargetBoundsForSize(current);
 148       if (target == bounds) {
 149         ++current;
 150         break;
 151       }
 152     }
 153   }
 154   return GetTargetBoundsForSize(current % usable_width_.size());
 155 }
 156
 157 void SnapSizer::SelectDefaultSizeAndDisableResize() {
 158   resize_disabled_ = true;
 159   size_index_ = 0;
 160   target_bounds_ = GetTargetBounds();
 161 }
 162
 163 gfx::Rect SnapSizer::GetTargetBoundsForSize(size_t size_index) const {
 164   gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_));
 165   int y = work_area.y();
 166   // We don't align to the bottom of the grid as the launcher may not
 167   // necessarily align to the grid (happens when auto-hidden).
 168   int max_y = work_area.bottom();
 169   int width = 0;
 170   if (resize_disabled_) {
 171     // Make sure that we keep the size of the window smaller then a certain
 172     // fraction of the screen space.
 173     int minimum_size = (kMinimumScreenPercent * work_area.width()) / 100;
 174     width = std::max(std::min(minimum_size, 1024), work_area.width() / 2);
 175   } else {
 176     DCHECK(size_index < usable_width_.size());
 177     width = usable_width_[size_index];
 178   }
 179
 180   if (edge_ == LEFT_EDGE) {
 181     int x = work_area.x();
 182     int mid_x = x + width;
 183     return gfx::Rect(x, y, mid_x - x, max_y - y);
 184   }
 185   int max_x = work_area.right();
 186   int x = max_x - width;
 187   return gfx::Rect(x , y, max_x - x, max_y - y);
 188 }
 189
 190 int SnapSizer::CalculateIncrement(int x, int reference_x) const {
 191   if (AlongEdge(x))
 192     return 1;
 193   if (x == reference_x)
 194     return 0;
 195   if (edge_ == LEFT_EDGE) {
 196     if (x < reference_x)
 197       return 1;
 198     return -1;
 199   }
 200   // edge_ == RIGHT_EDGE.
 201   if (x > reference_x)
 202     return 1;
 203   return -1;
 204 }
 205
 206 void SnapSizer::ChangeBounds(int x, int delta) {
 207   int index = std::min(static_cast<int>(usable_width_.size()) - 1,
 208                        std::max(size_index_ + delta, 0));
 209   if (index != size_index_) {
 210     size_index_ = index;
 211     target_bounds_ = GetTargetBounds();
 212   }
 213   num_moves_since_adjust_ = 0;
 214   last_adjust_x_ = x;
 215 }
 216
 217 gfx::Rect SnapSizer::GetTargetBounds() const {
 218   return GetTargetBoundsForSize(size_index_);
 219 }
 220
 221 bool SnapSizer::AlongEdge(int x) const {
 222   gfx::Rect area(ScreenAsh::GetDisplayBoundsInParent(window_));
 223   return (x <= area.x()) || (x >= area.right() - 1);
 224 }
 225
 226 }  // namespace internal
 227 }  // namespace ash