[ash-md] Allows ToggleButton to have a border and adds focus rectangle

ui/views/controls/button/toggle_button.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 "ui/views/controls/button/toggle_button.h"
 
 #include "third_party/skia/include/core/SkDrawLooper.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/accessibility/ax_node_data.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/color_utils.h"
+#include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/views/animation/ink_drop_impl.h"
 #include "ui/views/animation/ink_drop_ripple.h"
 #include "ui/views/border.h"
+#include "ui/views/painter.h"
 
 namespace views {
 
 namespace {
 
 // Constants are measured in dip.
 const int kTrackHeight = 12;
 const int kTrackWidth = 28;
 // Margins from edge of track to edge of view.
 const int kTrackVerticalMargin = 5;
 const int kTrackHorizontalMargin = 6;
-// Margin from edge of thumb to closest edge of view. Note that the thumb
-// margins must be sufficiently large to allow space for the shadow.
-const int kThumbHorizontalMargin = 4;
-// Margin from top/bottom edge of thumb to top/bottom edge of view.
-const int kThumbVerticalMargin = 3;
+// Inset from the rounded edge of the thumb to the rounded edge of the track.
+const int kThumbInset = 2;
 
 }  // namespace
 
 // Class representing the thumb (the circle that slides horizontally).
 class ToggleButton::ThumbView : public InkDropHostView {
  public:
   ThumbView() : color_ratio_(0.) {}
   ~ThumbView() override {}
 
   void Update(const gfx::Rect& bounds, double color_ratio) {
     SetBoundsRect(bounds);
     color_ratio_ = color_ratio;
     SchedulePaint();
   }
 
   // Returns the extra space needed to draw the shadows around the thumb. Since
   // the extra space is around the thumb, the insets will be negative.
   static gfx::Insets GetShadowOutsets() {
     return gfx::Insets(-kShadowBlur)
         .Offset(gfx::Vector2d(kShadowOffsetX, kShadowOffsetY));
   }
 
+ protected:
+  // views::View:
+  bool CanProcessEventsWithinSubtree() const override {
+    // Make the thumb behave as part of the parent for event handling.

[Evan Stade, 2016/11/18 14:29:06]

other events like clicks and so forth already trickle up by default when
unhandled, so isn't this unnecessary without tooltips?

[Evan Stade, 2016/11/18 16:25:38]

I guess it's good to keep this anyway as some other user of ToggleButton may
want a tooltip, even if our current uses don't need one.

+    return false;
+  }
+
  private:
   static const int kShadowOffsetX = 0;
   static const int kShadowOffsetY = 1;
   static const int kShadowBlur = 2;
 
   // views::View:
   const char* GetClassName() const override {
     return "ToggleButton::ThumbView";
   }
 
@@ skipping 37 matching lines @@
 // static
 const char ToggleButton::kViewClassName[] = "ToggleButton";
 
 ToggleButton::ToggleButton(ButtonListener* listener)
     : CustomButton(listener),
       is_on_(false),
       slide_animation_(this),
       thumb_view_(new ThumbView()) {
   slide_animation_.SetSlideDuration(80 /* ms */);
   slide_animation_.SetTweenType(gfx::Tween::LINEAR);
-  SetBorder(CreateEmptyBorder(
-      gfx::Insets(kTrackVerticalMargin, kTrackHorizontalMargin)));
   AddChildView(thumb_view_);
   SetInkDropMode(InkDropMode::ON);
+  SetFocusForPlatform();
   set_has_ink_drop_action_on_click(true);
 }
 
 ToggleButton::~ToggleButton() {
   // Destroying ink drop early allows ink drop layer to be properly removed,
   SetInkDropMode(InkDropMode::OFF);
 }
 
 void ToggleButton::SetIsOn(bool is_on, bool animate) {
   if (is_on_ == is_on)
     return;
 
   is_on_ = is_on;
   if (!animate) {
     slide_animation_.Reset(is_on_ ? 1.0 : 0.0);
     UpdateThumb();
     SchedulePaint();
   } else if (is_on_) {
     slide_animation_.Show();
   } else {
     slide_animation_.Hide();
   }
 }
 
+void ToggleButton::set_focus_painter(std::unique_ptr<Painter> focus_painter) {

[sadrul, 2016/11/18 16:37:30]

Not sure if std::move is trivial enough to allow this, or whether this should be
SetFocusPainter() (although I notice we call View::SetBorder() instead of
View::set_border(), so perhaps this should be SetFocusPainter() too)

[varkha, 2016/11/18 16:55:35]

Done.

[Evan Stade, 2016/11/18 17:10:42]

I requested set_focus_painter --- it seems that std::move is sufficiently
trivial from a conceptual perspective (regardless of what may be going on under
the hood, the naming convention to me signals whether something above and beyond
assignment happens).

I hate that we use different naming conventions for set_background and
SetBorder. Always trips me up.

[sadrul, 2016/11/18 17:22:45]

set_background takes a raw-pointer, vs. SetBorder takes a unique_ptr<>

It used to be called set_border() too, and take a raw pointer. But it was then
changed to SetBorder(unique_ptr<>) later
(https://codereview.chromium.org/145033006). No one just converted
set_background() to be consistent with that yet.

+  focus_painter_ = std::move(focus_painter);
+}
+
+gfx::Size ToggleButton::GetPreferredSize() const {
+  gfx::Rect rect(kTrackWidth, kTrackHeight);
+  rect.Inset(gfx::Insets(-kTrackVerticalMargin, -kTrackHorizontalMargin));
+  if (border())
+    rect.Inset(-border()->GetInsets());
+  return rect.size();
+}
+
+gfx::Rect ToggleButton::GetTrackBounds() const {
+  gfx::Rect track_bounds(GetContentsBounds());
+  track_bounds.ClampToCenteredSize(gfx::Size(kTrackWidth, kTrackHeight));
+  return track_bounds;
+}
+
 gfx::Rect ToggleButton::GetThumbBounds() const {
-  gfx::Rect thumb_bounds = GetLocalBounds();
-  thumb_bounds.Inset(gfx::Insets(kThumbVerticalMargin, kThumbHorizontalMargin));
+  gfx::Rect thumb_bounds(GetTrackBounds());
+  thumb_bounds.Inset(gfx::Insets(-kThumbInset));
   thumb_bounds.set_x(thumb_bounds.x() +
                      slide_animation_.GetCurrentValue() *
                          (thumb_bounds.width() - thumb_bounds.height()));
   // The thumb is a circle, so the width should match the height.
   thumb_bounds.set_width(thumb_bounds.height());
   thumb_bounds.set_x(GetMirroredXForRect(thumb_bounds));
   thumb_bounds.Inset(ThumbView::GetShadowOutsets());
   return thumb_bounds;
 }
 
 void ToggleButton::UpdateThumb() {
   thumb_view_->Update(GetThumbBounds(), slide_animation_.GetCurrentValue());
 }
 
 SkColor ToggleButton::GetTrackColor(bool is_on) const {
   const SkAlpha kOffTrackAlpha = 0x29;
   const SkAlpha kOnTrackAlpha = kOffTrackAlpha * 2;
   ui::NativeTheme::ColorId color_id =
       is_on ? ui::NativeTheme::kColorId_ProminentButtonColor
             : ui::NativeTheme::kColorId_LabelEnabledColor;
   return SkColorSetA(GetNativeTheme()->GetSystemColor(color_id),
                      is_on ? kOnTrackAlpha : kOffTrackAlpha);
 }
 
-gfx::Size ToggleButton::GetPreferredSize() const {
-  gfx::Rect rect(0, 0, kTrackWidth, kTrackHeight);
-  if (border())
-    rect.Inset(-border()->GetInsets());
-  return rect.size();
-}
-
 const char* ToggleButton::GetClassName() const {
   return kViewClassName;
 }
 
 void ToggleButton::OnPaint(gfx::Canvas* canvas) {
   // Paint the toggle track. To look sharp even at fractional scale factors,
   // round up to pixel boundaries.
+  canvas->Save();

[sadrul, 2016/11/18 16:37:30]

gfx::ScopedCanvas

But why do you need to do this? View::Paint already does this save/restore
before calling OnPaint()

[varkha, 2016/11/18 16:55:35]

This is to restore scale before painting the focus rect. I'll update the rest,
hope this one is right.

   float dsf = canvas->UndoDeviceScaleFactor();
-  gfx::RectF track_rect(GetContentsBounds());
+  gfx::RectF track_rect(GetTrackBounds());
   track_rect.Scale(dsf);
   track_rect = gfx::RectF(gfx::ToEnclosingRect(track_rect));
   SkPaint track_paint;
   track_paint.setAntiAlias(true);
   const double color_ratio = slide_animation_.GetCurrentValue();
   track_paint.setColor(color_utils::AlphaBlend(
       GetTrackColor(true), GetTrackColor(false),
       static_cast<SkAlpha>(SK_AlphaOPAQUE * color_ratio)));
   canvas->DrawRoundRect(track_rect, track_rect.height() / 2, track_paint);
+  canvas->Restore();
+
+  views::Painter::PaintFocusPainter(this, canvas, focus_painter_.get());

[sadrul, 2016/11/18 16:37:30]

Omit views::

[varkha, 2016/11/18 16:55:35]

Done.

 }
 
-void ToggleButton::NotifyClick(const ui::Event& event) {
-  SetIsOn(!is_on(), true);
-  CustomButton::NotifyClick(event);
+void ToggleButton::OnFocus() {
+  CustomButton::OnFocus();
+  if (focus_painter_)
+    SchedulePaint();
+}
+
+void ToggleButton::OnBlur() {
+  CustomButton::OnBlur();
+  if (focus_painter_)
+    SchedulePaint();
 }
 
 void ToggleButton::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   UpdateThumb();
 }
 
 void ToggleButton::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   SchedulePaint();
 }
 
 void ToggleButton::GetAccessibleNodeData(ui::AXNodeData* node_data) {
   CustomButton::GetAccessibleNodeData(node_data);
 
   node_data->role = ui::AX_ROLE_SWITCH;
   if (is_on_)
     node_data->AddStateFlag(ui::AX_STATE_CHECKED);
 }
 
+void ToggleButton::NotifyClick(const ui::Event& event) {
+  SetIsOn(!is_on(), true);
+  CustomButton::NotifyClick(event);
+}
+
 void ToggleButton::AddInkDropLayer(ui::Layer* ink_drop_layer) {
   thumb_view_->AddInkDropLayer(ink_drop_layer);
 }
 
 void ToggleButton::RemoveInkDropLayer(ui::Layer* ink_drop_layer) {
   thumb_view_->RemoveInkDropLayer(ink_drop_layer);
 }
 
 std::unique_ptr<InkDrop> ToggleButton::CreateInkDrop() {
   std::unique_ptr<InkDropImpl> ink_drop =
@@ skipping 17 matching lines @@
     // TODO(varkha, estade): The thumb is using its own view. Investigate if
     // repainting in every animation step to update colors could be avoided.
     UpdateThumb();
     SchedulePaint();
     return;
   }
   CustomButton::AnimationProgressed(animation);
 }
 
 }  // namespace views