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.
5 #include "ash/wm/immersive_fullscreen_controller.h"
9 #include "ash/ash_constants.h"
10 #include "ash/shell.h"
11 #include "ash/wm/resize_handle_window_targeter.h"
12 #include "ash/wm/window_state.h"
13 #include "base/metrics/histogram.h"
14 #include "ui/aura/client/aura_constants.h"
15 #include "ui/aura/client/capture_client.h"
16 #include "ui/aura/client/cursor_client.h"
17 #include "ui/aura/client/screen_position_client.h"
18 #include "ui/aura/env.h"
19 #include "ui/aura/window.h"
20 #include "ui/aura/window_event_dispatcher.h"
21 #include "ui/gfx/animation/slide_animation.h"
22 #include "ui/gfx/display.h"
23 #include "ui/gfx/point.h"
24 #include "ui/gfx/rect.h"
25 #include "ui/gfx/screen.h"
26 #include "ui/views/bubble/bubble_delegate.h"
27 #include "ui/views/view.h"
28 #include "ui/views/widget/widget.h"
29 #include "ui/wm/core/transient_window_manager.h"
30 #include "ui/wm/core/window_util.h"
31 #include "ui/wm/public/activation_client.h"
39 // Duration for the reveal show/hide slide animation. The slower duration is
40 // used for the initial slide out to give the user more change to see what
42 const int kRevealSlowAnimationDurationMs = 400;
43 const int kRevealFastAnimationDurationMs = 200;
45 // The delay in milliseconds between the mouse stopping at the top edge of the
46 // screen and the top-of-window views revealing.
47 const int kMouseRevealDelayMs = 200;
49 // The maximum amount of pixels that the cursor can move for the cursor to be
50 // considered "stopped". This allows the user to reveal the top-of-window views
51 // without holding the cursor completely still.
52 const int kMouseRevealXThresholdPixels = 3;
54 // Used to multiply x value of an update in check to determine if gesture is
55 // vertical. This is used to make sure that gesture is close to vertical instead
56 // of just more vertical then horizontal.
57 const int kSwipeVerticalThresholdMultiplier = 3;
59 // The height in pixels of the region above the top edge of the display which
60 // hosts the immersive fullscreen window in which mouse events are ignored
61 // (cannot reveal or unreveal the top-of-window views).
62 // See ShouldIgnoreMouseEventAtLocation() for more details.
63 const int kHeightOfDeadRegionAboveTopContainer = 10;
65 // Returns the BubbleDelegateView corresponding to |maybe_bubble| if
66 // |maybe_bubble| is a bubble.
67 views::BubbleDelegateView* AsBubbleDelegate(aura::Window* maybe_bubble) {
70 views::Widget* widget = views::Widget::GetWidgetForNativeView(maybe_bubble);
73 return widget->widget_delegate()->AsBubbleDelegate();
76 // Returns true if |maybe_transient| is a transient child of |toplevel|.
77 bool IsWindowTransientChildOf(aura::Window* maybe_transient,
78 aura::Window* toplevel) {
79 if (!maybe_transient || !toplevel)
82 for (aura::Window* window = maybe_transient; window;
83 window = ::wm::GetTransientParent(window)) {
84 if (window == toplevel)
90 // Returns the location of |event| in screen coordinates.
91 gfx::Point GetEventLocationInScreen(const ui::LocatedEvent& event) {
92 gfx::Point location_in_screen = event.location();
93 aura::Window* target = static_cast<aura::Window*>(event.target());
94 aura::client::ScreenPositionClient* screen_position_client =
95 aura::client::GetScreenPositionClient(target->GetRootWindow());
96 screen_position_client->ConvertPointToScreen(target, &location_in_screen);
97 return location_in_screen;
100 // Returns the bounds of the display nearest to |window| in screen coordinates.
101 gfx::Rect GetDisplayBoundsInScreen(aura::Window* window) {
102 return Shell::GetScreen()->GetDisplayNearestWindow(window).bounds();
107 // The height in pixels of the region below the top edge of the display in which
108 // the mouse can trigger revealing the top-of-window views.
110 // Windows 8 reserves some pixels at the top of the screen for the hand icon
111 // that allows you to drag a metro app off the screen, so a few additional
112 // pixels of space must be reserved for the mouse reveal.
113 const int ImmersiveFullscreenController::kMouseRevealBoundsHeight = 9;
115 // The height must be greater than 1px because the top pixel is used to trigger
116 // moving the cursor between displays if the user has a vertical display layout
117 // (primary display above/below secondary display).
118 const int ImmersiveFullscreenController::kMouseRevealBoundsHeight = 3;
121 ////////////////////////////////////////////////////////////////////////////////
123 // Class which keeps the top-of-window views revealed as long as one of the
124 // bubbles it is observing is visible. The logic to keep the top-of-window
125 // views revealed based on the visibility of bubbles anchored to
126 // children of |ImmersiveFullscreenController::top_container_| is separate from
127 // the logic related to |ImmersiveFullscreenController::focus_revealed_lock_|
128 // so that bubbles which are not activatable and bubbles which do not close
129 // upon deactivation also keep the top-of-window views revealed for the
130 // duration of their visibility.
131 class ImmersiveFullscreenController::BubbleManager
132 : public aura::WindowObserver {
134 explicit BubbleManager(ImmersiveFullscreenController* controller);
135 virtual ~BubbleManager();
137 // Start / stop observing changes to |bubble|'s visibility.
138 void StartObserving(aura::Window* bubble);
139 void StopObserving(aura::Window* bubble);
142 // Updates |revealed_lock_| based on whether any of |bubbles_| is visible.
143 void UpdateRevealedLock();
145 // aura::WindowObserver overrides:
146 virtual void OnWindowVisibilityChanged(aura::Window* window,
147 bool visible) OVERRIDE;
148 virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
150 ImmersiveFullscreenController* controller_;
152 std::set<aura::Window*> bubbles_;
154 // Lock which keeps the top-of-window views revealed based on whether any of
155 // |bubbles_| is visible.
156 scoped_ptr<ImmersiveRevealedLock> revealed_lock_;
158 DISALLOW_COPY_AND_ASSIGN(BubbleManager);
161 ImmersiveFullscreenController::BubbleManager::BubbleManager(
162 ImmersiveFullscreenController* controller)
163 : controller_(controller) {
166 ImmersiveFullscreenController::BubbleManager::~BubbleManager() {
167 for (std::set<aura::Window*>::const_iterator it = bubbles_.begin();
168 it != bubbles_.end(); ++it) {
169 (*it)->RemoveObserver(this);
173 void ImmersiveFullscreenController::BubbleManager::StartObserving(
174 aura::Window* bubble) {
175 if (bubbles_.insert(bubble).second) {
176 bubble->AddObserver(this);
177 UpdateRevealedLock();
181 void ImmersiveFullscreenController::BubbleManager::StopObserving(
182 aura::Window* bubble) {
183 if (bubbles_.erase(bubble)) {
184 bubble->RemoveObserver(this);
185 UpdateRevealedLock();
189 void ImmersiveFullscreenController::BubbleManager::UpdateRevealedLock() {
190 bool has_visible_bubble = false;
191 for (std::set<aura::Window*>::const_iterator it = bubbles_.begin();
192 it != bubbles_.end(); ++it) {
193 if ((*it)->IsVisible()) {
194 has_visible_bubble = true;
199 bool was_revealed = controller_->IsRevealed();
200 if (has_visible_bubble) {
201 if (!revealed_lock_.get()) {
202 // Reveal the top-of-window views without animating because it looks
203 // weird for the top-of-window views to animate and the bubble not to
204 // animate along with the top-of-window views.
205 revealed_lock_.reset(controller_->GetRevealedLock(
206 ImmersiveFullscreenController::ANIMATE_REVEAL_NO));
209 revealed_lock_.reset();
212 if (!was_revealed && revealed_lock_.get()) {
213 // Currently, there is no nice way for bubbles to reposition themselves
214 // whenever the anchor view moves. Tell the bubbles to reposition themselves
215 // explicitly instead. The hidden bubbles are also repositioned because
216 // BubbleDelegateView does not reposition its widget as a result of a
217 // visibility change.
218 for (std::set<aura::Window*>::const_iterator it = bubbles_.begin();
219 it != bubbles_.end(); ++it) {
220 AsBubbleDelegate(*it)->OnAnchorBoundsChanged();
225 void ImmersiveFullscreenController::BubbleManager::OnWindowVisibilityChanged(
228 UpdateRevealedLock();
231 void ImmersiveFullscreenController::BubbleManager::OnWindowDestroying(
232 aura::Window* window) {
233 StopObserving(window);
236 ////////////////////////////////////////////////////////////////////////////////
238 ImmersiveFullscreenController::ImmersiveFullscreenController()
240 top_container_(NULL),
242 native_window_(NULL),
243 observers_enabled_(false),
245 reveal_state_(CLOSED),
246 revealed_lock_count_(0),
247 mouse_x_when_hit_top_in_screen_(-1),
248 gesture_begun_(false),
249 animation_(new gfx::SlideAnimation(this)),
250 animations_disabled_for_test_(false),
251 weak_ptr_factory_(this) {
254 ImmersiveFullscreenController::~ImmersiveFullscreenController() {
255 EnableWindowObservers(false);
258 void ImmersiveFullscreenController::Init(Delegate* delegate,
259 views::Widget* widget,
260 views::View* top_container) {
261 delegate_ = delegate;
262 top_container_ = top_container;
264 native_window_ = widget_->GetNativeWindow();
265 native_window_->SetEventTargeter(scoped_ptr<ui::EventTargeter>(
266 new ResizeHandleWindowTargeter(native_window_, this)));
269 void ImmersiveFullscreenController::SetEnabled(WindowType window_type,
271 if (enabled_ == enabled)
275 EnableWindowObservers(enabled_);
277 ash::wm::WindowState* window_state = wm::GetWindowState(native_window_);
278 // Auto hide the shelf in immersive fullscreen instead of hiding it.
279 window_state->set_hide_shelf_when_fullscreen(!enabled);
281 // Update the window's immersive mode state for the window manager.
282 window_state->set_in_immersive_fullscreen(enabled);
284 Shell::GetInstance()->UpdateShelfVisibility();
287 // Animate enabling immersive mode by sliding out the top-of-window views.
288 // No animation occurs if a lock is holding the top-of-window views open.
290 // Do a reveal to set the initial state for the animation. (And any
291 // required state in case the animation cannot run because of a lock holding
292 // the top-of-window views open.)
293 MaybeStartReveal(ANIMATE_NO);
295 // Reset the located event and the focus revealed locks so that they do not
296 // affect whether the top-of-window views are hidden.
297 located_event_revealed_lock_.reset();
298 focus_revealed_lock_.reset();
300 // Try doing the animation.
301 MaybeEndReveal(ANIMATE_SLOW);
303 if (reveal_state_ == REVEALED) {
304 // Reveal was unsuccessful. Reacquire the revealed locks if appropriate.
305 UpdateLocatedEventRevealedLock(NULL);
306 UpdateFocusRevealedLock();
308 // Clearing focus is important because it closes focus-related popups like
309 // the touch selection handles.
310 widget_->GetFocusManager()->ClearFocus();
313 // Stop cursor-at-top tracking.
314 top_edge_hover_timer_.Stop();
315 reveal_state_ = CLOSED;
317 delegate_->OnImmersiveFullscreenExited();
321 UMA_HISTOGRAM_ENUMERATION("Ash.ImmersiveFullscreen.WindowType",
327 bool ImmersiveFullscreenController::IsEnabled() const {
331 bool ImmersiveFullscreenController::IsRevealed() const {
332 return enabled_ && reveal_state_ != CLOSED;
335 ImmersiveRevealedLock* ImmersiveFullscreenController::GetRevealedLock(
336 AnimateReveal animate_reveal) {
337 return new ImmersiveRevealedLock(weak_ptr_factory_.GetWeakPtr(),
341 ////////////////////////////////////////////////////////////////////////////////
342 // Testing interface:
344 void ImmersiveFullscreenController::SetupForTest() {
346 animations_disabled_for_test_ = true;
348 // Move the mouse off of the top-of-window views so that it does not keep the
349 // top-of-window views revealed.
350 std::vector<gfx::Rect> bounds_in_screen(
351 delegate_->GetVisibleBoundsInScreen());
352 DCHECK(!bounds_in_screen.empty());
353 int bottommost_in_screen = bounds_in_screen[0].bottom();
354 for (size_t i = 1; i < bounds_in_screen.size(); ++i) {
355 if (bounds_in_screen[i].bottom() > bottommost_in_screen)
356 bottommost_in_screen = bounds_in_screen[i].bottom();
358 gfx::Point cursor_pos(0, bottommost_in_screen + 100);
359 aura::Env::GetInstance()->set_last_mouse_location(cursor_pos);
360 UpdateLocatedEventRevealedLock(NULL);
363 ////////////////////////////////////////////////////////////////////////////////
364 // ui::EventHandler overrides:
366 void ImmersiveFullscreenController::OnMouseEvent(ui::MouseEvent* event) {
370 if (event->type() != ui::ET_MOUSE_MOVED &&
371 event->type() != ui::ET_MOUSE_PRESSED &&
372 event->type() != ui::ET_MOUSE_RELEASED &&
373 event->type() != ui::ET_MOUSE_CAPTURE_CHANGED) {
377 // Mouse hover can initiate revealing the top-of-window views while |widget_|
380 if (reveal_state_ == SLIDING_OPEN || reveal_state_ == REVEALED) {
381 top_edge_hover_timer_.Stop();
382 UpdateLocatedEventRevealedLock(event);
383 } else if (event->type() != ui::ET_MOUSE_CAPTURE_CHANGED) {
384 // Trigger a reveal if the cursor pauses at the top of the screen for a
386 UpdateTopEdgeHoverTimer(event);
390 void ImmersiveFullscreenController::OnTouchEvent(ui::TouchEvent* event) {
391 if (!enabled_ || event->type() != ui::ET_TOUCH_PRESSED)
394 // Touch should not initiate revealing the top-of-window views while |widget_|
396 if (!widget_->IsActive())
399 UpdateLocatedEventRevealedLock(event);
402 void ImmersiveFullscreenController::OnGestureEvent(ui::GestureEvent* event) {
406 // Touch gestures should not initiate revealing the top-of-window views while
407 // |widget_| is inactive.
408 if (!widget_->IsActive())
411 switch (event->type()) {
413 case ui::ET_GESTURE_WIN8_EDGE_SWIPE:
414 UpdateRevealedLocksForSwipe(GetSwipeType(event));
418 case ui::ET_GESTURE_SCROLL_BEGIN:
419 if (ShouldHandleGestureEvent(GetEventLocationInScreen(*event))) {
420 gesture_begun_ = true;
421 // Do not consume the event. Otherwise, we end up consuming all
422 // ui::ET_GESTURE_SCROLL_BEGIN events in the top-of-window views
423 // when the top-of-window views are revealed.
426 case ui::ET_GESTURE_SCROLL_UPDATE:
427 if (gesture_begun_) {
428 if (UpdateRevealedLocksForSwipe(GetSwipeType(event)))
430 gesture_begun_ = false;
433 case ui::ET_GESTURE_SCROLL_END:
434 case ui::ET_SCROLL_FLING_START:
435 gesture_begun_ = false;
442 ////////////////////////////////////////////////////////////////////////////////
443 // views::FocusChangeListener overrides:
445 void ImmersiveFullscreenController::OnWillChangeFocus(
446 views::View* focused_before,
447 views::View* focused_now) {
450 void ImmersiveFullscreenController::OnDidChangeFocus(
451 views::View* focused_before,
452 views::View* focused_now) {
453 UpdateFocusRevealedLock();
456 ////////////////////////////////////////////////////////////////////////////////
457 // views::WidgetObserver overrides:
459 void ImmersiveFullscreenController::OnWidgetDestroying(views::Widget* widget) {
460 EnableWindowObservers(false);
461 native_window_ = NULL;
463 // Set |enabled_| to false such that any calls to MaybeStartReveal() and
464 // MaybeEndReveal() have no effect.
468 void ImmersiveFullscreenController::OnWidgetActivationChanged(
469 views::Widget* widget,
471 UpdateFocusRevealedLock();
474 ////////////////////////////////////////////////////////////////////////////////
475 // gfx::AnimationDelegate overrides:
477 void ImmersiveFullscreenController::AnimationEnded(
478 const gfx::Animation* animation) {
479 if (reveal_state_ == SLIDING_OPEN) {
480 OnSlideOpenAnimationCompleted();
481 } else if (reveal_state_ == SLIDING_CLOSED) {
482 OnSlideClosedAnimationCompleted();
486 void ImmersiveFullscreenController::AnimationProgressed(
487 const gfx::Animation* animation) {
488 delegate_->SetVisibleFraction(animation->GetCurrentValue());
491 ////////////////////////////////////////////////////////////////////////////////
492 // aura::WindowObserver overrides:
494 void ImmersiveFullscreenController::OnTransientChildAdded(
495 aura::Window* window,
496 aura::Window* transient) {
497 views::BubbleDelegateView* bubble_delegate = AsBubbleDelegate(transient);
498 if (bubble_delegate &&
499 bubble_delegate->GetAnchorView() &&
500 top_container_->Contains(bubble_delegate->GetAnchorView())) {
501 // Observe the aura::Window because the BubbleDelegateView may not be
502 // parented to the widget's root view yet so |bubble_delegate->GetWidget()|
503 // may still return NULL.
504 bubble_manager_->StartObserving(transient);
508 void ImmersiveFullscreenController::OnTransientChildRemoved(
509 aura::Window* window,
510 aura::Window* transient) {
511 bubble_manager_->StopObserving(transient);
514 ////////////////////////////////////////////////////////////////////////////////
515 // ash::ImmersiveRevealedLock::Delegate overrides:
517 void ImmersiveFullscreenController::LockRevealedState(
518 AnimateReveal animate_reveal) {
519 ++revealed_lock_count_;
520 Animate animate = (animate_reveal == ANIMATE_REVEAL_YES) ?
521 ANIMATE_FAST : ANIMATE_NO;
522 MaybeStartReveal(animate);
525 void ImmersiveFullscreenController::UnlockRevealedState() {
526 --revealed_lock_count_;
527 DCHECK_GE(revealed_lock_count_, 0);
528 if (revealed_lock_count_ == 0) {
529 // Always animate ending the reveal fast.
530 MaybeEndReveal(ANIMATE_FAST);
534 ////////////////////////////////////////////////////////////////////////////////
537 void ImmersiveFullscreenController::EnableWindowObservers(bool enable) {
538 if (observers_enabled_ == enable)
540 observers_enabled_ = enable;
542 views::FocusManager* focus_manager = widget_->GetFocusManager();
545 widget_->AddObserver(this);
546 focus_manager->AddFocusChangeListener(this);
547 Shell::GetInstance()->AddPreTargetHandler(this);
548 ::wm::TransientWindowManager::Get(native_window_)->
551 RecreateBubbleManager();
553 widget_->RemoveObserver(this);
554 focus_manager->RemoveFocusChangeListener(this);
555 Shell::GetInstance()->RemovePreTargetHandler(this);
556 ::wm::TransientWindowManager::Get(native_window_)->
557 RemoveObserver(this);
559 // We have stopped observing whether transient children are added or removed
560 // to |native_window_|. The set of bubbles that BubbleManager is observing
561 // will become stale really quickly. Destroy BubbleManager and recreate it
562 // when we start observing |native_window_| again.
563 bubble_manager_.reset();
569 void ImmersiveFullscreenController::UpdateTopEdgeHoverTimer(
570 ui::MouseEvent* event) {
572 DCHECK(reveal_state_ == SLIDING_CLOSED || reveal_state_ == CLOSED);
574 // Check whether |native_window_| is the event target's parent window instead
575 // of checking for activation. This allows the timer to be started when
576 // |widget_| is inactive but prevents starting the timer if the mouse is over
577 // a portion of the top edge obscured by an unrelated widget.
578 if (!top_edge_hover_timer_.IsRunning() &&
579 !native_window_->Contains(static_cast<aura::Window*>(event->target()))) {
583 // Mouse hover should not initiate revealing the top-of-window views while a
584 // window has mouse capture.
585 if (aura::client::GetCaptureWindow(native_window_))
588 gfx::Point location_in_screen = GetEventLocationInScreen(*event);
589 if (ShouldIgnoreMouseEventAtLocation(location_in_screen))
592 // Stop the timer if the cursor left the top edge or is on a different
594 gfx::Rect hit_bounds_in_screen = GetDisplayBoundsInScreen(native_window_);
595 hit_bounds_in_screen.set_height(kMouseRevealBoundsHeight);
596 if (!hit_bounds_in_screen.Contains(location_in_screen)) {
597 top_edge_hover_timer_.Stop();
601 // The cursor is now at the top of the screen. Consider the cursor "not
602 // moving" even if it moves a little bit because users don't have perfect
603 // pointing precision. (The y position is not tested because
604 // |hit_bounds_in_screen| is short.)
605 if (top_edge_hover_timer_.IsRunning() &&
606 abs(location_in_screen.x() - mouse_x_when_hit_top_in_screen_) <=
607 kMouseRevealXThresholdPixels)
610 // Start the reveal if the cursor doesn't move for some amount of time.
611 mouse_x_when_hit_top_in_screen_ = location_in_screen.x();
612 top_edge_hover_timer_.Stop();
613 // Timer is stopped when |this| is destroyed, hence Unretained() is safe.
614 top_edge_hover_timer_.Start(
616 base::TimeDelta::FromMilliseconds(kMouseRevealDelayMs),
618 &ImmersiveFullscreenController::AcquireLocatedEventRevealedLock,
619 base::Unretained(this)));
622 void ImmersiveFullscreenController::UpdateLocatedEventRevealedLock(
623 ui::LocatedEvent* event) {
626 DCHECK(!event || event->IsMouseEvent() || event->IsTouchEvent());
628 // Neither the mouse nor touch can initiate a reveal when the top-of-window
629 // views are sliding closed or are closed with the following exceptions:
630 // - Hovering at y = 0 which is handled in OnMouseEvent().
631 // - Doing a SWIPE_OPEN edge gesture which is handled in OnGestureEvent().
632 if (reveal_state_ == CLOSED || reveal_state_ == SLIDING_CLOSED)
635 // For the sake of simplicity, ignore |widget_|'s activation in computing
636 // whether the top-of-window views should stay revealed. Ideally, the
637 // top-of-window views would stay revealed only when the mouse cursor is
638 // hovered above a non-obscured portion of the top-of-window views. The
639 // top-of-window views may be partially obscured when |widget_| is inactive.
641 // Ignore all events while a window has capture. This keeps the top-of-window
642 // views revealed during a drag.
643 if (aura::client::GetCaptureWindow(native_window_))
646 gfx::Point location_in_screen;
647 if (event && event->type() != ui::ET_MOUSE_CAPTURE_CHANGED) {
648 location_in_screen = GetEventLocationInScreen(*event);
650 aura::client::CursorClient* cursor_client = aura::client::GetCursorClient(
651 native_window_->GetRootWindow());
652 if (!cursor_client->IsMouseEventsEnabled()) {
653 // If mouse events are disabled, the user's last interaction was probably
654 // via touch. Do no do further processing in this case as there is no easy
655 // way of retrieving the position of the user's last touch.
658 location_in_screen = aura::Env::GetInstance()->last_mouse_location();
661 if ((!event || event->IsMouseEvent()) &&
662 ShouldIgnoreMouseEventAtLocation(location_in_screen)) {
666 // The visible bounds of |top_container_| should be contained in
667 // |hit_bounds_in_screen|.
668 std::vector<gfx::Rect> hit_bounds_in_screen =
669 delegate_->GetVisibleBoundsInScreen();
670 bool keep_revealed = false;
671 for (size_t i = 0; i < hit_bounds_in_screen.size(); ++i) {
672 // Allow the cursor to move slightly off the top-of-window views before
673 // sliding closed. In the case of ImmersiveModeControllerAsh, this helps
674 // when the user is attempting to click on the bookmark bar and overshoots
676 if (event && event->type() == ui::ET_MOUSE_MOVED) {
677 const int kBoundsOffsetY = 8;
678 hit_bounds_in_screen[i].Inset(0, 0, 0, -kBoundsOffsetY);
681 if (hit_bounds_in_screen[i].Contains(location_in_screen)) {
682 keep_revealed = true;
688 AcquireLocatedEventRevealedLock();
690 located_event_revealed_lock_.reset();
693 void ImmersiveFullscreenController::AcquireLocatedEventRevealedLock() {
694 // CAUTION: Acquiring the lock results in a reentrant call to
695 // AcquireLocatedEventRevealedLock() when
696 // |ImmersiveFullscreenController::animations_disabled_for_test_| is true.
697 if (!located_event_revealed_lock_.get())
698 located_event_revealed_lock_.reset(GetRevealedLock(ANIMATE_REVEAL_YES));
701 void ImmersiveFullscreenController::UpdateFocusRevealedLock() {
705 bool hold_lock = false;
706 if (widget_->IsActive()) {
707 views::View* focused_view = widget_->GetFocusManager()->GetFocusedView();
708 if (top_container_->Contains(focused_view))
711 aura::Window* active_window = aura::client::GetActivationClient(
712 native_window_->GetRootWindow())->GetActiveWindow();
713 views::BubbleDelegateView* bubble_delegate =
714 AsBubbleDelegate(active_window);
715 if (bubble_delegate && bubble_delegate->anchor_widget()) {
716 // BubbleManager will already have locked the top-of-window views if the
717 // bubble is anchored to a child of |top_container_|. Don't acquire
718 // |focus_revealed_lock_| here for the sake of simplicity.
719 // Note: Instead of checking for the existence of the |anchor_view|,
720 // the existence of the |anchor_widget| is performed to avoid the case
721 // where the view is already gone (and the widget is still running).
723 // The currently active window is not |native_window_| and it is not a
724 // bubble with an anchor view. The top-of-window views should be revealed
726 // 1) The active window is a transient child of |native_window_|.
727 // 2) The top-of-window views are already revealed. This restriction
728 // prevents a transient window opened by the web contents while the
729 // top-of-window views are hidden from from initiating a reveal.
730 // The top-of-window views will stay revealed till |native_window_| is
733 IsWindowTransientChildOf(active_window, native_window_)) {
740 if (!focus_revealed_lock_.get())
741 focus_revealed_lock_.reset(GetRevealedLock(ANIMATE_REVEAL_YES));
743 focus_revealed_lock_.reset();
747 bool ImmersiveFullscreenController::UpdateRevealedLocksForSwipe(
748 SwipeType swipe_type) {
749 if (!enabled_ || swipe_type == SWIPE_NONE)
752 // Swipes while |native_window_| is inactive should have been filtered out in
754 DCHECK(widget_->IsActive());
756 if (reveal_state_ == SLIDING_CLOSED || reveal_state_ == CLOSED) {
757 if (swipe_type == SWIPE_OPEN && !located_event_revealed_lock_.get()) {
758 located_event_revealed_lock_.reset(GetRevealedLock(ANIMATE_REVEAL_YES));
762 if (swipe_type == SWIPE_CLOSE) {
763 // Attempt to end the reveal. If other code is holding onto a lock, the
764 // attempt will be unsuccessful.
765 located_event_revealed_lock_.reset();
766 focus_revealed_lock_.reset();
768 if (reveal_state_ == SLIDING_CLOSED || reveal_state_ == CLOSED) {
769 widget_->GetFocusManager()->ClearFocus();
773 // Ending the reveal was unsuccessful. Reaquire the locks if appropriate.
774 UpdateLocatedEventRevealedLock(NULL);
775 UpdateFocusRevealedLock();
781 int ImmersiveFullscreenController::GetAnimationDuration(Animate animate) const {
786 return kRevealSlowAnimationDurationMs;
788 return kRevealFastAnimationDurationMs;
794 void ImmersiveFullscreenController::MaybeStartReveal(Animate animate) {
798 if (animations_disabled_for_test_)
799 animate = ANIMATE_NO;
801 // Callers with ANIMATE_NO expect this function to synchronously reveal the
802 // top-of-window views.
803 if (reveal_state_ == REVEALED ||
804 (reveal_state_ == SLIDING_OPEN && animate != ANIMATE_NO)) {
808 RevealState previous_reveal_state = reveal_state_;
809 reveal_state_ = SLIDING_OPEN;
810 if (previous_reveal_state == CLOSED) {
811 delegate_->OnImmersiveRevealStarted();
813 // Do not do any more processing if OnImmersiveRevealStarted() changed
815 if (reveal_state_ != SLIDING_OPEN)
818 // Slide in the reveal view.
819 if (animate == ANIMATE_NO) {
820 animation_->Reset(1);
821 OnSlideOpenAnimationCompleted();
823 animation_->SetSlideDuration(GetAnimationDuration(animate));
828 void ImmersiveFullscreenController::OnSlideOpenAnimationCompleted() {
829 DCHECK_EQ(SLIDING_OPEN, reveal_state_);
830 reveal_state_ = REVEALED;
831 delegate_->SetVisibleFraction(1);
833 // The user may not have moved the mouse since the reveal was initiated.
834 // Update the revealed lock to reflect the mouse's current state.
835 UpdateLocatedEventRevealedLock(NULL);
838 void ImmersiveFullscreenController::MaybeEndReveal(Animate animate) {
839 if (!enabled_ || revealed_lock_count_ != 0)
842 if (animations_disabled_for_test_)
843 animate = ANIMATE_NO;
845 // Callers with ANIMATE_NO expect this function to synchronously close the
846 // top-of-window views.
847 if (reveal_state_ == CLOSED ||
848 (reveal_state_ == SLIDING_CLOSED && animate != ANIMATE_NO)) {
852 reveal_state_ = SLIDING_CLOSED;
853 int duration_ms = GetAnimationDuration(animate);
854 if (duration_ms > 0) {
855 animation_->SetSlideDuration(duration_ms);
858 animation_->Reset(0);
859 OnSlideClosedAnimationCompleted();
863 void ImmersiveFullscreenController::OnSlideClosedAnimationCompleted() {
864 DCHECK_EQ(SLIDING_CLOSED, reveal_state_);
865 reveal_state_ = CLOSED;
866 delegate_->OnImmersiveRevealEnded();
869 ImmersiveFullscreenController::SwipeType
870 ImmersiveFullscreenController::GetSwipeType(ui::GestureEvent* event) const {
872 if (event->type() == ui::ET_GESTURE_WIN8_EDGE_SWIPE)
875 if (event->type() != ui::ET_GESTURE_SCROLL_UPDATE)
877 // Make sure that it is a clear vertical gesture.
878 if (std::abs(event->details().scroll_y()) <=
879 kSwipeVerticalThresholdMultiplier * std::abs(event->details().scroll_x()))
881 if (event->details().scroll_y() < 0)
883 else if (event->details().scroll_y() > 0)
888 bool ImmersiveFullscreenController::ShouldIgnoreMouseEventAtLocation(
889 const gfx::Point& location) const {
890 // Ignore mouse events in the region immediately above the top edge of the
891 // display. This is to handle the case of a user with a vertical display
892 // layout (primary display above/below secondary display) and the immersive
893 // fullscreen window on the bottom display. It is really hard to trigger a
894 // reveal in this case because:
895 // - It is hard to stop the cursor in the top |kMouseRevealBoundsHeight|
896 // pixels of the bottom display.
897 // - The cursor is warped to the top display if the cursor gets to the top
898 // edge of the bottom display.
899 // Mouse events are ignored in the bottom few pixels of the top display
900 // (Mouse events in this region cannot start or end a reveal). This allows a
901 // user to overshoot the top of the bottom display and still reveal the
902 // top-of-window views.
903 gfx::Rect dead_region = GetDisplayBoundsInScreen(native_window_);
904 dead_region.set_y(dead_region.y() - kHeightOfDeadRegionAboveTopContainer);
905 dead_region.set_height(kHeightOfDeadRegionAboveTopContainer);
906 return dead_region.Contains(location);
909 bool ImmersiveFullscreenController::ShouldHandleGestureEvent(
910 const gfx::Point& location) const {
911 DCHECK(widget_->IsActive());
912 if (reveal_state_ == REVEALED) {
913 std::vector<gfx::Rect> hit_bounds_in_screen(
914 delegate_->GetVisibleBoundsInScreen());
915 for (size_t i = 0; i < hit_bounds_in_screen.size(); ++i) {
916 if (hit_bounds_in_screen[i].Contains(location))
922 // When the top-of-window views are not fully revealed, handle gestures which
923 // start in the top few pixels of the screen.
924 gfx::Rect hit_bounds_in_screen(GetDisplayBoundsInScreen(native_window_));
925 hit_bounds_in_screen.set_height(kImmersiveFullscreenTopEdgeInset);
926 if (hit_bounds_in_screen.Contains(location))
929 // There may be a bezel sensor off screen logically above
930 // |hit_bounds_in_screen|. The check for the event not contained by the
931 // closest screen ensures that the event is from a valid bezel (as opposed to
932 // another screen in an extended desktop).
933 gfx::Rect screen_bounds =
934 Shell::GetScreen()->GetDisplayNearestPoint(location).bounds();
935 return (!screen_bounds.Contains(location) &&
936 location.y() < hit_bounds_in_screen.y() &&
937 location.x() >= hit_bounds_in_screen.x() &&
938 location.x() < hit_bounds_in_screen.right());
941 void ImmersiveFullscreenController::RecreateBubbleManager() {
942 bubble_manager_.reset(new BubbleManager(this));
943 const std::vector<aura::Window*> transient_children =
944 ::wm::GetTransientChildren(native_window_);
945 for (size_t i = 0; i < transient_children.size(); ++i) {
946 aura::Window* transient_child = transient_children[i];
947 views::BubbleDelegateView* bubble_delegate =
948 AsBubbleDelegate(transient_child);
949 if (bubble_delegate &&
950 bubble_delegate->GetAnchorView() &&
951 top_container_->Contains(bubble_delegate->GetAnchorView())) {
952 bubble_manager_->StartObserving(transient_child);