Touch gestures for System Tray/ IME/ Stylus/ Notifications

ash/system/tray/tray_background_view.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/tray_background_view.h"
 
 #include <algorithm>
 
 #include "ash/ash_constants.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shell.h"
 #include "ash/system/status_area_widget_delegate.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "ash/system/tray/tray_constants.h"
 #include "ash/system/tray/tray_container.h"
 #include "ash/system/tray/tray_event_filter.h"
+#include "ash/wm/maximize_mode/maximize_mode_controller.h"
 #include "base/memory/ptr_util.h"
 #include "ui/accessibility/ax_node_data.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/transform.h"
@@ skipping 94 matching lines @@
   }
 
   // Reference to the TrayBackgroundView for which this is a background.
   TrayBackgroundView* tray_background_view_;
 
   SkColor color_;
 
   DISALLOW_COPY_AND_ASSIGN(TrayBackground);
 };
 
+// CloseBubbleObserver is used to delay closing the tray bubbles until the
+// animation completes.
+class CloseBubbleObserver : public ui::ImplicitAnimationObserver {
+ public:
+  explicit CloseBubbleObserver(TrayBackgroundView* tray_background_view)
+      : tray_background_view_(tray_background_view) {}
+
+  ~CloseBubbleObserver() override {}
+
+  void OnImplicitAnimationsCompleted() override {
+    tray_background_view_->CloseBubble();
+    delete this;
+  }
+
+ private:
+  TrayBackgroundView* tray_background_view_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(CloseBubbleObserver);
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 // TrayBackgroundView
 
 TrayBackgroundView::TrayBackgroundView(Shelf* shelf)
     // Note the ink drop style is ignored.
     : ActionableView(nullptr, TrayPopupInkDropStyle::FILL_BOUNDS),
       shelf_(shelf),
       tray_container_(new TrayContainer(shelf)),
       background_(new TrayBackground(this)),
       is_active_(false),
@@ skipping 86 matching lines @@
     layer()->SetOpacity(0.0f);
     layer()->SetVisible(false);
     HideTransformation();
   }
 }
 
 const char* TrayBackgroundView::GetClassName() const {
   return kViewClassName;
 }
 
-void TrayBackgroundView::ChildPreferredSizeChanged(views::View* child) {
-  PreferredSizeChanged();
-}
+void TrayBackgroundView::OnGestureEvent(ui::GestureEvent* event) {
+  if (drag_controller())
+    drag_controller_->ProcessGestureEvent(event, this);
 
-void TrayBackgroundView::GetAccessibleNodeData(ui::AXNodeData* node_data) {
-  ActionableView::GetAccessibleNodeData(node_data);
-  node_data->SetName(GetAccessibleNameForTray());
+  if (!event->handled())
+    ActionableView::OnGestureEvent(event);
 }
 
 void TrayBackgroundView::AboutToRequestFocusFromTabTraversal(bool reverse) {
   StatusAreaWidgetDelegate* delegate =
       StatusAreaWidgetDelegate::GetPrimaryInstance();
   if (delegate && delegate->ShouldFocusOut(reverse))
     Shell::Get()->system_tray_notifier()->NotifyFocusOut(reverse);
 }
 
+void TrayBackgroundView::GetAccessibleNodeData(ui::AXNodeData* node_data) {
+  ActionableView::GetAccessibleNodeData(node_data);
+  node_data->SetName(GetAccessibleNameForTray());
+}
+
+void TrayBackgroundView::ChildPreferredSizeChanged(views::View* child) {
+  PreferredSizeChanged();
+}
+
 std::unique_ptr<views::InkDropRipple> TrayBackgroundView::CreateInkDropRipple()
     const {
   return base::MakeUnique<views::FloodFillInkDropRipple>(
       size(), GetBackgroundInsets(), GetInkDropCenterBasedOnLastEvent(),
       GetInkDropBaseColor(), ink_drop_visible_opacity());
 }
 
 std::unique_ptr<views::InkDropHighlight>
 TrayBackgroundView::CreateInkDropHighlight() const {
   gfx::Rect bounds = GetBackgroundBounds();
@@ skipping 34 matching lines @@
     const gfx::Vector2dF vector(0, kTrayItemSize);
     canvas->Draw1pxLine(point, point + vector, color);
   } else {
     const gfx::PointF point((kShelfSize - kTrayItemSize) / 2,
                             local_bounds.height() - kSeparatorWidth);
     const gfx::Vector2dF vector(kTrayItemSize, 0);
     canvas->Draw1pxLine(point, point + vector, color);
   }
 }
 
+void TrayBackgroundView::ProcessGestureEventForBubble(ui::GestureEvent* event) {
+  if (drag_controller())
+    drag_controller_->ProcessGestureEvent(event, this);
+}
+
+TrayBubbleView* TrayBackgroundView::GetBubbleView() {
+  return nullptr;
+}
+
+void TrayBackgroundView::CloseBubble() {}
+
+void TrayBackgroundView::ShowBubble() {}
+
 void TrayBackgroundView::UpdateAfterShelfAlignmentChange() {
   tray_container_->UpdateAfterShelfAlignmentChange();
 
   // The tray itself expands to the right and bottom edge of the screen to make
   // sure clicking on the edges brings up the popup. However, the focus border
   // should be only around the container.
   gfx::Rect paint_bounds(GetBackgroundBounds());
   paint_bounds.Inset(gfx::Insets(-kFocusBorderThickness));
   SetFocusPainter(views::Painter::CreateSolidFocusPainter(
       kFocusBorderColor, kFocusBorderThickness,
       GetLocalBounds().InsetsFrom(paint_bounds)));
 }
 
+void TrayBackgroundView::AnchorUpdated() {}
+
+void TrayBackgroundView::BubbleResized(
+    const views::TrayBubbleView* bubble_view) {}
+
 void TrayBackgroundView::OnImplicitAnimationsCompleted() {
   // If there is another animation in the queue, the reverse animation was
   // triggered before the completion of animating to invisible. Do not turn off
   // the visibility so that the next animation may render. The value of
   // layer()->GetTargetVisibility() can be incorrect if the hide animation was
   // aborted to schedule an animation to become visible. As the new animation
   // is not yet added to the queue. crbug.com/374236
   if (layer()->GetAnimator()->is_animating() || layer()->GetTargetVisibility())
     return;
   views::View::SetVisible(false);
@@ skipping 53 matching lines @@
   gfx::Insets tray_bg_insets = GetInsets();
   if (GetAnchorAlignment() == TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM) {
     return gfx::Insets(-tray_bg_insets.top(), anchor_insets.left(),
                        -tray_bg_insets.bottom(), anchor_insets.right());
   } else {
     return gfx::Insets(anchor_insets.top(), -tray_bg_insets.left(),
                        anchor_insets.bottom(), -tray_bg_insets.right());
   }
 }
 
-aura::Window* TrayBackgroundView::GetBubbleWindowContainer() const {
-  return Shell::GetContainer(
+aura::Window* TrayBackgroundView::GetBubbleWindowContainer() {
+  aura::Window* container = Shell::GetContainer(
       tray_container()->GetWidget()->GetNativeWindow()->GetRootWindow(),
       kShellWindowId_SettingBubbleContainer);
+
+  // Place the bubble in |container|, or in a window clipped to the work area
+  // in maximize mode, to avoid tray bubble and shelf overlap.
+  if (Shell::Get()
+          ->maximize_mode_controller()
+          ->IsMaximizeModeWindowManagerEnabled()) {
+    if (!clipping_window_.get()) {
+      clipping_window_ = base::MakeUnique<aura::Window>(nullptr);
+      clipping_window_->Init(ui::LAYER_NOT_DRAWN);
+      clipping_window_->layer()->SetMasksToBounds(true);
+      container->AddChild(clipping_window_.get());
+      clipping_window_->Show();
+    }
+    clipping_window_->SetBounds(shelf_->GetUserWorkAreaBounds());
+    return clipping_window_.get();
+  }
+  return container;
+}
+
+void TrayBackgroundView::AnimateToTargetBounds(const gfx::Rect& target_bounds,
+                                               bool close_bubble) {
+  const int kAnimationDurationMS = 200;
+
+  ui::ScopedLayerAnimationSettings settings(
+      GetBubbleView()->GetWidget()->GetNativeView()->layer()->GetAnimator());
+  settings.SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(kAnimationDurationMS));
+  settings.SetTweenType(gfx::Tween::EASE_OUT);
+  settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  if (close_bubble)
+    settings.AddObserver(new CloseBubbleObserver(this));
+  GetBubbleView()->GetWidget()->SetBounds(target_bounds);
 }
 
 std::unique_ptr<views::InkDropMask> TrayBackgroundView::CreateInkDropMask()
     const {
   return base::MakeUnique<views::RoundRectInkDropMask>(
       size(), GetBackgroundInsets(), kTrayRoundedBorderRadius);
 }
 
 bool TrayBackgroundView::ShouldEnterPushedState(const ui::Event& event) {
   if (is_active_)
@@ skipping 29 matching lines @@
 }
 
 gfx::Rect TrayBackgroundView::GetBackgroundBounds() const {
   gfx::Insets insets = GetBackgroundInsets();
   gfx::Rect bounds = GetLocalBounds();
   bounds.Inset(insets);
   return bounds;
 }
 
 }  // namespace ash