Stick windows to sides of workspaces

ash/wm/dock/dock_layout_manager.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.

[sky, 2013/06/11 00:03:13]

Dates are wrong in all new files.

[varkha, 2013/06/11 02:34:24]

Done.

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef ASH_WM_PANELS_PANEL_LAYOUT_MANAGER_H_
-#define ASH_WM_PANELS_PANEL_LAYOUT_MANAGER_H_
-
-#include <list>
+#ifndef ASH_WM_DOCK_DOCK_LAYOUT_MANAGER_H_
+#define ASH_WM_DOCK_DOCK_LAYOUT_MANAGER_H_
 
 #include "ash/ash_export.h"
-#include "ash/launcher/launcher_icon_observer.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
 #include "ash/shell_observer.h"
+#include "ash/wm/property_util.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.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.h"
 #include "ui/keyboard/keyboard_controller_observer.h"
 
 namespace aura {
 class Window;
 }
 
 namespace gfx {
 class Rect;
 }
 
-namespace views {
-class Widget;
-}
-
 namespace ash {
 class Launcher;
 
 namespace internal {
-class PanelCalloutWidget;
 class ShelfLayoutManager;
 
-// PanelLayoutManager is responsible for organizing panels within the
-// workspace. It is associated with a specific container window (i.e.
-// kShellWindowId_PanelContainer) and controls the layout of any windows
+// DockLayoutManager is responsible for organizing windows within the

[sky, 2013/06/11 00:03:13]

IMO dock is an overloaded term and the use of it here is confusing. There are a
couple of places in the document you pointed me at that use 'dock' when they
mean launcher. This was my initial thinking when looking at these files.

WorkspaceWindowResizer uses 'stick to work area' for clarity. Maybe
WorkAreaAlignedLayoutManager. 'Docked' would be better than 'dock', eg
DockedWindowLayoutManager.

[varkha, 2013/06/11 02:34:24]

I like DockedWindowLayoutManager better. I checked "dock" in code and it did not
seem to be overly used. We usually call the launcher "launcher" or "shelf". I
think "stick to work area" as a term leaves more to interpretation.

[sky, 2013/06/11 16:15:26]

I think many people use the term 'dock' to mean 'launcher'. The document you
pointed me at for the wm spec uses 'dock' in a couple of places to mean
'launcher'. This why I think using 'dock' is too ambiguous here. 'docked' is a
better match for what is happening.

[varkha, 2013/06/12 04:52:13]

I now try to avoid using "dock" as a term for the area where it is confusing and
rather mention "windows docked to the side of a screen" now. I still use
"dock_container" and kShellWindowId_DockContainer, I hope those are OK since
they don't really overlap with the other similar items in code and are shorter
than kShellWindowId_ContainerOfWindowsDockedToSide.

+// dock (gutter). 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 |panel_container| argument which is expected to set
+// The constructor takes a |dock_container| argument which is expected to set
 // its layout manager to this instance, e.g.:
-// panel_container->SetLayoutManager(new PanelLayoutManager(panel_container));
+// dock_container->SetLayoutManager(new DockLayoutManager(dock_container));
 
-class ASH_EXPORT PanelLayoutManager
+class ASH_EXPORT DockLayoutManager
     : public aura::LayoutManager,
-      public ash::LauncherIconObserver,
       public ash::ShellObserver,
       public aura::WindowObserver,
       public aura::client::ActivationChangeObserver,
       public keyboard::KeyboardControllerObserver,
-      public ShelfLayoutManagerObserver {
+      public ash::ShelfLayoutManagerObserver {
  public:
-  explicit PanelLayoutManager(aura::Window* panel_container);
-  virtual ~PanelLayoutManager();
+  explicit DockLayoutManager(aura::Window* dock_container);
+  virtual ~DockLayoutManager();
 
-  // Call Shutdown() before deleting children of panel_container.
+  // Call Shutdown() before deleting children of dock_container.
   void Shutdown();
 
-  void StartDragging(aura::Window* panel);
+  void StartDragging(aura::Window* window);
   void FinishDragging();
 
-  void ToggleMinimize(aura::Window* panel);
+  void ToggleMinimize(aura::Window* window);

[sky, 2013/06/11 00:03:13]

Description?

[varkha, 2013/06/11 02:34:24]

This one is removed.

 
   ash::Launcher* launcher() { return launcher_; }
   void SetLauncher(ash::Launcher* launcher);
 
+  // checks if the window touches the screen edge (no dock yet) or has entered

[sky, 2013/06/11 00:03:13]

Start with cap and end with appropriate punctuation.

Also, seems like this is more of 'Returns edge for specified window' rather than
'checks'.

[varkha, 2013/06/11 02:34:24]

Done.

+  // existing dock area
+  static DockEdge FindDockEdge(aura::Window* window);
+
   // Overridden from 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;
 
-  // Overridden from ash::LauncherIconObserver
-  virtual void OnLauncherIconPositionsChanged() OVERRIDE;
-
   // Overridden from ash::ShellObserver
   virtual void OnShelfAlignmentChanged(aura::RootWindow* root_window) OVERRIDE;
 
   // Overridden from aura::WindowObserver
   virtual void OnWindowPropertyChanged(aura::Window* window,
                                        const void* key,
                                        intptr_t old) OVERRIDE;
   virtual void OnWindowVisibilityChanged(aura::Window* window,
                                          bool visible) OVERRIDE;
 
   // Overridden from aura::client::ActivationChangeObserver
   virtual void OnWindowActivated(aura::Window* gained_active,
                                  aura::Window* lost_active) OVERRIDE;
 
   // Overridden from ShelfLayoutManagerObserver
   virtual void WillChangeVisibilityState(
       ShelfVisibilityState new_state) OVERRIDE;
 
  private:
-  friend class PanelLayoutManagerTest;
-  friend class PanelWindowResizerTest;
+  friend class DockLayoutManagerTest;
+  friend class DockWindowResizerTest;
 
-  views::Widget* CreateCalloutWidget();
+  // minimize / restore window and relayout
+  void MinimizeWindow(aura::Window* window);
+  void RestoreWindow(aura::Window* window);
 
-  struct PanelInfo{
-    PanelInfo() : window(NULL), callout_widget(NULL), slide_in(false) {}
-
-    bool operator==(const aura::Window* other_window) const {
-      return window == other_window;
-    }
-
-    // A weak pointer to the panel window.
-    aura::Window* window;
-    // The callout widget for this panel. This pointer must be managed
-    // manually as this structure is used in a std::list. See
-    // http://www.chromium.org/developers/smart-pointer-guidelines
-    PanelCalloutWidget* callout_widget;
-
-    // True on new and restored panel windows until the panel has been
-    // positioned. The first time Relayout is called the panel will slide into
-    // position and this will be set to false.
-    bool slide_in;
-  };
-
-  typedef std::list<PanelInfo> PanelList;
-
-  void MinimizePanel(aura::Window* panel);
-  void RestorePanel(aura::Window* panel);
-
-  // Called whenever the panel layout might change.
+  // Called whenever the window layout might change.
   void Relayout();
 
-  // Called whenever the panel stacking order needs to be updated (e.g. focus
-  // changes or a panel is moved).
-  void UpdateStacking(aura::Window* active_panel);
-
-  // Update the callout arrows for all managed panels.
-  void UpdateCallouts();
+  // 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);
 
   // Overridden from keyboard::KeyboardControllerObserver:
   virtual void OnKeyboardBoundsChanging(
       const gfx::Rect& keyboard_bounds) OVERRIDE;
 
   // Parent window associated with this layout manager.
-  aura::Window* panel_container_;
+  aura::Window* dock_container_;
   // Protect against recursive calls to Relayout().
   bool in_layout_;
-  // Ordered list of unowned pointers to panel windows.
-  PanelList panel_windows_;
-  // The panel being dragged.
-  aura::Window* dragged_panel_;
+  // 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_;
-  // The last active panel. Used to maintain stacking even if no panels are
-  // currently focused.
-  aura::Window* last_active_panel_;
-  base::WeakPtrFactory<PanelLayoutManager> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(PanelLayoutManager);
+  // side of the screen the dock is positioned at
+  enum DockAlignment {

[sky, 2013/06/11 00:03:13]

enums should be near the top of a section (see style guide for specific
ordering).

[varkha, 2013/06/11 02:34:24]

Done.

+    DOCK_ALIGNMENT_NONE,
+    DOCK_ALIGNMENT_LEFT,
+    DOCK_ALIGNMENT_RIGHT,
+  };
+  DockAlignment alignment_;
+
+  DISALLOW_COPY_AND_ASSIGN(DockLayoutManager);
 };
 
 }  // namespace internal
 }  // namespace ash
 
-#endif  // ASH_WM_PANELS_PANEL_LAYOUT_MANAGER_H_
+#endif  // ASH_WM_DOCK_DOCK_LAYOUT_MANAGER_H_