src/ash/wm/immersive_fullscreen_controller.h

   1 // Copyright 2013 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_WM_IMMERSIVE_FULLSCREEN_CONTROLLER_H_
   6 #define ASH_WM_IMMERSIVE_FULLSCREEN_CONTROLLER_H_
   7
   8 #include <vector>
   9
  10 #include "ash/ash_export.h"
  11 #include "ash/wm/immersive_revealed_lock.h"
  12 #include "base/timer/timer.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/views/focus/focus_manager.h"
  17 #include "ui/views/widget/widget_observer.h"
  18 #include "ui/wm/core/transient_window_observer.h"
  19
  20 namespace aura {
  21 class Window;
  22 }
  23
  24 namespace gfx {
  25 class Point;
  26 class Rect;
  27 class SlideAnimation;
  28 }
  29
  30 namespace ui {
  31 class LocatedEvent;
  32 }
  33
  34 namespace views {
  35 class View;
  36 class Widget;
  37 }
  38
  39 namespace ash {
  40
  41 class ASH_EXPORT ImmersiveFullscreenController
  42     : public gfx::AnimationDelegate,
  43       public ui::EventHandler,
  44       public ::wm::TransientWindowObserver,
  45       public views::FocusChangeListener,
  46       public views::WidgetObserver,
  47       public ImmersiveRevealedLock::Delegate {
  48  public:
  49   static const int kMouseRevealBoundsHeight;
  50
  51   // The enum is used for an enumerated histogram. New items should be only
  52   // added to the end.
  53   enum WindowType {
  54     WINDOW_TYPE_OTHER,
  55     WINDOW_TYPE_BROWSER,
  56     WINDOW_TYPE_HOSTED_APP,
  57     WINDOW_TYPE_PACKAGED_APP,
  58     WINDOW_TYPE_COUNT
  59   };
  60
  61   class Delegate {
  62    public:
  63     // Called when a reveal of the top-of-window views starts.
  64     virtual void OnImmersiveRevealStarted() = 0;
  65
  66     // Called when the top-of-window views have finished closing. This call
  67     // implies a visible fraction of 0. SetVisibleFraction(0) may not be called
  68     // prior to OnImmersiveRevealEnded().
  69     virtual void OnImmersiveRevealEnded() = 0;
  70
  71     // Called as a result of disabling immersive fullscreen via SetEnabled().
  72     virtual void OnImmersiveFullscreenExited() = 0;
  73
  74     // Called to update the fraction of the top-of-window views height which is
  75     // visible.
  76     virtual void SetVisibleFraction(double visible_fraction) = 0;
  77
  78     // Returns a list of rects whose union makes up the top-of-window views.
  79     // The returned list is used for hittesting when the top-of-window views
  80     // are revealed. GetVisibleBoundsInScreen() must return a valid value when
  81     // not in immersive fullscreen for the sake of SetupForTest().
  82     virtual std::vector<gfx::Rect> GetVisibleBoundsInScreen() const = 0;
  83
  84    protected:
  85     virtual ~Delegate() {}
  86   };
  87
  88   ImmersiveFullscreenController();
  89   virtual ~ImmersiveFullscreenController();
  90
  91   // Initializes the controller. Must be called prior to enabling immersive
  92   // fullscreen via SetEnabled(). |top_container| is used to keep the
  93   // top-of-window views revealed when a child of |top_container| has focus.
  94   // |top_container| does not affect which mouse and touch events keep the
  95   // top-of-window views revealed.
  96   void Init(Delegate* delegate,
  97             views::Widget* widget,
  98             views::View* top_container);
  99
 100   // Enables or disables immersive fullscreen.
 101   // |window_type| is the type of window which is put in immersive fullscreen.
 102   // It is only used for histogramming.
 103   void SetEnabled(WindowType window_type, bool enable);
 104
 105   // Returns true if |native_window_| is in immersive fullscreen.
 106   bool IsEnabled() const;
 107
 108   // Returns true if |native_window_| is in immersive fullscreen and the
 109   // top-of-window views are fully or partially visible.
 110   bool IsRevealed() const;
 111
 112   // Returns a lock which will keep the top-of-window views revealed for its
 113   // lifetime. Several locks can be obtained. When all of the locks are
 114   // destroyed, if immersive fullscreen is enabled and there is nothing else
 115   // keeping the top-of-window views revealed, the top-of-window views will be
 116   // closed. This method always returns a valid lock regardless of whether
 117   // immersive fullscreen is enabled. The lock's lifetime can span immersive
 118   // fullscreen being enabled / disabled. If acquiring the lock causes a reveal,
 119   // the top-of-window views will animate according to |animate_reveal|. The
 120   // caller takes ownership of the returned lock.
 121   ImmersiveRevealedLock* GetRevealedLock(
 122       AnimateReveal animate_reveal) WARN_UNUSED_RESULT;
 123
 124   // Disables animations and moves the mouse so that it is not over the
 125   // top-of-window views for the sake of testing.
 126   void SetupForTest();
 127
 128   // ui::EventHandler overrides:
 129   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 130   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
 131   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 132
 133   // views::FocusChangeObserver overrides:
 134   virtual void OnWillChangeFocus(views::View* focused_before,
 135                                  views::View* focused_now) OVERRIDE;
 136   virtual void OnDidChangeFocus(views::View* focused_before,
 137                                 views::View* focused_now) OVERRIDE;
 138
 139   // views::WidgetObserver overrides:
 140   virtual void OnWidgetDestroying(views::Widget* widget) OVERRIDE;
 141   virtual void OnWidgetActivationChanged(views::Widget* widget,
 142                                          bool active) OVERRIDE;
 143
 144   // gfx::AnimationDelegate overrides:
 145   virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE;
 146   virtual void AnimationProgressed(const gfx::Animation* animation) OVERRIDE;
 147
 148   // ::wm::TransientWindowObserver overrides:
 149   virtual void OnTransientChildAdded(aura::Window* window,
 150                                      aura::Window* transient) OVERRIDE;
 151   virtual void OnTransientChildRemoved(aura::Window* window,
 152                                        aura::Window* transient) OVERRIDE;
 153
 154   // ash::ImmersiveRevealedLock::Delegate overrides:
 155   virtual void LockRevealedState(AnimateReveal animate_reveal) OVERRIDE;
 156   virtual void UnlockRevealedState() OVERRIDE;
 157
 158  private:
 159   friend class ImmersiveFullscreenControllerTest;
 160
 161   enum Animate {
 162     ANIMATE_NO,
 163     ANIMATE_SLOW,
 164     ANIMATE_FAST,
 165   };
 166   enum RevealState {
 167     CLOSED,
 168     SLIDING_OPEN,
 169     REVEALED,
 170     SLIDING_CLOSED,
 171   };
 172   enum SwipeType {
 173     SWIPE_OPEN,
 174     SWIPE_CLOSE,
 175     SWIPE_NONE
 176   };
 177
 178   // Enables or disables observers for mouse, touch, focus, and activation.
 179   void EnableWindowObservers(bool enable);
 180
 181   // Updates |top_edge_hover_timer_| based on a mouse |event|. If the mouse is
 182   // hovered at the top of the screen the timer is started. If the mouse moves
 183   // away from the top edge, or moves too much in the x direction, the timer is
 184   // stopped.
 185   void UpdateTopEdgeHoverTimer(ui::MouseEvent* event);
 186
 187   // Updates |located_event_revealed_lock_| based on the current mouse state and
 188   // the current touch state.
 189   // |event| is NULL if the source event is not known.
 190   void UpdateLocatedEventRevealedLock(ui::LocatedEvent* event);
 191
 192   // Acquires |located_event_revealed_lock_| if it is not already held.
 193   void AcquireLocatedEventRevealedLock();
 194
 195   // Updates |focus_revealed_lock_| based on the currently active view and the
 196   // currently active widget.
 197   void UpdateFocusRevealedLock();
 198
 199   // Update |located_event_revealed_lock_| and |focus_revealed_lock_| as a
 200   // result of a gesture of |swipe_type|. Returns true if any locks were
 201   // acquired or released.
 202   bool UpdateRevealedLocksForSwipe(SwipeType swipe_type);
 203
 204   // Returns the animation duration given |animate|.
 205   int GetAnimationDuration(Animate animate) const;
 206
 207   // Temporarily reveals the top-of-window views while in immersive mode,
 208   // hiding them when the cursor exits the area of the top views. If |animate|
 209   // is not ANIMATE_NO, slides in the view, otherwise shows it immediately.
 210   void MaybeStartReveal(Animate animate);
 211
 212   // Called when the animation to slide open the top-of-window views has
 213   // completed.
 214   void OnSlideOpenAnimationCompleted();
 215
 216   // Hides the top-of-window views if immersive mode is enabled and nothing is
 217   // keeping them revealed. Optionally animates.
 218   void MaybeEndReveal(Animate animate);
 219
 220   // Called when the animation to slide out the top-of-window views has
 221   // completed.
 222   void OnSlideClosedAnimationCompleted();
 223
 224   // Returns the type of swipe given |event|.
 225   SwipeType GetSwipeType(ui::GestureEvent* event) const;
 226
 227   // Returns true if a mouse event at |location_in_screen| should be ignored.
 228   // Ignored mouse events should not contribute to revealing or unrevealing the
 229   // top-of-window views.
 230   bool ShouldIgnoreMouseEventAtLocation(
 231       const gfx::Point& location_in_screen) const;
 232
 233   // True when |location| is "near" to the top container. When the top container
 234   // is not closed "near" means within the displayed bounds or above it. When
 235   // the top container is closed "near" means either within the displayed
 236   // bounds, above it, or within a few pixels below it. This allow the container
 237   // to steal enough pixels to detect a swipe in and handles the case that there
 238   // is a bezel sensor above the top container.
 239   bool ShouldHandleGestureEvent(const gfx::Point& location) const;
 240
 241   // Recreate |bubble_manager_| and start observing any bubbles anchored to a
 242   // child of |top_container_|.
 243   void RecreateBubbleManager();
 244
 245   // Not owned.
 246   Delegate* delegate_;
 247   views::View* top_container_;
 248   views::Widget* widget_;
 249   aura::Window* native_window_;
 250
 251   // True if the observers have been enabled.
 252   bool observers_enabled_;
 253
 254   // True when in immersive fullscreen.
 255   bool enabled_;
 256
 257   // State machine for the revealed/closed animations.
 258   RevealState reveal_state_;
 259
 260   int revealed_lock_count_;
 261
 262   // Timer to track cursor being held at the top edge of the screen.
 263   base::OneShotTimer<ImmersiveFullscreenController> top_edge_hover_timer_;
 264
 265   // The cursor x position in screen coordinates when the cursor first hit the
 266   // top edge of the screen.
 267   int mouse_x_when_hit_top_in_screen_;
 268
 269   // Tracks if the controller has seen a ET_GESTURE_SCROLL_BEGIN, without the
 270   // following events.
 271   bool gesture_begun_;
 272
 273   // Lock which keeps the top-of-window views revealed based on the current
 274   // mouse state and the current touch state. Acquiring the lock is used to
 275   // trigger a reveal when the user moves the mouse to the top of the screen
 276   // and when the user does a SWIPE_OPEN edge gesture.
 277   scoped_ptr<ImmersiveRevealedLock> located_event_revealed_lock_;
 278
 279   // Lock which keeps the top-of-window views revealed based on the focused view
 280   // and the active widget. Acquiring the lock never triggers a reveal because
 281   // a view is not focusable till a reveal has made it visible.
 282   scoped_ptr<ImmersiveRevealedLock> focus_revealed_lock_;
 283
 284   // The animation which controls sliding the top-of-window views in and out.
 285   scoped_ptr<gfx::SlideAnimation> animation_;
 286
 287   // Whether the animations are disabled for testing.
 288   bool animations_disabled_for_test_;
 289
 290   // Manages bubbles which are anchored to a child of |top_container_|.
 291   class BubbleManager;
 292   scoped_ptr<BubbleManager> bubble_manager_;
 293
 294   base::WeakPtrFactory<ImmersiveFullscreenController> weak_ptr_factory_;
 295
 296   DISALLOW_COPY_AND_ASSIGN(ImmersiveFullscreenController);
 297 };
 298
 299 }  // namespace ash
 300
 301 #endif  // ASH_WM_IMMERSIVE_FULLSCREEN_CONTROLLER_H_