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

[flackr, 2013/09/06 02:18:43]

Looks like an out of date comment, this returns the list.

[varkha, 2013/09/09 15:38:42]

Done.

 // 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).

[flackr, 2013/09/06 02:18:43]

Comment |allow_max| and |allow_dock|.

[varkha, 2013/09/09 15:38:42]

Done.

-std::vector<int> BuildIdealWidthList(aura::Window* window) {
+std::vector<int> BuildIdealWidthList(aura::Window* window,
+                                     bool allow_max,
+                                     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_max) {
+    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_max) {
+//    gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window));
+//    ideal_width_list.push_back(work_area.width() / 2);
+//  }

[flackr, 2013/09/06 02:18:43]

Remove commented code.

[varkha, 2013/09/09 15:38:42]

Done.

+
+  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 ||

[flackr, 2013/09/06 02:18:43]

nit: Move up to previous line.

[varkha, 2013/09/09 15:38:42]

Done.

+      (wm::CanSnapWindow(window_) &&
+       !dock_layout_->is_dragged_window_docked() &&
+       window->bounds().width() > DockedWindowLayoutManager::kMaxDockWidth &&
+       (window_->type() != aura::client::WINDOW_TYPE_PANEL));
+  usable_width_ = BuildIdealWidthList(window, allow_snap, allow_dock);

[flackr, 2013/09/06 02:18:43]

In BuildIdealWidthList, you call allow_snap allox_max. It's unclear why these
are the same.

[varkha, 2013/09/09 15:38:42]

Done (renamed allow_max -> allow_snap for consistency).

   DCHECK(!usable_width_.empty());
+  UpdateDockedState();
   target_bounds_ = GetTargetBounds();
 }
 
 SnapSizer::~SnapSizer() {
+  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.
     // To avoid an unnecessary bounds changes (which may have side effects)
     // we set the restore bounds to the bounds we want, restore the window,
     // then reset the restore bounds. This way no unnecessary bounds
     // changes occurs and the original restore bounds is remembered.
     gfx::Rect restore = *GetRestoreBoundsInScreen(window);
     SetRestoreBoundsInParent(window, sizer.GetSnapBounds(window->bounds()));
     wm::RestoreWindow(window);
     SetRestoreBoundsInScreen(window, restore);
   } else {
     window->SetBounds(sizer.GetSnapBounds(window->bounds()));
   }
 }
 
 void SnapSizer::Update(const gfx::Point& location) {
+  LOG(INFO) << "Update to " << location.ToString();
+
   // See description above for details on this behavior.
   num_moves_since_adjust_++;
   if ((base::TimeTicks::Now() - time_last_update_).InMilliseconds() >
       kDelayBeforeIncreaseMS) {
     ChangeBounds(location.x(),
                  CalculateIncrement(location.x(), last_update_x_));
   } else {
     bool along_edge = AlongEdge(location.x());
     int pixels_before_adjust = kPixelsBeforeAdjust;
     if (input_type_ == TOUCH_MAXIMIZE_BUTTON_INPUT) {
       const gfx::Rect& workspace_bounds = window_->parent()->bounds();
       if (start_x_ > location.x()) {
         pixels_before_adjust =
             std::min(pixels_before_adjust, start_x_ / 10);
       } else {
         pixels_before_adjust =
             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) {
+    LOG(INFO) << "snap bounds " << dock_layout_->dragged_bounds().ToString();
+    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 {
+  if (!CanDockWindow(window_, edge_))

[flackr, 2013/09/06 02:18:43]

If !CanDockWindow, 0 shouldn't be in the list of usable widths. Can we not just
check for a usable width of 0?

[varkha, 2013/09/09 15:38:42]

Done.

+    return false;
+  // Avoid returning true when the last step is not docking.

[flackr, 2013/09/06 02:18:43]

This comment is confusing. The last step is the only one that can be docking
right? So you should avoid returning true if the window shouldn't dock, but then
that's the name of the method so self explanatory. Is there some extra condition
to convey here?

[varkha, 2013/09/09 15:38:42]

More to do with how this code was modified. This is of no value anymore so
removed.

+  // TODO(varkha): use dedicated state.
+  return (usable_width_[size_index_] == 0 &&
+          size_index_ == static_cast<int>(usable_width_.size()) - 1);

[flackr, 2013/09/06 02:18:43]

Shouldn't 0 always be the last element in usable_width_? I'm not sure checking
that we're at the end is necessary.

[varkha, 2013/09/09 15:38:42]

Done.

+}
+
+// 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* launcher = Launcher::ForWindow(window);
+  if (!launcher)
+    return true;
+  return (edge == LEFT_EDGE && launcher->alignment() != SHELF_ALIGNMENT_LEFT) ||
+         (edge == RIGHT_EDGE && launcher->alignment() != SHELF_ALIGNMENT_RIGHT);
+
+}
+
 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()) {
+      LOG(INFO) << "dock";
+      dock_layout_->DockDraggedWindow(window_);
+    }
+    target_bounds_ = GetTargetBounds();
+  } else {
+    if (dock_layout_->is_dragged_window_docked()) {
+      LOG(INFO) << "undock";
+      dock_layout_->UndockDraggedWindow();
+    }
+  }
+}
+
 }  // namespace internal
 }  // namespace ash