Windows docking should get triggered by pressing against the screen edge

ash/wm/dock/docked_window_layout_manager.cc

 // Copyright (c) 2013 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/dock/docked_window_layout_manager.h"
 
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_types.h"
@@ skipping 10 matching lines @@
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/rect.h"
 
 namespace ash {
 namespace internal {
 
 // Minimum, maximum width of the dock area and a width of the gap
 const int DockedWindowLayoutManager::kMinDockWidth = 200;
-const int DockedWindowLayoutManager::kMaxDockWidth = 450;
+const int DockedWindowLayoutManager::kMaxDockWidth = 360;
 const int DockedWindowLayoutManager::kMinDockGap = 2;
+const int kMaxVerticalPercentage = 90;

[flackr, 2013/09/06 02:18:43]

Just to simplify this CL, adding the max vertical percentage seems like a
tangential change that could be done as a separate CL.

[varkha, 2013/09/09 15:38:42]

Done.

 const int kWindowIdealSpacing = 4;
 
 namespace {
 
 const SkColor kDockBackgroundColor = SkColorSetARGB(0xff, 0x10, 0x10, 0x10);
 const float kDockBackgroundOpacity = 0.5f;
 
 class DockedBackgroundWidget : public views::Widget {
  public:
   explicit DockedBackgroundWidget(aura::Window* container) {
@@ skipping 143 matching lines @@
 void DockedWindowLayoutManager::RemoveObserver(
     DockedWindowLayoutManagerObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void DockedWindowLayoutManager::StartDragging(aura::Window* window) {
   DCHECK(!dragged_window_);
   dragged_window_ = window;
   // Start observing a window unless it is docked container's child in which
   // case it is already observed.
+  LOG(INFO) << "start dragging " << window;
   if (dragged_window_->parent() != dock_container_)
     dragged_window_->AddObserver(this);
   is_dragged_from_dock_ = window->parent() == dock_container_;
   DCHECK(!is_dragged_window_docked_);
 }
 
 void DockedWindowLayoutManager::DockDraggedWindow(aura::Window* window) {
   OnWindowDocked(window);
   Relayout();
 }
 
 void DockedWindowLayoutManager::UndockDraggedWindow() {
   OnWindowUndocked();
   Relayout();
+  UpdateDockBounds();
   is_dragged_from_dock_ = false;
 }
 
 void DockedWindowLayoutManager::FinishDragging() {
   DCHECK(dragged_window_);
   if (is_dragged_window_docked_)
     OnWindowUndocked();
   DCHECK (!is_dragged_window_docked_);
+  LOG(INFO) << "finish dragging " << dragged_window_;
   // Stop observing a window unless it is docked container's child in which
   // case it needs to keep being observed after the drag completes.
-  if (dragged_window_->parent() != dock_container_)
+  if (dragged_window_->parent() != dock_container_) {
     dragged_window_->RemoveObserver(this);
+    if (last_active_window_ == dragged_window_)
+      last_active_window_ = NULL;
+  }
   dragged_window_ = NULL;
+  dragged_bounds_ = gfx::Rect();
   Relayout();
   UpdateDockBounds();
 }
 
 void DockedWindowLayoutManager::SetLauncher(ash::Launcher* launcher) {
   DCHECK(!launcher_);
   DCHECK(!shelf_layout_manager_);
   launcher_ = launcher;
   if (launcher_->shelf_widget()) {
     shelf_layout_manager_ = ash::internal::ShelfLayoutManager::ForLauncher(
         launcher_->shelf_widget()->GetNativeWindow());
     WillChangeVisibilityState(shelf_layout_manager_->visibility_state());
     shelf_layout_manager_->AddObserver(this);
   }
 }
 
 DockedAlignment DockedWindowLayoutManager::GetAlignmentOfWindow(
     const aura::Window* window) const {
   const gfx::Rect& bounds(window->GetBoundsInScreen());
-  const gfx::Rect docked_bounds = dock_container_->GetBoundsInScreen();
 
-  // Do not allow docking if a window is vertically maximized (as is the case
-  // when it is snapped).
-  const gfx::Rect work_area =
-      Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
-  if (bounds.y() == work_area.y() && bounds.height() == work_area.height())
-    return DOCKED_ALIGNMENT_NONE;
+  // Test overlap with an existing docked area first.
+  if (docked_bounds_.Intersects(bounds) &&
+      alignment_ != DOCKED_ALIGNMENT_NONE) {
+    // A window is being added to other docked windows (on the same side).
+    return alignment_;
+  }
 
-  // Do not allow docking on the same side as launcher shelf.
-  ShelfAlignment shelf_alignment = SHELF_ALIGNMENT_BOTTOM;
-  if (launcher_)
-    shelf_alignment = launcher_->alignment();
-
-  if (bounds.x() == docked_bounds.x() &&
-      shelf_alignment != SHELF_ALIGNMENT_LEFT) {
+  const gfx::Rect container_bounds = dock_container_->GetBoundsInScreen();
+  if (bounds.x() <= container_bounds.x() &&
+      bounds.right() > container_bounds.x()) {
     return DOCKED_ALIGNMENT_LEFT;
-  }
-  if (bounds.right() == docked_bounds.right() &&
-      shelf_alignment != SHELF_ALIGNMENT_RIGHT) {
+  } else if (bounds.x() < container_bounds.right() &&
+             bounds.right() >= container_bounds.right()) {
     return DOCKED_ALIGNMENT_RIGHT;
   }
   return DOCKED_ALIGNMENT_NONE;
 }
 
 DockedAlignment DockedWindowLayoutManager::CalculateAlignment() const {
   // Find a child that is not being dragged and is not a popup.
   // If such exists the current alignment is returned - even if some of the
   // children are hidden or minimized (so they can be restored without losing
   // the docked state).
@@ skipping 14 matching lines @@
 void DockedWindowLayoutManager::OnWindowResized() {
   Relayout();
   // When screen resizes update the insets even when dock width or alignment
   // does not change.
   UpdateDockBounds();
 }
 
 void DockedWindowLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
   if (child->type() == aura::client::WINDOW_TYPE_POPUP)
     return;
+  LOG(INFO) << "added " << child;
   // Dragged windows are already observed by StartDragging and do not change
   // docked alignment during the drag.
   if (child == dragged_window_)
     return;
   // If this is the first window getting docked - update alignment.
   if (alignment_ == DOCKED_ALIGNMENT_NONE) {
     alignment_ = GetAlignmentOfWindow(child);
     DCHECK(alignment_ != DOCKED_ALIGNMENT_NONE);
   }
   child->AddObserver(this);
   Relayout();
   UpdateDockBounds();
 }
 
 void DockedWindowLayoutManager::OnWindowRemovedFromLayout(aura::Window* child) {
   if (child->type() == aura::client::WINDOW_TYPE_POPUP)
     return;
+  LOG(INFO) << "removed " << child;
   // Dragged windows are stopped being observed by FinishDragging and do not
   // change alignment during the drag. They also cannot be set to be the
   // |last_active_window_|.
   if (child == dragged_window_)
     return;
   // If this is the last window, set alignment and maximize the workspace.
   if (!IsAnyWindowDocked()) {
     alignment_ = DOCKED_ALIGNMENT_NONE;
     docked_width_ = 0;
   }
@@ skipping 70 matching lines @@
 void DockedWindowLayoutManager::OnWindowBoundsChanged(
     aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   // Only relayout if the dragged window would get docked.
   if (window == dragged_window_ && is_dragged_window_docked_)
     Relayout();
 }
 
 void DockedWindowLayoutManager::OnWindowDestroying(aura::Window* window) {
+  LOG(INFO) << "destroying " << window;
   if (dragged_window_ == window) {
     FinishDragging();
     DCHECK(!dragged_window_);
     DCHECK (!is_dragged_window_docked_);
   }
   if (window == last_active_window_)
     last_active_window_ = NULL;
 }
 
 
@@ skipping 55 matching lines @@
   window->Hide();
   if (wm::IsActiveWindow(window))
     wm::DeactivateWindow(window);
 }
 
 void DockedWindowLayoutManager::RestoreWindow(aura::Window* window) {
   window->Show();
 }
 
 void DockedWindowLayoutManager::OnWindowDocked(aura::Window* window) {
+  LOG(INFO) << "docked";
   DCHECK(!is_dragged_window_docked_);
   is_dragged_window_docked_ = true;
 
   // If there are no other docked windows update alignment.
   if (!IsAnyWindowDocked())
     alignment_ = DOCKED_ALIGNMENT_NONE;
 }
 
 void DockedWindowLayoutManager::OnWindowUndocked() {
+  LOG(INFO) << "undocked";
   // If this is the first window getting docked - update alignment.
   if (!IsAnyWindowDocked())
     alignment_ = GetAlignmentOfWindow(dragged_window_);
 
   DCHECK (is_dragged_window_docked_);
   is_dragged_window_docked_ = false;
 }
 
 bool DockedWindowLayoutManager::IsAnyWindowDocked() {
   return CalculateAlignment() != DOCKED_ALIGNMENT_NONE;
@@ skipping 40 matching lines @@
     active_window = dragged_window_;
   }
 
   // Calculate free space or overlap.
   gfx::Display display = Shell::GetScreen()->GetDisplayNearestWindow(
       dock_container_);
   const gfx::Rect work_area = display.work_area();
   int available_room = work_area.height();
   for (aura::Window::Windows::const_iterator iter = visible_windows.begin();
       iter != visible_windows.end(); ++iter) {
-    available_room -= (*iter)->bounds().height();
+    int height = (*iter)->bounds().height();
+    if (height == work_area.height())

[flackr, 2013/09/06 02:18:43]

This allows the height to be greater than kMaxVerticalPercentage as long as it's
less than work_area.height(). Setting height to min of the percentage and height
would be cleaner.

[varkha, 2013/09/09 15:38:42]

This was intentional to target vertically maximized windows rather than just
tall windows. I wanted to preserve vertical size when resized by a user but make
docking more friendly for the tiled windows. I am taking this part out as part
of vertical size split / minimizing.

+      height = work_area.height() * kMaxVerticalPercentage / 100;
+    available_room -= height;
   }
   const int num_windows = visible_windows.size();
   const float delta = (float)available_room /
       ((available_room > 0 || num_windows <= 1) ?
           num_windows + 1 : num_windows - 1);
   float y_pos = work_area.y() + ((available_room > 0) ? delta : 0);
 
   // Sort windows by their center positions and fan out overlapping
   // windows.
   std::sort(visible_windows.begin(),
             visible_windows.end(),
             CompareWindowPos(is_dragged_from_dock_ ? dragged_window_ : NULL,
                              delta));
   is_dragged_from_dock_ = true;
   for (aura::Window::Windows::const_iterator iter = visible_windows.begin();
       iter != visible_windows.end(); ++iter) {
     aura::Window* window = *iter;
     gfx::Rect bounds = window->GetBoundsInScreen();
 
+    DockedAlignment alignment = alignment_;
+    if (alignment == DOCKED_ALIGNMENT_NONE && window == dragged_window_) {
+      alignment = GetAlignmentOfWindow(window);
+      if (alignment == DOCKED_ALIGNMENT_NONE)
+        bounds.set_size(gfx::Size());
+    }
+
+    // Restrict width.
+    if (bounds.width() > kMaxDockWidth)
+      bounds.set_width(kMaxDockWidth);
+    // Shrink height of vertically maximized windows to kMaxVerticalPercentage.
+    if (bounds.height() == work_area.height())
+      bounds.set_height(work_area.height() * kMaxVerticalPercentage / 100);
+
     // Fan out windows evenly distributing the overlap or remaining free space.
     bounds.set_y(std::max(work_area.y(),
                           std::min(work_area.bottom() - bounds.height(),
                                    static_cast<int>(y_pos + 0.5))));
     y_pos += bounds.height() + delta;
 
     // All docked windows other than the one currently dragged remain stuck
     // to the screen edge.
-    switch (alignment_) {
+    switch (alignment) {
       case DOCKED_ALIGNMENT_LEFT:
         bounds.set_x(dock_bounds.x());
         break;
       case DOCKED_ALIGNMENT_RIGHT:
         bounds.set_x(dock_bounds.right() - bounds.width());
         break;
       case DOCKED_ALIGNMENT_NONE:
         break;
     }
     if (window == dragged_window_) {
       dragged_bounds_ = bounds;
       continue;
     }
+    // If the following asserts it is probably because not all the children
+    // have been removed when dock was closed.
     DCHECK_NE(alignment_, DOCKED_ALIGNMENT_NONE);
     // Keep the dock at least kMinDockWidth when all windows in it overhang.
     docked_width_ = std::min(kMaxDockWidth,
                              std::max(docked_width_,
                                       bounds.width() > kMaxDockWidth ?
                                           kMinDockWidth : bounds.width()));
     bounds = ScreenAsh::ConvertRectFromScreen(dock_container_, bounds);
     SetChildBoundsDirect(window, bounds);
   }
   UpdateStacking(active_window);
@@ skipping 87 matching lines @@
 
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   UpdateDockBounds();
 }
 
 }  // namespace internal
 }  // namespace ash