Stick windows to sides of workspaces

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"
+#include "ash/shelf/shelf_widget.h"
+#include "ash/shell.h"
+#include "ash/shell_window_ids.h"
+#include "ash/wm/coordinate_conversion.h"
+#include "ash/wm/window_util.h"
+#include "base/auto_reset.h"
+#include "ui/aura/client/activation_client.h"
+#include "ui/aura/client/aura_constants.h"
+#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 {
+
+namespace {
+
+DockedWindowLayoutManager* GetDockLayoutManager(aura::Window* window,
+                                                const gfx::Point& location) {
+  gfx::Rect near_location(location, gfx::Size());
+  aura::Window* dock = Shell::GetContainer(
+      wm::GetRootWindowMatching(near_location),
+      kShellWindowId_DockContainer);
+  return static_cast<internal::DockedWindowLayoutManager*>(
+      dock->layout_manager());
+}
+
+}  // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+// DockLayoutManager public implementation:
+DockedWindowLayoutManager::DockedWindowLayoutManager(
+    aura::Window* dock_container)
+    : dock_container_(dock_container),
+      in_layout_(false),
+      dragged_window_(NULL),
+      launcher_(NULL),
+      shelf_layout_manager_(NULL),
+      shelf_hidden_(false),
+      alignment_(DOCK_ALIGNMENT_NONE) {
+  DCHECK(dock_container);
+  aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
+      AddObserver(this);
+  Shell::GetInstance()->AddShellObserver(this);
+}
+
+DockedWindowLayoutManager::~DockedWindowLayoutManager() {
+  Shutdown();
+}
+
+void DockedWindowLayoutManager::Shutdown() {
+  launcher_ = NULL;
+  if (shelf_layout_manager_)
+    shelf_layout_manager_->RemoveObserver(this);
+  aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
+      RemoveObserver(this);
+  Shell::GetInstance()->RemoveShellObserver(this);
+}

[sky, 2013/06/12 21:50:17]

Remove observer on all child windows.

[varkha, 2013/06/13 05:02:11]

Done.

+
+void DockedWindowLayoutManager::StartDragging(aura::Window* window) {
+  if (window->parent() != dock_container_)
+    return;
+  DCHECK(!dragged_window_);
+  dragged_window_ = window;
+  Relayout();
+}
+
+void DockedWindowLayoutManager::FinishDragging() {
+  dragged_window_ = NULL;
+  Relayout();
+}
+
+// static
+bool DockedWindowLayoutManager::ShouldWindowDock(aura::Window* window,
+                                                 const gfx::Point& location) {
+  DockedWindowLayoutManager* layout_manager = GetDockLayoutManager(window,
+                                                                   location);
+  const gfx::Rect& bounds(window->GetBoundsInScreen());
+  gfx::Rect dock_bounds = layout_manager->dock_container_->GetBoundsInScreen();
+  // Possible sides of the screen that a window can be touching.
+  enum DockedEdge {
+    DOCKED_EDGE_NONE,
+    DOCKED_EDGE_LEFT,
+    DOCKED_EDGE_RIGHT,
+  } dock_edge = DOCKED_EDGE_NONE;
+  if (bounds.x() == dock_bounds.x() &&
+      layout_manager->alignment_ != DOCK_ALIGNMENT_RIGHT) {
+    dock_edge = DOCKED_EDGE_LEFT;
+  } else if (bounds.right() == dock_bounds.right() &&
+             layout_manager->alignment_ != DOCK_ALIGNMENT_LEFT) {
+    dock_edge = DOCKED_EDGE_RIGHT;
+  }
+
+  // do not allow dock on the same side as launcher shelf
+  if (layout_manager->launcher_ && layout_manager->launcher_->shelf_widget()) {
+    ShelfAlignment shelf_alignment =
+        layout_manager->launcher_->shelf_widget()->GetAlignment();
+    if ((shelf_alignment == SHELF_ALIGNMENT_LEFT &&
+         dock_edge == DOCKED_EDGE_LEFT) ||
+        (shelf_alignment == SHELF_ALIGNMENT_RIGHT &&
+         dock_edge == DOCKED_EDGE_RIGHT)) {
+      dock_edge = DOCKED_EDGE_NONE;
+    }
+  }
+  return dock_edge != DOCKED_EDGE_NONE;
+}
+
+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);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DockLayoutManager, aura::LayoutManager implementation:
+void DockedWindowLayoutManager::OnWindowResized() {
+  Relayout();
+}
+
+void DockedWindowLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
+  child->AddObserver(this);
+  Relayout();
+}
+
+void DockedWindowLayoutManager::OnWillRemoveWindowFromLayout(
+    aura::Window* child) {
+}
+
+void DockedWindowLayoutManager::OnWindowRemovedFromLayout(aura::Window* child) {
+  child->RemoveObserver(this);
+  Relayout();
+}
+
+void DockedWindowLayoutManager::OnChildWindowVisibilityChanged(
+    aura::Window* child, bool visible) {
+  Relayout();
+}
+
+void DockedWindowLayoutManager::SetChildBounds(
+    aura::Window* child, const gfx::Rect& requested_bounds) {

[sky, 2013/06/12 21:50:17]

nit: when you wrap, one param per line.

[varkha, 2013/06/13 05:02:11]

Done (here and above).

+  // Whenever one of our windows is moved or resized we need to enforce layout.
+  SetChildBoundsDirect(child, requested_bounds);
+  Relayout();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DockLayoutManager, ash::ShellObserver implementation:
+
+void DockedWindowLayoutManager::OnShelfAlignmentChanged(
+    aura::RootWindow* root_window) {
+  if (dock_container_->GetRootWindow() != root_window)
+    return;
+
+  if (!launcher_ || !launcher_->shelf_widget())
+    return;
+
+  if (alignment_ == DOCK_ALIGNMENT_NONE)
+    return;
+
+  DCHECK(!dock_container_->children().empty());

[sky, 2013/06/12 21:50:17]

How come this is a DCHECK? How do you know there is at least one child window?
284 checks for empty.

[varkha, 2013/06/13 05:02:11]

My logic was that since the only assignments of anything other than NONE to
alignment_ happen after the check for children().empty() the check above is
sufficient.  It should not be possible to get into this method with all children
removed and alignment_ not set to NONE in Relayout. I have added a run-time
check as well but I want that assertion.

+  aura::Window* window = dock_container_->children()[0];
+  gfx::Rect dock_bounds = dock_container_->bounds();

[sky, 2013/06/12 21:50:17]

const gfx::Rect&

[varkha, 2013/06/13 05:02:11]

Done.

+  gfx::Rect bounds = window->bounds();
+
+  // Do not allow launcher and dock on the same side. Switch side that
+  // the dock is attached to and move all dock windows to that new side.
+  // We actually only need to move the first window and the rest will follow
+  // in Relayout
+  ShelfAlignment shelf_alignment =
+      launcher_->shelf_widget()->GetAlignment();
+  if (alignment_ == DOCK_ALIGNMENT_LEFT &&
+      shelf_alignment == SHELF_ALIGNMENT_LEFT) {
+    bounds.set_x(dock_bounds.right() - bounds.width());
+    SetChildBoundsDirect(window, bounds);
+  } else if (alignment_ == DOCK_ALIGNMENT_RIGHT &&
+             shelf_alignment == SHELF_ALIGNMENT_RIGHT) {
+    bounds.set_x(0);
+    SetChildBoundsDirect(window, bounds);
+  }
+  Relayout();
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// DockLayoutManager, WindowObserver implementation:
+
+void DockedWindowLayoutManager::OnWindowPropertyChanged(aura::Window* window,
+                                                const void* key,
+                                                intptr_t old) {
+  if (key != aura::client::kShowStateKey)
+    return;
+  // The window property will still be set, but no actual change will occur
+  // until WillChangeVisibilityState is called when the shelf is visible again
+  if (shelf_hidden_)
+    return;
+  ui::WindowShowState new_state =
+      window->GetProperty(aura::client::kShowStateKey);
+  if (new_state == ui::SHOW_STATE_MINIMIZED)
+    MinimizeWindow(window);
+  else
+    RestoreWindow(window);
+}
+
+void DockedWindowLayoutManager::OnWindowVisibilityChanged(
+    aura::Window* window, bool visible) {

[sky, 2013/06/12 21:50:17]

nit: one param per line.

[varkha, 2013/06/13 05:02:11]

Done.

+  if (visible)
+    window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DockLayoutManager, aura::client::ActivationChangeObserver implementation:
+
+void DockedWindowLayoutManager::OnWindowActivated(aura::Window* gained_active,
+                                          aura::Window* lost_active) {

[sky, 2013/06/12 21:50:17]

nit: indentation is off.

[varkha, 2013/06/13 05:02:11]

Done.

+  // Ignore if the window that is not managed by this was activated.
+  if (gained_active && gained_active->parent() == dock_container_)

[sky, 2013/06/12 21:50:17]

Seems like this should be an ancestor check. That is, if gained_active if a
descendant of dock_container_, and if so find the child of dock_container_.

[varkha, 2013/06/13 05:02:11]

Done.

+    UpdateStacking(gained_active);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DockLayoutManager, ShelfLayoutManagerObserver implementation:
+
+void DockedWindowLayoutManager::WillChangeVisibilityState(
+    ShelfVisibilityState new_state) {
+  // On entering / leaving full screen mode the shelf visibility state is
+  // changed to / from SHELF_HIDDEN. In this state, docked windows should hide
+  // to allow the full-screen application to use the full screen.
+
+  // TODO(varkha): ShelfLayoutManager::UpdateVisibilityState sets state to
+  // SHELF_AUTO_HIDE when in immersive mode. We need to distinguish this from
+  // when shelf enters auto-hide state based on mouse hover when auto-hide
+  // setting is enabled and hide all windows (immersive mode should hide dock).
+  shelf_hidden_ = new_state == ash::SHELF_HIDDEN;
+  for (size_t i = 0; i < dock_container_->children().size(); ++i) {

[sky, 2013/06/12 21:50:17]

Might this end up doing n Relayouts (n=number of children)?

[varkha, 2013/06/13 05:02:11]

More like 3xN because of upstream and downstream visibility update messages. Of
course Relayout is running an N loop so this is quite bad. We are lucky there
are not too many windows usually. This should be fixable.

+    aura::Window* window = dock_container_->children()[i];
+    if (shelf_hidden_) {
+      if (window->IsVisible())
+        MinimizeWindow(window);
+    } else {
+      if (window->GetProperty(aura::client::kShowStateKey) !=
+          ui::SHOW_STATE_MINIMIZED) {
+        RestoreWindow(window);
+      }
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DockLayoutManager private implementation:
+
+void DockedWindowLayoutManager::MinimizeWindow(aura::Window* window) {
+  window->Hide();
+  if (wm::IsActiveWindow(window))
+    wm::DeactivateWindow(window);
+  Relayout();
+}
+
+void DockedWindowLayoutManager::RestoreWindow(aura::Window* window) {
+  window->Show();
+  Relayout();
+}
+
+void DockedWindowLayoutManager::Relayout() {
+  if (in_layout_)
+    return;
+  base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
+
+  if (dock_container_->children().empty()) {
+    alignment_ = DOCK_ALIGNMENT_NONE;
+    return;
+  }
+
+  gfx::Rect dock_bounds = dock_container_->bounds();
+  aura::Window* active_window = NULL;
+  std::vector<aura::Window*> visible_windows;
+  alignment_ = DOCK_ALIGNMENT_ANY;
+  for (size_t i = 0; i < dock_container_->children().size(); ++i) {
+    aura::Window* window(dock_container_->children()[i]);
+
+    if (!window->IsVisible() ||
+        window->GetProperty(aura::client::kShowStateKey) ==
+            ui::SHOW_STATE_MINIMIZED) {
+      continue;
+    }
+
+    // If the shelf is currently hidden (full-screen mode), hide window until
+    // full-screen mode is exited.
+    if (shelf_hidden_) {
+      // The call to Hide does not set the minimize property, so the window will
+      // be restored when the shelf becomes visible again.
+      window->Hide();
+      continue;
+    }
+
+    gfx::Rect bounds = window->GetTargetBounds();
+    if (window != dragged_window_ && alignment_ == DOCK_ALIGNMENT_ANY) {
+      if (bounds.x() == 0)
+        alignment_ = DOCK_ALIGNMENT_LEFT;
+      else if (bounds.right() == dock_bounds.right())
+        alignment_ = DOCK_ALIGNMENT_RIGHT;
+    }
+
+    if (window->HasFocus() ||
+        window->Contains(
+            aura::client::GetFocusClient(window)->GetFocusedWindow())) {
+      DCHECK(!active_window);
+      active_window = window;
+    }
+
+    // all docked windows remain stuck to the screen edge
+    if (window != dragged_window_) {
+      switch (alignment_) {
+        case DOCK_ALIGNMENT_LEFT:
+          bounds.set_x(0);
+          break;
+        case DOCK_ALIGNMENT_RIGHT:
+        case DOCK_ALIGNMENT_ANY:
+          bounds.set_x(dock_bounds.right() - bounds.width());
+          break;
+        case DOCK_ALIGNMENT_NONE:
+          NOTREACHED() << "Relayout called when dock alignment is 'NONE'";
+          break;
+      }
+    }
+    SetChildBoundsDirect(window, bounds);
+  }
+
+  UpdateStacking(active_window);
+}
+
+void DockedWindowLayoutManager::UpdateStacking(aura::Window* active_window) {
+  // TODO(varkha): Implement restacking to ensure that all docked windows are at
+  // least partially visible and selectable.
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// keyboard::KeyboardControllerObserver implementation:
+
+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.
+  OnWindowResized();
+}
+
+}  // namespace internal
+}  // namespace ash