Windows docking should get triggered by pressing against the screen edge

ash/wm/dock/docked_window_resizer.cc

 // Copyright 2013 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/dock/docked_window_resizer.h"
 
 #include "ash/ash_switches.h"
+#include "ash/display/display_controller.h"
 #include "ash/launcher/launcher.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.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/workspace/magnetism_matcher.h"
-#include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "base/command_line.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace internal {
 
 namespace {
 
 DockedWindowLayoutManager* GetDockedLayoutManagerAtPoint(
     const gfx::Point& point) {
+  gfx::Display display = ScreenAsh::FindDisplayContainingPoint(point);
+  if (!display.is_valid())
+    return NULL;
+  aura::RootWindow* root = Shell::GetInstance()->display_controller()->
+      GetRootWindowForDisplayId(display.id());
   aura::Window* dock_container = Shell::GetContainer(
-      wm::GetRootWindowAt(point),
-      kShellWindowId_DockedContainer);
+      root, kShellWindowId_DockedContainer);
   return static_cast<DockedWindowLayoutManager*>(
       dock_container->layout_manager());
 }
 
 }  // namespace
 
 DockedWindowResizer::~DockedWindowResizer() {
   if (destroyed_)
     *destroyed_ = true;
 }
@@ skipping 37 matching lines @@
   // resizers to avoid the awkward pattern here for checking if
   // next_window_resizer_ destroys the resizer object.
   if (destroyed)
     return;
   destroyed_ = NULL;
   if (set_tracked_by_workspace)
     SetTrackedByWorkspace(GetTarget(), tracked_by_workspace);
 
   DockedWindowLayoutManager* new_dock_layout =
       GetDockedLayoutManagerAtPoint(last_location_);
-  if (new_dock_layout != dock_layout_) {
+  if (new_dock_layout && new_dock_layout != dock_layout_) {
     // The window is being dragged to a new display. If the previous
     // container is the current parent of the window it will be informed of
     // the end of drag when the window is reparented, otherwise let the
     // previous container know the drag is complete. If we told the
     // window's parent that the drag was complete it would begin
     // positioning the window.
     if (is_docked_)
       dock_layout_->UndockDraggedWindow();
     if (dock_layout_ != initial_dock_layout_)
       dock_layout_->FinishDragging();
     is_docked_ = false;
     dock_layout_ = new_dock_layout;
     // The window's initial layout manager already knows that the drag is
     // in progress for this window.
     if (new_dock_layout != initial_dock_layout_)
       new_dock_layout->StartDragging(GetTarget());
   }
-
-  // Show snapping animation when a window touches a screen edge or when
-  // it is about to get docked.
-  DockedAlignment new_docked_alignment = GetDraggedWindowAlignment();
-  if (new_docked_alignment != DOCKED_ALIGNMENT_NONE) {
-    if (!is_docked_) {
-      dock_layout_->DockDraggedWindow(GetTarget());
-      is_docked_ = true;
-    }
-    UpdateSnapPhantomWindow();
-  } else {
-    if (is_docked_) {
-      dock_layout_->UndockDraggedWindow();
-      is_docked_ = false;
-    }
-    // Clear phantom window when a window gets undocked.
-    snap_phantom_window_controller_.reset();
-  }
+  // Window could get marked as docked by the SnapSizer, so update the state.
+  is_docked_ = dock_layout_->is_dragged_window_docked();
 }
 
 void DockedWindowResizer::CompleteDrag(int event_flags) {
-  snap_phantom_window_controller_.reset();
-
   // Temporarily clear kWindowTrackedByWorkspaceKey for panels so that they
   // don't get forced into the workspace that may be shrunken because of docked
   // windows.
   bool tracked_by_workspace = GetTrackedByWorkspace(GetTarget());
   bool set_tracked_by_workspace = was_docked_;
   if (set_tracked_by_workspace)
     SetTrackedByWorkspace(GetTarget(), false);
   // The root window can change when dragging into a different screen.
   next_window_resizer_->CompleteDrag(event_flags);
   FinishedDragging();
   if (set_tracked_by_workspace)
     SetTrackedByWorkspace(GetTarget(), tracked_by_workspace);
 }
 
 void DockedWindowResizer::RevertDrag() {
-  snap_phantom_window_controller_.reset();
-
   // Temporarily clear kWindowTrackedByWorkspaceKey for panels so that they
   // don't get forced into the workspace that may be shrunken because of docked
   // windows.
   bool tracked_by_workspace = GetTrackedByWorkspace(GetTarget());
   bool set_tracked_by_workspace = was_docked_;
   if (set_tracked_by_workspace)
     SetTrackedByWorkspace(GetTarget(), false);
   next_window_resizer_->RevertDrag();
+  // Restore docked state to what it was before the drag if necessary.
+  if (was_docked_ && !is_docked_) {
+    dock_layout_->DockDraggedWindow(GetTarget());
+    is_docked_ = was_docked_;
+  }
   FinishedDragging();
   if (set_tracked_by_workspace)
     SetTrackedByWorkspace(GetTarget(), tracked_by_workspace);
 }
 
 aura::Window* DockedWindowResizer::GetTarget() {
   return next_window_resizer_->GetTarget();
 }
 
 const gfx::Point& DockedWindowResizer::GetInitialLocation() const {
@@ skipping 14 matching lines @@
   aura::Window* dock_container = Shell::GetContainer(
       details.window->GetRootWindow(),
       kShellWindowId_DockedContainer);
   dock_layout_ = static_cast<DockedWindowLayoutManager*>(
       dock_container->layout_manager());
   initial_dock_layout_ = dock_layout_;
   was_docked_ = details.window->parent() == dock_container;
   is_docked_ = was_docked_;
 }
 
-DockedAlignment DockedWindowResizer::GetDraggedWindowAlignment() {
-  aura::Window* window = GetTarget();
-  DockedWindowLayoutManager* layout_manager =
-      GetDockedLayoutManagerAtPoint(last_location_);
-  const DockedAlignment alignment = layout_manager->CalculateAlignment();
-  const gfx::Rect& bounds(window->GetBoundsInScreen());
-
-  // Check if the window is touching the edge - it may need to get docked.
-  if (alignment == DOCKED_ALIGNMENT_NONE)
-    return layout_manager->GetAlignmentOfWindow(window);
-
-  // Both bounds and pointer location are checked because some drags involve
-  // stickiness at the workspace-to-dock boundary and so the |location| may be
-  // outside of the |bounds|.
-  // It is also possible that all the docked windows are minimized or hidden
-  // in which case the dragged window needs to be exactly touching the same
-  // edge that those docked windows were aligned before they got minimized.
-  // TODO(varkha): Consider eliminating sticky behavior on that boundary when
-  // a pointer enters docked area.
-  if ((layout_manager->docked_bounds().Intersects(bounds) &&
-       layout_manager->docked_bounds().Contains(last_location_)) ||
-      alignment == layout_manager->GetAlignmentOfWindow(window)) {
-    // A window is being added to other docked windows (on the same side).
-    return alignment;
-  }
-  return DOCKED_ALIGNMENT_NONE;
-}
-
 bool DockedWindowResizer::MaybeSnapToEdge(const gfx::Rect& bounds,
                                           gfx::Point* offset) {
-  aura::Window* dock_container = Shell::GetContainer(
-      wm::GetRootWindowAt(last_location_),
-      kShellWindowId_DockedContainer);
-  DockedAlignment dock_alignment =
-      GetDockedLayoutManagerAtPoint(last_location_)->CalculateAlignment();
+  // Windows only snap magnetically when they were previously docked.
+  if (!was_docked_)
+    return false;
+  DockedAlignment dock_alignment = dock_layout_->CalculateAlignment();
   gfx::Rect dock_bounds = ScreenAsh::ConvertRectFromScreen(
-      GetTarget()->parent(), dock_container->GetBoundsInScreen());
-  // Windows only snap magnetically when they are close to the edge of the
-  // screen and when the cursor is over other docked windows.
-  // When a window being dragged is the last window that was previously
-  // docked it is still allowed to magnetically snap to either side.
-  bool can_snap = was_docked_ ||
-      (GetDraggedWindowAlignment() != DOCKED_ALIGNMENT_NONE);
-  if (!can_snap)
-    return false;
+      GetTarget()->parent(),
+      dock_layout_->dock_container()->GetBoundsInScreen());
 
   // Distance in pixels that the cursor must move past an edge for a window
   // to move beyond that edge. Same constant as in WorkspaceWindowResizer
   // is used for consistency.
   const int kStickyDistance = WorkspaceWindowResizer::kStickyDistancePixels;
 
   // Short-range magnetism when retaining docked state. Same constant as in
   // MagnetismMatcher is used for consistency.
   const int kSnapToDockDistance = MagnetismMatcher::kMagneticDistance;
 
   if (dock_alignment == DOCKED_ALIGNMENT_LEFT ||
-      (dock_alignment == DOCKED_ALIGNMENT_NONE && was_docked_)) {
+      dock_alignment == DOCKED_ALIGNMENT_NONE) {
     const int distance = bounds.x() - dock_bounds.x();
-    if (distance < (was_docked_ ? kSnapToDockDistance : 0) &&
-        distance > -kStickyDistance) {
+    if (distance < kSnapToDockDistance && distance > -kStickyDistance) {
       offset->set_x(-distance);
       return true;
     }
   }
   if (dock_alignment == DOCKED_ALIGNMENT_RIGHT ||
-      (dock_alignment == DOCKED_ALIGNMENT_NONE && was_docked_)) {
+      dock_alignment == DOCKED_ALIGNMENT_NONE) {
     const int distance = dock_bounds.right() - bounds.right();
-    if (distance < (was_docked_ ? kSnapToDockDistance : 0) &&
-        distance > -kStickyDistance) {
+    if (distance < kSnapToDockDistance && distance > -kStickyDistance) {
       offset->set_x(distance);
       return true;
     }
   }
   return false;
 }
 
 void DockedWindowResizer::StartedDragging() {
   // Tell the dock layout manager that we are dragging this window.
   // At this point we are not yet animating the window as it may not be
@@ skipping 16 matching lines @@
   }
   if (is_docked_)
     dock_layout_->DockDraggedWindow(GetTarget());
 }
 
 void DockedWindowResizer::FinishedDragging() {
   if (!did_move_or_resize_)
     return;
 
   aura::Window* window = GetTarget();
-  bool should_dock = was_docked_;
-  const bool attached_panel =
-      window->type() == aura::client::WINDOW_TYPE_PANEL &&
-      window->GetProperty(kPanelAttachedKey);
-  // If a window was previously docked then keep it docked if it is resized and
-  // still aligned at the screen edge.
-  if ((was_docked_ ||
-       ((details_.bounds_change & WindowResizer::kBoundsChange_Repositions) &&
-        !(details_.bounds_change & WindowResizer::kBoundsChange_Resizes)))) {
-    should_dock = GetDraggedWindowAlignment() != DOCKED_ALIGNMENT_NONE;
+  bool attached_panel = false;
+  if (details_.bounds_change & WindowResizer::kBoundsChange_Resizes) {
+    // No longer restore to pre-docked bounds if a window has been resized.
+    if (is_docked_)
+      ClearRestoreBounds(window);
+  } else {
+    attached_panel =
+        window->type() == aura::client::WINDOW_TYPE_PANEL &&
+        window->GetProperty(kPanelAttachedKey);
   }
 
   // Check if the window needs to be docked or returned to workspace.
   aura::Window* dock_container = Shell::GetContainer(
       window->GetRootWindow(),
       kShellWindowId_DockedContainer);
-  if (!attached_panel &&
-      should_dock != (window->parent() == dock_container)) {
-    if (should_dock) {
+  if (!attached_panel && is_docked_ != (window->parent() == dock_container)) {
+    if (is_docked_) {
       dock_container->AddChild(window);
     } else if (window->parent()->id() == kShellWindowId_DockedContainer) {
       // Reparent the window back to workspace.
       // We need to be careful to give SetDefaultParentByRootWindow location in
       // the right root window (matching the logic in DragWindowResizer) based
       // on which root window a mouse pointer is in. We want to undock into the
       // right screen near the edge of a multiscreen setup (based on where the
       // mouse is).
       gfx::Rect near_last_location(last_location_, gfx::Size());
       // Reparenting will cause Relayout and possible dock shrinking.
       window->SetDefaultParentByRootWindow(window->GetRootWindow(),
                                            near_last_location);
     }
   }
   dock_layout_->FinishDragging();
 
   // If we started the drag in one root window and moved into another root
   // but then canceled the drag we may need to inform the original layout
   // manager that the drag is finished.
   if (initial_dock_layout_ != dock_layout_)
     initial_dock_layout_->FinishDragging();
   is_docked_ = false;
-}
-
-void DockedWindowResizer::UpdateSnapPhantomWindow() {
-  if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
-    return;
-
-  if (!snap_phantom_window_controller_) {
-    snap_phantom_window_controller_.reset(
-        new PhantomWindowController(GetTarget()));
+  // Retain restore bounds when dragging inside the docked area.
+  if (was_docked_ &&
+      window->parent()->id() == kShellWindowId_DockedContainer &&
+      !(details_.bounds_change & WindowResizer::kBoundsChange_Resizes)) {
+    gfx::Rect initial_bounds = ScreenAsh::ConvertRectToScreen(
+        window->parent(), details_.initial_bounds_in_parent);
+    SetRestoreBoundsInScreen(window, details_.restore_bounds.IsEmpty() ?
+                             initial_bounds :
+                             details_.restore_bounds);
   }
-  snap_phantom_window_controller_->Show(dock_layout_->dragged_bounds());
 }
 
 }  // namespace internal
 }  // namespace ash