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 22 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;
 }
 
+bool HasSecondaryRootWindow() {
+  return Shell::GetAllRootWindows().size() > 1;
+}
+
+aura::RootWindow* GetAnotherRootWindow(aura::RootWindow* root_window) {
+  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
+  if (root_windows.size() < 2)
+    return NULL;  // an extended display is not connected.
+  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();
   if (details_.window_component == HTCAPTION)
     shell->display_controller()->set_allow_warp_during_lock(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_in_screen,
                                   int event_flags) {
-  // TODO(yusukes): Implement dragging a window from one display to another.
   aura::RootWindow* current_root = Shell::GetRootWindowAt(location_in_screen);
-  if (current_root != window()->GetRootWindow())
-    return;
+  const bool in_original_root = (window()->GetRootWindow() == current_root);
 
   gfx::Point location_in_root = location_in_screen;
   aura::client::GetScreenPositionClient(current_root)->
       ConvertPointFromScreen(current_root, &location_in_root);
 
   int grid_size = event_flags & ui::EF_CONTROL_DOWN ?
                   0 : ash::Shell::GetInstance()->GetGridSize();
-  gfx::Rect bounds =
-      CalculateBoundsForDrag(details_, location_in_root, grid_size);
+  gfx::Rect bounds =  // in |window()->GetRootWindow()|'s coordinates.
+      CalculateBoundsForDrag(details_, location_in_screen, 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_in_root, bounds, grid_size);
+
+  // Hide a phantom window for snapping if the cursor is in another root window.
+  if (in_original_root)
+    UpdatePhantomWindow(location_in_root, bounds, grid_size);
+  else
+    phantom_window_controller_.reset();
+
+  // Show a phantom window for dragging in another root window.
+  aura::RootWindow* another_root =
+      GetAnotherRootWindow(window()->GetRootWindow());
+  gfx::Rect bounds_in_screen =
+      ScreenAsh::ConvertRectToScreen(window()->GetRootWindow(), bounds);
+  UpdateDragPhantomWindow(another_root, bounds_in_screen);
+
   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) {
+  drag_phantom_window_controller_.reset();
   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;
   }
 
   int grid_size = event_flags & ui::EF_CONTROL_DOWN ?
                   0 : ash::Shell::GetInstance()->GetGridSize();
   if (grid_size <= 1)
     return;
 
   gfx::Rect bounds(GetFinalBounds(details_.window->bounds(), grid_size));
   if (bounds == details_.window->bounds())
     return;
 
   if (bounds.size() != details_.window->bounds().size()) {
     // Don't attempt to animate a size change.
     details_.window->SetBounds(bounds);
     return;
   }
   // TODO(oshima|yusukes): This is temporary solution until better drag & move

[Yusuke Sato, 2012/08/01 17:44:06]

The UX team told us that we should determine the destination display based on
the current position of the cursor rather than calling
gfx::Screen::GetDisplayMatching.

I'll implement it in the next CL.

   // is implemented. (crbug.com/136816).
   gfx::Rect dst_bounds =
       ScreenAsh::ConvertRectToScreen(details_.window->parent(), bounds);
   gfx::Display dst_display = gfx::Screen::GetDisplayMatching(dst_bounds);
   if (dst_display.id() !=
       gfx::Screen::GetDisplayNearestWindow(details_.window).id()) {
     // Don't animate when moving to another display.
     details_.window->SetBoundsInScreen(dst_bounds);
   } else {
     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() {
+  drag_phantom_window_controller_.reset();
   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());
@@ skipping 147 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::UpdateDragPhantomWindow(
+    aura::RootWindow* another_root,
+    const gfx::Rect& window_bounds_in_screen) {
+  if (!another_root) {
+    // An extended display is not available.
+    drag_phantom_window_controller_.reset();
+    return;
+  }
+
+  // It's available. Show a phantom window on the display if needed.
+  const gfx::Rect root_bounds_in_screen(another_root->GetBoundsInScreen());
+  const gfx::Rect phantom(
+      root_bounds_in_screen.Intersect(window_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::UpdatePhantomWindow(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();
@@ skipping 55 matching lines @@
   gfx::Rect area(ScreenAsh::GetDisplayBoundsInParent(details_.window));
   if (location.x() <= area.x())
     return SNAP_LEFT_EDGE;
   if (location.x() >= area.right() - 1)
     return SNAP_RIGHT_EDGE;
   return SNAP_NONE;
 }
 
 }  // namespace internal
 }  // namespace ash