Support dragging panels to stack and snap.

chrome/browser/ui/panels/panel_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_PANELS_PANEL_MANAGER_H_
 #define CHROME_BROWSER_UI_PANELS_PANEL_MANAGER_H_
 
+#include <list>
 #include <vector>
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/ui/panels/display_settings_provider.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_collection.h"
 #include "chrome/browser/ui/panels/panel_constants.h"
 #include "ui/gfx/rect.h"
 
 class DetachedPanelCollection;
 class DockedPanelCollection;
 class GURL;
 class PanelDragController;
 class PanelResizeController;
 class PanelMouseWatcher;
+class StackedPanelCollection;
 
 // This class manages a set of panels.
 class PanelManager : public DisplaySettingsProvider::DisplayAreaObserver,
                      public DisplaySettingsProvider::FullScreenObserver {
  public:
+  typedef std::list<StackedPanelCollection*> Stacks;
+
   enum CreateMode {
     CREATE_AS_DOCKED,  // Creates a docked panel. The default.
     CREATE_AS_DETACHED  // Creates a detached panel.
   };
 
   // Returns a single instance.
   static PanelManager* GetInstance();
 
   // Returns true if panels should be used for the extension.
   static bool ShouldUsePanels(const std::string& extension_id);
@@ skipping 17 matching lines @@
                      const GURL& url,
                      const gfx::Rect& requested_bounds,
                      CreateMode mode);
 
   // Close all panels (asynchronous). Panels will be removed after closing.
   void CloseAll();
 
   // Asynchronous confirmation of panel having been closed.
   void OnPanelClosed(Panel* panel);
 
+  // Creates a StackedPanelCollection and returns it.
+  StackedPanelCollection* CreateStack();
+
+  // Deletes |stack|. The stack must be empty at the time of deletion.
+  void RemoveStack(StackedPanelCollection* stack);
+
   // Returns the maximum size that panel can be auto-resized or resized by the
   // API.
   int GetMaxPanelWidth() const;
   int GetMaxPanelHeight() const;
 
   // Drags the given panel.
   // |mouse_location| is in screen coordinate system.
   void StartDragging(Panel* panel, const gfx::Point& mouse_location);
   void Drag(const gfx::Point& mouse_location);
   void EndDragging(bool cancelled);
@@ skipping 13 matching lines @@
                              PanelCollection* target_collection,
                              PanelCollection::PositioningMask positioning_mask);
 
   // Returns true if we should bring up the titlebars, given the current mouse
   // point.
   bool ShouldBringUpTitlebars(int mouse_x, int mouse_y) const;
 
   // Brings up or down the titlebars for all minimized panels.
   void BringUpOrDownTitlebars(bool bring_up);
 
+  std::vector<Panel*> GetDetachedAndStackedPanels() const;
+
   int num_panels() const;
   std::vector<Panel*> panels() const;
 
+  const Stacks& stacks() const { return stacks_; }
+  int num_stacks() const { return stacks_.size(); }
+
   PanelDragController* drag_controller() const {
     return drag_controller_.get();
   }
 
 #ifdef UNIT_TEST
   PanelResizeController* resize_controller() const {
     return resize_controller_.get();
   }
 #endif
 
@@ skipping 64 matching lines @@
   virtual void OnFullScreenModeChanged(bool is_full_screen) OVERRIDE;
 
   // Tests may want to use a mock panel mouse watcher.
   void SetMouseWatcher(PanelMouseWatcher* watcher);
 
   // Tests may want to shorten time intervals to reduce running time.
   static bool shorten_time_intervals_;
 
   scoped_ptr<DetachedPanelCollection> detached_collection_;
   scoped_ptr<DockedPanelCollection> docked_collection_;
+  Stacks stacks_;
 
   scoped_ptr<PanelDragController> drag_controller_;
   scoped_ptr<PanelResizeController> resize_controller_;
 
   // Use a mouse watcher to know when to bring up titlebars to "peek" at
   // minimized panels. Mouse movement is only tracked when there is a minimized
   // panel.
   scoped_ptr<PanelMouseWatcher> panel_mouse_watcher_;
 
   scoped_ptr<DisplaySettingsProvider> display_settings_provider_;
 
   gfx::Rect display_area_;
 
   // Whether or not bounds will be updated when the preferred content size is
   // changed. The testing code could set this flag to false so that other tests
   // will not be affected.
   bool auto_sizing_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(PanelManager);
 };
 
 #endif  // CHROME_BROWSER_UI_PANELS_PANEL_MANAGER_H_