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) {

[stevenjb, 2013/06/03 18:19:03]

align

[varkha, 2013/06/03 21:03:17]

Done.

     window_resizer = PanelWindowResizer::Create(
         window_resizer, window, point_in_parent, window_component);
   }
   return make_scoped_ptr<WindowResizer>(window_resizer);
 }
 
 namespace internal {
 
 namespace {
 
@@ skipping 134 matching lines @@
     case HTRIGHT:
       return MAGNETISM_EDGE_RIGHT;
     case HTLEFT:
       return MAGNETISM_EDGE_LEFT;
     default:
       break;
   }
   return 0;
 }
 
+internal::DockLayoutManager* GetDockLayoutManager(aura::Window* window) {
+  aura::Window* dock_container = Shell::GetContainer(
+      window->GetRootWindow(), internal::kShellWindowId_DockContainer);
+  return static_cast<internal::DockLayoutManager*>(
+      dock_container->layout_manager());
+}
+
 }  // namespace
 
 // static
 const int WorkspaceWindowResizer::kMinOnscreenSize = 20;
 
 // static
 const int WorkspaceWindowResizer::kMinOnscreenHeight = 32;
 
 // static
 const int WorkspaceWindowResizer::kScreenEdgeInset = 8;
@@ skipping 63 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_);
 }
 
 // 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_ = FindDockEdge(*bounds);
     }
   } 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 53 matching lines @@
   if (edges & MAGNETISM_EDGE_BOTTOM &&
       ShouldStickToEdge(bottom_edge - bounds->bottom(), sticky_size)) {
     bounds->set_height(bottom_edge - bounds->y());
   }
   if (edges & MAGNETISM_EDGE_RIGHT &&
       ShouldStickToEdge(right_edge - bounds->right(), sticky_size)) {
     bounds->set_width(right_edge - bounds->x());
   }
 }
 
+ash::DockEdge WorkspaceWindowResizer::FindDockEdge(
+    const gfx::Rect& bounds) const {

[stevenjb, 2013/06/03 18:19:03]

This seems like it should be either a static in DockLayoutManager, or a function
in window_util.cc, instead of here. 

[varkha, 2013/06/03 21:03:17]

Done (as a static in DockLayoutManager). Also moved GetDockLayoutManager there
to improve encapsulation).

+  DockEdge dock_edge = DOCK_EDGE_NONE;
+  DockLayoutManager* dock_layout = GetDockLayoutManager(window());
+  if (dock_layout)
+    dock_edge = dock_layout->FindDockEdge(bounds);
+
+  return dock_edge;
+}
+
 int WorkspaceWindowResizer::PrimaryAxisSize(const gfx::Size& size) const {
   return PrimaryAxisCoordinate(size.width(), size.height());
 }
 
 int WorkspaceWindowResizer::PrimaryAxisCoordinate(int x, int y) const {
   switch (details_.window_component) {
     case HTRIGHT:
       return x;
     case HTBOTTOM:
       return y;
@@ skipping 75 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