Deleted check for if Aes128Gcm12Encrypter::IsSupported or not beacuse we
[chromium-blink-merge.git] / ash / shelf / shelf_layout_manager.h
blob486596402d0efc42ce72c1518a0ce722675f06b7
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.
5 #ifndef ASH_SHELF_SHELF_LAYOUT_MANAGER_H_
6 #define ASH_SHELF_SHELF_LAYOUT_MANAGER_H_
8 #include <vector>
10 #include "ash/ash_export.h"
11 #include "ash/launcher/launcher.h"
12 #include "ash/shelf/background_animator.h"
13 #include "ash/shelf/shelf_types.h"
14 #include "ash/shell_observer.h"
15 #include "ash/system/status_area_widget.h"
16 #include "ash/wm/dock/docked_window_layout_manager_observer.h"
17 #include "ash/wm/lock_state_observer.h"
18 #include "ash/wm/workspace/workspace_types.h"
19 #include "base/basictypes.h"
20 #include "base/compiler_specific.h"
21 #include "base/logging.h"
22 #include "base/observer_list.h"
23 #include "base/timer/timer.h"
24 #include "ui/aura/client/activation_change_observer.h"
25 #include "ui/aura/layout_manager.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"
31 namespace aura {
32 class RootWindow;
35 namespace ui {
36 class GestureEvent;
37 class ImplicitAnimationObserver;
40 namespace ash {
41 class ScreenAsh;
42 class ShelfLayoutManagerObserver;
43 class ShelfWidget;
44 FORWARD_DECLARE_TEST(WebNotificationTrayTest, PopupAndFullscreen);
46 namespace internal {
48 class PanelLayoutManagerTest;
49 class ShelfBezelEventFilter;
50 class ShelfLayoutManagerTest;
51 class StatusAreaWidget;
52 class WorkspaceController;
54 // ShelfLayoutManager is the layout manager responsible for the launcher and
55 // status widgets. The launcher is given the total available width and told the
56 // width of the status area. This allows the launcher to draw the background and
57 // layout to the status area.
58 // To respond to bounds changes in the status area StatusAreaLayoutManager works
59 // closely with ShelfLayoutManager.
60 class ASH_EXPORT ShelfLayoutManager :
61 public aura::LayoutManager,
62 public ash::ShellObserver,
63 public aura::client::ActivationChangeObserver,
64 public DockedWindowLayoutManagerObserver,
65 public keyboard::KeyboardControllerObserver,
66 public LockStateObserver {
67 public:
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;
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;
77 // Size of the shelf when auto-hidden.
78 static const int kAutoHideSize;
80 // The size of the shelf when shown (currently only used in alternate
81 // settings see ash::switches::UseAlternateShelfLayout).
82 static const int kShelfSize;
84 // Inset between the inner edge of the shelf (towards centre of screen), and
85 // the launcher items, notifications, status area etc.
86 static const int kShelfItemInset;
88 // Returns the preferred size for the shelf (either kLauncherPreferredSize or
89 // kShelfSize).
90 static int GetPreferredShelfSize();
92 explicit ShelfLayoutManager(ShelfWidget* shelf);
93 virtual ~ShelfLayoutManager();
95 // Sets the ShelfAutoHideBehavior. See enum description for details.
96 void SetAutoHideBehavior(ShelfAutoHideBehavior behavior);
97 ShelfAutoHideBehavior auto_hide_behavior() const {
98 return auto_hide_behavior_;
101 // Sets the alignment. Returns true if the alignment is changed. Otherwise,
102 // returns false.
103 bool SetAlignment(ShelfAlignment alignment);
104 // Returns the desired alignment for the current state, either the user's
105 // set alignment (alignment_) or SHELF_ALIGNMENT_BOTTOM when the screen
106 // is locked.
107 ShelfAlignment GetAlignment() const;
109 void set_workspace_controller(WorkspaceController* controller) {
110 workspace_controller_ = controller;
113 bool updating_bounds() const { return updating_bounds_; }
115 // Clears internal data for shutdown process.
116 void PrepareForShutdown();
118 // Returns whether the shelf and its contents (launcher, status) are visible
119 // on the screen.
120 bool IsVisible() const;
122 // Returns the ideal bounds of the shelf assuming it is visible.
123 gfx::Rect GetIdealBounds();
125 // Stops any animations and sets the bounds of the launcher and status
126 // widgets.
127 void LayoutShelf();
129 // Returns shelf visibility state based on current value of auto hide
130 // behavior setting.
131 ShelfVisibilityState CalculateShelfVisibility();
133 // Updates the visibility state.
134 void UpdateVisibilityState();
136 // Invoked by the shelf/launcher when the auto-hide state may have changed.
137 void UpdateAutoHideState();
139 ShelfVisibilityState visibility_state() const {
140 return state_.visibility_state;
142 ShelfAutoHideState auto_hide_state() const { return state_.auto_hide_state; }
144 ShelfWidget* shelf_widget() { return shelf_; }
146 // Sets whether any windows overlap the shelf. If a window overlaps the shelf
147 // the shelf renders slightly differently.
148 void SetWindowOverlapsShelf(bool value);
149 bool window_overlaps_shelf() const { return window_overlaps_shelf_; }
151 void AddObserver(ShelfLayoutManagerObserver* observer);
152 void RemoveObserver(ShelfLayoutManagerObserver* observer);
154 // Gesture dragging related functions:
155 void StartGestureDrag(const ui::GestureEvent& gesture);
156 enum DragState {
157 DRAG_SHELF,
158 DRAG_TRAY
160 // Returns DRAG_SHELF if the gesture should continue to drag the entire shelf.
161 // Returns DRAG_TRAY if the gesture can start dragging the tray-bubble from
162 // this point on.
163 DragState UpdateGestureDrag(const ui::GestureEvent& gesture);
164 void CompleteGestureDrag(const ui::GestureEvent& gesture);
165 void CancelGestureDrag();
167 // Overridden from aura::LayoutManager:
168 virtual void OnWindowResized() OVERRIDE;
169 virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE;
170 virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE;
171 virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE;
172 virtual void OnChildWindowVisibilityChanged(aura::Window* child,
173 bool visible) OVERRIDE;
174 virtual void SetChildBounds(aura::Window* child,
175 const gfx::Rect& requested_bounds) OVERRIDE;
177 // Overridden from ash::ShellObserver:
178 virtual void OnLockStateChanged(bool locked) OVERRIDE;
180 // Overriden from aura::client::ActivationChangeObserver:
181 virtual void OnWindowActivated(aura::Window* gained_active,
182 aura::Window* lost_active) OVERRIDE;
184 // Overridden from ash::LockStateObserver:
185 virtual void OnLockStateEvent(LockStateObserver::EventType event) OVERRIDE;
187 // TODO(harrym|oshima): These templates will be moved to
188 // new Shelf class.
189 // A helper function that provides a shortcut for choosing
190 // values specific to a shelf alignment.
191 template<typename T>
192 T SelectValueForShelfAlignment(T bottom, T left, T right, T top) const {
193 switch (GetAlignment()) {
194 case SHELF_ALIGNMENT_BOTTOM:
195 return bottom;
196 case SHELF_ALIGNMENT_LEFT:
197 return left;
198 case SHELF_ALIGNMENT_RIGHT:
199 return right;
200 case SHELF_ALIGNMENT_TOP:
201 return top;
203 NOTREACHED();
204 return right;
207 template<typename T>
208 T PrimaryAxisValue(T horizontal, T vertical) const {
209 return IsHorizontalAlignment() ? horizontal : vertical;
212 // Is the shelf's alignment horizontal?
213 bool IsHorizontalAlignment() const;
215 // Tests if the browser is currently in fullscreen mode with minimal
216 // Chrome. When minimal Chrome is present the shelf should be displayed.
217 bool FullscreenWithMinimalChrome() const;
219 // Returns a ShelfLayoutManager on the display which has a launcher for
220 // given |window|. See RootWindowController::ForLauncher for more info.
221 static ShelfLayoutManager* ForLauncher(aura::Window* window);
223 private:
224 class AutoHideEventFilter;
225 class UpdateShelfObserver;
226 friend class ash::ScreenAsh;
227 friend class PanelLayoutManagerTest;
228 friend class ShelfLayoutManagerTest;
229 FRIEND_TEST_ALL_PREFIXES(ash::WebNotificationTrayTest, PopupAndFullscreen);
231 struct TargetBounds {
232 TargetBounds();
233 ~TargetBounds();
235 float opacity;
236 float status_opacity;
237 gfx::Rect shelf_bounds_in_root;
238 gfx::Rect launcher_bounds_in_shelf;
239 gfx::Rect status_bounds_in_shelf;
240 gfx::Insets work_area_insets;
243 struct State {
244 State() : visibility_state(SHELF_VISIBLE),
245 auto_hide_state(SHELF_AUTO_HIDE_HIDDEN),
246 window_state(WORKSPACE_WINDOW_STATE_DEFAULT),
247 is_screen_locked(false) {}
249 // Returns true if the two states are considered equal. As
250 // |auto_hide_state| only matters if |visibility_state| is
251 // |SHELF_AUTO_HIDE|, Equals() ignores the |auto_hide_state| as
252 // appropriate.
253 bool Equals(const State& other) const {
254 return other.visibility_state == visibility_state &&
255 (visibility_state != SHELF_AUTO_HIDE ||
256 other.auto_hide_state == auto_hide_state) &&
257 other.window_state == window_state &&
258 other.is_screen_locked == is_screen_locked;
261 ShelfVisibilityState visibility_state;
262 ShelfAutoHideState auto_hide_state;
263 WorkspaceWindowState window_state;
264 bool is_screen_locked;
267 // Sets the visibility of the shelf to |state|.
268 void SetState(ShelfVisibilityState visibility_state);
270 // Updates the bounds and opacity of the launcher and status widgets.
271 // If |observer| is specified, it will be called back when the animations, if
272 // any, are complete.
273 void UpdateBoundsAndOpacity(const TargetBounds& target_bounds,
274 bool animate,
275 ui::ImplicitAnimationObserver* observer);
277 // Stops any animations and progresses them to the end.
278 void StopAnimating();
280 // Returns the width (if aligned to the side) or height (if aligned to the
281 // bottom).
282 void GetShelfSize(int* width, int* height);
284 // Insets |bounds| by |inset| on the edge the shelf is aligned to.
285 void AdjustBoundsBasedOnAlignment(int inset, gfx::Rect* bounds) const;
287 // Calculates the target bounds assuming visibility of |visible|.
288 void CalculateTargetBounds(const State& state, TargetBounds* target_bounds);
290 // Updates the target bounds if a gesture-drag is in progress. This is only
291 // used by |CalculateTargetBounds()|.
292 void UpdateTargetBoundsForGesture(TargetBounds* target_bounds) const;
294 // Updates the background of the shelf.
295 void UpdateShelfBackground(BackgroundAnimator::ChangeType type);
297 // Returns how the shelf background is painted.
298 ShelfBackgroundType GetShelfBackgroundType() const;
300 // Updates the auto hide state immediately.
301 void UpdateAutoHideStateNow();
303 // Stops the auto hide timer and clears
304 // |mouse_over_shelf_when_auto_hide_timer_started_|.
305 void StopAutoHideTimer();
307 // Returns the bounds of an additional region which can trigger showing the
308 // shelf. This region exists to make it easier to trigger showing the shelf
309 // when the shelf is auto hidden and the shelf is on the boundary between
310 // two displays.
311 gfx::Rect GetAutoHideShowShelfRegionInScreen() const;
313 // Returns the AutoHideState. This value is determined from the launcher and
314 // tray.
315 ShelfAutoHideState CalculateAutoHideState(
316 ShelfVisibilityState visibility_state) const;
318 // Updates the hit test bounds override for launcher and status area.
319 void UpdateHitTestBounds();
321 // Returns true if |window| is a descendant of the shelf.
322 bool IsShelfWindow(aura::Window* window);
324 int GetWorkAreaSize(const State& state, int size) const;
326 // Return the bounds available in the parent, taking into account the bounds
327 // of the keyboard if necessary.
328 gfx::Rect GetAvailableBounds() const;
330 // Overridden from keyboard::KeyboardControllerObserver:
331 virtual void OnKeyboardBoundsChanging(
332 const gfx::Rect& keyboard_bounds) OVERRIDE;
334 // Overridden from dock::DockObserver:
335 virtual void OnDockBoundsChanging(const gfx::Rect& dock_bounds) OVERRIDE;
337 // Generates insets for inward edge based on the current shelf alignment.
338 gfx::Insets GetInsetsForAlignment(int distance) const;
340 // The RootWindow is cached so that we don't invoke Shell::GetInstance() from
341 // our destructor. We avoid that as at the time we're deleted Shell is being
342 // deleted too.
343 aura::RootWindow* root_window_;
345 // True when inside UpdateBoundsAndOpacity() method. Used to prevent calling
346 // UpdateBoundsAndOpacity() again from SetChildBounds().
347 bool updating_bounds_;
349 // See description above setter.
350 ShelfAutoHideBehavior auto_hide_behavior_;
352 // See description above getter.
353 ShelfAlignment alignment_;
355 // Current state.
356 State state_;
358 ShelfWidget* shelf_;
360 WorkspaceController* workspace_controller_;
362 // Do any windows overlap the shelf? This is maintained by WorkspaceManager.
363 bool window_overlaps_shelf_;
365 base::OneShotTimer<ShelfLayoutManager> auto_hide_timer_;
367 // Whether the mouse was over the shelf when the auto hide timer started.
368 // False when neither the auto hide timer nor the timer task are running.
369 bool mouse_over_shelf_when_auto_hide_timer_started_;
371 // EventFilter used to detect when user moves the mouse over the launcher to
372 // trigger showing the launcher.
373 scoped_ptr<AutoHideEventFilter> auto_hide_event_filter_;
375 // EventFilter used to detect when user issues a gesture on a bezel sensor.
376 scoped_ptr<ShelfBezelEventFilter> bezel_event_filter_;
378 ObserverList<ShelfLayoutManagerObserver> observers_;
380 // The shelf reacts to gesture-drags, and can be set to auto-hide for certain
381 // gestures. Some shelf behaviour (e.g. visibility state, background color
382 // etc.) are affected by various stages of the drag. The enum keeps track of
383 // the present status of the gesture drag.
384 enum GestureDragStatus {
385 GESTURE_DRAG_NONE,
386 GESTURE_DRAG_IN_PROGRESS,
387 GESTURE_DRAG_CANCEL_IN_PROGRESS,
388 GESTURE_DRAG_COMPLETE_IN_PROGRESS
390 GestureDragStatus gesture_drag_status_;
392 // Tracks the amount of the drag. The value is only valid when
393 // |gesture_drag_status_| is set to GESTURE_DRAG_IN_PROGRESS.
394 float gesture_drag_amount_;
396 // Manage the auto-hide state during the gesture.
397 ShelfAutoHideState gesture_drag_auto_hide_state_;
399 // Used to delay updating shelf background.
400 UpdateShelfObserver* update_shelf_observer_;
402 // The bounds of the keyboard.
403 gfx::Rect keyboard_bounds_;
405 // The bounds of the dock.
406 gfx::Rect dock_bounds_;
408 DISALLOW_COPY_AND_ASSIGN(ShelfLayoutManager);
411 } // namespace internal
412 } // namespace ash
414 #endif // ASH_SHELF_SHELF_LAYOUT_MANAGER_H_