ash/login/ui/note_action_launch_button.cc - chromium/src - Git at Google

 // Copyright 2017 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/login/ui/note_action_launch_button.h"

 #include <memory>

 #include "ash/public/interfaces/tray_action.mojom.h"
 #include "ash/resources/vector_icons/vector_icons.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/strings/grit/ash_strings.h"
 #include "base/i18n/rtl.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/views/animation/ink_drop_painted_layer_delegates.h"
 #include "ui/views/controls/button/button.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/masked_targeter_delegate.h"
 #include "ui/views/view_targeter.h"

 namespace ash {

 namespace {

 // The default note action bubble size.
 constexpr int kSmallBubbleRadiusDp = 48;

 // The default note action bubble opacity.
 constexpr float kSmallBubbleOpacity = 0.34;

 // The note action bubble size when it's hovered/focused.
 constexpr int kLargeBubbleRadiusDp = 56;

 // The note action bubble opacity when it's hovered/focused.
 constexpr float kLargeBubbleOpacity = 0.46;

 // The note action background color.
 constexpr int kBubbleColor = SkColorSetRGB(0x9E, 0x9E, 0x9E);

 // The note action icon size.
 constexpr int kIconSizeDp = 16;

 // The note action icon padding from top and right bubble edges (assuming LTR
 // layout).
 constexpr int kIconPaddingDp = 12;

 // Layer delegate for painting a bubble of the specified radius and color to a
 // layer. The bubble is painted as a quarter of a circle with the center in top
 // right corner of the painted bounds.
 // This is used to paint the bubble on the background view's layer.
 class BubbleLayerDelegate : public views::BasePaintedLayerDelegate {
  public:
   BubbleLayerDelegate(SkColor color, int radius)
       : views::BasePaintedLayerDelegate(color), radius_(radius) {}

   ~BubbleLayerDelegate() override = default;

   // views::BasePaintedLayerDelegate:
   gfx::RectF GetPaintedBounds() const override {
     return gfx::RectF(0, 0, radius_, radius_);
   }

   void OnPaintLayer(const ui::PaintContext& context) override {
     cc::PaintFlags flags;
     flags.setColor(color());
     flags.setAntiAlias(true);
     flags.setStyle(cc::PaintFlags::kFill_Style);

     ui::PaintRecorder recorder(context, gfx::Size(radius_, radius_));
     gfx::Canvas* canvas = recorder.canvas();
     canvas->Save();
     canvas->ClipRect(GetPaintedBounds());
     canvas->DrawCircle(base::i18n::IsRTL() ? GetPaintedBounds().origin()
                                            : GetPaintedBounds().top_right(),
                        radius_, flags);
     canvas->Restore();
   }

  private:
   // The radius of the circle.
   int radius_;

   DISALLOW_COPY_AND_ASSIGN(BubbleLayerDelegate);
 };

 }  // namespace

 // The (background) view that paints and animates the note action bubble.
 class NoteActionLaunchButton::BackgroundView : public NonAccessibleView {
  public:
   // NOTE: the background layer is set to the large bubble bounds and scaled
   // down when needed.
   BackgroundView()
       : background_layer_delegate_(kBubbleColor, kLargeBubbleRadiusDp) {
     // Painted to layer to provide background animations when the background
     // bubble is resized due to the action button changing its state (for
     // example when the button is hovered, the background should be expanded to
     // kLargeBubbleRadiusDp).
     SetPaintToLayer();

     layer()->set_delegate(&background_layer_delegate_);
     layer()->SetMasksToBounds(true);
     layer()->SetFillsBoundsOpaquely(false);
     layer()->SetVisible(true);
     layer()->SetOpacity(opacity_);
   }

   ~BackgroundView() override = default;

   // Updates the bubble's opacity and radius. The bubble radius is updated
   // applying scale transform to the view's layout. Transformations are
   // animated.
   void SetBubbleRadiusAndOpacity(int target_radius, float opacity) {
     if (target_radius == bubble_radius_ && opacity_ == opacity)
       return;

     ui::ScopedLayerAnimationSettings settings(layer()->GetAnimator());
     settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     settings.SetTweenType(gfx::Tween::EASE_IN);

     gfx::Transform transform;
     if (target_radius != kLargeBubbleRadiusDp) {
       // Move the buble to it's new origin before scaling the image - note that
       // in RTL layout, the origin remains the same - (0, 0) in local bounds.
       if (!base::i18n::IsRTL())
         transform.Translate(kLargeBubbleRadiusDp - target_radius, 0);
       float scale = target_radius / static_cast<float>(kLargeBubbleRadiusDp);
       transform.Scale(scale, scale);
     }

     layer()->SetTransform(transform);
     layer()->SetOpacity(opacity);

     bubble_radius_ = target_radius;
   }

  private:
   float opacity_ = 0;
   int bubble_radius_ = 0;

   BubbleLayerDelegate background_layer_delegate_;

   DISALLOW_COPY_AND_ASSIGN(BackgroundView);
 };

 // The event target delegate used for the note action view. It matches the
 // shape of the bubble with the provided radius.
 class BubbleTargeterDelegate : public views::MaskedTargeterDelegate {
  public:
   explicit BubbleTargeterDelegate(int view_width, int circle_radius)
       : view_width_(view_width), circle_radius_(circle_radius) {}
   ~BubbleTargeterDelegate() override = default;

   bool GetHitTestMask(SkPath* mask) const override {
     int center_x = base::i18n::IsRTL() ? 0 : view_width_;
     mask->addCircle(SkIntToScalar(center_x), SkIntToScalar(0),
                     SkIntToScalar(circle_radius_));
     return true;
   }

  private:
   int view_width_;
   int circle_radius_;

   DISALLOW_COPY_AND_ASSIGN(BubbleTargeterDelegate);
 };

 // The action button foreground - an image button with actionable area matching
 // the (small) bubble shape centered in the top right corner of the action
 // button bounds.
 class NoteActionLaunchButton::ActionButton : public views::ImageButton,
                                              public views::ButtonListener {
  public:
   explicit ActionButton(NoteActionLaunchButton::BackgroundView* background)
       : views::ImageButton(this),
         background_(background),
         event_targeter_delegate_(kLargeBubbleRadiusDp, kSmallBubbleRadiusDp) {
     SetAccessibleName(
         l10n_util::GetStringUTF16(IDS_ASH_STYLUS_TOOLS_CREATE_NOTE_ACTION));
     SetImage(
         views::Button::STATE_NORMAL,
         CreateVectorIcon(kTrayActionNewLockScreenNoteIcon, kShelfIconColor));
     SetFocusBehavior(views::View::FocusBehavior::ALWAYS);
     SetFocusPainter(nullptr);
     EnableCanvasFlippingForRTLUI(true);
     SetPreferredSize(gfx::Size(kLargeBubbleRadiusDp, kLargeBubbleRadiusDp));
     SetEventTargeter(
         std::make_unique<views::ViewTargeter>(&event_targeter_delegate_));

     // Paint to layer because the background is painted to layer - if the button
     // was not painted to layer as well, the background would be painted over
     // it.
     SetPaintToLayer();
     layer()->SetMasksToBounds(true);
     layer()->SetFillsBoundsOpaquely(false);

     UpdateBubbleRadiusAndOpacity();
   }

   ~ActionButton() override = default;

   // views::ImageButton:
   void PaintButtonContents(gfx::Canvas* canvas) override {
     canvas->Save();
     // Correctly position the icon image on the button's canvas.
     canvas->Translate(gfx::Vector2d(
         kLargeBubbleRadiusDp - kIconSizeDp - kIconPaddingDp, kIconPaddingDp));
     canvas->ClipRect(gfx::Rect(0, 0, kIconSizeDp, kIconSizeDp));

     views::ImageButton::PaintButtonContents(canvas);
     canvas->Restore();
   }
   void StateChanged(ButtonState old_state) override {
     UpdateBubbleRadiusAndOpacity();
   }
   void OnFocus() override {
     ImageButton::OnFocus();
     UpdateBubbleRadiusAndOpacity();
   }
   void OnBlur() override {
     ImageButton::OnBlur();
     UpdateBubbleRadiusAndOpacity();
   }
   void OnGestureEvent(ui::GestureEvent* event) override {
     switch (event->type()) {
       case ui::ET_GESTURE_SCROLL_BEGIN:
         // Mark scroll begin handled, so the view starts receiving scroll
         // events (in particular) fling/swipe.
         // Ignore multi-finger gestures - the note action requests are
         // restricted to single finger gestures.
         if (event->details().touch_points() == 1) {
           SetTrackingPotentialActivationGesture(true);
           event->SetHandled();
         }
         break;
       case ui::ET_GESTURE_SCROLL_UPDATE:
         // If the user has added fingers to the gesture, cancel the fling
         // detection - the note action requests are restricted to single finger
         // gestures.
         if (event->details().touch_points() != 1)
           SetTrackingPotentialActivationGesture(false);
         break;
       case ui::ET_GESTURE_END:
       case ui::ET_GESTURE_SCROLL_END:
       case ui::ET_SCROLL_FLING_CANCEL:
         SetTrackingPotentialActivationGesture(false);
         break;
       case ui::ET_SCROLL_FLING_START:
         MaybeActivateActionOnFling(event);
         SetTrackingPotentialActivationGesture(false);
         event->StopPropagation();
         break;
       default:
         break;
     }

     if (!event->handled())
       views::ImageButton::OnGestureEvent(event);
   }

   // views::ButtonListener:
   void ButtonPressed(views::Button* sender, const ui::Event& event) override {
     UserMetricsRecorder::RecordUserClickOnTray(
         LoginMetricsRecorder::TrayClickTarget::kTrayActionNoteButton);
     if (event.IsKeyEvent()) {
       Shell::Get()->tray_action()->RequestNewLockScreenNote(
           mojom::LockScreenNoteOrigin::kLockScreenButtonKeyboard);
     } else {
       Shell::Get()->tray_action()->RequestNewLockScreenNote(
           mojom::LockScreenNoteOrigin::kLockScreenButtonTap);
     }
   }

  private:
   // Updates the background view size and opacity depending on the current note
   // action button state.
   void UpdateBubbleRadiusAndOpacity() {
     bool show_large_bubble = HasFocus() || state() == STATE_HOVERED ||
                              state() == STATE_PRESSED ||
                              tracking_activation_gesture_;
     background_->SetBubbleRadiusAndOpacity(
         show_large_bubble ? kLargeBubbleRadiusDp : kSmallBubbleRadiusDp,
         show_large_bubble ? kLargeBubbleOpacity : kSmallBubbleOpacity);
   }

   // Called when a fling is detected - if the gesture direction was bottom-left,
   // it requests a new lock screen note.
   void MaybeActivateActionOnFling(ui::GestureEvent* event) {
     int adjust_x_for_rtl = base::i18n::IsRTL() ? -1 : 1;
     if (!tracking_activation_gesture_ || event->details().touch_points() != 1 ||
         adjust_x_for_rtl * event->details().velocity_x() > 0 ||
         event->details().velocity_y() < 0) {
       return;
     }

     Shell::Get()->tray_action()->RequestNewLockScreenNote(
         mojom::LockScreenNoteOrigin::kLockScreenButtonSwipe);
   }

   // Sets a flag indicating that the button is tracking a potential note
   // activation gesture, updating the background view appearance (as the
   // background bubble should be expanded if a gesture is tracked.
   void SetTrackingPotentialActivationGesture(bool tracking_activation_gesture) {
     tracking_activation_gesture_ = tracking_activation_gesture;
     UpdateBubbleRadiusAndOpacity();
   }

   // The background view, which paints the note action bubble.
   NoteActionLaunchButton::BackgroundView* background_;

   BubbleTargeterDelegate event_targeter_delegate_;

   // Set when a potention note activation gesture is tracked - i.e. while a
   // scroll gesture (which could lead to a fling) is in progress.
   bool tracking_activation_gesture_ = false;

   DISALLOW_COPY_AND_ASSIGN(ActionButton);
 };

 NoteActionLaunchButton::TestApi::TestApi(NoteActionLaunchButton* launch_button)
     : launch_button_(launch_button) {}

 NoteActionLaunchButton::TestApi::~TestApi() = default;

 const views::View* NoteActionLaunchButton::TestApi::ActionButtonView() const {
   return launch_button_->action_button_;
 }

 const views::View* NoteActionLaunchButton::TestApi::BackgroundView() const {
   return launch_button_->background_;
 }

 NoteActionLaunchButton::NoteActionLaunchButton(
     mojom::TrayActionState initial_note_action_state) {
   SetLayoutManager(std::make_unique<views::FillLayout>());

   background_ = new BackgroundView();
   AddChildView(background_);

   action_button_ = new ActionButton(background_);
   AddChildView(action_button_);

   UpdateVisibility(initial_note_action_state);
 }

 NoteActionLaunchButton::~NoteActionLaunchButton() = default;

 void NoteActionLaunchButton::UpdateVisibility(
     mojom::TrayActionState action_state) {
   SetVisible(action_state == mojom::TrayActionState::kAvailable);
 }

 }  // namespace ash
	// Copyright 2017 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/login/ui/note_action_launch_button.h"

	#include <memory>

	#include "ash/public/interfaces/tray_action.mojom.h"
	#include "ash/resources/vector_icons/vector_icons.h"
	#include "ash/shelf/shelf_constants.h"
	#include "ash/strings/grit/ash_strings.h"
	#include "base/i18n/rtl.h"
	#include "ui/base/l10n/l10n_util.h"
	#include "ui/compositor/layer.h"
	#include "ui/compositor/layer_animator.h"
	#include "ui/compositor/paint_recorder.h"
	#include "ui/compositor/scoped_layer_animation_settings.h"
	#include "ui/gfx/canvas.h"
	#include "ui/gfx/geometry/rect.h"
	#include "ui/gfx/geometry/size.h"
	#include "ui/gfx/paint_vector_icon.h"
	#include "ui/views/animation/ink_drop_painted_layer_delegates.h"
	#include "ui/views/controls/button/button.h"
	#include "ui/views/controls/button/image_button.h"
	#include "ui/views/layout/fill_layout.h"
	#include "ui/views/masked_targeter_delegate.h"
	#include "ui/views/view_targeter.h"

	namespace ash {

	namespace {

	// The default note action bubble size.
	constexpr int kSmallBubbleRadiusDp = 48;

	// The default note action bubble opacity.
	constexpr float kSmallBubbleOpacity = 0.34;

	// The note action bubble size when it's hovered/focused.
	constexpr int kLargeBubbleRadiusDp = 56;

	// The note action bubble opacity when it's hovered/focused.
	constexpr float kLargeBubbleOpacity = 0.46;

	// The note action background color.
	constexpr int kBubbleColor = SkColorSetRGB(0x9E, 0x9E, 0x9E);

	// The note action icon size.
	constexpr int kIconSizeDp = 16;

	// The note action icon padding from top and right bubble edges (assuming LTR
	// layout).
	constexpr int kIconPaddingDp = 12;

	// Layer delegate for painting a bubble of the specified radius and color to a
	// layer. The bubble is painted as a quarter of a circle with the center in top
	// right corner of the painted bounds.
	// This is used to paint the bubble on the background view's layer.
	class BubbleLayerDelegate : public views::BasePaintedLayerDelegate {
	public:
	BubbleLayerDelegate(SkColor color, int radius)
	: views::BasePaintedLayerDelegate(color), radius_(radius) {}

	~BubbleLayerDelegate() override = default;

	// views::BasePaintedLayerDelegate:
	gfx::RectF GetPaintedBounds() const override {
	return gfx::RectF(0, 0, radius_, radius_);
	}

	void OnPaintLayer(const ui::PaintContext& context) override {
	cc::PaintFlags flags;
	flags.setColor(color());
	flags.setAntiAlias(true);
	flags.setStyle(cc::PaintFlags::kFill_Style);

	ui::PaintRecorder recorder(context, gfx::Size(radius_, radius_));
	gfx::Canvas* canvas = recorder.canvas();
	canvas->Save();
	canvas->ClipRect(GetPaintedBounds());
	canvas->DrawCircle(base::i18n::IsRTL() ? GetPaintedBounds().origin()
	: GetPaintedBounds().top_right(),
	radius_, flags);
	canvas->Restore();
	}

	private:
	// The radius of the circle.
	int radius_;

	DISALLOW_COPY_AND_ASSIGN(BubbleLayerDelegate);
	};

	} // namespace

	// The (background) view that paints and animates the note action bubble.
	class NoteActionLaunchButton::BackgroundView : public NonAccessibleView {
	public:
	// NOTE: the background layer is set to the large bubble bounds and scaled
	// down when needed.
	BackgroundView()
	: background_layer_delegate_(kBubbleColor, kLargeBubbleRadiusDp) {
	// Painted to layer to provide background animations when the background
	// bubble is resized due to the action button changing its state (for
	// example when the button is hovered, the background should be expanded to
	// kLargeBubbleRadiusDp).
	SetPaintToLayer();

	layer()->set_delegate(&background_layer_delegate_);
	layer()->SetMasksToBounds(true);
	layer()->SetFillsBoundsOpaquely(false);
	layer()->SetVisible(true);
	layer()->SetOpacity(opacity_);
	}

	~BackgroundView() override = default;

	// Updates the bubble's opacity and radius. The bubble radius is updated
	// applying scale transform to the view's layout. Transformations are
	// animated.
	void SetBubbleRadiusAndOpacity(int target_radius, float opacity) {
	if (target_radius == bubble_radius_ && opacity_ == opacity)
	return;

	ui::ScopedLayerAnimationSettings settings(layer()->GetAnimator());
	settings.SetPreemptionStrategy(
	ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
	settings.SetTweenType(gfx::Tween::EASE_IN);

	gfx::Transform transform;
	if (target_radius != kLargeBubbleRadiusDp) {
	// Move the buble to it's new origin before scaling the image - note that
	// in RTL layout, the origin remains the same - (0, 0) in local bounds.
	if (!base::i18n::IsRTL())
	transform.Translate(kLargeBubbleRadiusDp - target_radius, 0);
	float scale = target_radius / static_cast<float>(kLargeBubbleRadiusDp);
	transform.Scale(scale, scale);
	}

	layer()->SetTransform(transform);
	layer()->SetOpacity(opacity);

	bubble_radius_ = target_radius;
	}

	private:
	float opacity_ = 0;
	int bubble_radius_ = 0;

	BubbleLayerDelegate background_layer_delegate_;

	DISALLOW_COPY_AND_ASSIGN(BackgroundView);
	};

	// The event target delegate used for the note action view. It matches the
	// shape of the bubble with the provided radius.
	class BubbleTargeterDelegate : public views::MaskedTargeterDelegate {
	public:
	explicit BubbleTargeterDelegate(int view_width, int circle_radius)
	: view_width_(view_width), circle_radius_(circle_radius) {}
	~BubbleTargeterDelegate() override = default;

	bool GetHitTestMask(SkPath* mask) const override {
	int center_x = base::i18n::IsRTL() ? 0 : view_width_;
	mask->addCircle(SkIntToScalar(center_x), SkIntToScalar(0),
	SkIntToScalar(circle_radius_));
	return true;
	}

	private:
	int view_width_;
	int circle_radius_;

	DISALLOW_COPY_AND_ASSIGN(BubbleTargeterDelegate);
	};

	// The action button foreground - an image button with actionable area matching
	// the (small) bubble shape centered in the top right corner of the action
	// button bounds.
	class NoteActionLaunchButton::ActionButton : public views::ImageButton,
	public views::ButtonListener {
	public:
	explicit ActionButton(NoteActionLaunchButton::BackgroundView* background)
	: views::ImageButton(this),
	background_(background),
	event_targeter_delegate_(kLargeBubbleRadiusDp, kSmallBubbleRadiusDp) {
	SetAccessibleName(
	l10n_util::GetStringUTF16(IDS_ASH_STYLUS_TOOLS_CREATE_NOTE_ACTION));
	SetImage(
	views::Button::STATE_NORMAL,
	CreateVectorIcon(kTrayActionNewLockScreenNoteIcon, kShelfIconColor));
	SetFocusBehavior(views::View::FocusBehavior::ALWAYS);
	SetFocusPainter(nullptr);
	EnableCanvasFlippingForRTLUI(true);
	SetPreferredSize(gfx::Size(kLargeBubbleRadiusDp, kLargeBubbleRadiusDp));
	SetEventTargeter(
	std::make_unique<views::ViewTargeter>(&event_targeter_delegate_));

	// Paint to layer because the background is painted to layer - if the button
	// was not painted to layer as well, the background would be painted over
	// it.
	SetPaintToLayer();
	layer()->SetMasksToBounds(true);
	layer()->SetFillsBoundsOpaquely(false);

	UpdateBubbleRadiusAndOpacity();
	}

	~ActionButton() override = default;

	// views::ImageButton:
	void PaintButtonContents(gfx::Canvas* canvas) override {
	canvas->Save();
	// Correctly position the icon image on the button's canvas.
	canvas->Translate(gfx::Vector2d(
	kLargeBubbleRadiusDp - kIconSizeDp - kIconPaddingDp, kIconPaddingDp));
	canvas->ClipRect(gfx::Rect(0, 0, kIconSizeDp, kIconSizeDp));

	views::ImageButton::PaintButtonContents(canvas);
	canvas->Restore();
	}
	void StateChanged(ButtonState old_state) override {
	UpdateBubbleRadiusAndOpacity();
	}
	void OnFocus() override {
	ImageButton::OnFocus();
	UpdateBubbleRadiusAndOpacity();
	}
	void OnBlur() override {
	ImageButton::OnBlur();
	UpdateBubbleRadiusAndOpacity();
	}
	void OnGestureEvent(ui::GestureEvent* event) override {
	switch (event->type()) {
	case ui::ET_GESTURE_SCROLL_BEGIN:
	// Mark scroll begin handled, so the view starts receiving scroll
	// events (in particular) fling/swipe.
	// Ignore multi-finger gestures - the note action requests are
	// restricted to single finger gestures.
	if (event->details().touch_points() == 1) {
	SetTrackingPotentialActivationGesture(true);
	event->SetHandled();
	}
	break;
	case ui::ET_GESTURE_SCROLL_UPDATE:
	// If the user has added fingers to the gesture, cancel the fling
	// detection - the note action requests are restricted to single finger
	// gestures.
	if (event->details().touch_points() != 1)
	SetTrackingPotentialActivationGesture(false);
	break;
	case ui::ET_GESTURE_END:
	case ui::ET_GESTURE_SCROLL_END:
	case ui::ET_SCROLL_FLING_CANCEL:
	SetTrackingPotentialActivationGesture(false);
	break;
	case ui::ET_SCROLL_FLING_START:
	MaybeActivateActionOnFling(event);
	SetTrackingPotentialActivationGesture(false);
	event->StopPropagation();
	break;
	default:
	break;
	}

	if (!event->handled())
	views::ImageButton::OnGestureEvent(event);
	}

	// views::ButtonListener:
	void ButtonPressed(views::Button* sender, const ui::Event& event) override {
	UserMetricsRecorder::RecordUserClickOnTray(
	LoginMetricsRecorder::TrayClickTarget::kTrayActionNoteButton);
	if (event.IsKeyEvent()) {
	Shell::Get()->tray_action()->RequestNewLockScreenNote(
	mojom::LockScreenNoteOrigin::kLockScreenButtonKeyboard);
	} else {
	Shell::Get()->tray_action()->RequestNewLockScreenNote(
	mojom::LockScreenNoteOrigin::kLockScreenButtonTap);
	}
	}

	private:
	// Updates the background view size and opacity depending on the current note
	// action button state.
	void UpdateBubbleRadiusAndOpacity() {
	bool show_large_bubble = HasFocus() \|\| state() == STATE_HOVERED \|\|
	state() == STATE_PRESSED \|\|
	tracking_activation_gesture_;
	background_->SetBubbleRadiusAndOpacity(
	show_large_bubble ? kLargeBubbleRadiusDp : kSmallBubbleRadiusDp,
	show_large_bubble ? kLargeBubbleOpacity : kSmallBubbleOpacity);
	}

	// Called when a fling is detected - if the gesture direction was bottom-left,
	// it requests a new lock screen note.
	void MaybeActivateActionOnFling(ui::GestureEvent* event) {
	int adjust_x_for_rtl = base::i18n::IsRTL() ? -1 : 1;
	if (!tracking_activation_gesture_ \|\| event->details().touch_points() != 1 \|\|
	adjust_x_for_rtl * event->details().velocity_x() > 0 \|\|
	event->details().velocity_y() < 0) {
	return;
	}

	Shell::Get()->tray_action()->RequestNewLockScreenNote(
	mojom::LockScreenNoteOrigin::kLockScreenButtonSwipe);
	}

	// Sets a flag indicating that the button is tracking a potential note
	// activation gesture, updating the background view appearance (as the
	// background bubble should be expanded if a gesture is tracked.
	void SetTrackingPotentialActivationGesture(bool tracking_activation_gesture) {
	tracking_activation_gesture_ = tracking_activation_gesture;
	UpdateBubbleRadiusAndOpacity();
	}

	// The background view, which paints the note action bubble.
	NoteActionLaunchButton::BackgroundView* background_;

	BubbleTargeterDelegate event_targeter_delegate_;

	// Set when a potention note activation gesture is tracked - i.e. while a
	// scroll gesture (which could lead to a fling) is in progress.
	bool tracking_activation_gesture_ = false;

	DISALLOW_COPY_AND_ASSIGN(ActionButton);
	};

	NoteActionLaunchButton::TestApi::TestApi(NoteActionLaunchButton* launch_button)
	: launch_button_(launch_button) {}

	NoteActionLaunchButton::TestApi::~TestApi() = default;

	const views::View* NoteActionLaunchButton::TestApi::ActionButtonView() const {
	return launch_button_->action_button_;
	}

	const views::View* NoteActionLaunchButton::TestApi::BackgroundView() const {
	return launch_button_->background_;
	}

	NoteActionLaunchButton::NoteActionLaunchButton(
	mojom::TrayActionState initial_note_action_state) {
	SetLayoutManager(std::make_unique<views::FillLayout>());

	background_ = new BackgroundView();
	AddChildView(background_);

	action_button_ = new ActionButton(background_);
	AddChildView(action_button_);

	UpdateVisibility(initial_note_action_state);
	}

	NoteActionLaunchButton::~NoteActionLaunchButton() = default;

	void NoteActionLaunchButton::UpdateVisibility(
	mojom::TrayActionState action_state) {
	SetVisible(action_state == mojom::TrayActionState::kAvailable);
	}

	} // namespace ash