Windows docking should get triggered by pressing against the screen edge

ash/wm/workspace/snap_sizer.cc

 // 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 "ash/wm/workspace/snap_sizer.h"
 
 #include <cmath>
 
+#include "ash/ash_switches.h"
+#include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
+#include "ash/shell.h"
+#include "ash/shell_window_ids.h"
+#include "ash/wm/dock/docked_window_layout_manager.h"
 #include "ash/wm/property_util.h"
+#include "ash/wm/window_properties.h"
 #include "ash/wm/window_resizer.h"
 #include "ash/wm/window_util.h"
+#include "base/command_line.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/screen.h"
 
 namespace ash {
 namespace internal {
 
 namespace {
 
 // A list of ideal window width in pixel which will be used to populate the
 // |usable_width_| list.
 const int kIdealWidth[] = { 1280, 1024, 768, 640 };
 
 // Windows are initially snapped to the size in |usable_width_| at index 0.
 // The index into |usable_width_| is changed if any of the following happen:
 // . The user stops moving the mouse for |kDelayBeforeIncreaseMS| and then
 //   moves the mouse again.
 // . The mouse moves |kPixelsBeforeAdjust| horizontal pixels.
 // . The mouse is against the edge of the screen and the mouse is moved
 //   |kMovesBeforeAdjust| times.
 const int kDelayBeforeIncreaseMS = 500;
 const int kMovesBeforeAdjust = 25;
 const int kPixelsBeforeAdjust = 100;
 
 // When the smallest resolution does not fit on the screen, we take this
 // fraction of the available space.
 const int kMinimumScreenPercent = 90;
 
 // Create the list of possible width for the current screen configuration:
-// Fill the |usable_width_| list with items from |kIdealWidth| which fit on
-// the screen and supplement it with the 'half of screen' size. Furthermore,
-// add an entry for 90% of the screen size if it is smaller then the biggest
-// value in the |kIdealWidth| list (to get a step between the values).
-std::vector<int> BuildIdealWidthList(aura::Window* window) {
+// Returns a list that for windows that can be snapped (|allow_snap| set)
+// includes items from |kIdealWidth| which fit on the screen and supplement it
+// with the 'half of screen' size. Furthermore, add an entry for 90% of the
+// screen size if it is smaller then the biggest value in the |kIdealWidth|
+// list (to get a step between the values).
+// When a window can be docked (|allow_dock| set) a zero-width is added as the
+// last value to facilitate showing a docking guide.
+std::vector<int> BuildIdealWidthList(aura::Window* window,
+                                     bool allow_snap,
+                                     bool allow_dock) {
   std::vector<int> ideal_width_list;
-  gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window));
-  int half_size = work_area.width() / 2;
-  int maximum_width = (kMinimumScreenPercent * work_area.width()) / 100;
-  for (size_t i = 0; i < arraysize(kIdealWidth); i++) {
-    if (maximum_width >= kIdealWidth[i]) {
-      if (i && !ideal_width_list.size() && maximum_width != kIdealWidth[i])
-        ideal_width_list.push_back(maximum_width);
-      if (half_size > kIdealWidth[i])
-        ideal_width_list.push_back(half_size);
-      if (half_size >= kIdealWidth[i])
-        half_size = 0;
-      ideal_width_list.push_back(kIdealWidth[i]);
+  if (allow_snap) {
+    gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window));
+    int half_size = work_area.width() / 2;
+    int maximum_width = (kMinimumScreenPercent * work_area.width()) / 100;
+    for (size_t i = 0; i < arraysize(kIdealWidth); i++) {
+      if (maximum_width >= kIdealWidth[i]) {
+        if (i && !ideal_width_list.size() && maximum_width != kIdealWidth[i])
+          ideal_width_list.push_back(maximum_width);
+        if (half_size > kIdealWidth[i])
+          ideal_width_list.push_back(half_size);
+        if (half_size >= kIdealWidth[i])
+          half_size = 0;
+        ideal_width_list.push_back(kIdealWidth[i]);
+      }
     }
+    if (half_size)
+      ideal_width_list.push_back(half_size);
   }
-  if (half_size)
-    ideal_width_list.push_back(half_size);
+  if (allow_dock)
+    ideal_width_list.push_back(0);
 
   return ideal_width_list;
 }
 
 }  // namespace
 
 SnapSizer::SnapSizer(aura::Window* window,
                      const gfx::Point& start,
                      Edge edge,
                      InputType input_type)
     : window_(window),
       edge_(edge),
       time_last_update_(base::TimeTicks::Now()),
       size_index_(0),
       resize_disabled_(false),
       num_moves_since_adjust_(0),
       last_adjust_x_(start.x()),
       last_update_x_(start.x()),
       start_x_(start.x()),
-      input_type_(input_type),
-      usable_width_(BuildIdealWidthList(window)) {
+      input_type_(input_type) {
+  aura::Window* dock_container = Shell::GetContainer(
+      window_->GetRootWindow(), kShellWindowId_DockedContainer);
+  dock_layout_ = static_cast<DockedWindowLayoutManager*>(
+      dock_container->layout_manager());
+  bool allow_dock =
+      input_type_ == internal::SnapSizer::WORKSPACE_DRAG_INPUT &&
+      CanDockWindow(window_, edge_);
+  bool allow_snap = !allow_dock ||
+      (wm::CanSnapWindow(window_) &&
+       !dock_layout_->is_dragged_window_docked() &&
+       window->bounds().width() > DockedWindowLayoutManager::kMaxDockWidth);
+  usable_width_ = BuildIdealWidthList(window, allow_snap, allow_dock);
   DCHECK(!usable_width_.empty());
+  UpdateDockedState();
   target_bounds_ = GetTargetBounds();
 }
 
 SnapSizer::~SnapSizer() {
+  // Normally when a drag is completed CompleteDrag will be called making
+  // the following a no-op. updating state is necessary when a window gets
+  // snapped in and out during the drag.
+  if (dock_layout_->is_dragged_window_docked())
+    dock_layout_->UndockDraggedWindow();
 }
 
 void SnapSizer::SnapWindow(aura::Window* window, SnapSizer::Edge edge) {
   if (!wm::CanSnapWindow(window))
     return;
   internal::SnapSizer sizer(window, gfx::Point(), edge,
       internal::SnapSizer::OTHER_INPUT);
   if (wm::IsWindowFullscreen(window) || wm::IsWindowMaximized(window)) {
     // Before we can set the bounds we need to restore the window.
     // Restoring the window will set the window to its restored bounds.
@@ skipping 30 matching lines @@
             std::min(pixels_before_adjust,
                      (workspace_bounds.width() - start_x_) / 10);
       }
     }
     if (std::abs(location.x() - last_adjust_x_) >= pixels_before_adjust ||
         (along_edge && num_moves_since_adjust_ >= kMovesBeforeAdjust)) {
       ChangeBounds(location.x(),
                    CalculateIncrement(location.x(), last_adjust_x_));
     }
   }
+  UpdateDockedState();
   last_update_x_ = location.x();
   time_last_update_ = base::TimeTicks::Now();
 }
 
 gfx::Rect SnapSizer::GetSnapBounds(const gfx::Rect& bounds) {
   int current = 0;
   if (!resize_disabled_) {
     for (current = usable_width_.size() - 1; current >= 0; current--) {
       gfx::Rect target = GetTargetBoundsForSize(current);
       if (target == bounds) {
         ++current;
         break;
       }
     }
   }
   return GetTargetBoundsForSize(current % usable_width_.size());
 }
 
 void SnapSizer::SelectDefaultSizeAndDisableResize() {
   resize_disabled_ = true;
   size_index_ = 0;
+  UpdateDockedState();
   target_bounds_ = GetTargetBounds();
 }
 
 gfx::Rect SnapSizer::GetTargetBoundsForSize(size_t size_index) const {
   gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_));
   int y = work_area.y();
   // We don't align to the bottom of the grid as the launcher may not
   // necessarily align to the grid (happens when auto-hidden).
   int max_y = work_area.bottom();
   int width = 0;
   if (resize_disabled_) {
     // Make sure that we keep the size of the window smaller then a certain
     // fraction of the screen space.
     int minimum_size = (kMinimumScreenPercent * work_area.width()) / 100;
     width = std::max(std::min(minimum_size, 1024), work_area.width() / 2);
   } else {
     DCHECK(size_index < usable_width_.size());
     width = usable_width_[size_index];
   }
 
+  if (width == 0) {
+    return ScreenAsh::ConvertRectFromScreen(window_->parent(),
+                                            dock_layout_->dragged_bounds());
+  }
+
   if (edge_ == LEFT_EDGE) {
     int x = work_area.x();
     int mid_x = x + width;
     return gfx::Rect(x, y, mid_x - x, max_y - y);
   }
   int max_x = work_area.right();
   int x = max_x - width;
   return gfx::Rect(x , y, max_x - x, max_y - y);
 }
 
+bool SnapSizer::ShouldDockWindow() const {
+  // TODO(varkha): use dedicated state.
+  return (usable_width_[size_index_] == 0);
+}
+
+// static
+bool SnapSizer::CanDockWindow(aura::Window* window, SnapSizer::Edge edge) {
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kAshEnableDockedWindows)) {
+    return false;
+  }
+  // Cannot dock on the other size from an existing dock.
+  aura::Window* dock_container = Shell::GetContainer(
+      window->GetRootWindow(), kShellWindowId_DockedContainer);
+  DockedWindowLayoutManager* dock_layout =
+      static_cast<DockedWindowLayoutManager*>(dock_container->layout_manager());
+  const DockedAlignment alignment = dock_layout->CalculateAlignment();
+  if ((edge == LEFT_EDGE && alignment == DOCKED_ALIGNMENT_RIGHT) ||
+      (edge == RIGHT_EDGE && alignment == DOCKED_ALIGNMENT_LEFT)) {
+    return false;
+  }
+
+  // Do not allow docking on the same side as launcher shelf.
+  Launcher* shelf = Launcher::ForWindow(window);
+  if (shelf &&
+      ((edge == LEFT_EDGE && shelf->alignment() == SHELF_ALIGNMENT_LEFT) ||
+       (edge == RIGHT_EDGE && shelf->alignment() == SHELF_ALIGNMENT_RIGHT))) {
+    return false;
+  }
+  return true;
+}
+
 int SnapSizer::CalculateIncrement(int x, int reference_x) const {
   if (AlongEdge(x))
     return 1;
   if (x == reference_x)
     return 0;
   if (edge_ == LEFT_EDGE) {
     if (x < reference_x)
       return 1;
     return -1;
   }
@@ skipping 12 matching lines @@
   }
   num_moves_since_adjust_ = 0;
   last_adjust_x_ = x;
 }
 
 gfx::Rect SnapSizer::GetTargetBounds() const {
   return GetTargetBoundsForSize(size_index_);
 }
 
 bool SnapSizer::AlongEdge(int x) const {
-  gfx::Rect area(ScreenAsh::GetDisplayBoundsInParent(window_));
+  gfx::Rect area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_));
   return (x <= area.x()) || (x >= area.right() - 1);
 }
 
+void SnapSizer::UpdateDockedState() {
+  if (ShouldDockWindow() &&
+      dock_layout_->GetAlignmentOfWindow(window_) != DOCKED_ALIGNMENT_NONE) {
+    if (!dock_layout_->is_dragged_window_docked())
+      dock_layout_->DockDraggedWindow(window_);
+    target_bounds_ = GetTargetBounds();
+  } else {
+    if (dock_layout_->is_dragged_window_docked())
+      dock_layout_->UndockDraggedWindow();
+  }
+}
+
 }  // namespace internal
 }  // namespace ash