Touch gestures for System Tray/ IME/ Stylus/ Notifications

ash/system/ime_menu/ime_menu_tray.cc

 // Copyright 2016 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/ime_menu/ime_menu_tray.h"
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accessibility_delegate.h"
 #include "ash/ash_constants.h"
 #include "ash/ime/ime_controller.h"
@@ skipping 172 matching lines @@
     DCHECK(ime_menu_tray_);
 
     Init(show_emoji, show_handwriting, show_voice);
   }
 
   ~ImeButtonsView() override {}
 
   // views::ButtonListener:
   void ButtonPressed(views::Button* sender, const ui::Event& event) override {
     if (sender == settings_button_) {
-      ime_menu_tray_->HideImeMenuBubble();
+      ime_menu_tray_->CloseBubble();
       ShowIMESettings();
       return;
     }
 
     // The |keyset| will be used for drawing input view keyset in IME
     // extensions. InputMethodManager::ShowKeyboardWithKeyset() will deal with
     // the |keyset| string to generate the right input view url.
     std::string keyset;
     if (sender == emoji_button_) {
       keyset = "emoji";
@@ skipping 109 matching lines @@
     bubble_->bubble_view()->ResetDelegate();
   SystemTrayNotifier* tray_notifier = Shell::Get()->system_tray_notifier();
   tray_notifier->RemoveIMEObserver(this);
   tray_notifier->RemoveVirtualKeyboardObserver(this);
   keyboard::KeyboardController* keyboard_controller =
       keyboard::KeyboardController::GetInstance();
   if (keyboard_controller)
     keyboard_controller->RemoveObserver(this);
 }
 
-void ImeMenuTray::ShowImeMenuBubble() {
-  keyboard::KeyboardController* keyboard_controller =
-      keyboard::KeyboardController::GetInstance();
-  if (keyboard_controller && keyboard_controller->keyboard_visible()) {
-    show_bubble_after_keyboard_hidden_ = true;
-    keyboard_controller->AddObserver(this);
-    keyboard_controller->HideKeyboard(
-        keyboard::KeyboardController::HIDE_REASON_AUTOMATIC);
-  } else {
-    ShowImeMenuBubbleInternal();
-  }
-}
-
 void ImeMenuTray::ShowImeMenuBubbleInternal() {
   views::TrayBubbleView::InitParams init_params;
   init_params.delegate = this;
   init_params.parent_window = GetBubbleWindowContainer();
   init_params.anchor_view = GetBubbleAnchor();
   init_params.anchor_alignment = GetAnchorAlignment();
   init_params.min_width = kTrayMenuMinimumWidth;
   init_params.max_width = kTrayMenuMinimumWidth;
   init_params.close_on_deactivate = true;
 
@@ skipping 12 matching lines @@
 
   if (show_bottom_buttons) {
     bubble_view->AddChildView(new ImeButtonsView(
         this, emoji_enabled_, handwriting_enabled_, voice_enabled_));
   }
 
   bubble_.reset(new TrayBubbleWrapper(this, bubble_view));
   SetIsActive(true);
 }
 
-void ImeMenuTray::HideImeMenuBubble() {
-  bubble_.reset();
-  ime_list_view_ = nullptr;
-  SetIsActive(false);
-  shelf()->UpdateAutoHideState();
-}
-
-bool ImeMenuTray::IsImeMenuBubbleShown() {
-  return !!bubble_;
-}
-
 void ImeMenuTray::ShowKeyboardWithKeyset(const std::string& keyset) {
-  HideImeMenuBubble();
+  CloseBubble();
 
   // Overrides the keyboard url ref to make it shown with the given keyset.
   if (InputMethodManager::Get())
     InputMethodManager::Get()->OverrideKeyboardUrlRef(keyset);
 
   // If onscreen keyboard has been enabled, shows the keyboard directly.
   keyboard::KeyboardController* keyboard_controller =
       keyboard::KeyboardController::GetInstance();
   show_keyboard_ = true;
   if (keyboard_controller) {
@@ skipping 57 matching lines @@
   return keyboard_suppressed_ &&
          !Shell::Get()->accessibility_delegate()->IsVirtualKeyboardEnabled();
 }
 
 base::string16 ImeMenuTray::GetAccessibleNameForTray() {
   return l10n_util::GetStringUTF16(IDS_ASH_IME_MENU_ACCESSIBLE_NAME);
 }
 
 void ImeMenuTray::HideBubbleWithView(const views::TrayBubbleView* bubble_view) {
   if (bubble_->bubble_view() == bubble_view)
-    HideImeMenuBubble();
+    CloseBubble();
 }
 
 void ImeMenuTray::ClickedOutsideBubble() {
-  HideImeMenuBubble();
+  CloseBubble();
 }
 
 bool ImeMenuTray::PerformAction(const ui::Event& event) {
   if (bubble_)
-    HideImeMenuBubble();
+    CloseBubble();
   else
-    ShowImeMenuBubble();
+    ShowBubble();
   return true;
 }
 
+void ImeMenuTray::CloseBubble() {
+  bubble_.reset();
+  ime_list_view_ = nullptr;
+  SetIsActive(false);
+  shelf()->UpdateAutoHideState();
+}
+
+void ImeMenuTray::ShowBubble() {
+  keyboard::KeyboardController* keyboard_controller =
+      keyboard::KeyboardController::GetInstance();
+  if (keyboard_controller && keyboard_controller->keyboard_visible()) {
+    show_bubble_after_keyboard_hidden_ = true;
+    keyboard_controller->AddObserver(this);
+    keyboard_controller->HideKeyboard(
+        keyboard::KeyboardController::HIDE_REASON_AUTOMATIC);
+  } else {
+    ShowImeMenuBubbleInternal();
+  }
+}
+
+views::TrayBubbleView* ImeMenuTray::GetBubbleView() {
+  return bubble_ ? bubble_->bubble_view() : nullptr;
+}
+
+void ImeMenuTray::OnGestureEvent(ui::GestureEvent* event) {
+  if (!drag_controller()->ProcessGestureEvent(event, this))
+    TrayBackgroundView::OnGestureEvent(event);
+}
+
 void ImeMenuTray::OnIMERefresh() {
   UpdateTrayLabel();
   if (bubble_ && ime_list_view_) {
     ime_list_view_->Update(ime_controller_->current_ime().id,
                            ime_controller_->available_imes(),
                            ime_controller_->current_ime_menu_items(), false,
                            ImeListView::SHOW_SINGLE_IME);
   }
 }
 
 void ImeMenuTray::OnIMEMenuActivationChanged(bool is_activated) {
   SetVisible(is_activated);
   if (is_activated)
     UpdateTrayLabel();
   else
-    HideImeMenuBubble();
+    CloseBubble();
 }
 
 void ImeMenuTray::BubbleViewDestroyed() {
 }
 
 void ImeMenuTray::OnMouseEnteredView() {}
 
 void ImeMenuTray::OnMouseExitedView() {}
 
 void ImeMenuTray::RegisterAccelerators(
@@ skipping 13 matching lines @@
 }
 
 bool ImeMenuTray::ShouldEnableExtraKeyboardAccessibility() {
   return Shell::Get()->accessibility_delegate()->IsSpokenFeedbackEnabled();
 }
 
 void ImeMenuTray::HideBubble(const views::TrayBubbleView* bubble_view) {
   HideBubbleWithView(bubble_view);
 }
 
+bool ImeMenuTray::ProcessGestureEventForBubble(ui::GestureEvent* event) {
+  return drag_controller()->ProcessGestureEvent(event, this);
+}
 void ImeMenuTray::OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) {}
 
 void ImeMenuTray::OnKeyboardClosed() {
   if (InputMethodManager::Get())
     InputMethodManager::Get()->OverrideKeyboardUrlRef(std::string());
   keyboard::KeyboardController* keyboard_controller =
       keyboard::KeyboardController::GetInstance();
   if (keyboard_controller)
     keyboard_controller->RemoveObserver(this);
 
@@ skipping 33 matching lines @@
     return;
 
   // Posts a task to disable the virtual keyboard.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&ImeMenuTray::DisableVirtualKeyboard,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ImeMenuTray::OnKeyboardSuppressionChanged(bool suppressed) {
   if (suppressed != keyboard_suppressed_ && bubble_)
-    HideImeMenuBubble();
+    CloseBubble();
   keyboard_suppressed_ = suppressed;
 }
 
 void ImeMenuTray::UpdateTrayLabel() {
   const mojom::ImeInfo& current_ime = ime_controller_->current_ime();
 
   // Updates the tray label based on the current input method.
   if (current_ime.third_party)
     label_->SetText(current_ime.short_name + base::UTF8ToUTF16("*"));
   else
     label_->SetText(current_ime.short_name);
 }
 
 void ImeMenuTray::DisableVirtualKeyboard() {
   Shell::Get()->accessibility_delegate()->SetVirtualKeyboardEnabled(false);
   force_show_keyboard_ = false;
 }
 
 }  // namespace ash