Stick windows to sides of workspaces

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 <utility>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/default_window_resizer.h"
+#include "ash/wm/dock/dock_layout_manager.h"
+#include "ash/wm/dock/dock_window_resizer.h"
 #include "ash/wm/drag_window_resizer.h"
 #include "ash/wm/panels/panel_window_resizer.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/snap_sizer.h"
 #include "base/command_line.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/window_types.h"
@@ skipping 29 matching lines @@
         window_component,
         std::vector<aura::Window*>());
   } else if (wm::IsWindowNormal(window)) {
     window_resizer = DefaultWindowResizer::Create(
         window, point_in_parent, window_component);
   }
   if (window_resizer) {
     window_resizer = internal::DragWindowResizer::Create(
         window_resizer, window, point_in_parent, window_component);
   }
-  if (window_resizer && window->type() == aura::client::WINDOW_TYPE_PANEL) {
+  if (window_resizer && GetDockEdge(window) != DOCK_EDGE_NONE) {
+    window_resizer = DockWindowResizer::Create(
+        window_resizer, window, point_in_parent, window_component);
+  } else if (window_resizer &&
+             window->type() == aura::client::WINDOW_TYPE_PANEL) {

[flackr, 2013/06/04 19:58:10]

Should this really be an else if? Wouldn't this prevent dragging from the dock
to the launcher?

[varkha, 2013/06/07 19:01:28]

It would (for the panels). This is a symmetrical situation to what is described
in http://crbug.com/247085 and I have left a TODO about it. It looks like it
does not introduce anything unexpected so I have made this change.

     window_resizer = PanelWindowResizer::Create(
         window_resizer, window, point_in_parent, window_component);
   }
   return make_scoped_ptr<WindowResizer>(window_resizer);
 }
 
 namespace internal {
 
 namespace {
 
@@ skipping 217 matching lines @@
 
  private:
   int size_;
   int min_;
   int max_;
 };
 
 WorkspaceWindowResizer::~WorkspaceWindowResizer() {
   Shell* shell = Shell::GetInstance();
   shell->cursor_manager()->UnlockCursor();
+
+  if (GetDockEdge(window()) != dock_edge_ &&
+      CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAshEnableDockedWindows))
+    if (window()->type() != aura::client::WINDOW_TYPE_PANEL ||
+        !window()->GetProperty(internal::kPanelAttachedKey))
+      SetDockEdge(window(), dock_edge_);

[flackr, 2013/06/04 19:58:10]

This should probably be in CompleteDrag. Also we should handle undocking windows
here too, in the same place as docking them.

[varkha, 2013/06/07 19:01:28]

Done (the first part). The second part may get addressed if we refactor chained
resizers, it is difficult to do it now since the WorkspaceWindowResizer is not
used when moving docked windows (or attached panels for that matter).

 }
 
 // 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 ?
@@ skipping 45 matching lines @@
   if (bounds != window()->bounds())
     window()->SetBounds(bounds);
 }
 
 void WorkspaceWindowResizer::CompleteDrag(int event_flags) {
   wm::SetUserHasChangedWindowPositionOrSize(details_.window, true);
   snap_phantom_window_controller_.reset();
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
-  // When the window is not in the normal show state, we do not snap thw window.
+  // When the window is not in the normal show state, we do not snap the window.
   // This happens when the user minimizes or maximizes the window by keyboard
   // shortcut while dragging it. If the window is the result of dragging a tab
   // out of a maximized window, it's already in the normal show state when this
   // is called, so it does not matter.
   if (wm::IsWindowNormal(window()) &&
       (window()->type() != aura::client::WINDOW_TYPE_PANEL ||
        !window()->GetProperty(kPanelAttachedKey)) &&
       (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE)) {
     if (!GetRestoreBoundsInScreen(window())) {
       gfx::Rect initial_bounds = ScreenAsh::ConvertRectToScreen(
@@ skipping 44 matching lines @@
 
 WorkspaceWindowResizer::WorkspaceWindowResizer(
     const Details& details,
     const std::vector<aura::Window*>& attached_windows)
     : details_(details),
       attached_windows_(attached_windows),
       did_move_or_resize_(false),
       total_min_(0),
       total_initial_size_(0),
       snap_type_(SNAP_NONE),
+      dock_edge_(DOCK_EDGE_NONE),
       num_mouse_moves_since_bounds_change_(0),
       magnetism_window_(NULL) {
   DCHECK(details_.is_resizable);
 
   Shell* shell = Shell::GetInstance();
   shell->cursor_manager()->LockCursor();
 
   // Only support attaching to the right/bottom.
   DCHECK(attached_windows_.empty() ||
          (details.window_component == HTRIGHT ||
@@ skipping 230 matching lines @@
       bounds->set_y(max_y);
     } else if (bounds->y() <= work_area.y()) {
       // Don't allow dragging above the top of the display until the mouse
       // cursor reaches the work area above if any.
       bounds->set_y(work_area.y());
     }
 
     if (sticky_size > 0) {
       StickToWorkAreaOnMove(work_area, sticky_size, bounds);
       MagneticallySnapToOtherWindows(bounds);
+      dock_edge_ = DockLayoutManager::FindDockEdge(window());

[flackr, 2013/06/04 20:58:03]

As discussed, you shouldn't need to track this since you can check from the drag
Details object whether it was a resize or not. See
https://code.google.com/p/chromium/codesearch#chromium/src/ash/wm/panels/pane...
for an example.

[varkha, 2013/06/07 19:01:28]

Done.

     }
   } else if (sticky_size > 0) {
     MagneticallySnapResizeToOtherWindows(bounds);
     if (!magnetism_window_ && sticky_size > 0)
       StickToWorkAreaOnResize(work_area, sticky_size, bounds);
   }
 
   if (attached_windows_.empty())
     return;
 
@@ skipping 148 matching lines @@
   gfx::Rect area(ScreenAsh::GetDisplayBoundsInParent(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