53498e973e
Some catalog images are blank because the image wasn't selected in the fiddle example. Also continue to add documentation and examples for SkRRect R=caryclark@google.com NOTRY=true Docs-Preview: https://skia.org/?cl=138382 Bug: skia:6898 Change-Id: I282a14ffcbaf2f8383294724900960f5ba40a2aa Reviewed-on: https://skia-review.googlesource.com/138382 Reviewed-by: Cary Clark <caryclark@skia.org> Commit-Queue: Cary Clark <caryclark@skia.org> Auto-Submit: Cary Clark <caryclark@skia.org>
1537 lines
46 KiB
Plaintext
1537 lines
46 KiB
Plaintext
#Topic RRect
|
|
#Alias Round_Rect ##
|
|
#Alias RRect_Reference ##
|
|
|
|
#Class SkRRect
|
|
|
|
#Private
|
|
Path forward:
|
|
core work
|
|
add contains(SkRect&) - for clip stack
|
|
add contains(SkRRect&) - for clip stack
|
|
add heart rect computation (max rect inside RR)
|
|
add 9patch rect computation
|
|
add growToInclude(SkPath&)
|
|
analysis
|
|
use growToInclude to fit skp round rects & generate stats (RRs vs. real paths)
|
|
check on # of rectorus's the RRs could handle
|
|
rendering work
|
|
update SkPath.addRRect() to only use quads
|
|
add GM and bench
|
|
further out
|
|
detect and triangulate RRectorii rather than falling back to SW in Ganesh
|
|
##
|
|
|
|
The SkRRect class represents a rounded rect with a potentially different
|
|
radii for each corner. It does not have a constructor so must be
|
|
initialized with one of the initialization functions (e.g., setEmpty,
|
|
setRectRadii, etc.)
|
|
|
|
This class allows implementing CSS properties that describe rounded corners.
|
|
A rectangle may have up to eight radii, one for each axis on each of its four
|
|
corners.
|
|
|
|
If either corner's radii are zero, the corner is square.
|
|
Negative radii are treated as zero.
|
|
If corner curves overlap, they are proportionally reduced to fit.
|
|
|
|
#Subtopic Overview
|
|
#Populate
|
|
##
|
|
|
|
#Subtopic Constructor
|
|
#Populate
|
|
##
|
|
|
|
#Subtopic Operator
|
|
#Populate
|
|
##
|
|
|
|
#Subtopic Member_Function
|
|
#Populate
|
|
##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkRRect()
|
|
#In Constructor
|
|
#Line # creates with zeroed bounds and corner radii ##
|
|
|
|
Initializes bounds at (0, 0), the origin, with zero width and height.
|
|
Initializes corner radii to (0, 0), and sets type of kEmpty_Type.
|
|
|
|
#Return empty Round_Rect ##
|
|
|
|
#Example
|
|
#Height 60
|
|
SkRRect rrect;
|
|
SkPaint p;
|
|
p.setStyle(SkPaint::kStroke_Style);
|
|
p.setStrokeWidth(10);
|
|
canvas->drawRRect(rrect, p);
|
|
rrect.setRect({10, 10, 100, 50});
|
|
canvas->drawRRect(rrect, p);
|
|
##
|
|
|
|
#SeeAlso setEmpty isEmpty
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkRRect(const SkRRect& rrect)
|
|
#In Constructor
|
|
#Line # copies bounds and corner radii ##
|
|
|
|
Initializes to copy of rrect bounds and corner radii.
|
|
|
|
#Param rrect bounds and corner to copy ##
|
|
|
|
#Return copy of rrect ##
|
|
|
|
#Bug 8115
|
|
#Example
|
|
SkRRect rrect = SkRRect::MakeRect({10, 10, 100, 50});
|
|
SkRRect rrect2(rrect);
|
|
rrect2.inset(20, 20);
|
|
SkPaint p;
|
|
p.setStyle(SkPaint::kStroke_Style);
|
|
p.setStrokeWidth(10);
|
|
canvas->drawRRect(rrect, p);
|
|
canvas->drawRRect(rrect2, p);
|
|
##
|
|
|
|
#SeeAlso operator=(const SkRRect& rrect) MakeRect
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkRRect& operator=(const SkRRect& rrect)
|
|
#In Operator
|
|
#Line # copies bounds and corner radii ##
|
|
|
|
Copies rrect bounds and corner radii.
|
|
|
|
#Param rrect bounds and corner to copy ##
|
|
|
|
#Return copy of rrect ##
|
|
|
|
#Example
|
|
SkRRect rrect = SkRRect::MakeRect({40, 40, 100, 70});
|
|
SkRRect rrect2 = rrect;
|
|
rrect2.inset(-20, -20);
|
|
SkPaint p;
|
|
p.setStyle(SkPaint::kStroke_Style);
|
|
p.setStrokeWidth(10);
|
|
canvas->drawRRect(rrect, p);
|
|
canvas->drawRRect(rrect2, p);
|
|
##
|
|
|
|
#SeeAlso SkRRect(const SkRRect& rrect) MakeRect
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
#Subtopic Type
|
|
#Line # specialization of Round_Rect geometry ##
|
|
|
|
#PhraseDef list_of_rrect_types
|
|
kEmpty_Type, kRect_Type, kOval_Type, kSimple_Type, kNinePatch_Type,
|
|
kComplex_Type
|
|
##
|
|
|
|
#Enum Type
|
|
#Line # specialization of Round_Rect geometry ##
|
|
|
|
#Code
|
|
enum Type {
|
|
kEmpty_Type,
|
|
kRect_Type,
|
|
kOval_Type,
|
|
kSimple_Type,
|
|
kNinePatch_Type,
|
|
kComplex_Type,
|
|
kLastType = kComplex_Type,
|
|
};
|
|
##
|
|
|
|
Type describes possible specializations of Round_Rect. Each Type is
|
|
exclusive; a Round_Rect may only have one type.
|
|
|
|
The enum members become progressively less restrictive; larger values of
|
|
Type have more degrees of freedom than smaller values.
|
|
|
|
#Const kEmpty_Type
|
|
#Line # zero width or height ##
|
|
Round_Rect has zero width or height. All radii are zero.
|
|
##
|
|
#Const kRect_Type
|
|
#Line # non-zero width and height, and zeroed radii ##
|
|
Round_Rect has width and height. All radii are zero.
|
|
##
|
|
#Const kOval_Type
|
|
#Line # non-zero width and height filled with radii ##
|
|
Round_Rect has width and height. All four x-radii are equal,
|
|
and at least half the width. All four y-radii are equal,
|
|
and at least half the height.
|
|
##
|
|
#Const kSimple_Type
|
|
#Line # non-zero width and height with equal radii ##
|
|
Round_Rect has width and height. All four x-radii are equal and
|
|
greater than zero, and all four y-radii are equal and greater than
|
|
zero. Either x-radii are less than half the width, or y-radii is
|
|
less than half the height, or both.
|
|
##
|
|
#Const kNinePatch_Type
|
|
#Line # non-zero width and height with axis-aligned radii ##
|
|
Round_Rect has width and height. Left x-radii are equal, top
|
|
y-radii are equal, right x-radii are equal, and bottom y-radii
|
|
are equal. The radii do not describe a rect, oval, or simple type.
|
|
|
|
The centers of the corner ellipses form an axis-aligned rectangle
|
|
that divides the Round_Rect into nine rectangular patches; an
|
|
interior rectangle, four edges, and four corners.
|
|
##
|
|
#Const kComplex_Type
|
|
#Line # non-zero width and height with arbitrary radii ##
|
|
both radii are non-zero.
|
|
##
|
|
#Const kLastType = kComplex_Type
|
|
#Line # largest Type value ##
|
|
##
|
|
|
|
#Example
|
|
#Height 128
|
|
struct Radii { SkVector data[4]; };
|
|
auto drawRRectType = [=](const SkRect& rect, const Radii& radii) {
|
|
SkRRect rrect;
|
|
rrect.setRectRadii(rect, radii.data);
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
const char* typeStr[] = { "empty", "rect", "oval", "simple", "nine patch", "complex" };
|
|
paint.setTextAlign(SkPaint::kCenter_Align);
|
|
canvas->drawString(typeStr[(int) rrect.type()], rect.centerX(), rect.bottom() + 20, paint);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
canvas->drawRRect(rrect, paint);
|
|
};
|
|
drawRRectType({ 45, 30, 45, 30}, {{{ 5, 5}, { 5, 5}, { 5, 5}, { 5, 5}}});
|
|
drawRRectType({ 90, 10, 140, 30}, {{{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}}});
|
|
drawRRectType({160, 10, 210, 30}, {{{25, 10}, {25, 10}, {25, 10}, {25, 10}}});
|
|
drawRRectType({ 20, 80, 70, 100}, {{{ 5, 5}, { 5, 5}, { 5, 5}, { 5, 5}}});
|
|
drawRRectType({ 90, 80, 140, 100}, {{{ 5, 5}, {10, 5}, {10, 5}, { 5, 5}}});
|
|
drawRRectType({160, 80, 210, 100}, {{{ 5, 5}, {10, 5}, { 5, 5}, { 5, 5}}});
|
|
##
|
|
|
|
#SeeAlso Rect Path
|
|
|
|
#Enum ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method Type getType() const
|
|
#In Property
|
|
#Line # returns Type ##
|
|
|
|
Returns Type, one of: #list_of_rrect_types#.
|
|
|
|
#Return Type ##
|
|
|
|
#Example
|
|
#Description
|
|
rrect2 is not a Rect; inset() has made it empty.
|
|
##
|
|
SkRRect rrect = SkRRect::MakeRect({10, 10, 100, 50});
|
|
SkRRect rrect2(rrect);
|
|
rrect2.inset(20, 20);
|
|
SkPaint p;
|
|
p.setStyle(SkPaint::kStroke_Style);
|
|
p.setStrokeWidth(10);
|
|
std::string str("Type ");
|
|
str += SkRRect::kRect_Type == rrect2.getType() ? "=" : "!";
|
|
str += "= SkRRect::kRect_Type";
|
|
canvas->drawString(str.c_str(), 20, 80, SkPaint());
|
|
canvas->drawRRect(rrect2, p);
|
|
##
|
|
|
|
#SeeAlso Type type
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method Type type() const
|
|
#In Property
|
|
#Line # returns Type ##
|
|
|
|
Returns Type, one of: #list_of_rrect_types#.
|
|
|
|
#Return Type ##
|
|
|
|
#Example
|
|
#Description
|
|
inset() has made rrect2 empty.
|
|
##
|
|
SkRRect rrect = SkRRect::MakeRect({10, 10, 100, 50});
|
|
SkRRect rrect2(rrect);
|
|
rrect2.inset(20, 20);
|
|
SkPaint p;
|
|
p.setStyle(SkPaint::kStroke_Style);
|
|
p.setStrokeWidth(10);
|
|
std::string str("Type ");
|
|
str += SkRRect::kEmpty_Type == rrect2.type() ? "=" : "!";
|
|
str += "= SkRRect::kEmpty_Type";
|
|
canvas->drawString(str.c_str(), 20, 80, SkPaint());
|
|
canvas->drawRRect(rrect2, p);
|
|
##
|
|
|
|
#SeeAlso Type getType
|
|
|
|
#Method ##
|
|
|
|
#Subtopic Type ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method inline bool isEmpty() const
|
|
#In Property
|
|
#Line # returns true if width or height are zero ##
|
|
Returns true if rect().fLeft is equal to rect().fRight, or if rect().fTop is equal
|
|
to rect().fBottom.
|
|
|
|
#Return true if width() or height() are zero ##
|
|
|
|
#Example
|
|
#Height 100
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setTextAlign(SkPaint::kCenter_Align);
|
|
paint.setTextSize(16);
|
|
SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 10, 5);
|
|
canvas->drawRRect(rrect, paint);
|
|
canvas->drawString(rrect.isEmpty() ? "empty" : "not empty", 64, 90, paint);
|
|
rrect.inset(40, 0);
|
|
canvas->translate(128, 0);
|
|
canvas->drawRRect(rrect, paint);
|
|
canvas->drawString(rrect.isEmpty() ? "empty" : "not empty", 64, 90, paint);
|
|
##
|
|
|
|
#SeeAlso SkRect::isEmpty height width
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method inline bool isRect() const
|
|
#In Property
|
|
#Line # returns true if not empty, and one radius at each corner is zero ##
|
|
Returns true if not empty, and if either x or y radius at each corner is zero.
|
|
|
|
#Return true if not empty, and one radius at each corner is zero ##
|
|
|
|
#Example
|
|
#Height 100
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setTextAlign(SkPaint::kCenter_Align);
|
|
paint.setTextSize(16);
|
|
SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
|
|
canvas->drawRRect(rrect, paint);
|
|
canvas->drawString(rrect.isRect() ? "rect" : "not rect", 64, 90, paint);
|
|
SkVector radii[] = {{10, 10}, {0, 0}, {0, 0}, {0, 0}};
|
|
rrect.setRectRadii(rrect.getBounds(), radii);
|
|
canvas->translate(128, 0);
|
|
canvas->drawRRect(rrect, paint);
|
|
canvas->drawString(rrect.isRect() ? "rect" : "not rect", 64, 90, paint);
|
|
##
|
|
|
|
#SeeAlso isEmpty radii
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method inline bool isOval() const
|
|
#In Property
|
|
#Line # returns true if not empty, axes radii are equal, radii fill bounds ##
|
|
Returns true if not empty, if all x-axis radii are equal, if all y-axis radii
|
|
are equal, x-axis radii are at least half the width, and y-axis radii are at
|
|
least half the height.
|
|
|
|
#Return true if has identical geometry to Oval ##
|
|
|
|
#Example
|
|
#Height 100
|
|
#Description
|
|
The first radii are scaled down proportionately until both x-axis and y-axis fit
|
|
within the bounds. After scaling, x-axis radius is smaller than half the width;
|
|
left round rect is not an oval. The second radii are equal to half the
|
|
dimensions; right round rect is an oval.
|
|
##
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setTextAlign(SkPaint::kCenter_Align);
|
|
paint.setTextSize(16);
|
|
SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 40, 30);
|
|
canvas->drawRRect(rrect, paint);
|
|
canvas->drawString(rrect.isOval() ? "oval" : "not oval", 64, 90, paint);
|
|
rrect.setRectXY(rrect.getBounds(), 35, 25);
|
|
canvas->translate(128, 0);
|
|
canvas->drawRRect(rrect, paint);
|
|
canvas->drawString(rrect.isOval() ? "oval" : "not oval", 64, 90, paint);
|
|
##
|
|
|
|
#SeeAlso isEmpty isSimple SkCanvas::drawOval
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method inline bool isSimple() const
|
|
#In Property
|
|
#Line # returns true if not empty, rect or oval; and axes radii are equal ##
|
|
Returns true if not empty, if all x-axis radii are equal but not zero,
|
|
if all y-axis radii are equal but not zero; and x-axis radius is less than half
|
|
width(), or y-axis radius is less than half height().
|
|
|
|
#Return true if not empty, rect or oval; and axes radii are equal ##
|
|
|
|
#Bug 8107
|
|
#Example
|
|
#Height 100
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setTextAlign(SkPaint::kCenter_Align);
|
|
paint.setTextSize(16);
|
|
SkVector radii[] = {{40, 30}, {40, 30}, {40, 30}, {40, 30}};
|
|
SkRRect rrect;
|
|
rrect.setRectRadii({30, 10, 100, 60}, radii);
|
|
canvas->drawRRect(rrect, paint);
|
|
canvas->drawString(rrect.isSimple() ? "simple" : "not simple", 64, 90, paint);
|
|
radii[0].fX = 35;
|
|
rrect.setRectRadii(rrect.getBounds(), radii);
|
|
canvas->translate(128, 0);
|
|
canvas->drawRRect(rrect, paint);
|
|
canvas->drawString(rrect.isSimple() ? "simple" : "not simple", 64, 90, paint);
|
|
##
|
|
|
|
#SeeAlso isEmpty isRect isOval isNinePatch
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method inline bool isNinePatch() const
|
|
#In Property
|
|
#Line # returns true if not empty, rect, oval or simple; and radii are axis-aligned ##
|
|
Returns true if isEmpty, isRect, isOval, and isSimple return false; and if
|
|
left x-axis radii are equal, right x-axis radii are equal, top y-axis radii are
|
|
equal, and bottom y-axis radii are equal.
|
|
|
|
#Return true if not empty, rect, oval or simple; and radii are axis-aligned ##
|
|
|
|
#Bug 8107
|
|
#Example
|
|
#Height 100
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setTextAlign(SkPaint::kCenter_Align);
|
|
paint.setTextSize(16);
|
|
SkVector radii[] = {{20, 30}, {40, 30}, {40, 30}, {20, 30}};
|
|
SkRRect rrect;
|
|
rrect.setRectRadii({30, 10, 100, 60}, radii);
|
|
canvas->drawRRect(rrect, paint);
|
|
canvas->drawString(rrect.isNinePatch() ? "9 patch" : "not 9 patch", 64, 90, paint);
|
|
radii[0].fX = 35;
|
|
rrect.setRectRadii(rrect.getBounds(), radii);
|
|
canvas->translate(128, 0);
|
|
canvas->drawRRect(rrect, paint);
|
|
canvas->drawString(rrect.isNinePatch() ? "9 patch" : "not 9 patch", 64, 90, paint);
|
|
##
|
|
|
|
#SeeAlso isEmpty isRect isOval isSimple isComplex
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method inline bool isComplex() const
|
|
#In Property
|
|
#Line # returns true if not empty, rect, oval, simple, or nine-patch ##
|
|
|
|
Returns true if isEmpty, isRect, isOval, isSimple, and isNinePatch return false.
|
|
If true: width and height are greater than zero, at least one corner radii are
|
|
both greater than zero; left x-axis radii are not equal, or right x-axis radii
|
|
are not equal, or top y-axis radii are not equal, or bottom y-axis radii are not
|
|
equal.
|
|
|
|
#Return true if not empty, rect, oval, simple, or nine-patch ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setTextAlign(SkPaint::kCenter_Align);
|
|
paint.setTextSize(16);
|
|
SkVector radii[] = {{25, 30}, {40, 30}, {40, 30}, {20, 30}};
|
|
SkRRect rrect;
|
|
rrect.setRectRadii({30, 10, 100, 60}, radii);
|
|
canvas->drawRRect(rrect, paint);
|
|
canvas->drawString(rrect.isComplex() ? "complex" : "not complex", 64, 90, paint);
|
|
radii[0].fX = 20;
|
|
rrect.setRectRadii(rrect.getBounds(), radii);
|
|
canvas->translate(128, 0);
|
|
canvas->drawRRect(rrect, paint);
|
|
canvas->drawString(rrect.isComplex() ? "complex" : "not complex", 64, 90, paint);
|
|
##
|
|
|
|
#SeeAlso isEmpty isRect isOval isSimple isNinePatch
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkScalar width() const
|
|
#In Property
|
|
#Line # returns span in x ##
|
|
Returns span on the x-axis. This does not check if result fits in 32-bit float;
|
|
result may be infinity.
|
|
|
|
#Return bounds().fRight minus bounds().fLeft ##
|
|
|
|
#Example
|
|
#Description
|
|
SkRRect::MakeRect sorts its input, so width() is always zero or larger.
|
|
##
|
|
SkRRect unsorted = SkRRect::MakeRect({ 15, 25, 10, 5 });
|
|
SkDebugf("unsorted width: %g\n", unsorted.width());
|
|
SkRRect large = SkRRect::MakeRect({ -FLT_MAX, 1, FLT_MAX, 2 });
|
|
SkDebugf("large width: %.0f\n", large.width());
|
|
#StdOut
|
|
unsorted width: 5
|
|
large width: inf
|
|
##
|
|
##
|
|
|
|
#SeeAlso SkRect::width height getBounds
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkScalar height() const
|
|
#In Property
|
|
#Line # returns span in y ##
|
|
Returns span on the y-axis. This does not check if result fits in 32-bit float;
|
|
result may be infinity.
|
|
|
|
#Return bounds().fBottom minus bounds().fTop ##
|
|
|
|
#Example
|
|
#Description
|
|
SkRRect::MakeRect sorts its input, so height() is always zero or larger.
|
|
##
|
|
SkRRect unsorted = SkRRect::MakeRect({ 15, 25, 10, 20 });
|
|
SkDebugf("unsorted height: %g\n", unsorted.height());
|
|
SkRRect large = SkRRect::MakeRect({ 1, -FLT_MAX, 2, FLT_MAX });
|
|
SkDebugf("large height: %.0f\n", large.height());
|
|
#StdOut
|
|
unsorted height: 5
|
|
large height: inf
|
|
##
|
|
##
|
|
|
|
#SeeAlso SkRect.height width getBounds
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkVector getSimpleRadii() const
|
|
#In Property
|
|
#Line # returns corner radii for simple types ##
|
|
|
|
Returns top-left corner x-radii. If type() returns kEmpty_Type, kRect_Type,
|
|
kOval_Type, or kSimple_Type, returns a value representative of all corner radii.
|
|
If type() returns kNinePatch_Type or kComplex_Type, at least one of the
|
|
remaining three corners has a different value.
|
|
|
|
#Return corner radii for simple types ##
|
|
|
|
#Example
|
|
auto drawDetails = [=](const SkRRect& rrect) {
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setTextAlign(SkPaint::kCenter_Align);
|
|
paint.setTextSize(12);
|
|
canvas->drawRRect(rrect, paint);
|
|
SkVector corner = rrect.getSimpleRadii();
|
|
std::string label = "corner: " + std::to_string(corner.fX).substr(0, 3) + ", " +
|
|
std::to_string(corner.fY).substr(0, 3);
|
|
canvas->drawString(label.c_str(), 64, 90, paint);
|
|
canvas->translate(128, 0);
|
|
};
|
|
SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
|
|
drawDetails(rrect);
|
|
rrect.setRectXY(rrect.getBounds(), 5, 8);
|
|
drawDetails(rrect);
|
|
##
|
|
|
|
#SeeAlso radii getBounds getType isSimple
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void setEmpty()
|
|
#In Set
|
|
#Line # zeroes width, height, and corner radii ##
|
|
|
|
Sets bounds to zero width and height at (0, 0), the origin. Sets
|
|
corner radii to zero and sets type to kEmpty_Type.
|
|
|
|
#Example
|
|
#Description
|
|
Nothing blue is drawn because rrect is set to empty.
|
|
##
|
|
SkPaint paint;
|
|
SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect.setEmpty();
|
|
paint.setColor(SK_ColorBLUE);
|
|
canvas->drawRRect(rrect, paint);
|
|
##
|
|
|
|
#SeeAlso MakeEmpty setRect
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void setRect(const SkRect& rect)
|
|
#In Set
|
|
#Line # sets rect bounds with zeroed corners ##
|
|
|
|
Sets bounds to sorted rect, and sets corner radii to zero.
|
|
If set bounds has width and height, and sets type to kRect_Type;
|
|
otherwise, sets type to kEmpty_Type.
|
|
|
|
#Param rect bounds to set ##
|
|
|
|
#Example
|
|
#Height 90
|
|
SkPaint paint;
|
|
SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect.setRect({60, 30, 120, 80});
|
|
paint.setColor(SK_ColorBLUE);
|
|
canvas->drawRRect(rrect, paint);
|
|
##
|
|
|
|
#SeeAlso MakeRect setRectXY
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkRRect MakeEmpty()
|
|
#In Constructor
|
|
#Line # creates with zeroed bounds and corner radii ##
|
|
|
|
Initializes bounds at (0, 0), the origin, with zero width and height.
|
|
Initializes corner radii to (0, 0), and sets type of kEmpty_Type.
|
|
|
|
#Return empty Round_Rect ##
|
|
|
|
#Example
|
|
#Height 90
|
|
SkRRect rrect = SkRRect::MakeEmpty();
|
|
SkRRect rrect2(rrect);
|
|
rrect2.inset(-20, -20);
|
|
SkPaint p;
|
|
p.setStyle(SkPaint::kStroke_Style);
|
|
p.setStrokeWidth(10);
|
|
std::string str("Type ");
|
|
str += SkRRect::kEmpty_Type == rrect2.type() ? "=" : "!";
|
|
str += "= SkRRect::kEmpty_Type";
|
|
canvas->drawString(str.c_str(), 20, 80, SkPaint());
|
|
canvas->drawRRect(rrect2, p);
|
|
##
|
|
|
|
#SeeAlso SkRRect() SkRect::MakeEmpty
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkRRect MakeRect(const SkRect& r)
|
|
#In Constructor
|
|
#Line # copies bounds and zeroes corner radii ##
|
|
|
|
Initializes to copy of r bounds and zeroes corner radii.
|
|
|
|
#Param r bounds to copy ##
|
|
|
|
#Return copy of r ##
|
|
|
|
#Example
|
|
#Height 70
|
|
SkPaint paint;
|
|
SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect.setOval(rrect.getBounds());
|
|
paint.setColor(SK_ColorBLUE);
|
|
canvas->drawRRect(rrect, paint);
|
|
##
|
|
|
|
#SeeAlso setRect MakeOval MakeRectXY
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkRRect MakeOval(const SkRect& oval)
|
|
#In Constructor
|
|
#Line # creates Oval to fit bounds ##
|
|
|
|
Sets bounds to oval, x-axis radii to half oval.width(), and all y-axis radii
|
|
to half oval.height(). If rect is empty, sets to kEmpty_Type.
|
|
Otherwise, sets to kOval_Type.
|
|
|
|
#Param oval bounds of Oval ##
|
|
|
|
#Return Oval ##
|
|
|
|
#Example
|
|
#Height 70
|
|
SkPaint paint;
|
|
SkRRect rrect = SkRRect::MakeOval({30, 10, 100, 60});
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect.setRect(rrect.getBounds());
|
|
paint.setColor(SK_ColorBLUE);
|
|
paint.setBlendMode(SkBlendMode::kDifference);
|
|
canvas->drawRRect(rrect, paint);
|
|
##
|
|
|
|
#SeeAlso setOval MakeRect MakeRectXY
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkRRect MakeRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad)
|
|
#In Constructor
|
|
#Line # creates rounded rectangle ##
|
|
|
|
Sets to rounded rectangle with the same radii for all four corners.
|
|
If rect is empty, sets to kEmpty_Type.
|
|
Otherwise, if xRad and yRad are zero, sets to kRect_Type.
|
|
Otherwise, if xRad is at least half rect.width() and yRad is at least half
|
|
rect.height(), sets to kOval_Type.
|
|
Otherwise, sets to kSimple_Type.
|
|
|
|
#Param rect bounds of rounded rectangle ##
|
|
#Param xRad x-axis radius of corners ##
|
|
#Param yRad y-axis radius of corners ##
|
|
|
|
#Return rounded rectangle ##
|
|
|
|
#Example
|
|
#Height 70
|
|
SkPaint paint;
|
|
SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 20, 20);
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect.setRect(rrect.getBounds());
|
|
paint.setColor(SK_ColorBLUE);
|
|
paint.setBlendMode(SkBlendMode::kModulate);
|
|
canvas->drawRRect(rrect, paint);
|
|
##
|
|
|
|
#SeeAlso setRectXY
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void setOval(const SkRect& oval)
|
|
#In Set
|
|
#Line # replaces with Oval to fit bounds ##
|
|
|
|
Sets bounds to oval, x-axis radii to half oval.width(), and all y-axis radii
|
|
to half oval.height(). If rect is empty, sets to kEmpty_Type.
|
|
Otherwise, sets to kOval_Type.
|
|
|
|
#Param oval bounds of Oval ##
|
|
|
|
#Example
|
|
#Height 70
|
|
SkPaint paint;
|
|
SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 20, 20);
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect.setOval(rrect.getBounds());
|
|
paint.setColor(SK_ColorWHITE);
|
|
paint.setBlendMode(SkBlendMode::kExclusion);
|
|
canvas->drawRRect(rrect, paint);
|
|
##
|
|
|
|
#SeeAlso MakeOval
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void setRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad)
|
|
#In Set
|
|
#Line # replaces with rounded rectangle ##
|
|
|
|
Sets to rounded rectangle with the same radii for all four corners.
|
|
If rect is empty, sets to kEmpty_Type.
|
|
Otherwise, if xRad or yRad is zero, sets to kRect_Type.
|
|
Otherwise, if xRad is at least half rect.width() and yRad is at least half
|
|
rect.height(), sets to kOval_Type.
|
|
Otherwise, sets to kSimple_Type.
|
|
|
|
#Param rect bounds of rounded rectangle ##
|
|
#Param xRad x-axis radius of corners ##
|
|
#Param yRad y-axis radius of corners ##
|
|
|
|
#Example
|
|
#Height 70
|
|
SkPaint paint;
|
|
SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 20, 20);
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect.setRectXY(rrect.getBounds(), 5, 5);
|
|
paint.setColor(SK_ColorWHITE);
|
|
paint.setBlendMode(SkBlendMode::kExclusion);
|
|
canvas->drawRRect(rrect, paint);
|
|
##
|
|
|
|
#SeeAlso MakeRectXY SkPath::addRoundRect
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void setNinePatch(const SkRect& rect, SkScalar leftRad, SkScalar topRad,
|
|
SkScalar rightRad, SkScalar bottomRad)
|
|
#In Set
|
|
#Line # replaces with rounded rectangle ##
|
|
|
|
Sets bounds to rect. Sets radii to (leftRad, topRad), (rightRad, topRad),
|
|
(rightRad, bottomRad), (leftRad, bottomRad).
|
|
|
|
If rect is empty, sets to kEmpty_Type.
|
|
Otherwise, if leftRad and rightRad are zero, sets to kRect_Type.
|
|
Otherwise, if topRad and bottomRad are zero, sets to kRect_Type.
|
|
Otherwise, if leftRad and rightRad are equal and at least half rect.width(), and
|
|
topRad and bottomRad are equal at least half rect.height(), sets to kOval_Type.
|
|
Otherwise, if leftRad and rightRad are equal, and topRad and bottomRad are equal,
|
|
sets to kSimple_Type. Otherwise, sets to kNinePatch_Type.
|
|
|
|
Nine patch refers to the nine parts defined by the radii: one center rectangle,
|
|
four edge patches, and four corner patches.
|
|
|
|
#Param rect bounds of rounded rectangle ##
|
|
#Param leftRad left-top and left-bottom x-axis radius ##
|
|
#Param topRad left-top and right-top y-axis radius ##
|
|
#Param rightRad right-top and right-bottom x-axis radius ##
|
|
#Param bottomRad left-bottom and right-bottom y-axis radius ##
|
|
|
|
#Example
|
|
#Height 70
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkRRect rrect;
|
|
rrect.setNinePatch({30, 10, 100, 60}, 10, 20, 20, 10);
|
|
canvas->drawRRect(rrect, paint);
|
|
paint.setColor(SK_ColorWHITE);
|
|
const SkRect r = rrect.getBounds();
|
|
canvas->drawLine(r.fLeft, r.fTop + rrect.radii(SkRRect::kUpperLeft_Corner).fY,
|
|
r.fRight, r.fTop + rrect.radii(SkRRect::kUpperRight_Corner).fY, paint);
|
|
canvas->drawLine(r.fLeft, r.fBottom - rrect.radii(SkRRect::kLowerLeft_Corner).fY,
|
|
r.fRight, r.fBottom - rrect.radii(SkRRect::kLowerRight_Corner).fY, paint);
|
|
canvas->drawLine(r.fLeft + rrect.radii(SkRRect::kUpperLeft_Corner).fX, r.fTop,
|
|
r.fLeft + rrect.radii(SkRRect::kLowerLeft_Corner).fX, r.fBottom, paint);
|
|
canvas->drawLine(r.fRight - rrect.radii(SkRRect::kUpperRight_Corner).fX, r.fTop,
|
|
r.fRight - rrect.radii(SkRRect::kLowerRight_Corner).fX, r.fBottom, paint);
|
|
##
|
|
|
|
#SeeAlso setRectRadii
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void setRectRadii(const SkRect& rect, const SkVector radii[4])
|
|
#In Set
|
|
#Line # replaces with rounded rectangle ##
|
|
|
|
Sets bounds to rect. Sets radii array for individual control of all for corners.
|
|
|
|
If rect is empty, sets to kEmpty_Type.
|
|
Otherwise, if one of each corner radii are zero, sets to kRect_Type.
|
|
Otherwise, if all x-axis radii are equal and at least half rect.width(), and
|
|
all y-axis radii are equal at least half rect.height(), sets to kOval_Type.
|
|
Otherwise, if all x-axis radii are equal, and all y-axis radii are equal,
|
|
sets to kSimple_Type. Otherwise, sets to kNinePatch_Type.
|
|
|
|
#Param rect bounds of rounded rectangle ##
|
|
#Param radii corner x-axis and y-axis radii ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setStrokeWidth(15);
|
|
paint.setStrokeCap(SkPaint::kSquare_Cap);
|
|
paint.setAntiAlias(true);
|
|
float intervals[] = { 5, 21.75f };
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
paint.setPathEffect(SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0));
|
|
SkPath path;
|
|
SkRRect rrect;
|
|
SkVector corners[] = {{15, 17}, {17, 19}, {19, 15}, {15, 15}};
|
|
rrect.setRectRadii({20, 20, 100, 100}, corners);
|
|
path.addRRect(rrect, SkPath::kCW_Direction);
|
|
canvas->drawPath(path, paint);
|
|
path.rewind();
|
|
path.addRRect(rrect, SkPath::kCCW_Direction, 1);
|
|
canvas->translate(120, 0);
|
|
canvas->drawPath(path, paint);
|
|
##
|
|
|
|
#SeeAlso setNinePatch SkPath::addRoundRect
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Enum Corner
|
|
#Line # corner radii order ##
|
|
|
|
#Code
|
|
enum Corner {
|
|
kUpperLeft_Corner,
|
|
kUpperRight_Corner,
|
|
kLowerRight_Corner,
|
|
kLowerLeft_Corner,
|
|
};
|
|
##
|
|
|
|
The radii are stored: top-left, top-right, bottom-right, bottom-left.
|
|
|
|
#Const kUpperLeft_Corner 0
|
|
#Line # index of top-left corner radii ##
|
|
##
|
|
#Const kUpperRight_Corner 1
|
|
#Line # index of top-right corner radii ##
|
|
##
|
|
#Const kLowerRight_Corner 2
|
|
#Line # index of bottom-right corner radii ##
|
|
##
|
|
#Const kLowerLeft_Corner 3
|
|
#Line # index of bottom-left corner radii ##
|
|
##
|
|
|
|
#Example
|
|
#Height 70
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkRRect rrect;
|
|
SkVector corners[] = {{25, 17}, {17, 19}, {19, 15}, {15, 15}};
|
|
rrect.setRectRadii({30, 10, 100, 60}, corners);
|
|
canvas->drawRRect(rrect, paint);
|
|
paint.setColor(SK_ColorWHITE);
|
|
const SkRect r = rrect.getBounds();
|
|
canvas->drawLine(r.fLeft, r.fTop + rrect.radii(SkRRect::kUpperLeft_Corner).fY,
|
|
r.fRight, r.fTop + rrect.radii(SkRRect::kUpperRight_Corner).fY, paint);
|
|
canvas->drawLine(r.fLeft, r.fBottom - rrect.radii(SkRRect::kLowerLeft_Corner).fY,
|
|
r.fRight, r.fBottom - rrect.radii(SkRRect::kLowerRight_Corner).fY, paint);
|
|
canvas->drawLine(r.fLeft + rrect.radii(SkRRect::kUpperLeft_Corner).fX, r.fTop,
|
|
r.fLeft + rrect.radii(SkRRect::kLowerLeft_Corner).fX, r.fBottom, paint);
|
|
canvas->drawLine(r.fRight - rrect.radii(SkRRect::kUpperRight_Corner).fX, r.fTop,
|
|
r.fRight - rrect.radii(SkRRect::kLowerRight_Corner).fX, r.fBottom, paint);
|
|
##
|
|
|
|
#SeeAlso radii
|
|
|
|
#Enum ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method const SkRect& rect() const
|
|
#In Property
|
|
#Line # returns bounds ##
|
|
Returns bounds. Bounds may have zero width or zero height. Bounds right is
|
|
greater than or equal to left; bounds bottom is greater than or equal to top.
|
|
Result is identical to getBounds.
|
|
|
|
#Return bounding box ##
|
|
|
|
#Example
|
|
for (SkScalar left : { SK_ScalarNaN, SK_ScalarInfinity, 100.f, 50.f, 25.f} ) {
|
|
SkRRect rrect1 = SkRRect::MakeRectXY({left, 20, 60, 220}, 50, 200);
|
|
SkDebugf("left bounds: (%g) %g\n", left, rrect1.rect().fLeft);
|
|
}
|
|
#StdOut
|
|
left bounds: (nan) 0
|
|
left bounds: (inf) 0
|
|
left bounds: (100) 60
|
|
left bounds: (50) 50
|
|
left bounds: (25) 25
|
|
##
|
|
##
|
|
|
|
#SeeAlso getBounds
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkVector radii(Corner corner) const
|
|
#In Property
|
|
#Line # returns x-axis and y-axis radii for one corner ##
|
|
Returns Scalar pair for radius of curve on x-axis and y-axis for one corner.
|
|
Both radii may be zero. If not zero, both are positive and finite.
|
|
|
|
|
|
#Param corner one of: kUpperLeft_Corner, kUpperRight_Corner,
|
|
kLowerRight_Corner, kLowerLeft_Corner
|
|
##
|
|
|
|
#Return x-axis and y-axis radii for one corner ##
|
|
|
|
#Example
|
|
#Description
|
|
Finite values are scaled proportionately to fit; other values are set to zero.
|
|
Scaled values cannot be larger than 25, half the bounding rect width.
|
|
Small scaled values are halved to scale in proportion to the y-axis corner
|
|
radius, which is twice the bounds height.
|
|
##
|
|
for (SkScalar radiusX : { SK_ScalarNaN, SK_ScalarInfinity, 100.f, 50.f, 25.f} ) {
|
|
SkRRect rrect1 = SkRRect::MakeRectXY({10, 20, 60, 220}, radiusX, 200);
|
|
SkDebugf("left corner: (%g) %g\n", radiusX, rrect1.radii(SkRRect::kUpperLeft_Corner).fX);
|
|
}
|
|
#StdOut
|
|
left corner: (nan) 0
|
|
left corner: (inf) 0
|
|
left corner: (100) 25
|
|
left corner: (50) 25
|
|
left corner: (25) 12.5
|
|
##
|
|
##
|
|
|
|
#SeeAlso Corner
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method const SkRect& getBounds() const
|
|
#In Property
|
|
#Line # returns bounds ##
|
|
Returns bounds. Bounds may have zero width or zero height. Bounds right is
|
|
greater than or equal to left; bounds bottom is greater than or equal to top.
|
|
Result is identical to rect().
|
|
|
|
#Return bounding box ##
|
|
|
|
#Example
|
|
#Height 120
|
|
SkPaint paint;
|
|
SkRRect rrect = SkRRect::MakeRectXY({20, 20, 220, 100}, 15, 15);
|
|
canvas->drawRRect(rrect, paint);
|
|
paint.setColor(SK_ColorWHITE);
|
|
rrect = SkRRect::MakeOval(rrect.getBounds());
|
|
canvas->drawRRect(rrect, paint);
|
|
##
|
|
|
|
#SeeAlso rect
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool operator==(const SkRRect& a, const SkRRect& b)
|
|
#In Operator
|
|
#Line # returns true if members are equal ##
|
|
Returns true if bounds and radii in a are equal to bounds and radii in b.
|
|
|
|
a and b are not equal if either contain NaN. a and b are equal if members
|
|
contain zeroes width different signs.
|
|
|
|
#Param a Rect bounds and radii to compare ##
|
|
#Param b Rect bounds and radii to compare ##
|
|
|
|
#Return true if members are equal ##
|
|
|
|
#Example
|
|
SkRRect rrect1 = SkRRect::MakeRectXY({10, 20, 60, 220}, 50, 200);
|
|
SkRRect rrect2 = SkRRect::MakeRectXY(rrect1.rect(), 25, 100);
|
|
SkRRect rrect3 = SkRRect::MakeOval(rrect1.rect());
|
|
canvas->drawRRect(rrect1, SkPaint());
|
|
std::string str = "rrect1 " + std::string(rrect1 == rrect2 ? "=" : "!") + "= rrect2";
|
|
canvas->drawString(str.c_str(), 10, 240, SkPaint());
|
|
canvas->translate(70, 0);
|
|
canvas->drawRRect(rrect2, SkPaint());
|
|
canvas->translate(70, 0);
|
|
canvas->drawRRect(rrect3, SkPaint());
|
|
str = "rrect2 " + std::string(rrect2 == rrect3 ? "=" : "!") + "= rrect3";
|
|
canvas->drawString(str.c_str(), -20, 240, SkPaint());
|
|
##
|
|
|
|
#SeeAlso operator!=(const SkRRect& a, const SkRRect& b)
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool operator!=(const SkRRect& a, const SkRRect& b)
|
|
#In Operator
|
|
#Line # returns true if members are unequal ##
|
|
Returns true if bounds and radii in a are not equal to bounds and radii in b.
|
|
|
|
a and b are not equal if either contain NaN. a and b are equal if members
|
|
contain zeroes width different signs.
|
|
|
|
#Param a Rect bounds and radii to compare ##
|
|
#Param b Rect bounds and radii to compare ##
|
|
|
|
#Return true if members are not equal ##
|
|
|
|
#Example
|
|
SkRRect rrect1 = SkRRect::MakeRectXY({10, 20, 60, 220}, 50, 100);
|
|
SkRRect rrect2 = SkRRect::MakeRectXY(rrect1.rect(), 50, 50);
|
|
SkRRect rrect3 = SkRRect::MakeOval(rrect1.rect());
|
|
canvas->drawRRect(rrect1, SkPaint());
|
|
std::string str = "rrect1 " + std::string(rrect1 == rrect2 ? "=" : "!") + "= rrect2";
|
|
canvas->drawString(str.c_str(), 10, 240, SkPaint());
|
|
canvas->translate(70, 0);
|
|
canvas->drawRRect(rrect2, SkPaint());
|
|
canvas->translate(70, 0);
|
|
canvas->drawRRect(rrect3, SkPaint());
|
|
str = "rrect2 " + std::string(rrect2 == rrect3 ? "=" : "!") + "= rrect3";
|
|
canvas->drawString(str.c_str(), -20, 240, SkPaint());
|
|
##
|
|
|
|
#SeeAlso operator==(const SkRRect& a, const SkRRect& b)
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void inset(SkScalar dx, SkScalar dy, SkRRect* dst) const
|
|
#In Inset_Outset_Offset
|
|
#Line # insets bounds and radii ##
|
|
|
|
Calls inset on the bounds, and adjust the radii to reflect what happens.
|
|
If the corner is sharp (no curvature), leave it alone,
|
|
otherwise we grow/shrink the radii by the amount of the inset. If a
|
|
given radius becomes negative, it is pinned to 0.
|
|
If the inset amount is larger than the width/height then the rrect collapses to
|
|
a degenerate line or point.
|
|
If the inset is sufficiently negative to cause the bounds to become infinite then
|
|
the result is a default initialized rrect.
|
|
It is valid for dst == this.
|
|
|
|
#Param dx added to rect().fLeft, and subtracted from rect().fRight ##
|
|
#Param dy added to rect().fTop, and subtracted from rect().fBottom ##
|
|
#Param dst insets bounds and radii ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
|
|
for (int index = 0; index < 25; ++index) {
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect.inset(-3, 3, &rrect);
|
|
}
|
|
##
|
|
|
|
#SeeAlso outset offset makeOffset
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void inset(SkScalar dx, SkScalar dy)
|
|
#In Inset_Outset_Offset
|
|
#Line # insets bounds and radii ##
|
|
|
|
#Param dx added to rect().fLeft, and subtracted from rect().fRight ##
|
|
#Param dy added to rect().fTop, and subtracted from rect().fBottom ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
SkRRect rrect = SkRRect::MakeRectXY({10, 20, 180, 220}, 50, 100);
|
|
for (int index = 0; index < 25; ++index) {
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect.inset(3, 3);
|
|
}
|
|
##
|
|
|
|
#SeeAlso outset offset makeOffset
|
|
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void outset(SkScalar dx, SkScalar dy, SkRRect* dst) const
|
|
#In Inset_Outset_Offset
|
|
#Line # outsets bounds and radii ##
|
|
|
|
Call outset on the bounds, and adjust the radii to reflect what happens
|
|
in stroking. If the corner is sharp (no curvature), leave it alone,
|
|
otherwise we grow/shrink the radii by the amount of the inset. If a
|
|
given radius becomes negative, it is pinned to 0.
|
|
It is valid for dst == this.
|
|
|
|
#Param dx subtracted from rect().fLeft, and added to rect().fRight ##
|
|
#Param dy subtracted from rect().fTop, and added to rect().fBottom ##
|
|
#Param dst outset bounds and radii ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
|
|
for (int index = 0; index < 25; ++index) {
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect.outset(-3, 3, &rrect);
|
|
}
|
|
##
|
|
|
|
#SeeAlso inset offset makeOffset
|
|
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void outset(SkScalar dx, SkScalar dy)
|
|
#In Inset_Outset_Offset
|
|
#Line # outsets bounds and radii ##
|
|
|
|
#Param dx subtracted from rect().fLeft, and added to rect().fRight ##
|
|
#Param dy subtracted from rect().fTop, and added to rect().fBottom ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
|
|
for (int index = 0; index < 25; ++index) {
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect.outset(3, 3);
|
|
}
|
|
##
|
|
|
|
#SeeAlso inset offset makeOffset
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void offset(SkScalar dx, SkScalar dy)
|
|
#In Inset_Outset_Offset
|
|
#Line # offsets bounds and radii ##
|
|
|
|
Translates the rrect by (dx, dy).
|
|
|
|
#Param dx offset added to rect().fLeft and rect().fRight ##
|
|
#Param dy offset added to rect().fTop and rect().fBottom ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
|
|
for (int index = 0; index < 25; ++index) {
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect.offset(3, 3);
|
|
}
|
|
##
|
|
|
|
#SeeAlso makeOffset inset outset
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkRRect SK_WARN_UNUSED_RESULT makeOffset(SkScalar dx, SkScalar dy) const
|
|
#In Inset_Outset_Offset
|
|
#Line # offsets bounds and radii ##
|
|
|
|
#Param dx offset added to rect().fLeft and rect().fRight ##
|
|
#Param dy offset added to rect().fTop and rect().fBottom ##
|
|
|
|
#Return Round_Rect bounds offset by (dx, dy), with unchanged corner radii ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
|
|
for (int index = 0; index < 25; ++index) {
|
|
canvas->drawRRect(rrect, paint);
|
|
rrect = rrect.makeOffset(-3, 3);
|
|
}
|
|
##
|
|
|
|
#SeeAlso offset inset outset
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool contains(const SkRect& rect) const
|
|
#In Intersection
|
|
#Line # returns true if Rect is inside ##
|
|
|
|
Returns true if rect is inside the bounds and corner radii, and if
|
|
Round_Rect and rect are not empty.
|
|
|
|
#Param rect area tested for containment ##
|
|
|
|
#Return true if Round_Rect contains rect ##
|
|
|
|
#Example
|
|
// incomplete
|
|
##
|
|
|
|
#SeeAlso SkRect::contains
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool isValid() const
|
|
#In Utility
|
|
#Line # incomplete ##
|
|
|
|
#Return incomplete ##
|
|
|
|
#Example
|
|
// incomplete
|
|
##
|
|
|
|
#SeeAlso incomplete
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Const kSizeInMemory 48
|
|
#Line # incomplete ##
|
|
|
|
#Example
|
|
// incomplete
|
|
##
|
|
|
|
#Const ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method size_t writeToMemory(void* buffer) const
|
|
#In Utility
|
|
#Line # incomplete ##
|
|
|
|
Write the rrect into the specified buffer. This is guaranteed to always
|
|
write kSizeInMemory bytes, and that value is guaranteed to always be
|
|
a multiple of 4. Return kSizeInMemory.
|
|
|
|
#Param buffer incomplete ##
|
|
|
|
#Return incomplete ##
|
|
|
|
#Example
|
|
// incomplete
|
|
##
|
|
|
|
#SeeAlso incomplete
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method size_t readFromMemory(const void* buffer, size_t length)
|
|
#In Utility
|
|
#Line # incomplete ##
|
|
|
|
Reads the rrect from the specified buffer.
|
|
If the specified buffer is large enough, this will read kSizeInMemory bytes,
|
|
and that value is guaranteed to always be a multiple of 4.
|
|
|
|
#Param buffer memory to read from
|
|
##
|
|
#Param length amount of memory available in the buffer
|
|
##
|
|
|
|
#Return number of bytes read (must be a multiple of 4) or
|
|
0 if there was not enough memory available
|
|
##
|
|
|
|
#Example
|
|
// incomplete
|
|
##
|
|
|
|
#SeeAlso incomplete
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool transform(const SkMatrix& matrix, SkRRect* dst) const
|
|
#In Inset_Outset_Offset
|
|
#Line # scales and offsets into copy ##
|
|
|
|
Transforms by Round_Rect by matrix, storing result in dst.
|
|
Returns true if Round_Rect transformed can be represented by another Round_Rect.
|
|
Returns false if matrix contains transformations other than scale and translate.
|
|
|
|
Asserts in debug builds if Round_Rect equals dst.
|
|
|
|
#Param matrix SkMatrix specifying the transform ##
|
|
#Param dst SkRRect to store the result ##
|
|
|
|
#Return true if transformation succeeded.
|
|
##
|
|
|
|
#Example
|
|
// incomplete
|
|
##
|
|
|
|
#SeeAlso incomplete
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void dump(bool asHex) const
|
|
#In Utility
|
|
#Line # sends text representation to standard output ##
|
|
Writes text representation of Round_Rect to standard output.
|
|
Set asHex true to generate exact binary representations
|
|
of floating point numbers.
|
|
|
|
#Param asHex true if SkScalar values are written as hexadecimal ##
|
|
|
|
#Example
|
|
SkRRect rrect = SkRRect::MakeRect({6.f / 7, 2.f / 3, 6.f / 7, 2.f / 3});
|
|
for (bool dumpAsHex : { false, true } ) {
|
|
rrect.dump(dumpAsHex);
|
|
}
|
|
#StdOut
|
|
SkRect::MakeLTRB(0.857143f, 0.666667f, 0.857143f, 0.666667f);
|
|
const SkPoint corners[] = {
|
|
{ 0, 0 },
|
|
{ 0, 0 },
|
|
{ 0, 0 },
|
|
{ 0, 0 },
|
|
};
|
|
SkRect::MakeLTRB(SkBits2Float(0x3f5b6db7), /* 0.857143 */
|
|
SkBits2Float(0x3f2aaaab), /* 0.666667 */
|
|
SkBits2Float(0x3f5b6db7), /* 0.857143 */
|
|
SkBits2Float(0x3f2aaaab) /* 0.666667 */);
|
|
const SkPoint corners[] = {
|
|
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
|
|
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
|
|
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
|
|
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
|
|
};
|
|
##
|
|
##
|
|
|
|
#SeeAlso dumpHex SkRect::dump SkPath::dump SkPathMeasure::dump
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void dump() const
|
|
#In Utility
|
|
#Line # sends text representation using floats to standard output ##
|
|
Writes text representation of Round_Rect to standard output. The representation
|
|
may be directly compiled as C++ code. Floating point values are written
|
|
with limited precision; it may not be possible to reconstruct original
|
|
Round_Rect from output.
|
|
|
|
#Example
|
|
SkRRect rrect = SkRRect::MakeRect({6.f / 7, 2.f / 3, 6.f / 7, 2.f / 3});
|
|
rrect.dump();
|
|
SkRect bounds = SkRect::MakeLTRB(0.857143f, 0.666667f, 0.857143f, 0.666667f);
|
|
const SkPoint corners[] = {
|
|
{ 0, 0 },
|
|
{ 0, 0 },
|
|
{ 0, 0 },
|
|
{ 0, 0 },
|
|
};
|
|
SkRRect copy;
|
|
copy.setRectRadii(bounds, corners);
|
|
SkDebugf("rrect is " "%s" "equal to copy\n", rrect == copy ? "" : "not ");
|
|
#StdOut
|
|
SkRect::MakeLTRB(0.857143f, 0.666667f, 0.857143f, 0.666667f);
|
|
const SkPoint corners[] = {
|
|
{ 0, 0 },
|
|
{ 0, 0 },
|
|
{ 0, 0 },
|
|
{ 0, 0 },
|
|
};
|
|
rrect is not equal to copy
|
|
##
|
|
##
|
|
|
|
#SeeAlso dumpHex SkRect::dump SkPath::dump SkPathMeasure::dump
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void dumpHex() const
|
|
#In Utility
|
|
#Line # sends text representation using hexadecimal to standard output ##
|
|
Writes text representation of Round_Rect to standard output. The representation
|
|
may be directly compiled as C++ code. Floating point values are written
|
|
in hexadecimal to preserve their exact bit pattern. The output reconstructs the
|
|
original Round_Rect.
|
|
|
|
#Example
|
|
SkRRect rrect = SkRRect::MakeRect({6.f / 7, 2.f / 3, 6.f / 7, 2.f / 3});
|
|
rrect.dumpHex();
|
|
SkRect bounds = SkRect::MakeLTRB(SkBits2Float(0x3f5b6db7), /* 0.857143 */
|
|
SkBits2Float(0x3f2aaaab), /* 0.666667 */
|
|
SkBits2Float(0x3f5b6db7), /* 0.857143 */
|
|
SkBits2Float(0x3f2aaaab) /* 0.666667 */);
|
|
const SkPoint corners[] = {
|
|
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
|
|
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
|
|
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
|
|
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
|
|
};
|
|
SkRRect copy;
|
|
copy.setRectRadii(bounds, corners);
|
|
SkDebugf("rrect is " "%s" "equal to copy\n", rrect == copy ? "" : "not ");
|
|
#StdOut
|
|
SkRect::MakeLTRB(SkBits2Float(0x3f5b6db7), /* 0.857143 */
|
|
SkBits2Float(0x3f2aaaab), /* 0.666667 */
|
|
SkBits2Float(0x3f5b6db7), /* 0.857143 */
|
|
SkBits2Float(0x3f2aaaab) /* 0.666667 */);
|
|
const SkPoint corners[] = {
|
|
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
|
|
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
|
|
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
|
|
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
|
|
};
|
|
rrect is equal to copy
|
|
##
|
|
##
|
|
|
|
#SeeAlso dump SkRect::dumpHex SkPath::dumpHex
|
|
|
|
#Method ##
|
|
|
|
#Class SkRRect ##
|
|
|
|
#Topic RRect ##
|