Touch gestures for System Tray/ IME/ Stylus/ Notifications

ash/system/tray/system_tray.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/system/tray/system_tray.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
@@ skipping 35 matching lines @@
 #include "ash/system/tray/tray_bubble_wrapper.h"
 #include "ash/system/tray/tray_constants.h"
 #include "ash/system/tray/tray_container.h"
 #include "ash/system/tray_accessibility.h"
 #include "ash/system/tray_caps_lock.h"
 #include "ash/system/tray_tracing.h"
 #include "ash/system/update/tray_update.h"
 #include "ash/system/user/tray_user.h"
 #include "ash/system/web_notification/web_notification_tray.h"
 #include "ash/wm/container_finder.h"
 #include "ash/wm/maximize_mode/maximize_mode_controller.h"

[msw, 2017/07/12 05:04:51]

nit: remove if no longer needed

[minch1, 2017/07/13 19:10:35]

Done.

 #include "ash/wm/widget_finder.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/timer/timer.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
@@ skipping 125 matching lines @@
   }
 
  private:
   SystemTray* tray_;
 
   DISALLOW_COPY_AND_ASSIGN(ActivationObserver);
 };
 
 // SystemTray
 
-SystemTray::SystemTray(Shelf* shelf)
-    : TrayBackgroundView(shelf), shelf_(shelf) {
+SystemTray::SystemTray(Shelf* shelf) : TrayBackgroundView(shelf) {
   SetInkDropMode(InkDropMode::ON);
 
   // Since user avatar is on the right hand side of System tray of a
   // horizontal shelf and that is sufficient to indicate separation, no
   // separator is required.
   set_separator_visibility(false);
 }
 
 SystemTray::~SystemTray() {
   // Destroy any child views that might have back pointers before ~View().
@@ skipping 338 matching lines @@
     shelf()->UpdateAutoHideState();
   }
 }
 
 void SystemTray::ClickedOutsideBubble() {
   if (!system_bubble_ || system_bubble_->is_persistent())
     return;
   HideBubbleWithView(system_bubble_->bubble_view());
 }
 
+bool SystemTray::PerformAction(const ui::Event& event) {
+  // If we're already showing a full system tray menu, either default or
+  // detailed menu, hide it; otherwise, show it (and hide any popup that's
+  // currently shown).
+  if (HasSystemBubble() && full_system_tray_menu_) {
+    system_bubble_->bubble()->Close();
+  } else {
+    ShowDefaultView(BUBBLE_CREATE_NEW);
+    if (event.IsKeyEvent() || (event.flags() & ui::EF_TOUCH_ACCESSIBILITY))
+      ActivateBubble();
+  }
+  return true;
+}
+
+bool SystemTray::HasBubble() {
+  return HasSystemBubble() && full_system_tray_menu_;
+}
+
+void SystemTray::CloseBubble() {
+  CloseSystemBubble();
+}
+
+void SystemTray::ShowBubble() {
+  ShowDefaultView(BUBBLE_CREATE_NEW);
+}
+
+views::TrayBubbleView* SystemTray::GetBubbleView() {
+  if (system_bubble_)
+    return system_bubble_->bubble_view();
+  return nullptr;
+}
+
 void SystemTray::BubbleViewDestroyed() {
   if (system_bubble_) {
     system_bubble_->bubble()->DestroyItemViews();
     system_bubble_->bubble()->BubbleViewDestroyed();
   }
 }
 
 void SystemTray::OnMouseEnteredView() {
   if (system_bubble_)
     system_bubble_->bubble()->StopAutoCloseTimer();
@@ skipping 25 matching lines @@
   // e.g. volume slider. Persistent system bubble is a bubble which is not
   // closed even if user clicks outside of the bubble.
   return system_bubble_ && !system_bubble_->is_persistent() &&
          Shell::Get()->accessibility_delegate()->IsSpokenFeedbackEnabled();
 }
 
 void SystemTray::HideBubble(const TrayBubbleView* bubble_view) {
   HideBubbleWithView(bubble_view);
 }
 
+bool SystemTray::ProcessGestureEventForBubble(ui::GestureEvent* event) {

[msw, 2017/07/12 05:04:51]

It would be nice if we didn't need to have so many redundant declarations, but
the only way I can imagine that happening is by making a
TrayBubbleView::Delegate abstract class in Ash (kinda ugly), or making
TrayBackgroundView itself a subclass of TrayBubbleView::Delegate, does the
latter option seem reasonable?

[minch1, 2017/07/13 19:10:35]

For the latter option, since TrayBubbleView::Delegate has some other pure
virtual functions (8 functions). If make TrayBackgroundView as a subclass of
TrayBubbleView::Delegate, it should have default implementation for all these
pure virtual functions, since except SystemTray/ ImeMenuTray/
WebNotificationTray/ PaletteTray what we used in this cl, some other classes
which is the subclass of TrayBackgroundView also need to implement these
functions. Otherwise, we can make all the functions in TrayBubbleView::Delegate
not pure virtual only virtual instead, which should have the default
implementation in TrayBubbleView::Delegate instead.
Which one do you think is better? (I guess if we really want to do this, maybe
just make the functions in TrayBubbleView::Delegate not pure looks better? But
we also need to add the default implementation for all of these functions in
TrayBubbleView? Or just keep this function like this?)

[msw, 2017/07/14 02:00:45]

Thanks for thinking about this, the code will be better if we can consolidate
some of the implementations. My preference would be to make TrayBackgroundView
inherit from TrayBubbleView::Delegate, but only provide default implementations
of the new ProcessGestureEventForBubble function and the common OnGestureEvent
override impl pattern. Consolidating more from all the TrayBackgroundView
subclasses (like the common PerformAction impl) would be a bonus, but less
important for now. I think it should be possible to leave the
TrayBubbleView::Delegate interface pure-virtual, and make TrayBackgroundView an
abstract class (missing some of the pure-virtual implementations), since nothing
instantiates TrayBackgroundView directly. We can leave it up to the
TrayBackgroundView subclasses like SystemTray to continue implementing the other
pure virtual functions, since those are the classes that are actually
instantiated. Does that seem feasible? (otherwise making the interface not pure
via TrayBackgroundView seems okay to me).

[minch1, 2017/07/14 19:45:17]

I think TrayBakgroundView is already an abstract class currently. If make
TrayBackgroundView a subclass of TrayBubbleView::Delegate, all of its subclasses
should implement the pure-virtual functions in TrayBubbleView::Delegate (except
ProcessGestureEventForBubble that we want to implement in TrayBackgroundView).
Since like OverViewButtonTray is also a subclass of TrayBackgroundView, it will
also need to implement these pure-virtual functions in TrayBubbleView::Delegate
(if we keep the TrayBubbleView::Delegate pure-virtual). This is totally not what
we want.
It might feasible to make TrayBubbleView::Delegate non pure-virtual. But ne more
thing, I think maybe we cann't implement ProcessGestureEventForBubble in
TrayBackgroundview? Since the argument |this| should be SystemTray, not
TrayBackgroundView. Then, the added help functions HasBubble, CloseBubble, etc,
will call into the correct subclass?

[msw, 2017/07/14 21:00:30]

Using |this| in a TrayBackgroundView::ProcessGestureEventForBubble base class
implementation would be totally fine (it'll still execute SystemTray, etc.
overrides as needed).

I definitely favor consolidating more logic in TrayBackgroundView, even if by
means of making TrayBubbleView::Delegate non pure-virtual (I'm hope that's not
necessary). TrayBackgroundView should help subclasses easily handle or ignore
swipe gestures, with minimal per-background overrides. And as TrayBackgroundView
owns the DragController, it may as well own the requisite client logic.

Someday, views::Button may even own a DragController and offer
views::ButtonListener::ButtonSwiped() to let clients and subclasses more easily
handle similar gestures.

[minch1, 2017/07/15 02:46:29]

Done.

+  return drag_controller()->ProcessGestureEvent(*event, this,
+                                                true /* is_on_bubble */);
+}
+
+void SystemTray::OnGestureEvent(ui::GestureEvent* event) {
+  if (drag_controller()->ProcessGestureEvent(*event, this,
+                                             false /* is_on_bubble */)) {
+    event->SetHandled();
+  } else {
+    TrayBackgroundView::OnGestureEvent(event);
+  }
+}
+
 void SystemTray::CloseBubble(const ui::KeyEvent& key_event) {
   CloseSystemBubble();
 }
 
 void SystemTray::ActivateAndStartNavigation(const ui::KeyEvent& key_event) {
   if (!system_bubble_)
     return;
   ActivateBubble();
 
   views::Widget* widget = GetSystemBubble()->bubble_view()->GetWidget();
   widget->GetFocusManager()->OnKeyEvent(key_event);
 }
 
 void SystemTray::ActivateBubble() {
   TrayBubbleView* bubble_view = GetSystemBubble()->bubble_view();
   // If system tray bubble is in the process of closing, do not try to activate
   // bubble.
   if (bubble_view->GetWidget()->IsClosed())
     return;
   bubble_view->set_can_activate(true);
   bubble_view->GetWidget()->Activate();
 }
 
-void SystemTray::OnGestureEvent(ui::GestureEvent* event) {
-  if (Shell::Get()
-          ->maximize_mode_controller()
-          ->IsMaximizeModeWindowManagerEnabled() &&
-      shelf_->IsHorizontalAlignment() && ProcessGestureEvent(*event)) {
-    event->SetHandled();
-  } else {
-    TrayBackgroundView::OnGestureEvent(event);
-  }
-}
-
-gfx::Rect SystemTray::GetWorkAreaBoundsInScreen() const {
-  return shelf_->GetUserWorkAreaBounds();
-}
-
-bool SystemTray::PerformAction(const ui::Event& event) {
-  // If we're already showing a full system tray menu, either default or
-  // detailed menu, hide it; otherwise, show it (and hide any popup that's
-  // currently shown).
-  if (HasSystemBubble() && full_system_tray_menu_) {
-    system_bubble_->bubble()->Close();
-  } else {
-    ShowDefaultView(BUBBLE_CREATE_NEW);
-    if (event.IsKeyEvent() || (event.flags() & ui::EF_TOUCH_ACCESSIBILITY))
-      ActivateBubble();
-  }
-  return true;
-}
-
-bool SystemTray::ProcessGestureEvent(const ui::GestureEvent& event) {
-  if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
-    return StartGestureDrag(event);
-
-  if (!HasSystemBubble() || !is_in_drag_)
-    return false;
-
-  if (event.type() == ui::ET_GESTURE_SCROLL_UPDATE) {
-    UpdateGestureDrag(event);
-    return true;
-  }
-
-  if (event.type() == ui::ET_GESTURE_SCROLL_END ||
-      event.type() == ui::ET_SCROLL_FLING_START) {
-    CompleteGestureDrag(event);
-    return true;
-  }
-
-  // Unexpected event. Reset the drag state and close the bubble.
-  is_in_drag_ = false;
-  CloseSystemBubble();
-  return false;
-}
-
-bool SystemTray::StartGestureDrag(const ui::GestureEvent& gesture) {
-  // Close the system bubble if there is already a full one opened. And return
-  // false to let shelf handle the event.
-  if (HasSystemBubble() && full_system_tray_menu_) {
-    system_bubble_->bubble()->Close();
-    return false;
-  }
-
-  // If the scroll sequence begins to scroll downward, return false so that the
-  // event will instead by handled by the shelf.
-  if (gesture.details().scroll_y_hint() > 0)
-    return false;
-
-  is_in_drag_ = true;
-  gesture_drag_amount_ = 0.f;
-  ShowDefaultView(BUBBLE_CREATE_NEW);
-  system_tray_bubble_bounds_ =
-      system_bubble_->bubble_view()->GetWidget()->GetWindowBoundsInScreen();
-  SetBubbleBounds(gesture.location());
-  return true;
-}
-
-void SystemTray::UpdateGestureDrag(const ui::GestureEvent& gesture) {
-  SetBubbleBounds(gesture.location());
-  gesture_drag_amount_ += gesture.details().scroll_y();
-}
-
-void SystemTray::CompleteGestureDrag(const ui::GestureEvent& gesture) {
-  const bool hide_bubble = !ShouldShowSystemBubbleAfterScrollSequence(gesture);
-  gfx::Rect target_bounds = system_tray_bubble_bounds_;
-
-  if (hide_bubble)
-    target_bounds.set_y(shelf_->GetIdealBounds().y());
-
-  system_bubble_->bubble()->AnimateToTargetBounds(target_bounds, hide_bubble);
-  is_in_drag_ = false;
-}
-
-void SystemTray::SetBubbleBounds(const gfx::Point& location) {
-  gfx::Point location_in_screen_coordinates(location);
-  View::ConvertPointToScreen(this, &location_in_screen_coordinates);
-
-  // System tray bubble should not be dragged higher than its original height.
-  if (location_in_screen_coordinates.y() < system_tray_bubble_bounds_.y())
-    location_in_screen_coordinates.set_y(system_tray_bubble_bounds_.y());
-
-  gfx::Rect bounds_on_location = system_tray_bubble_bounds_;
-  bounds_on_location.set_y(location_in_screen_coordinates.y());
-  system_bubble_->bubble_view()->GetWidget()->SetBounds(bounds_on_location);
-}
-
-bool SystemTray::ShouldShowSystemBubbleAfterScrollSequence(
-    const ui::GestureEvent& sequence_end) {
-  // If the scroll sequence terminates with a fling, show the system menu if the
-  // fling was fast enough and in the correct direction.
-  if (sequence_end.type() == ui::ET_SCROLL_FLING_START &&
-      fabs(sequence_end.details().velocity_y()) > kFlingVelocity) {
-    return sequence_end.details().velocity_y() < 0;
-  }
-
-  DCHECK(sequence_end.type() == ui::ET_GESTURE_SCROLL_END ||
-         sequence_end.type() == ui::ET_SCROLL_FLING_START);
-  // Show the system menu if it is already at least one-third visible.
-  return -gesture_drag_amount_ >= system_tray_bubble_bounds_.height() / 3.0;
-}
-
 void SystemTray::CloseSystemBubbleAndDeactivateSystemTray() {
   activation_observer_.reset();
   system_bubble_.reset();
   // When closing a system bubble with the alternate shelf layout, we need to
   // turn off the active tinting of the shelf.
   if (full_system_tray_menu_) {
     SetIsActive(false);
     full_system_tray_menu_ = false;
   }
 }
@@ skipping 19 matching lines @@
           .work_area()
           .height();
   if (work_area_height > 0) {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Ash.SystemMenu.PercentageOfWorkAreaHeightCoveredByMenu",
         100 * bubble_view->height() / work_area_height, 1, 300, 100);
   }
 }
 
 }  // namespace ash