Add ink drop ripple to overview mode button

ash/common/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/common/system/tray/tray_background_view.h"
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_util.h"
@@ skipping 15 matching lines @@
 #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/image/image_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/nine_image_painter.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
+#include "ui/views/animation/flood_fill_ink_drop_ripple.h"
+#include "ui/views/animation/ink_drop_highlight.h"
 #include "ui/views/background.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/wm/core/window_animations.h"
 
 namespace {
 
 const int kAnimationDurationForPopupMs = 200;
 
 // Duration of opacity animation for visibility changes.
 const int kAnimationDurationForVisibilityMs = 250;
 
 // When becoming visible delay the animation so that StatusAreaWidgetDelegate
 // can animate sibling views out of the position to be occuped by the
 // TrayBackgroundView.
 const int kShowAnimationDelayMs = 100;
 
 // Additional padding used to adjust the user-visible size of status tray
 // and overview button dark background.
 const int kBackgroundAdjustPadding = 3;
 
+const gfx::Rect GetBackgroundBounds(const gfx::Rect& local_bounds,
+                                    ash::ShelfAlignment shelf_alignment) {
+  if (IsHorizontalAlignment(shelf_alignment)) {
+    return gfx::Rect(local_bounds.x() + ash::kHitRegionPadding,
+                     local_bounds.y(),
+                     local_bounds.width() - ash::kHitRegionPadding -
+                         ash::kHitRegionPadding - ash::kSeparatorWidth,
+                     local_bounds.height());
+  }
+  return gfx::Rect(local_bounds.x(), local_bounds.y() + ash::kHitRegionPadding,
+                   local_bounds.width(),
+                   local_bounds.height() - ash::kHitRegionPadding -
+                       ash::kHitRegionPadding - ash::kSeparatorWidth);
+}
 }  // namespace
 
 using views::TrayBubbleView;
 
 namespace ash {
 
 // static
 const char TrayBackgroundView::kViewClassName[] = "tray/TrayBackgroundView";
 
 // Used to track when the anchor widget changes position on screen so that the
@@ skipping 21 matching lines @@
  public:
   const static int kImageTypeDefault = 0;
   const static int kImageTypeOnBlack = 1;
   const static int kImageTypePressed = 2;
   const static int kNumStates = 3;
 
   const static int kImageHorizontal = 0;
   const static int kImageVertical = 1;
   const static int kNumOrientations = 2;
 
-  explicit TrayBackground(TrayBackgroundView* tray_background_view)
-      : tray_background_view_(tray_background_view), alpha_(0) {}
+  TrayBackground(TrayBackgroundView* tray_background_view, bool draws_active)
+      : tray_background_view_(tray_background_view),
+        draws_active_(draws_active),
+        alpha_(0) {}
 
   ~TrayBackground() override {}
 
   void set_alpha(int alpha) { alpha_ = alpha; }
 
  private:
   WmShelf* GetShelf() const { return tray_background_view_->shelf(); }
 
   void PaintMaterial(gfx::Canvas* canvas, views::View* view) const {
     SkPaint background_paint;
     background_paint.setFlags(SkPaint::kAntiAlias_Flag);
     background_paint.setColor(SkColorSetA(kShelfBaseColor, alpha_));
-    gfx::Rect bounds;
     gfx::Rect local_bounds = view->GetLocalBounds();
-
-    // The hit region are padded to the |view| as insets, so they are included
-    // in the local bounds. Remove these regions from view because hit region is
-    // invisible.
-    if (IsHorizontalAlignment(GetShelf()->GetAlignment())) {
-      bounds = gfx::Rect(local_bounds.x() + kHitRegionPadding, local_bounds.y(),
-                         local_bounds.width() - kHitRegionPadding -
-                             kHitRegionPadding - kSeparatorWidth,
-                         local_bounds.height());
-    } else {
-      bounds = gfx::Rect(local_bounds.x(), local_bounds.y() + kHitRegionPadding,
-                         local_bounds.width(),
-                         local_bounds.height() - kHitRegionPadding -
-                             kHitRegionPadding - kSeparatorWidth);
-    }
+    gfx::Rect bounds =
+        GetBackgroundBounds(local_bounds, GetShelf()->GetAlignment());
     canvas->DrawRoundRect(bounds, kTrayRoundedBorderRadius, background_paint);
 
-    if (tray_background_view_->draw_background_as_active()) {
+    if (draws_active_ && tray_background_view_->is_active()) {
       SkPaint highlight_paint;
       highlight_paint.setFlags(SkPaint::kAntiAlias_Flag);
       highlight_paint.setColor(kShelfButtonActivatedHighlightColor);
       canvas->DrawRoundRect(bounds, kTrayRoundedBorderRadius, highlight_paint);
     }
   }
 
   void PaintNonMaterial(gfx::Canvas* canvas, views::View* view) const {
     const int kGridSizeForPainter = 9;
     const int kImages[kNumOrientations][kNumStates][kGridSizeForPainter] = {
         {
             // Horizontal
             IMAGE_GRID_HORIZONTAL(IDR_AURA_TRAY_BG_HORIZ),
             IMAGE_GRID_HORIZONTAL(IDR_AURA_TRAY_BG_HORIZ_ONBLACK),
             IMAGE_GRID_HORIZONTAL(IDR_AURA_TRAY_BG_HORIZ_PRESSED),
         },
         {
             // Vertical
             IMAGE_GRID_VERTICAL(IDR_AURA_TRAY_BG_VERTICAL),
             IMAGE_GRID_VERTICAL(IDR_AURA_TRAY_BG_VERTICAL_ONBLACK),
             IMAGE_GRID_VERTICAL(IDR_AURA_TRAY_BG_VERTICAL_PRESSED),
         }};
 
     WmShelf* shelf = GetShelf();
     const int orientation = IsHorizontalAlignment(shelf->GetAlignment())
                                 ? kImageHorizontal
                                 : kImageVertical;
 
     int state = kImageTypeDefault;
-    if (tray_background_view_->draw_background_as_active())
+    if (draws_active_ && tray_background_view_->is_active())
       state = kImageTypePressed;
     else if (shelf->IsDimmed())
       state = kImageTypeOnBlack;
     else
       state = kImageTypeDefault;
 
     ui::CreateNineImagePainter(kImages[orientation][state])
         ->Paint(canvas, view->GetLocalBounds());
   }
 
   // Overridden from views::Background.
   void Paint(gfx::Canvas* canvas, views::View* view) const override {
     if (MaterialDesignController::IsShelfMaterial())
       PaintMaterial(canvas, view);
     else
       PaintNonMaterial(canvas, view);
   }
 
   // Reference to the TrayBackgroundView for which this is a background.
   TrayBackgroundView* tray_background_view_;
 
+  // Determines whether we should draw an active background for the view when it
+  // is active.
+  // TODO(mohsen): This is used in non-MD version. Remove when non-MD code is
+  // removed (see https://crbug.com/614453).
+  bool draws_active_;
+
   int alpha_;
 
   DISALLOW_COPY_AND_ASSIGN(TrayBackground);
 };
 
 TrayBackgroundView::TrayContainer::TrayContainer(ShelfAlignment alignment)
     : alignment_(alignment) {
   UpdateLayout();
 }
 
@@ skipping 57 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // TrayBackgroundView
 
 TrayBackgroundView::TrayBackgroundView(WmShelf* wm_shelf)
     : ActionableView(nullptr),
       wm_shelf_(wm_shelf),
       tray_container_(NULL),
       shelf_alignment_(SHELF_ALIGNMENT_BOTTOM),
       background_(NULL),
-      draw_background_as_active_(false),
+      is_active_(false),
       is_separator_visible_(false),
       widget_observer_(new TrayWidgetObserver(this)) {
   DCHECK(wm_shelf_);
   set_notify_enter_exit_on_child(true);
+  set_ink_drop_base_color(SK_ColorWHITE);

[bruthig, 2016/11/11 17:30:40]

Can we move this color to a constant in tray_constants?

[mohsen, 2016/11/11 22:37:24]

Actually, there is a constant for this color! Done.

+  set_ink_drop_visible_opacity(kShelfInkDropVisibleOpacity);
 
   tray_container_ = new TrayContainer(shelf_alignment_);
   SetContents(tray_container_);
   tray_event_filter_.reset(new TrayEventFilter);
 
   SetPaintToLayer(true);
   layer()->SetFillsBoundsOpaquely(false);
   // Start the tray items not visible, because visibility changes are animated.
   views::View::SetVisible(false);
 }
@@ skipping 83 matching lines @@
   node_data->SetName(GetAccessibleNameForTray());
 }
 
 void TrayBackgroundView::AboutToRequestFocusFromTabTraversal(bool reverse) {
   // Return focus to the login view. See crbug.com/120500.
   views::View* v = GetNextFocusableView();
   if (v)
     v->AboutToRequestFocusFromTabTraversal(reverse);
 }
 
+std::unique_ptr<views::InkDropRipple> TrayBackgroundView::CreateInkDropRipple()
+    const {
+  return base::MakeUnique<views::FloodFillInkDropRipple>(
+      GetBackgroundBounds(GetContentsBounds(), shelf_alignment_),
+      GetInkDropCenterBasedOnLastEvent(), GetInkDropBaseColor(),
+      ink_drop_visible_opacity());
+}
+
+std::unique_ptr<views::InkDropHighlight>
+TrayBackgroundView::CreateInkDropHighlight() const {
+  gfx::Rect bounds = GetBackgroundBounds(GetContentsBounds(), shelf_alignment_);
+  std::unique_ptr<views::InkDropHighlight> highlight(
+      new views::InkDropHighlight(bounds.size(), 0,
+                                  gfx::RectF(bounds).CenterPoint(),
+                                  GetInkDropBaseColor()));
+  highlight->set_visible_opacity(kTrayPopupInkDropHighlightOpacity);
+  return highlight;
+}
+
+bool TrayBackgroundView::ShouldEnterPushedState(const ui::Event& event) {
+  if (is_active_)
+    return false;
+
+  return ActionableView::ShouldEnterPushedState(event);
+}
+
 bool TrayBackgroundView::PerformAction(const ui::Event& event) {
   return false;
 }
 
+void TrayBackgroundView::HandlePerformActionResult(bool action_performed,
+                                                   const ui::Event& event) {
+  // When an action is performed, ink drop ripple is handled in SetIsActive().
+  if (action_performed)
+    return;
+  ActionableView::HandlePerformActionResult(action_performed, event);
+}
+
 gfx::Rect TrayBackgroundView::GetFocusBounds() {
   // 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.
   return GetContentsBounds();
 }
 
 void TrayBackgroundView::OnGestureEvent(ui::GestureEvent* event) {
-  if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
-    SetDrawBackgroundAsActive(true);
-  } else if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN ||
-             event->type() == ui::ET_GESTURE_TAP_CANCEL) {
-    SetDrawBackgroundAsActive(false);
+  if (ink_drop_mode() == InkDropMode::OFF) {
+    if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
+      SetIsActive(true);
+    } else if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN ||
+               event->type() == ui::ET_GESTURE_TAP_CANCEL) {
+      SetIsActive(false);
+    }
   }
   ActionableView::OnGestureEvent(event);
 }
 
 void TrayBackgroundView::SetContents(views::View* contents) {
   SetLayoutManager(new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
   AddChildView(contents);
 }
-void TrayBackgroundView::SetContentsBackground() {
-  background_ = new TrayBackground(this);
+void TrayBackgroundView::SetContentsBackground(bool draws_active) {
+  background_ = new TrayBackground(this, draws_active);
   tray_container_->set_background(background_);
 }
 
 void TrayBackgroundView::SetShelfAlignment(ShelfAlignment alignment) {
   shelf_alignment_ = alignment;
   tray_container_->SetAlignment(alignment);
 }
 
 void TrayBackgroundView::OnImplicitAnimationsCompleted() {
   // If there is another animation in the queue, the reverse animation was
@@ skipping 104 matching lines @@
 }
 
 TrayBubbleView::AnchorAlignment TrayBackgroundView::GetAnchorAlignment() const {
   if (shelf_alignment_ == SHELF_ALIGNMENT_LEFT)
     return TrayBubbleView::ANCHOR_ALIGNMENT_LEFT;
   if (shelf_alignment_ == SHELF_ALIGNMENT_RIGHT)
     return TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT;
   return TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM;
 }
 
-void TrayBackgroundView::SetDrawBackgroundAsActive(bool visible) {
-  if (draw_background_as_active_ == visible)
+void TrayBackgroundView::SetIsActive(bool is_active) {
+  if (is_active_ == is_active)
     return;
-  draw_background_as_active_ = visible;
+  is_active_ = is_active;
+  AnimateInkDrop(is_active_ ? views::InkDropState::ACTIVATED
+                            : views::InkDropState::DEACTIVATED,
+                 nullptr);
   if (!background_)
     return;
+  // TODO(mohsen): This is needed for non-MD version. Remove when non-MD code is
+  // removed (see https://crbug.com/614453).
   SchedulePaint();
 }
 
 void TrayBackgroundView::UpdateBubbleViewArrow(
     views::TrayBubbleView* bubble_view) {
   // Nothing to do here.
 }
 
 void TrayBackgroundView::UpdateShelfItemBackground(int alpha) {
   if (background_) {
@@ skipping 32 matching lines @@
   paint.setAntiAlias(true);
 
   const gfx::Rect bounds = horizontal_shelf ? gfx::Rect(x, y, width, height)
                                             : gfx::Rect(y, x, height, width);
   gfx::RectF rect(gfx::ScaleRect(gfx::RectF(bounds), scale));
   canvas->DrawLine(horizontal_shelf ? rect.top_right() : rect.bottom_left(),
                    rect.bottom_right(), paint);
 }
 
 }  // namespace ash