Stick windows to sides of workspaces

ash/wm/dock/docked_window_layout_manager.h

Index: ash/wm/dock/docked_window_layout_manager.h
diff --git a/ash/wm/dock/docked_window_layout_manager.h b/ash/wm/dock/docked_window_layout_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..812d3c603bde9231029622ffc870a9f1b7d1661c
--- /dev/null
+++ b/ash/wm/dock/docked_window_layout_manager.h
@@ -0,0 +1,148 @@
+// 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.
+
+#ifndef ASH_WM_DOCK_DOCKED_WINDOW_LAYOUT_MANAGER_H_
+#define ASH_WM_DOCK_DOCKED_WINDOW_LAYOUT_MANAGER_H_
+
+#include "ash/ash_export.h"
+#include "ash/shelf/shelf_layout_manager_observer.h"
+#include "ash/shell_observer.h"
+#include "ash/wm/dock/dock_types.h"
+#include "ash/wm/property_util.h"
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "ui/aura/client/activation_change_observer.h"
+#include "ui/aura/layout_manager.h"
+#include "ui/aura/window_observer.h"
+#include "ui/keyboard/keyboard_controller_observer.h"
+
+namespace aura {
+class Window;
+}
+
+namespace gfx {
+class Point;
+class Rect;
+}
+
+namespace ash {
+class Launcher;
+
+namespace internal {
+class ShelfLayoutManager;
+
+// DockedWindowLayoutManager is responsible for organizing windows when they are
+// docked to the side of a screen. It is associated with a specific container
+// window (i.e. kShellWindowId_DockContainer) and controls the layout of any
+// windows added to that container.
+//
+// The constructor takes a |dock_container| argument which is expected to set
+// its layout manager to this instance, e.g.:
+// dock_container->SetLayoutManager(
+//     new DockedWindowLayoutManager(dock_container));
+
+class ASH_EXPORT DockedWindowLayoutManager
+    : public aura::LayoutManager,

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

BaseLayoutManager provides default implementation for some things, are you sure
you don't want to subclass it? If not, you should look through the
implementation and make sure there isn't anything you've missed. I took a quick
look and at least your implementation of OnChildWindowVisibilityChanged doesn't
do a lot of what BaseLayoutManager does. You need to take a closer look to make
sure you don't miss things.

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

Looking at the BaseLayoutManager it deals with many scenarios that are not
necessary or correct such as ensuring that all windows fit in work area or
dealing with insets. Of course we can override all or some of that, but from
what I could see the similarity is very small. We will likely not need
side-maximized windows, in fact the eventual layout will probably be forced
similar to attached panels. I will be watching this as the behavior develops
with actual layout and size manipulation.

+      public ash::ShellObserver,
+      public aura::WindowObserver,
+      public aura::client::ActivationChangeObserver,
+      public keyboard::KeyboardControllerObserver,
+      public ash::ShelfLayoutManagerObserver {
+ public:
+  explicit DockedWindowLayoutManager(aura::Window* dock_container);
+  virtual ~DockedWindowLayoutManager();
+
+  // Call Shutdown() before deleting children of dock_container.

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

This comment is misleading. AFAICT Shutdown() isn't needed before children are
removed, it's needed to make sure observers are removed before objects are
destroyed. Are you sure this is even needed? Can you instead delete objects in
the right order? If not, update comment.

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

I checked the logic and it seems that normal terminating sequence should be fine
without a need for this. I will run some trybot tests just to be sure.

+  void Shutdown();
+
+  // Called by a DockedWindowResizer to update which window is being dragged.
+  void StartDragging(aura::Window* window);
+  void FinishDragging();
+
+  // Returns true if a window is touching the side of the screen
+  // unless when other windows are already docked on the other side or
+  // unless launcher (shelf) is aligned on the same side.
+  static bool ShouldWindowDock(aura::Window* window,
+                               const gfx::Point& location);
+
+  ash::Launcher* launcher() { return launcher_; }
+  void SetLauncher(ash::Launcher* launcher);
+
+  // Used to snap docked windows to the side of screen during drag.
+  DockAlignment alignment() const { return alignment_; }
+
+  // Currently dragged window should be able to dock on another screen
+  aura::Window* dragged_window() const { return dragged_window_;}
+
+  // aura::LayoutManager:
+  virtual void OnWindowResized() OVERRIDE;
+  virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE;
+  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE;
+  virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE;
+  virtual void OnChildWindowVisibilityChanged(aura::Window* child,
+                                              bool visibile) OVERRIDE;
+  virtual void SetChildBounds(aura::Window* child,
+                              const gfx::Rect& requested_bounds) OVERRIDE;
+
+  // ash::ShellObserver:
+  virtual void OnShelfAlignmentChanged(aura::RootWindow* root_window) OVERRIDE;
+
+  // aura::WindowObserver:
+  virtual void OnWindowPropertyChanged(aura::Window* window,
+                                       const void* key,
+                                       intptr_t old) OVERRIDE;
+  virtual void OnWindowVisibilityChanged(aura::Window* window,
+                                         bool visible) OVERRIDE;
+
+  // aura::client::ActivationChangeObserver:
+  virtual void OnWindowActivated(aura::Window* gained_active,
+                                 aura::Window* lost_active) OVERRIDE;
+
+  // ShelfLayoutManagerObserver:
+  virtual void WillChangeVisibilityState(
+      ShelfVisibilityState new_state) OVERRIDE;
+
+ private:
+  friend class DockedWindowLayoutManagerTest;
+  friend class DockedWindowResizerTest;
+
+  // Minimize / restore window and relayout.
+  void MinimizeWindow(aura::Window* window);
+  void RestoreWindow(aura::Window* window);
+
+  // Called whenever the window layout might change.
+  void Relayout();
+
+  // Called whenever the window stacking order needs to be updated (e.g. focus
+  // changes or a window is moved).
+  void UpdateStacking(aura::Window* active_window);
+
+  // keyboard::KeyboardControllerObserver:
+  virtual void OnKeyboardBoundsChanging(
+      const gfx::Rect& keyboard_bounds) OVERRIDE;
+
+  // Parent window associated with this layout manager.
+  aura::Window* dock_container_;
+  // Protect against recursive calls to Relayout().
+  bool in_layout_;
+  // The docked window being dragged.
+  aura::Window* dragged_window_;
+  // The launcher we are observing for launcher icon changes.
+  Launcher* launcher_;
+  // The shelf layout manager being observed for visibility changes.
+  ShelfLayoutManager* shelf_layout_manager_;
+  // Tracks the visibility of the shelf. Defaults to false when there is no
+  // shelf.
+  bool shelf_hidden_;
+
+  // Side of the screen that the dock is positioned at.
+  DockAlignment alignment_;
+
+  DISALLOW_COPY_AND_ASSIGN(DockedWindowLayoutManager);
+};
+
+}  // namespace internal
+}  // namespace ash
+
+#endif  // ASH_WM_DOCK_DOCKED_WINDOW_LAYOUT_MANAGER_H_