chrome/browser/ui/panels/stacked_panel_collection.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_STACKED_PANEL_COLLECTION_H_
   6 #define CHROME_BROWSER_UI_PANELS_STACKED_PANEL_COLLECTION_H_
   7
   8 #include <list>
   9 #include <vector>
  10 #include "base/basictypes.h"
  11 #include "chrome/browser/ui/panels/native_panel_stack_window.h"
  12 #include "chrome/browser/ui/panels/panel_collection.h"
  13 #include "chrome/browser/ui/panels/panel_constants.h"
  14 #include "ui/gfx/rect.h"
  15
  16 class PanelManager;
  17 namespace gfx {
  18 class Vector2d;
  19 }
  20
  21 class StackedPanelCollection : public PanelCollection,
  22                                public NativePanelStackWindowDelegate {
  23  public:
  24   typedef std::list<Panel*> Panels;
  25
  26   explicit StackedPanelCollection(PanelManager* panel_manager);
  27   virtual ~StackedPanelCollection();
  28
  29   // PanelCollection OVERRIDES:
  30   virtual void OnDisplayChanged() OVERRIDE;
  31   virtual void RefreshLayout() OVERRIDE;
  32   virtual void AddPanel(Panel* panel,
  33                         PositioningMask positioning_mask) OVERRIDE;
  34   virtual void RemovePanel(Panel* panel, RemovalReason reason) OVERRIDE;
  35   virtual void CloseAll() OVERRIDE;
  36   virtual void ResizePanelWindow(
  37       Panel* panel,
  38       const gfx::Size& preferred_window_size) OVERRIDE;
  39   virtual panel::Resizability GetPanelResizability(
  40       const Panel* panel) const OVERRIDE;
  41   virtual void OnPanelResizedByMouse(Panel* panel,
  42                                      const gfx::Rect& new_bounds) OVERRIDE;
  43   virtual void OnPanelAttentionStateChanged(Panel* panel) OVERRIDE;
  44   virtual void OnPanelTitlebarClicked(Panel* panel,
  45                                       panel::ClickModifier modifier) OVERRIDE;
  46   virtual void ActivatePanel(Panel* panel) OVERRIDE;
  47   virtual void MinimizePanel(Panel* panel) OVERRIDE;
  48   virtual void RestorePanel(Panel* panel) OVERRIDE;
  49   virtual void OnMinimizeButtonClicked(Panel* panel,
  50                                        panel::ClickModifier modifier) OVERRIDE;
  51   virtual void OnRestoreButtonClicked(Panel* panel,
  52                                       panel::ClickModifier modifier) OVERRIDE;
  53   virtual bool CanShowMinimizeButton(const Panel* panel) const OVERRIDE;
  54   virtual bool CanShowRestoreButton(const Panel* panel) const OVERRIDE;
  55   virtual bool IsPanelMinimized(const Panel* panel) const OVERRIDE;
  56   virtual bool UsesAlwaysOnTopPanels() const OVERRIDE;
  57   virtual void SavePanelPlacement(Panel* panel) OVERRIDE;
  58   virtual void RestorePanelToSavedPlacement() OVERRIDE;
  59   virtual void DiscardSavedPanelPlacement()  OVERRIDE;
  60   virtual void UpdatePanelOnCollectionChange(Panel* panel) OVERRIDE;
  61   virtual void OnPanelExpansionStateChanged(Panel* panel) OVERRIDE;
  62   virtual void OnPanelActiveStateChanged(Panel* panel) OVERRIDE;
  63   virtual gfx::Rect GetInitialPanelBounds(
  64       const gfx::Rect& requested_bounds) const OVERRIDE;
  65
  66   Panel* GetPanelAbove(Panel* panel) const;
  67   Panel* GetPanelBelow(Panel* panel) const;
  68   bool HasPanel(Panel* panel) const;
  69
  70   void MoveAllDraggingPanelsInstantly(const gfx::Vector2d& delta_origin);
  71
  72   bool IsMinimized() const;
  73   bool IsAnimatingPanelBounds(Panel* panel) const;
  74
  75   // Returns the maximum available space from the bottom of the stack. The
  76   // maximum available space is defined as the distance between the bottom
  77   // of the stack and the bottom of the working area, assuming that all inactive
  78   // panels are collapsed.
  79   int GetMaximiumAvailableBottomSpace() const;
  80
  81   int num_panels() const { return panels_.size(); }
  82   const Panels& panels() const { return panels_; }
  83   Panel* top_panel() const { return panels_.empty() ? NULL : panels_.front(); }
  84   Panel* bottom_panel() const {
  85     return panels_.empty() ? NULL : panels_.back();
  86   }
  87   Panel* most_recently_active_panel() const {
  88     return most_recently_active_panels_.empty() ?
  89         NULL : most_recently_active_panels_.front();
  90   }
  91
  92  private:
  93   struct PanelPlacement {
  94     Panel* panel;
  95     gfx::Point position;
  96     // Used to remember the top panel, if different from |panel|, for use when
  97     // restoring it. When there're only 2 panels in the stack and the bottom
  98     // panel is being dragged out of the stack, both panels will be moved to
  99     // the detached collection. We need to track the top panel in order to
 100     // put it back to the same stack of the dragging panel.
 101     Panel* top_panel;
 102
 103     PanelPlacement() : panel(NULL), top_panel(NULL) { }
 104   };
 105
 106   // Overridden from PanelBoundsBatchUpdateObserver:
 107   virtual base::string16 GetTitle() const OVERRIDE;
 108   virtual gfx::Image GetIcon() const OVERRIDE;
 109   virtual void PanelBoundsBatchUpdateCompleted() OVERRIDE;
 110
 111   // Returns the enclosing bounds that include all panels in the stack.
 112   gfx::Rect GetEnclosingBounds() const;
 113
 114   // Returns the work area where the stack resides. If the stack spans across
 115   // multiple displays, return the work area of the display that most closely
 116   // intersects the stack.
 117   gfx::Rect GetWorkArea() const;
 118
 119   // Refresh all panel layouts, with top panel poisitoned at |start_position|.
 120   // All panels should have same width as |common_width|.
 121   void RefreshLayoutWithTopPanelStartingAt(const gfx::Point& start_position,
 122                                            int common_width);
 123
 124   // Tries to collapse panels in the least recently active order in order to get
 125   // enough bottom space for |needed_space|. Returns the current available space
 126   // so far if all panels that could be collapsed have been collapsed.
 127   int MinimizePanelsForSpace(int needed_space);
 128
 129   // Returns the current available space above the top of the stack. The current
 130   // available space is defined as the distance between the top of the working
 131   // area and the top of the stack.
 132   int GetCurrentAvailableTopSpace() const;
 133
 134   // Returns the current available space below the bottom of the stack. The
 135   // current available space is defined as the distance between the bottom
 136   // of the stack and the bottom of the working area.
 137   int GetCurrentAvailableBottomSpace() const;
 138
 139   // Minimizes or restores all panels in the collection.
 140   void MinimizeAll();
 141   void RestoreAll(Panel* panel_clicked);
 142
 143   void UpdatePanelCornerStyle(Panel* panel);
 144
 145   NativePanelStackWindow* GetStackWindowForPanel(Panel* panel) const;
 146
 147   PanelManager* panel_manager_;
 148
 149   // Both stack window pointers are weak pointers and self owned. Once a stack
 150   // window is created, it will only be destructed by calling Close when it is
 151   // not longer needed as in RemovePanel and CloseAll.
 152
 153   // The main background window that encloses all panels in the stack when
 154   // stacking is not occuring, or existing panels otherwise.
 155   // This window provides:
 156   // 1) the shadow around the the outer area of all panels.
 157   // 2) the consolidated taskbar icon and the consolidated preview
 158   //    (Windows only)
 159   NativePanelStackWindow* primary_stack_window_;
 160
 161   // The additional background window that encloses those panels that are
 162   // being added to the stack when the stacking is occuring. Since those panels
 163   // have not been fully aligned with existing panels in the stack before the
 164   // stacking ends, we put those panels in a separate background window that
 165   // only provides the shadow around the outer area of those panels.
 166   NativePanelStackWindow* secondary_stack_window_;
 167
 168   Panels panels_;  // The top panel is in the front of the list.
 169
 170   // Keeps track of the panels in their active order. The most recently active
 171   // panel is in the front of the list.
 172   Panels most_recently_active_panels_;
 173
 174   // Used to save the placement information for a panel.
 175   PanelPlacement saved_panel_placement_;
 176
 177   bool minimizing_all_;  // True while minimizing all panels.
 178
 179   DISALLOW_COPY_AND_ASSIGN(StackedPanelCollection);
 180 };
 181
 182 #endif  // CHROME_BROWSER_UI_PANELS_STACKED_PANEL_COLLECTION_H_