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());

[sky, 2012/08/07 03:28:05]

Is there a limitation that we only ever support at most 2 displays?

[Yusuke Sato, 2012/08/07 16:38:30]

According to oshima, yes. Actually DisplayController only supports 2 root
windows at most.

[oshima, 2012/08/08 01:40:31]

We only support to up 2 displays for now (in terms of hardware and options UI).
It's preferable if we can avoid such limitatino in aura/ash code if possible,
but not required.

+  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_original_root = actual_location.second;
+  aura::Window::ConvertPointToWindow(current_root,
+                                     window()->GetRootWindow(),
+                                     &location_in_original_root);
 
-  // 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_original_root|
+  // instead. When the pointer is on |window()->GetRootWindow()|, |location| and
+  // |location_in_original_root| have the same value and both of them are in
+  // |window()->GetRootWindow()|'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()->GetRootWindow()|'s coordinates.
+      CalculateBoundsForDrag(details_, location_in_original_root, grid_size);

[sky, 2012/08/07 03:28:05]

I'm confused, CalculateBoundsForDrag should take coordinates in the parent
coordinate system, not the root. Did something change? So I'm clear, I want
everything and by everything I mean all the methods in this class and other
WindowResizers to be in the same coordinate system. If that can't be in the
parents coordinates for some reason (say because then we have no way to detect
dragging to another root), then they should *all* to be converted to screen
coordinates. I prefer the former as it'll be a smaller change, but only if
possible.

[Yusuke Sato, 2012/08/07 16:38:30]

The variable name and the comment were wrong. Sorry about that. I've replaced
_in_original_root with _in_parent. I think all the new code I added now use the
same coordinates (parent's).

On 2012/08/07 03:28:05, sky wrote:

 
   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)
+    UpdatePhantomWindow(location_in_original_root, bounds, grid_size);
+  else
+    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) {
+  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;
   }
@@ skipping 25 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() {
+  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 152 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.

[sky, 2012/08/07 03:28:05]

Doesn't that only make sense if the extended display is below the current? Do we
even support that?

[Yusuke Sato, 2012/08/07 16:38:30]

Yes.
Yes, it's supported. The secondary display can be placed at the
left/right/top/bottom of the primary one.

   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(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()->GetRootWindow(), 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::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 61 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