immersive_mode_controller_ash.h revision d0247b1b59f9c528cb6df88b4f2b9afaf80d181e 
1// Copyright 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_VIEWS_FRAME_IMMERSIVE_MODE_CONTROLLER_ASH_H_
6#define CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_MODE_CONTROLLER_ASH_H_
7
8#include "chrome/browser/ui/views/frame/immersive_mode_controller.h"
9
10#include "base/timer/timer.h"
11#include "content/public/browser/notification_observer.h"
12#include "content/public/browser/notification_registrar.h"
13#include "ui/aura/window_observer.h"
14#include "ui/events/event_handler.h"
15#include "ui/gfx/animation/animation_delegate.h"
16#include "ui/gfx/rect.h"
17#include "ui/views/focus/focus_manager.h"
18#include "ui/views/widget/widget_observer.h"
19
20class BrowserView;
21class BookmarkBarView;
22
23namespace aura {
24class Window;
25}
26
27namespace gfx {
28class SlideAnimation;
29class Transform;
30}
31
32namespace ui {
33class Layer;
34class LocatedEvent;
35}
36
37namespace views {
38class View;
39}
40
41class ImmersiveModeControllerAsh : public ImmersiveModeController,
42                                   public content::NotificationObserver,
43                                   public gfx::AnimationDelegate,
44                                   public ui::EventHandler,
45                                   public views::FocusChangeListener,
46                                   public views::WidgetObserver,
47                                   public aura::WindowObserver {
48 public:
49  ImmersiveModeControllerAsh();
50  virtual ~ImmersiveModeControllerAsh();
51
52  // These methods are used to increment and decrement |revealed_lock_count_|.
53  // If immersive mode is enabled, a transition from 1 to 0 in
54  // |revealed_lock_count_| closes the top-of-window views and a transition
55  // from 0 to 1 in |revealed_lock_count_| reveals the top-of-window views.
56  void LockRevealedState(AnimateReveal animate_reveal);
57  void UnlockRevealedState();
58
59  // Exits immersive fullscreen based on |native_window_|'s show state.
60  void MaybeExitImmersiveFullscreen();
61
62  // ImmersiveModeController overrides:
63  virtual void Init(Delegate* delegate,
64                    views::Widget* widget,
65                    views::View* top_container) OVERRIDE;
66  virtual void SetEnabled(bool enabled) OVERRIDE;
67  virtual bool IsEnabled() const OVERRIDE;
68  virtual bool ShouldHideTabIndicators() const OVERRIDE;
69  virtual bool ShouldHideTopViews() const OVERRIDE;
70  virtual bool IsRevealed() const OVERRIDE;
71  virtual int GetTopContainerVerticalOffset(
72      const gfx::Size& top_container_size) const OVERRIDE;
73  virtual ImmersiveRevealedLock* GetRevealedLock(
74      AnimateReveal animate_reveal) OVERRIDE WARN_UNUSED_RESULT;
75  virtual void OnFindBarVisibleBoundsChanged(
76      const gfx::Rect& new_visible_bounds_in_screen) OVERRIDE;
77
78  // content::NotificationObserver override:
79  virtual void Observe(int type,
80                       const content::NotificationSource& source,
81                       const content::NotificationDetails& details) OVERRIDE;
82
83  // ui::EventHandler overrides:
84  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
85  virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
86  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
87
88  // views::FocusChangeObserver overrides:
89  virtual void OnWillChangeFocus(views::View* focused_before,
90                                 views::View* focused_now) OVERRIDE;
91  virtual void OnDidChangeFocus(views::View* focused_before,
92                                views::View* focused_now) OVERRIDE;
93
94  // views::WidgetObserver overrides:
95  virtual void OnWidgetDestroying(views::Widget* widget) OVERRIDE;
96  virtual void OnWidgetActivationChanged(views::Widget* widget,
97                                         bool active) OVERRIDE;
98
99  // gfx::AnimationDelegate overrides:
100  virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE;
101  virtual void AnimationProgressed(const gfx::Animation* animation) OVERRIDE;
102
103  // aura::WindowObserver overrides:
104  virtual void OnWindowPropertyChanged(aura::Window* window,
105                                       const void* key,
106                                       intptr_t old) OVERRIDE;
107  virtual void OnAddTransientChild(aura::Window* window,
108                                   aura::Window* transient) OVERRIDE;
109  virtual void OnRemoveTransientChild(aura::Window* window,
110                                      aura::Window* transient) OVERRIDE;
111
112  // Testing interface.
113  void SetForceHideTabIndicatorsForTest(bool force);
114  void StartRevealForTest(bool hovered);
115  void SetMouseHoveredForTest(bool hovered);
116  void DisableAnimationsForTest();
117
118 private:
119  friend class ImmersiveModeControllerAshTest;
120
121  enum AllowRevealWhileClosing {
122    ALLOW_REVEAL_WHILE_CLOSING_YES,
123    ALLOW_REVEAL_WHILE_CLOSING_NO
124  };
125  enum Animate {
126    ANIMATE_NO,
127    ANIMATE_SLOW,
128    ANIMATE_FAST,
129  };
130  enum Layout {
131    LAYOUT_YES,
132    LAYOUT_NO
133  };
134  enum RevealState {
135    CLOSED,          // Top container only showing tabstrip, y = 0.
136    SLIDING_OPEN,    // All views showing, y animating from -height to 0.
137    REVEALED,        // All views showing, y = 0.
138    SLIDING_CLOSED,  // All views showing, y animating from 0 to -height.
139  };
140  enum TabIndicatorVisibility {
141    TAB_INDICATORS_FORCE_HIDE,
142    TAB_INDICATORS_HIDE,
143    TAB_INDICATORS_SHOW
144  };
145  enum SwipeType {
146    SWIPE_OPEN,
147    SWIPE_CLOSE,
148    SWIPE_NONE
149  };
150
151  // Enables or disables observers for mouse move, focus, and window restore.
152  void EnableWindowObservers(bool enable);
153
154  // Updates |top_edge_hover_timer_| based on a mouse |event|. If the mouse is
155  // hovered at the top of the screen the timer is started. If the mouse moves
156  // away from the top edge, or moves too much in the x direction, the timer is
157  // stopped.
158  void UpdateTopEdgeHoverTimer(ui::MouseEvent* event);
159
160  // Updates |located_event_revealed_lock_| based on the current mouse state and
161  // the current touch state.
162  // |event| is NULL if the source event is not known.
163  // |allow_reveal_while_closing| indicates whether the mouse and touch
164  // are allowed to initiate a reveal while the top-of-window views are sliding
165  // closed.
166  void UpdateLocatedEventRevealedLock(
167      ui::LocatedEvent* event,
168      AllowRevealWhileClosing allow_reveal_while_closing);
169
170  // Acquires |located_event_revealed_lock_| if it is not already held.
171  void AcquireLocatedEventRevealedLock();
172
173  // Updates |focus_revealed_lock_| based on the currently active view and the
174  // currently active widget.
175  void UpdateFocusRevealedLock();
176
177  // Update |located_event_revealed_lock_| and |focus_revealed_lock_| as a
178  // result of a gesture of |swipe_type|. Returns true if any locks were
179  // acquired or released.
180  bool UpdateRevealedLocksForSwipe(SwipeType swipe_type);
181
182  // Updates whether fullscreen uses any chrome at all. When using minimal
183  // chrome, a 'light bar' is permanently visible for the launcher and possibly
184  // for the tabstrip.
185  void UpdateUseMinimalChrome(Layout layout);
186
187  // Returns the animation duration given |animate|.
188  int GetAnimationDuration(Animate animate) const;
189
190  // Temporarily reveals the top-of-window views while in immersive mode,
191  // hiding them when the cursor exits the area of the top views. If |animate|
192  // is not ANIMATE_NO, slides in the view, otherwise shows it immediately.
193  void MaybeStartReveal(Animate animate);
194
195  // Enables or disables layer-based painting to allow smooth animations.
196  void EnablePaintToLayer(bool enable);
197
198  // Updates the browser root view's layout including window caption controls.
199  void LayoutBrowserRootView();
200
201  // Called when the animation to slide open the top-of-window views has
202  // completed.
203  void OnSlideOpenAnimationCompleted(Layout layout);
204
205  // Hides the top-of-window views if immersive mode is enabled and nothing is
206  // keeping them revealed. Optionally animates.
207  void MaybeEndReveal(Animate animate);
208
209  // Called when the animation to slide out the top-of-window views has
210  // completed.
211  void OnSlideClosedAnimationCompleted();
212
213  // Returns whether immersive fullscreen should be exited based on
214  // |native_window_|'s show state. This handles cases where the user has
215  // exited immersive fullscreen without going through
216  // FullscreenController::ToggleFullscreenMode(). This is the case if the
217  // user exits fullscreen via the restore button.
218  bool ShouldExitImmersiveFullscreen() const;
219
220  // Returns the type of swipe given |event|.
221  SwipeType GetSwipeType(ui::GestureEvent* event) const;
222
223  // Returns true if a mouse event at |location_in_screen| should be ignored.
224  // Ignored mouse events should not contribute to revealing or unrevealing the
225  // top-of-window views.
226  bool ShouldIgnoreMouseEventAtLocation(
227      const gfx::Point& location_in_screen) const;
228
229  // True when |location| is "near" to the top container. When the top container
230  // is not closed "near" means within the displayed bounds or above it. When
231  // the top container is closed "near" means either within the displayed
232  // bounds, above it, or within a few pixels below it. This allow the container
233  // to steal enough pixels to detect a swipe in and handles the case that there
234  // is a bezel sensor above the top container.
235  bool ShouldHandleGestureEvent(const gfx::Point& location) const;
236
237  // Recreate |bubble_manager_| and start observing any bubbles anchored to a
238  // child of |top_container_|.
239  void RecreateBubbleManager();
240
241  // Shrinks or expands the touch hit test by updating insets for the render
242  // window depending on if top_inset is positive or negative respectively.
243  // Used to ensure that touch events at the top of the screen go to the top
244  // container so a slide gesture can be generated when the content window is
245  // consuming all touch events sent to it.
246  void SetRenderWindowTopInsetsForTouch(int top_inset);
247
248  // Injected dependencies. Not owned.
249  Delegate* delegate_;
250  views::Widget* widget_;
251  views::View* top_container_;
252
253  // True if the window observers are enabled.
254  bool observers_enabled_;
255
256  // True when in immersive mode.
257  bool enabled_;
258
259  // State machine for the revealed/closed animations.
260  RevealState reveal_state_;
261
262  int revealed_lock_count_;
263
264  // The visibility of the miniature "tab indicators" in the main browser view
265  // when immersive mode is enabled and the top-of-window views are closed.
266  TabIndicatorVisibility tab_indicator_visibility_;
267
268  // Timer to track cursor being held at the top edge of the screen.
269  base::OneShotTimer<ImmersiveModeController> top_edge_hover_timer_;
270
271  // The cursor x position in screen coordinates when the cursor first hit the
272  // top edge of the screen.
273  int mouse_x_when_hit_top_in_screen_;
274
275  // Tracks if the controller has seen a ET_GESTURE_SCROLL_BEGIN, without the
276  // following events.
277  bool gesture_begun_;
278
279  // The current visible bounds of the find bar, in screen coordinates. This is
280  // an empty rect if the find bar is not visible.
281  gfx::Rect find_bar_visible_bounds_in_screen_;
282
283  // Lock which keeps the top-of-window views revealed based on the current
284  // mouse state and the current touch state. Acquiring the lock is used to
285  // trigger a reveal when the user moves the mouse to the top of the screen
286  // and when the user does a SWIPE_OPEN edge gesture.
287  scoped_ptr<ImmersiveRevealedLock> located_event_revealed_lock_;
288
289  // Lock which keeps the top-of-window views revealed based on the focused view
290  // and the active widget. Acquiring the lock never triggers a reveal because
291  // a view is not focusable till a reveal has made it visible.
292  scoped_ptr<ImmersiveRevealedLock> focus_revealed_lock_;
293
294  // Native window for the browser.
295  aura::Window* native_window_;
296
297  // The animation which controls sliding the top-of-window views in and out.
298  scoped_ptr<gfx::SlideAnimation> animation_;
299
300  // Whether the animations are disabled for testing.
301  bool animations_disabled_for_test_;
302
303  // Manages bubbles which are anchored to a child of |top_container_|.
304  class BubbleManager;
305  scoped_ptr<BubbleManager> bubble_manager_;
306
307  content::NotificationRegistrar registrar_;
308
309  base::WeakPtrFactory<ImmersiveModeControllerAsh> weak_ptr_factory_;
310
311  DISALLOW_COPY_AND_ASSIGN(ImmersiveModeControllerAsh);
312};
313
314#endif  // CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_MODE_CONTROLLER_ASH_H_
315