chrome/browser/ui/panels/panel_manager.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_UI_PANELS_PANEL_MANAGER_H_
   6 #define CHROME_BROWSER_UI_PANELS_PANEL_MANAGER_H_
   7
   8 #include <list>
   9 #include <vector>
  10 #include "base/basictypes.h"
  11 #include "base/lazy_instance.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "chrome/browser/ui/panels/display_settings_provider.h"
  14 #include "chrome/browser/ui/panels/panel.h"
  15 #include "chrome/browser/ui/panels/panel_collection.h"
  16 #include "chrome/browser/ui/panels/panel_constants.h"
  17 #include "ui/gfx/geometry/rect.h"
  18
  19 class DetachedPanelCollection;
  20 class DockedPanelCollection;
  21 class GURL;
  22 class PanelDragController;
  23 class PanelResizeController;
  24 class PanelMouseWatcher;
  25 class StackedPanelCollection;
  26
  27 // This class manages a set of panels.
  28 class PanelManager : public DisplaySettingsProvider::DisplayObserver,
  29                      public DisplaySettingsProvider::FullScreenObserver {
  30  public:
  31   typedef std::list<StackedPanelCollection*> Stacks;
  32
  33   enum CreateMode {
  34     CREATE_AS_DOCKED,  // Creates a docked panel. The default.
  35     CREATE_AS_DETACHED  // Creates a detached panel.
  36   };
  37
  38   // Returns a single instance.
  39   static PanelManager* GetInstance();
  40
  41   // Tells PanelManager to use |provider| for testing purpose. This has to be
  42   // called before GetInstance.
  43   static void SetDisplaySettingsProviderForTesting(
  44       DisplaySettingsProvider* provider);
  45
  46   // Returns true if panels should be used for the extension.
  47   static bool ShouldUsePanels(const std::string& extension_id);
  48
  49   // Returns true if panel stacking support is enabled.
  50   static bool IsPanelStackingEnabled();
  51
  52   // Returns true if a panel can be system-minimized by the desktop
  53   // environment. Some desktop environment, like Unity, does not trigger the
  54   // "window-state-event" which prevents the minimize and unminimize from
  55   // working.
  56   static bool CanUseSystemMinimize();
  57
  58   // Returns the default top-left position for a detached panel.
  59   gfx::Point GetDefaultDetachedPanelOrigin();
  60
  61   // Creates a panel and returns it. The panel might be queued for display
  62   // later.
  63   // |app_name| is the default title for Panels when the page content does not
  64   // provide a title. For extensions, this is usually the application name
  65   // generated from the extension id.
  66   // |requested_bounds| is the desired bounds for the panel, but actual
  67   // bounds may differ after panel layout depending on create |mode|.
  68   // |mode| indicates whether panel should be created as docked or detached.
  69   Panel* CreatePanel(const std::string& app_name,
  70                      Profile* profile,
  71                      const GURL& url,
  72                      const gfx::Rect& requested_bounds,
  73                      CreateMode mode);
  74
  75   // Close all panels (asynchronous). Panels will be removed after closing.
  76   void CloseAll();
  77
  78   // Asynchronous confirmation of panel having been closed.
  79   void OnPanelClosed(Panel* panel);
  80
  81   // Creates a StackedPanelCollection and returns it.
  82   StackedPanelCollection* CreateStack();
  83
  84   // Deletes |stack|. The stack must be empty at the time of deletion.
  85   void RemoveStack(StackedPanelCollection* stack);
  86
  87   // Returns the maximum size that panel can be auto-resized or resized by the
  88   // API.
  89   int GetMaxPanelWidth(const gfx::Rect& work_area) const;
  90   int GetMaxPanelHeight(const gfx::Rect& work_area) const;
  91
  92   // Drags the given panel.
  93   // |mouse_location| is in screen coordinate system.
  94   void StartDragging(Panel* panel, const gfx::Point& mouse_location);
  95   void Drag(const gfx::Point& mouse_location);
  96   void EndDragging(bool cancelled);
  97
  98   // Resizes the given panel.
  99   // |mouse_location| is in screen coordinate system.
 100   void StartResizingByMouse(Panel* panel, const gfx::Point& mouse_location,
 101                             int component);
 102   void ResizeByMouse(const gfx::Point& mouse_location);
 103   void EndResizingByMouse(bool cancelled);
 104
 105   // Invoked when a panel's expansion state changes.
 106   void OnPanelExpansionStateChanged(Panel* panel);
 107
 108   // Moves the |panel| to a different collection.
 109   void MovePanelToCollection(Panel* panel,
 110                              PanelCollection* target_collection,
 111                              PanelCollection::PositioningMask positioning_mask);
 112
 113   // Returns true if we should bring up the titlebars, given the current mouse
 114   // point.
 115   bool ShouldBringUpTitlebars(int mouse_x, int mouse_y) const;
 116
 117   // Brings up or down the titlebars for all minimized panels.
 118   void BringUpOrDownTitlebars(bool bring_up);
 119
 120   std::vector<Panel*> GetDetachedAndStackedPanels() const;
 121
 122   int num_panels() const;
 123   std::vector<Panel*> panels() const;
 124
 125   const Stacks& stacks() const { return stacks_; }
 126   int num_stacks() const { return stacks_.size(); }
 127
 128   PanelDragController* drag_controller() const {
 129     return drag_controller_.get();
 130   }
 131
 132 #ifdef UNIT_TEST
 133   PanelResizeController* resize_controller() const {
 134     return resize_controller_.get();
 135   }
 136 #endif
 137
 138   DisplaySettingsProvider* display_settings_provider() const {
 139     return display_settings_provider_.get();
 140   }
 141
 142   PanelMouseWatcher* mouse_watcher() const {
 143     return panel_mouse_watcher_.get();
 144   }
 145
 146   DetachedPanelCollection* detached_collection() const {
 147     return detached_collection_.get();
 148   }
 149
 150   DockedPanelCollection* docked_collection() const {
 151     return docked_collection_.get();
 152   }
 153
 154   // Reduces time interval in tests to shorten test run time.
 155   // Wrapper should be used around all time intervals in panels code.
 156   static inline double AdjustTimeInterval(double interval) {
 157     if (shorten_time_intervals_)
 158       return interval / 500.0;
 159     else
 160       return interval;
 161   }
 162
 163
 164   bool auto_sizing_enabled() const {
 165     return auto_sizing_enabled_;
 166   }
 167
 168   // Called from native level when panel animation ends.
 169   void OnPanelAnimationEnded(Panel* panel);
 170
 171 #ifdef UNIT_TEST
 172   static void shorten_time_intervals_for_testing() {
 173     shorten_time_intervals_ = true;
 174   }
 175
 176   void set_display_settings_provider(
 177       DisplaySettingsProvider* display_settings_provider) {
 178     display_settings_provider_.reset(display_settings_provider);
 179   }
 180
 181   void enable_auto_sizing(bool enabled) {
 182     auto_sizing_enabled_ = enabled;
 183   }
 184
 185   void SetMouseWatcherForTesting(PanelMouseWatcher* watcher) {
 186     SetMouseWatcher(watcher);
 187   }
 188 #endif
 189
 190  private:
 191   friend struct base::DefaultLazyInstanceTraits<PanelManager>;
 192
 193   PanelManager();
 194   virtual ~PanelManager();
 195
 196   void Initialize(DisplaySettingsProvider* provider);
 197
 198   // Overridden from DisplaySettingsProvider::DisplayObserver:
 199   void OnDisplayChanged() override;
 200
 201   // Overridden from DisplaySettingsProvider::FullScreenObserver:
 202   void OnFullScreenModeChanged(bool is_full_screen) override;
 203
 204   // Returns the collection to which a new panel should add. The new panel
 205   // is expected to be created with |bounds| and |mode|. The size of |bounds|
 206   // could be used to determine which collection is more appropriate to have
 207   // the new panel. Upon return, |positioning_mask| contains the required mask
 208   // to be applied when the new panel is being added to the collection.
 209   PanelCollection* GetCollectionForNewPanel(
 210       Panel* new_panel,
 211       const gfx::Rect& bounds,
 212       CreateMode mode,
 213       PanelCollection::PositioningMask* positioning_mask);
 214
 215   // Tests may want to use a mock panel mouse watcher.
 216   void SetMouseWatcher(PanelMouseWatcher* watcher);
 217
 218   // Tests may want to shorten time intervals to reduce running time.
 219   static bool shorten_time_intervals_;
 220
 221   scoped_ptr<DetachedPanelCollection> detached_collection_;
 222   scoped_ptr<DockedPanelCollection> docked_collection_;
 223   Stacks stacks_;
 224
 225   scoped_ptr<PanelDragController> drag_controller_;
 226   scoped_ptr<PanelResizeController> resize_controller_;
 227
 228   // Use a mouse watcher to know when to bring up titlebars to "peek" at
 229   // minimized panels. Mouse movement is only tracked when there is a minimized
 230   // panel.
 231   scoped_ptr<PanelMouseWatcher> panel_mouse_watcher_;
 232
 233   scoped_ptr<DisplaySettingsProvider> display_settings_provider_;
 234
 235   // Whether or not bounds will be updated when the preferred content size is
 236   // changed. The testing code could set this flag to false so that other tests
 237   // will not be affected.
 238   bool auto_sizing_enabled_;
 239
 240   DISALLOW_COPY_AND_ASSIGN(PanelManager);
 241 };
 242
 243 #endif  // CHROME_BROWSER_UI_PANELS_PANEL_MANAGER_H_