Allow the user to drag a window from one display to another

ash/wm/workspace/workspace_window_resizer.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/workspace_window_resizer.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "ash/display/display_controller.h"
@@ skipping 23 matching lines @@
 
 // Duration of the animation when snapping the window into place.
 const int kSnapDurationMS = 100;
 
 // Returns true if should snap to the edge.
 bool ShouldSnapToEdge(int distance_from_edge, int grid_size) {
   return distance_from_edge <= grid_size / 2 &&
       distance_from_edge > -grid_size * 2;
 }
 
+// Returns true if Ash has more than one root window.
+bool HasSecondaryRootWindow() {
+  return Shell::GetAllRootWindows().size() > 1;
+}
+
+// When there are two root windows, returns one of the root windows which is not
+// |root_window|. Returns NULL if only one root window exists.
+aura::RootWindow* GetAnotherRootWindow(aura::RootWindow* root_window) {
+  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
+  if (root_windows.size() < 2)
+    return NULL;
+  DCHECK_EQ(2U, root_windows.size());
+  if (root_windows[0] == root_window)
+    return root_windows[1];
+  return root_windows[0];
+}
+
 }  // namespace
 
 // static
 const int WorkspaceWindowResizer::kMinOnscreenSize = 20;
 
 // static
 const int WorkspaceWindowResizer::kMinOnscreenHeight = 32;
 
 WorkspaceWindowResizer::~WorkspaceWindowResizer() {
   Shell* shell = Shell::GetInstance();
   shell->display_controller()->set_dont_warp_mouse(false);
   shell->cursor_manager()->UnlockCursor();
 }
 
 // static
 WorkspaceWindowResizer* WorkspaceWindowResizer::Create(
     aura::Window* window,
     const gfx::Point& location_in_parent,
     int window_component,
     const std::vector<aura::Window*>& attached_windows) {
   Details details(window, location_in_parent, window_component);
   return details.is_resizable ?
       new WorkspaceWindowResizer(details, attached_windows) : NULL;
 }
 
 void WorkspaceWindowResizer::Drag(const gfx::Point& location, int event_flags) {
   std::pair<aura::RootWindow*, gfx::Point> actual_location =
       wm::GetRootWindowRelativeToWindow(window()->parent(), location);
+  aura::RootWindow* current_root = actual_location.first;
+  gfx::Point location_in_parent = actual_location.second;
+  aura::Window::ConvertPointToWindow(current_root,
+                                     window()->parent(),
+                                     &location_in_parent);
 
-  // TODO(yusukes): Implement dragging a window from one display to another.
-  aura::RootWindow* current_root = actual_location.first;
-  if (current_root != window()->GetRootWindow())
-    return;
+  // Do not use |location| below this point, use |location_in_parent| instead.
+  // When the pointer is on |window()->GetRootWindow()|, |location| and
+  // |location_in_parent| have the same value and both of them are in
+  // |window()->parent()|'s coordinates, but once the pointer enters the
+  // other root window, you will see an unexpected value on the former. See
+  // comments in wm::GetRootWindowRelativeToWindow() for details.
 
   int grid_size = event_flags & ui::EF_CONTROL_DOWN ?
                   0 : ash::Shell::GetInstance()->GetGridSize();
-  gfx::Rect bounds = CalculateBoundsForDrag(details_, location, grid_size);
+  gfx::Rect bounds =  // in |window()->parent()|'s coordinates.
+      CalculateBoundsForDrag(details_, location_in_parent, grid_size);
 
   if (wm::IsWindowNormal(details_.window))
     AdjustBoundsForMainWindow(&bounds, grid_size);
   if (bounds != details_.window->bounds()) {
     if (!did_move_or_resize_)
       RestackWindows();
     did_move_or_resize_ = true;
   }
-  UpdatePhantomWindow(location, bounds, grid_size);
+
+  const bool in_original_root = (window()->GetRootWindow() == current_root);
+  // Hide a phantom window for snapping if the cursor is in another root window.
+  if (in_original_root)
+    UpdateSnapPhantomWindow(location_in_parent, bounds, grid_size);
+  else
+    snap_phantom_window_controller_.reset();
+
+  // Show a phantom window for dragging in another root window.
+  if (HasSecondaryRootWindow())
+    UpdateDragPhantomWindow(bounds);
+  else
+    drag_phantom_window_controller_.reset();
+
   if (!attached_windows_.empty())
     LayoutAttachedWindows(bounds, grid_size);
   if (bounds != details_.window->bounds())
     details_.window->SetBounds(bounds);
   // WARNING: we may have been deleted.
 }
 
 void WorkspaceWindowResizer::CompleteDrag(int event_flags) {
-  phantom_window_controller_.reset();
+  drag_phantom_window_controller_.reset();
+  snap_phantom_window_controller_.reset();
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
   if (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE) {
     if (!GetRestoreBoundsInScreen(details_.window))
       SetRestoreBoundsInParent(details_.window, details_.initial_bounds);
     details_.window->SetBounds(snap_sizer_->target_bounds());
     return;
   }
 
@@ skipping 24 matching lines @@
     ui::ScopedLayerAnimationSettings scoped_setter(
         details_.window->layer()->GetAnimator());
     // Use a small duration since the grid is small.
     scoped_setter.SetTransitionDuration(
         base::TimeDelta::FromMilliseconds(kSnapDurationMS));
     details_.window->SetBounds(bounds);
   }
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
-  phantom_window_controller_.reset();
+  drag_phantom_window_controller_.reset();
+  snap_phantom_window_controller_.reset();
 
   if (!did_move_or_resize_)
     return;
 
   details_.window->SetBounds(details_.initial_bounds);
   if (details_.window_component == HTRIGHT) {
     int last_x = details_.initial_bounds.right();
     for (size_t i = 0; i < attached_windows_.size(); ++i) {
       gfx::Rect bounds(attached_windows_[i]->bounds());
       bounds.set_x(last_x);
@@ skipping 72 matching lines @@
           static_cast<float>(total_available));
     } else {
       compress_fraction_.push_back(0.0f);
     }
   }
 }
 
 gfx::Rect WorkspaceWindowResizer::GetFinalBounds(
     const gfx::Rect& bounds,
     int grid_size) const {
-  if (phantom_window_controller_.get() &&
-      phantom_window_controller_->IsShowing()) {
-    return phantom_window_controller_->bounds();
+  if (snap_phantom_window_controller_.get() &&
+      snap_phantom_window_controller_->IsShowing()) {
+    return snap_phantom_window_controller_->bounds();
   }
   return AdjustBoundsToGrid(bounds, grid_size);
 }
 
 void WorkspaceWindowResizer::LayoutAttachedWindows(
     const gfx::Rect& bounds,
     int grid_size) {
   gfx::Rect work_area(
       gfx::Screen::GetDisplayNearestWindow(window()).work_area());
   std::vector<int> sizes;
@@ skipping 56 matching lines @@
       if (i == attached_windows_.size())
         size = end - current;
       current += size;
       sizes->push_back(size);
     }
   }
 }
 
 void WorkspaceWindowResizer::AdjustBoundsForMainWindow(
     gfx::Rect* bounds, int grid_size) const {
-  // Always keep kMinOnscreenHeight on the bottom.
+  // Always keep kMinOnscreenHeight on the bottom except when an extended
+  // display is available and a window is being dragged.
   gfx::Rect work_area(
       ScreenAsh::GetDisplayWorkAreaBoundsInParent(details_.window));
   int max_y = AlignToGridRoundUp(work_area.bottom() - kMinOnscreenHeight,
                                  grid_size);
-  if (bounds->y() > max_y)
+  if ((details_.window_component != HTCAPTION || !HasSecondaryRootWindow()) &&
+      bounds->y() > max_y) {
     bounds->set_y(max_y);
+  }
 
-  // Don't allow dragging above the top of the display.
-  if (bounds->y() <= work_area.y())
+  // Don't allow dragging above the top of the display except when an extended
+  // display is available and a window is being dragged.
+  if ((details_.window_component != HTCAPTION || !HasSecondaryRootWindow()) &&
+      bounds->y() <= work_area.y()) {
     bounds->set_y(work_area.y());
+  }
 
   if (grid_size >= 0 && details_.window_component == HTCAPTION)
     SnapToWorkAreaEdges(work_area, bounds, grid_size);
 
   if (attached_windows_.empty())
     return;
 
   if (details_.window_component == HTRIGHT) {
     bounds->set_width(std::min(bounds->width(),
                                work_area.right() - total_min_ - bounds->x()));
@@ skipping 48 matching lines @@
     case HTRIGHT:
       return x;
     case HTBOTTOM:
       return y;
     default:
       NOTREACHED();
   }
   return 0;
 }
 
-void WorkspaceWindowResizer::UpdatePhantomWindow(const gfx::Point& location,
-                                                 const gfx::Rect& bounds,
-                                                 int grid_size) {
+void WorkspaceWindowResizer::UpdateDragPhantomWindow(const gfx::Rect& bounds) {
+  if (!did_move_or_resize_ || details_.window_component != HTCAPTION ||
+      !ShouldAllowMouseWarp()) {
+    return;
+  }
+
+  // It's available. Show a phantom window on the display if needed.
+  aura::RootWindow* another_root =
+      GetAnotherRootWindow(window()->GetRootWindow());
+  const gfx::Rect root_bounds_in_screen(another_root->GetBoundsInScreen());
+  const gfx::Rect bounds_in_screen =
+      ScreenAsh::ConvertRectToScreen(window()->parent(), bounds);
+  const gfx::Rect phantom(root_bounds_in_screen.Intersect(bounds_in_screen));
+
+  if (!phantom.IsEmpty()) {
+    if (!drag_phantom_window_controller_.get()) {
+      drag_phantom_window_controller_.reset(
+          new PhantomWindowController(window()));
+      drag_phantom_window_controller_->Show(phantom);
+    } else {
+      drag_phantom_window_controller_->SetBounds(phantom);  // no animation
+    }
+  } else {
+    drag_phantom_window_controller_.reset();
+  }
+}
+
+void WorkspaceWindowResizer::UpdateSnapPhantomWindow(const gfx::Point& location,
+                                                     const gfx::Rect& bounds,
+                                                     int grid_size) {
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
   SnapType last_type = snap_type_;
   snap_type_ = GetSnapType(location);
   if (snap_type_ == SNAP_NONE || snap_type_ != last_type) {
-    phantom_window_controller_.reset();
+    snap_phantom_window_controller_.reset();
     snap_sizer_.reset();
     if (snap_type_ == SNAP_NONE)
       return;
   }
   if (!snap_sizer_.get()) {
     SnapSizer::Edge edge = (snap_type_ == SNAP_LEFT_EDGE) ?
         SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
     snap_sizer_.reset(
         new SnapSizer(details_.window, location, edge, grid_size));
   } else {
     snap_sizer_->Update(location);
   }
-  if (!phantom_window_controller_.get()) {
-    phantom_window_controller_.reset(
+  if (!snap_phantom_window_controller_.get()) {
+    snap_phantom_window_controller_.reset(
         new PhantomWindowController(details_.window));
   }
-  phantom_window_controller_->Show(ScreenAsh::ConvertRectToScreen(
+  snap_phantom_window_controller_->Show(ScreenAsh::ConvertRectToScreen(
       details_.window->parent(), snap_sizer_->target_bounds()));
 }
 
 void WorkspaceWindowResizer::RestackWindows() {
   if (attached_windows_.empty())
     return;
   // Build a map from index in children to window, returning if there is a
   // window with a different parent.
   typedef std::map<size_t, aura::Window*> IndexToWindowMap;
   IndexToWindowMap map;
@@ skipping 34 matching lines @@
 }
 
 bool WorkspaceWindowResizer::ShouldAllowMouseWarp() const {
   return (details_.window_component == HTCAPTION) &&
       (window()->GetProperty(aura::client::kModalKey) == ui::MODAL_TYPE_NONE) &&
       (window()->type() == aura::client::WINDOW_TYPE_NORMAL);
 }
 
 }  // namespace internal
 }  // namespace ash