src/ash/shelf/shelf_layout_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 ASH_SHELF_SHELF_LAYOUT_MANAGER_H_
   6 #define ASH_SHELF_SHELF_LAYOUT_MANAGER_H_
   7
   8 #include <vector>
   9
  10 #include "ash/ash_export.h"
  11 #include "ash/session/session_state_observer.h"
  12 #include "ash/shelf/background_animator.h"
  13 #include "ash/shelf/shelf.h"
  14 #include "ash/shelf/shelf_types.h"
  15 #include "ash/shell_observer.h"
  16 #include "ash/snap_to_pixel_layout_manager.h"
  17 #include "ash/system/status_area_widget.h"
  18 #include "ash/wm/dock/docked_window_layout_manager_observer.h"
  19 #include "ash/wm/lock_state_observer.h"
  20 #include "ash/wm/workspace/workspace_types.h"
  21 #include "base/basictypes.h"
  22 #include "base/compiler_specific.h"
  23 #include "base/logging.h"
  24 #include "base/observer_list.h"
  25 #include "base/timer/timer.h"
  26 #include "ui/gfx/insets.h"
  27 #include "ui/gfx/rect.h"
  28 #include "ui/keyboard/keyboard_controller.h"
  29 #include "ui/keyboard/keyboard_controller_observer.h"
  30 #include "ui/wm/public/activation_change_observer.h"
  31
  32 namespace aura {
  33 class RootWindow;
  34 }
  35
  36 namespace ui {
  37 class GestureEvent;
  38 class ImplicitAnimationObserver;
  39 }
  40
  41 namespace ash {
  42 class PanelLayoutManagerTest;
  43 class ScreenAsh;
  44 class ShelfBezelEventFilter;
  45 class ShelfLayoutManagerObserver;
  46 class ShelfLayoutManagerTest;
  47 class ShelfWidget;
  48 class StatusAreaWidget;
  49 class WorkspaceController;
  50 FORWARD_DECLARE_TEST(AshPopupAlignmentDelegateTest, AutoHide);
  51 FORWARD_DECLARE_TEST(WebNotificationTrayTest, PopupAndFullscreen);
  52
  53 // ShelfLayoutManager is the layout manager responsible for the shelf and
  54 // status widgets. The shelf is given the total available width and told the
  55 // width of the status area. This allows the shelf to draw the background and
  56 // layout to the status area.
  57 // To respond to bounds changes in the status area StatusAreaLayoutManager works
  58 // closely with ShelfLayoutManager.
  59 class ASH_EXPORT ShelfLayoutManager
  60     : public ash::ShellObserver,
  61       public aura::client::ActivationChangeObserver,
  62       public DockedWindowLayoutManagerObserver,
  63       public keyboard::KeyboardControllerObserver,
  64       public LockStateObserver,
  65       public SnapToPixelLayoutManager,
  66       public SessionStateObserver {
  67  public:
  68
  69   // We reserve a small area on the edge of the workspace area to ensure that
  70   // the resize handle at the edge of the window can be hit.
  71   static const int kWorkspaceAreaVisibleInset;
  72
  73   // When autohidden we extend the touch hit target onto the screen so that the
  74   // user can drag the shelf out.
  75   static const int kWorkspaceAreaAutoHideInset;
  76
  77   // Size of the shelf when auto-hidden.
  78   static const int kAutoHideSize;
  79
  80   // Inset between the inner edge of the shelf (towards centre of screen), and
  81   // the shelf items, notifications, status area etc.
  82   static const int kShelfItemInset;
  83
  84   explicit ShelfLayoutManager(ShelfWidget* shelf);
  85   ~ShelfLayoutManager() override;
  86
  87   // Sets the ShelfAutoHideBehavior. See enum description for details.
  88   void SetAutoHideBehavior(ShelfAutoHideBehavior behavior);
  89   ShelfAutoHideBehavior auto_hide_behavior() const {
  90     return auto_hide_behavior_;
  91   }
  92
  93   // Sets the alignment. Returns true if the alignment is changed. Otherwise,
  94   // returns false.
  95   bool SetAlignment(ShelfAlignment alignment);
  96   // Returns the desired alignment for the current state, either the user's
  97   // set alignment (alignment_) or SHELF_ALIGNMENT_BOTTOM when the screen
  98   // is locked.
  99   ShelfAlignment GetAlignment() const;
 100
 101   void set_workspace_controller(WorkspaceController* controller) {
 102     workspace_controller_ = controller;
 103   }
 104
 105   bool updating_bounds() const { return updating_bounds_; }
 106
 107   // Clears internal data for shutdown process.
 108   void PrepareForShutdown();
 109
 110   // Returns whether the shelf and its contents (shelf, status) are visible
 111   // on the screen.
 112   bool IsVisible() const;
 113
 114   // Returns the ideal bounds of the shelf assuming it is visible.
 115   gfx::Rect GetIdealBounds();
 116
 117   // Returns the docked area bounds.
 118   const gfx::Rect& dock_bounds() const { return dock_bounds_; }
 119
 120   // Stops any animations and sets the bounds of the shelf and status
 121   // widgets.
 122   void LayoutShelf();
 123
 124   // Returns shelf visibility state based on current value of auto hide
 125   // behavior setting.
 126   ShelfVisibilityState CalculateShelfVisibility();
 127
 128   // Updates the visibility state.
 129   void UpdateVisibilityState();
 130
 131   // Invoked by the shelf when the auto-hide state may have changed.
 132   void UpdateAutoHideState();
 133
 134   ShelfVisibilityState visibility_state() const {
 135     return state_.visibility_state;
 136   }
 137   ShelfAutoHideState auto_hide_state() const { return state_.auto_hide_state; }
 138
 139   ShelfWidget* shelf_widget() { return shelf_; }
 140
 141   // Sets whether any windows overlap the shelf. If a window overlaps the shelf
 142   // the shelf renders slightly differently.
 143   void SetWindowOverlapsShelf(bool value);
 144   bool window_overlaps_shelf() const { return window_overlaps_shelf_; }
 145
 146   void AddObserver(ShelfLayoutManagerObserver* observer);
 147   void RemoveObserver(ShelfLayoutManagerObserver* observer);
 148
 149   // Gesture related functions:
 150   void OnGestureEdgeSwipe(const ui::GestureEvent& gesture);
 151   void StartGestureDrag(const ui::GestureEvent& gesture);
 152   enum DragState {
 153     DRAG_SHELF,
 154     DRAG_TRAY
 155   };
 156   // Returns DRAG_SHELF if the gesture should continue to drag the entire shelf.
 157   // Returns DRAG_TRAY if the gesture can start dragging the tray-bubble from
 158   // this point on.
 159   DragState UpdateGestureDrag(const ui::GestureEvent& gesture);
 160   void CompleteGestureDrag(const ui::GestureEvent& gesture);
 161   void CancelGestureDrag();
 162
 163   // Set an animation duration override for the show / hide animation of the
 164   // shelf. Specifying 0 leads to use the default.
 165   void SetAnimationDurationOverride(int duration_override_in_ms);
 166
 167   // Overridden from SnapLayoutManager:
 168   void OnWindowResized() override;
 169   void SetChildBounds(aura::Window* child,
 170                       const gfx::Rect& requested_bounds) override;
 171
 172   // Overridden from ash::ShellObserver:
 173   void OnLockStateChanged(bool locked) override;
 174
 175   // Overriden from aura::client::ActivationChangeObserver:
 176   void OnWindowActivated(aura::Window* gained_active,
 177                          aura::Window* lost_active) override;
 178
 179   // Overridden from ash::LockStateObserver:
 180   void OnLockStateEvent(LockStateObserver::EventType event) override;
 181
 182   // Overridden from ash::SessionStateObserver:
 183   void SessionStateChanged(SessionStateDelegate::SessionState state) override;
 184
 185   // TODO(harrym|oshima): These templates will be moved to
 186   // new Shelf class.
 187   // A helper function that provides a shortcut for choosing
 188   // values specific to a shelf alignment.
 189   template<typename T>
 190   T SelectValueForShelfAlignment(T bottom, T left, T right, T top) const {
 191     switch (GetAlignment()) {
 192       case SHELF_ALIGNMENT_BOTTOM:
 193         return bottom;
 194       case SHELF_ALIGNMENT_LEFT:
 195         return left;
 196       case SHELF_ALIGNMENT_RIGHT:
 197         return right;
 198       case SHELF_ALIGNMENT_TOP:
 199         return top;
 200     }
 201     NOTREACHED();
 202     return right;
 203   }
 204
 205   template<typename T>
 206   T PrimaryAxisValue(T horizontal, T vertical) const {
 207     return IsHorizontalAlignment() ? horizontal : vertical;
 208   }
 209
 210   // Is the shelf's alignment horizontal?
 211   bool IsHorizontalAlignment() const;
 212
 213   // Returns a ShelfLayoutManager on the display which has a shelf for
 214   // given |window|. See RootWindowController::ForShelf for more info.
 215   static ShelfLayoutManager* ForShelf(aura::Window* window);
 216
 217  private:
 218   class AutoHideEventFilter;
 219   class UpdateShelfObserver;
 220   friend class ash::ScreenAsh;
 221   friend class PanelLayoutManagerTest;
 222   friend class ShelfLayoutManagerTest;
 223   FRIEND_TEST_ALL_PREFIXES(ash::AshPopupAlignmentDelegateTest, AutoHide);
 224   FRIEND_TEST_ALL_PREFIXES(ash::WebNotificationTrayTest, PopupAndFullscreen);
 225
 226   struct TargetBounds {
 227     TargetBounds();
 228     ~TargetBounds();
 229
 230     float opacity;
 231     float status_opacity;
 232     gfx::Rect shelf_bounds_in_root;
 233     gfx::Rect shelf_bounds_in_shelf;
 234     gfx::Rect status_bounds_in_shelf;
 235     gfx::Insets work_area_insets;
 236   };
 237
 238   struct State {
 239     State() : visibility_state(SHELF_VISIBLE),
 240               auto_hide_state(SHELF_AUTO_HIDE_HIDDEN),
 241               window_state(WORKSPACE_WINDOW_STATE_DEFAULT),
 242               is_screen_locked(false) {}
 243
 244     // Returns true if the two states are considered equal. As
 245     // |auto_hide_state| only matters if |visibility_state| is
 246     // |SHELF_AUTO_HIDE|, Equals() ignores the |auto_hide_state| as
 247     // appropriate.
 248     bool Equals(const State& other) const {
 249       return other.visibility_state == visibility_state &&
 250           (visibility_state != SHELF_AUTO_HIDE ||
 251            other.auto_hide_state == auto_hide_state) &&
 252           other.window_state == window_state &&
 253           other.is_screen_locked == is_screen_locked;
 254     }
 255
 256     ShelfVisibilityState visibility_state;
 257     ShelfAutoHideState auto_hide_state;
 258     WorkspaceWindowState window_state;
 259     bool is_screen_locked;
 260   };
 261
 262   // Sets the visibility of the shelf to |state|.
 263   void SetState(ShelfVisibilityState visibility_state);
 264
 265   // Updates the bounds and opacity of the shelf and status widgets.
 266   // If |observer| is specified, it will be called back when the animations, if
 267   // any, are complete.
 268   void UpdateBoundsAndOpacity(const TargetBounds& target_bounds,
 269                               bool animate,
 270                               ui::ImplicitAnimationObserver* observer);
 271
 272   // Stops any animations and progresses them to the end.
 273   void StopAnimating();
 274
 275   // Returns the width (if aligned to the side) or height (if aligned to the
 276   // bottom).
 277   void GetShelfSize(int* width, int* height);
 278
 279   // Insets |bounds| by |inset| on the edge the shelf is aligned to.
 280   void AdjustBoundsBasedOnAlignment(int inset, gfx::Rect* bounds) const;
 281
 282   // Calculates the target bounds assuming visibility of |visible|.
 283   void CalculateTargetBounds(const State& state, TargetBounds* target_bounds);
 284
 285   // Updates the target bounds if a gesture-drag is in progress. This is only
 286   // used by |CalculateTargetBounds()|.
 287   void UpdateTargetBoundsForGesture(TargetBounds* target_bounds) const;
 288
 289   // Updates the background of the shelf.
 290   void UpdateShelfBackground(BackgroundAnimatorChangeType type);
 291
 292   // Returns how the shelf background is painted.
 293   ShelfBackgroundType GetShelfBackgroundType() const;
 294
 295   // Updates the auto hide state immediately.
 296   void UpdateAutoHideStateNow();
 297
 298   // Stops the auto hide timer and clears
 299   // |mouse_over_shelf_when_auto_hide_timer_started_|.
 300   void StopAutoHideTimer();
 301
 302   // Returns the bounds of an additional region which can trigger showing the
 303   // shelf. This region exists to make it easier to trigger showing the shelf
 304   // when the shelf is auto hidden and the shelf is on the boundary between
 305   // two displays.
 306   gfx::Rect GetAutoHideShowShelfRegionInScreen() const;
 307
 308   // Returns the AutoHideState. This value is determined from the shelf and
 309   // tray.
 310   ShelfAutoHideState CalculateAutoHideState(
 311       ShelfVisibilityState visibility_state) const;
 312
 313   // Returns true if |window| is a descendant of the shelf.
 314   bool IsShelfWindow(aura::Window* window);
 315
 316   int GetWorkAreaSize(const State& state, int size) const;
 317
 318   // Overridden from keyboard::KeyboardControllerObserver:
 319   void OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) override;
 320
 321   // Overridden from DockedWindowLayoutManagerObserver:
 322   void OnDockBoundsChanging(
 323       const gfx::Rect& dock_bounds,
 324       DockedWindowLayoutManagerObserver::Reason reason) override;
 325
 326   // The RootWindow is cached so that we don't invoke Shell::GetInstance() from
 327   // our destructor. We avoid that as at the time we're deleted Shell is being
 328   // deleted too.
 329   aura::Window* root_window_;
 330
 331   // True when inside UpdateBoundsAndOpacity() method. Used to prevent calling
 332   // UpdateBoundsAndOpacity() again from SetChildBounds().
 333   bool updating_bounds_;
 334
 335   // See description above setter.
 336   ShelfAutoHideBehavior auto_hide_behavior_;
 337
 338   // See description above getter.
 339   ShelfAlignment alignment_;
 340
 341   // Current state.
 342   State state_;
 343
 344   ShelfWidget* shelf_;
 345
 346   WorkspaceController* workspace_controller_;
 347
 348   // Do any windows overlap the shelf? This is maintained by WorkspaceManager.
 349   bool window_overlaps_shelf_;
 350
 351   base::OneShotTimer<ShelfLayoutManager> auto_hide_timer_;
 352
 353   // Whether the mouse was over the shelf when the auto hide timer started.
 354   // False when neither the auto hide timer nor the timer task are running.
 355   bool mouse_over_shelf_when_auto_hide_timer_started_;
 356
 357   // EventFilter used to detect when user moves the mouse over the shelf to
 358   // trigger showing the shelf.
 359   scoped_ptr<AutoHideEventFilter> auto_hide_event_filter_;
 360
 361   // EventFilter used to detect when user issues a gesture on a bezel sensor.
 362   scoped_ptr<ShelfBezelEventFilter> bezel_event_filter_;
 363
 364   ObserverList<ShelfLayoutManagerObserver> observers_;
 365
 366   // The shelf reacts to gesture-drags, and can be set to auto-hide for certain
 367   // gestures. Some shelf behaviour (e.g. visibility state, background color
 368   // etc.) are affected by various stages of the drag. The enum keeps track of
 369   // the present status of the gesture drag.
 370   enum GestureDragStatus {
 371     GESTURE_DRAG_NONE,
 372     GESTURE_DRAG_IN_PROGRESS,
 373     GESTURE_DRAG_CANCEL_IN_PROGRESS,
 374     GESTURE_DRAG_COMPLETE_IN_PROGRESS
 375   };
 376   GestureDragStatus gesture_drag_status_;
 377
 378   // Tracks the amount of the drag. The value is only valid when
 379   // |gesture_drag_status_| is set to GESTURE_DRAG_IN_PROGRESS.
 380   float gesture_drag_amount_;
 381
 382   // Manage the auto-hide state during the gesture.
 383   ShelfAutoHideState gesture_drag_auto_hide_state_;
 384
 385   // Used to delay updating shelf background.
 386   UpdateShelfObserver* update_shelf_observer_;
 387
 388   // The bounds of the keyboard.
 389   gfx::Rect keyboard_bounds_;
 390
 391   // The bounds of the dock.
 392   gfx::Rect dock_bounds_;
 393
 394   // The show hide animation duration override or 0 for default.
 395   int duration_override_in_ms_;
 396
 397   DISALLOW_COPY_AND_ASSIGN(ShelfLayoutManager);
 398 };
 399
 400 }  // namespace ash
 401
 402 #endif  // ASH_SHELF_SHELF_LAYOUT_MANAGER_H_