views::Border: Added CreateRoundedRectBorder.

ui/views/border.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 "ui/views/border.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "third_party/skia/include/core/SkPaint.h"
 #include "ui/gfx/canvas.h"
 #include "ui/views/painter.h"
 #include "ui/views/view.h"
 
 namespace views {
 
 namespace {
 
 // A simple border with different thicknesses on each side and single color.
 class SolidSidedBorder : public Border {
@@ skipping 33 matching lines @@
 }
 
 gfx::Insets SolidSidedBorder::GetInsets() const {
   return insets_;
 }
 
 gfx::Size SolidSidedBorder::GetMinimumSize() const {
   return gfx::Size(insets_.width(), insets_.height());
 }
 
+// A border with a rounded rectangle and single color.
+class RoundedRectBorder : public Border {
+ public:
+  RoundedRectBorder(int thickness, int corner_radius, SkColor color);
+
+  // Overridden from Border:
+  void Paint(const View& view, gfx::Canvas* canvas) override;
+  gfx::Insets GetInsets() const override;
+  gfx::Size GetMinimumSize() const override;
+
+ private:
+  const int thickness_;
+  const int corner_radius_;
+  const SkColor color_;
+
+  DISALLOW_COPY_AND_ASSIGN(RoundedRectBorder);
+};
+
+RoundedRectBorder::RoundedRectBorder(int thickness,
+                                     int corner_radius,
+                                     SkColor color)
+    : thickness_(thickness), corner_radius_(corner_radius), color_(color) {}
+
+void RoundedRectBorder::Paint(const View& view, gfx::Canvas* canvas) {
+  SkPaint paint;
+  paint.setStrokeWidth(thickness_);
+  paint.setColor(color_);
+  paint.setStyle(SkPaint::kStroke_Style);
+  paint.setAntiAlias(true);
+  int half_thickness = thickness_ / 2;

[Evan Stade, 2015/10/29 18:36:18]

I don't think this is correct. For thickness_ == 1, you actually want to inset
by 0.5, not 0.

[Matt Giuca, 2015/11/09 04:44:57]

Ah good catch. Well I can't use floating point numbers (DrawRoundRect takes an
int Rect). Instead just rounding UP instead of down.

[Evan Stade, 2015/11/09 18:41:48]

No, you really do need to use floats, or any odd-numbered thickness value will
be uncrisp (e.g. 1px/black will be two grey pixels instead of 1 black pixel).
Luckily, DrawRoundRect is just a thin wrapper around drawRoundRect, which takes
floats.

gfx::RectF bounds(view.GetLocalBounds());
bounds.Inset(...);
canvas->sk_canvas()->drawRoundRect(...);

[Matt Giuca, 2015/11/10 00:15:06]

Oh, yeah that fixes the 1px problem I was having (on the other CL). I looked for
a DrawRoundRect overload for this yesterday but didn't find one in Canvas.

It's actually kind of bad that all of these methods in Canvas take ints and
convert them to floats internally. At least for DrawRoundRect (but I suspect for
others), that is *never* desirable because of the above issue. So I decided to
add a float overload of DrawRoundRect rather than just bypassing the abstraction
layer.

[Evan Stade, 2015/11/10 00:22:06]

Yea, I was thinking the same thing, although I'd take it a step further and
deprecate the int version.

[Matt Giuca, 2015/11/10 00:28:28]

OK, I am "weakly" deprecating it by adding a comment recommending to use the
float version. Is the comment too cryptic? (Trying to keep it terse.)

+  canvas->DrawRoundRect(
+      gfx::Rect(half_thickness, half_thickness, view.width() - thickness_,
+                view.height() - thickness_),

[Evan Stade, 2015/10/29 18:36:18]

I would do

gfx::Rect bounds = view.GetLocalBounds();
bounds.Inset(half_thickness, half_thickness);

[Matt Giuca, 2015/11/09 04:44:57]

That's neat. Done.

+      corner_radius_, paint);
+}
+
+gfx::Insets RoundedRectBorder::GetInsets() const {
+  return gfx::Insets(thickness_, thickness_, thickness_, thickness_);
+}
+
+gfx::Size RoundedRectBorder::GetMinimumSize() const {
+  return gfx::Size(thickness_ * 2, thickness_ * 2);
+}
+
 class EmptyBorder : public Border {
  public:
   explicit EmptyBorder(const gfx::Insets& insets);
 
   // Overridden from Border:
   void Paint(const View& view, gfx::Canvas* canvas) override;
   gfx::Insets GetInsets() const override ;
   gfx::Size GetMinimumSize() const override;
 
  private:
@@ skipping 68 matching lines @@
   return make_scoped_ptr(new SolidSidedBorder(
       gfx::Insets(thickness, thickness, thickness, thickness), color));
 }
 
 // static
 scoped_ptr<Border> Border::CreateEmptyBorder(const gfx::Insets& insets) {
   return make_scoped_ptr(new EmptyBorder(insets));
 }
 
 // static
+scoped_ptr<Border> Border::CreateRoundedRectBorder(int thickness,
+                                                   int corner_radius,
+                                                   SkColor color) {
+  return make_scoped_ptr(
+      new RoundedRectBorder(thickness, corner_radius, color));
+}
+
+// static
 scoped_ptr<Border> Border::CreateEmptyBorder(int top,
                                              int left,
                                              int bottom,
                                              int right) {
   return CreateEmptyBorder(gfx::Insets(top, left, bottom, right));
 }
 
 // static
 scoped_ptr<Border> Border::CreateSolidSidedBorder(int top,
                                                   int left,
                                                   int bottom,
                                                   int right,
                                                   SkColor color) {
   return make_scoped_ptr(new SolidSidedBorder(
       gfx::Insets(top, left, bottom, right), color));
 }
 
 // static
 scoped_ptr<Border> Border::CreateBorderPainter(Painter* painter,
                                                const gfx::Insets& insets) {
   return make_scoped_ptr(new BorderPainter(painter, insets));
 }
 
 }  // namespace views