diff options
Diffstat (limited to 'chromium/ash/wm/panels/panel_layout_manager.h')
| -rw-r--r-- | chromium/ash/wm/panels/panel_layout_manager.h | 196 |
1 files changed, 196 insertions, 0 deletions
diff --git a/chromium/ash/wm/panels/panel_layout_manager.h b/chromium/ash/wm/panels/panel_layout_manager.h new file mode 100644 index 00000000000..042d285cb1d --- /dev/null +++ b/chromium/ash/wm/panels/panel_layout_manager.h @@ -0,0 +1,196 @@ +// 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 ASH_WM_PANELS_PANEL_LAYOUT_MANAGER_H_ +#define ASH_WM_PANELS_PANEL_LAYOUT_MANAGER_H_ + +#include <list> + +#include "ash/ash_export.h" +#include "ash/display/display_controller.h" +#include "ash/shelf/shelf_icon_observer.h" +#include "ash/shelf/shelf_layout_manager_observer.h" +#include "ash/shell_observer.h" +#include "ash/wm/window_state_observer.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; +class WindowTracker; +} + +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 +// added to that container. +// +// The constructor takes a |panel_container| argument which is expected to set +// its layout manager to this instance, e.g.: +// panel_container->SetLayoutManager(new PanelLayoutManager(panel_container)); + +class ASH_EXPORT PanelLayoutManager + : public aura::LayoutManager, + public ShelfIconObserver, + public ShellObserver, + public aura::WindowObserver, + public aura::client::ActivationChangeObserver, + public keyboard::KeyboardControllerObserver, + public DisplayController::Observer, + public ShelfLayoutManagerObserver, + public wm::WindowStateObserver { + public: + explicit PanelLayoutManager(aura::Window* panel_container); + virtual ~PanelLayoutManager(); + + // Call Shutdown() before deleting children of panel_container. + void Shutdown(); + + void StartDragging(aura::Window* panel); + void FinishDragging(); + + void ToggleMinimize(aura::Window* panel); + + // Returns the callout widget (arrow) for |panel|. + views::Widget* GetCalloutWidgetForPanel(aura::Window* panel); + + ash::Launcher* launcher() { return launcher_; } + void SetLauncher(ash::Launcher* launcher); + + // 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 ShelfIconObserver + virtual void OnShelfIconPositionsChanged() OVERRIDE; + + // Overridden from ShellObserver + virtual void OnShelfAlignmentChanged(aura::Window* root_window) OVERRIDE; + + // Overridden from ash::wm::WindowStateObserver + virtual void OnWindowShowTypeChanged(wm::WindowState* window_state, + wm::WindowShowType old_type) OVERRIDE; + + // Overridden from aura::WindowObserver + 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 DisplayController::Observer + virtual void OnDisplayConfigurationChanged() OVERRIDE; + + // Overridden from ShelfLayoutManagerObserver + virtual void WillChangeVisibilityState( + ShelfVisibilityState new_state) OVERRIDE; + + private: + friend class PanelLayoutManagerTest; + friend class PanelWindowResizerTest; + friend class DockedWindowResizerTest; + friend class DockedWindowLayoutManagerTest; + + views::Widget* CreateCalloutWidget(); + + 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. + 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(); + + // Overridden from keyboard::KeyboardControllerObserver: + virtual void OnKeyboardBoundsChanging( + const gfx::Rect& keyboard_bounds) OVERRIDE; + + // Parent window associated with this layout manager. + aura::Window* panel_container_; + // Protect against recursive calls to OnWindowAddedToLayout(). + bool in_add_window_; + // 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 launcher we are observing for launcher icon changes. + Launcher* launcher_; + // The shelf layout manager being observed for visibility changes. + ShelfLayoutManager* shelf_layout_manager_; + + // When not NULL, the shelf is hidden (i.e. full screen) and this tracks the + // set of panel windows which have been temporarily hidden and need to be + // restored when the shelf becomes visible again. + scoped_ptr<aura::WindowTracker> restore_windows_on_shelf_visible_; + + // The last active panel. Used to maintain stacking order even if no panels + // are currently focused. + aura::Window* last_active_panel_; + base::WeakPtrFactory<PanelLayoutManager> weak_factory_; + + DISALLOW_COPY_AND_ASSIGN(PanelLayoutManager); +}; + +} // namespace internal +} // namespace ash + +#endif // ASH_WM_PANELS_PANEL_LAYOUT_MANAGER_H_ |