Add MD ink drop ripple to shelf app items

ash/shelf/shelf_button.cc

 // Copyright 2013 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/shelf/shelf_button.h"
 
 #include <algorithm>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
@@ skipping 10 matching lines @@
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_constants.h"
 #include "ui/gfx/animation/animation_delegate.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skbitmap_operations.h"
+#include "ui/views/animation/square_ink_drop_ripple.h"
 #include "ui/views/controls/image_view.h"
 
 namespace {
 
 // Size of the bar. This is along the opposite axis of the shelf. For example,
 // if the shelf is aligned horizontally then this is the height of the bar.
 const int kBarSize = 3;
 const int kIconSize = 32;
 const int kIconPad = 5;
 const int kIconPadVertical = 6;
 const int kAttentionThrobDurationMS = 800;
 const int kMaxAnimationSeconds = 10;
 const int kIndicatorOffsetFromBottom = 2;
 const int kIndicatorRadius = 2;
 const SkColor kIndicatorColor = SK_ColorWHITE;
 
 // Canvas scale to ensure that the activity indicator is not pixelated even at
 // the highest possible device scale factors.
 const int kIndicatorCanvasScale = 5;
 
+// Shelf item ripple constants.
+const int kInkDropSmallSize = 48;
+const int kInkDropLargeSize = 60;
+const int kInkDropLargeCornerRadius = 4;
+const SkColor kInkDropBaseColor = SK_ColorWHITE;
+
 // Paints an activity indicator on |canvas| whose |size| is specified in DIP.
 void PaintIndicatorOnCanvas(gfx::Canvas* canvas, const gfx::Size& size) {
   SkPaint paint;
   paint.setColor(kIndicatorColor);
   paint.setFlags(SkPaint::kAntiAlias_Flag);
   canvas->DrawCircle(
       gfx::Point(size.width() / 2,
                  size.height() - kIndicatorOffsetFromBottom - kIndicatorRadius),
       kIndicatorRadius, paint);
 }
@@ skipping 175 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BarView);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfButton
 
 // static
 const char ShelfButton::kViewClassName[] = "ash/ShelfButton";
 
 ShelfButton::ShelfButton(ShelfView* shelf_view)
-    : CustomButton(shelf_view),
+    : CustomButton(nullptr),
       shelf_view_(shelf_view),
       icon_view_(new views::ImageView()),
       bar_(new BarView(shelf_view->shelf())),
       state_(STATE_NORMAL),
       destroyed_flag_(nullptr) {
   SetFocusBehavior(FocusBehavior::ACCESSIBLE_ONLY);
+  if (ash::MaterialDesignController::IsShelfMaterial()) {
+    SetHasInkDrop(true);
+    set_ink_drop_base_color(kInkDropBaseColor);
+  }
 
   const gfx::ShadowValue kShadows[] = {
       gfx::ShadowValue(gfx::Vector2d(0, 2), 0, SkColorSetARGB(0x1A, 0, 0, 0)),
       gfx::ShadowValue(gfx::Vector2d(0, 3), 1, SkColorSetARGB(0x1A, 0, 0, 0)),
       gfx::ShadowValue(gfx::Vector2d(0, 0), 1, SkColorSetARGB(0x54, 0, 0, 0)),
   };
   icon_shadows_.assign(kShadows, kShadows + arraysize(kShadows));
 
   // TODO: refactor the layers so each button doesn't require 2.
   icon_view_->SetPaintToLayer(true);
@@ skipping 62 matching lines @@
     Layout();
     if (state & STATE_ATTENTION)
       bar_->ShowAttention(false);
   }
 }
 
 gfx::Rect ShelfButton::GetIconBounds() const {
   return icon_view_->bounds();
 }
 
+void ShelfButton::OnDragStarted() {
+  AnimateInkDrop(views::InkDropState::HIDDEN);
+}
+
 void ShelfButton::ShowContextMenu(const gfx::Point& p,
                                   ui::MenuSourceType source_type) {
   if (!context_menu_controller())
     return;
 
   bool destroyed = false;
   destroyed_flag_ = &destroyed;
 
   CustomButton::ShowContextMenu(p, source_type);
 
@@ skipping 129 matching lines @@
     case ui::ET_GESTURE_SCROLL_END:
     case ui::ET_SCROLL_FLING_START:
       shelf_view_->PointerReleasedOnButton(this, ShelfView::TOUCH, false);
       event->SetHandled();
       return;
     default:
       return CustomButton::OnGestureEvent(event);
   }
 }
 
+std::unique_ptr<views::InkDropRipple> ShelfButton::CreateInkDropRipple() const {
+  return base::WrapUnique(new views::SquareInkDropRipple(
+      gfx::Size(kInkDropLargeSize, kInkDropLargeSize),
+      kInkDropLargeCornerRadius,
+      gfx::Size(kInkDropSmallSize, kInkDropSmallSize),
+      kInkDropSmallCornerRadius, GetInkDropCenter(), GetInkDropBaseColor()));
+}
+
+bool ShelfButton::ShouldEnterPushedState(const ui::Event& event) {
+  if (shelf_view_->WillIgnoreEventOnButton(this, event))
+    return false;
+
+  return CustomButton::ShouldEnterPushedState(event);
+}
+
+bool ShelfButton::ShouldShowInkDropHighlight() const {

[bruthig, 2016/06/09 03:25:59]

I can't remember what we discussed in person.  Am I correct that we are
deferring creating a ShouldShowInkDropHighlight() method until we switch the
keyboard focus on the shelf to use the InkDropHighlight?

[mohsen, 2016/06/09 21:24:50]

Yes. We don't want hover effect on shelf buttons. For focus, I'm not changing
anything yet as I'm waiting for specs.

[bruthig, 2016/06/10 15:25:19]

Acknowledged.

+  return false;
+}
+
+void ShelfButton::NotifyClick(const ui::Event& event) {
+  CustomButton::NotifyClick(event);
+  shelf_view_->ButtonPressed(this, event, ink_drop());
+}
+
 void ShelfButton::UpdateState() {
   UpdateBar();
   Shelf* shelf = shelf_view_->shelf();
   icon_view_->SetHorizontalAlignment(shelf->PrimaryAxisValue(
       views::ImageView::CENTER, views::ImageView::LEADING));
   icon_view_->SetVerticalAlignment(shelf->PrimaryAxisValue(
       views::ImageView::LEADING, views::ImageView::CENTER));
   SchedulePaint();
 }
 
@@ skipping 35 matching lines @@
         views::ImageView::TRAILING));
     bar_->SetVerticalAlignment(shelf->SelectValueForShelfAlignment(
         views::ImageView::TRAILING, views::ImageView::CENTER,
         views::ImageView::CENTER));
     bar_->SchedulePaint();
   }
   bar_->SetVisible(bar_id != 0 && state_ != STATE_NORMAL);
 }
 
 }  // namespace ash