1#Topic RRect
2#Alias Round_Rect ##
3#Alias RRect_Reference ##
4
5#Class SkRRect
6
7#Code
8class SkRRect {
9public:
10    SkRRect() = default;
11    SkRRect(const SkRRect& rrect) = default;
12    SkRRect& operator=(const SkRRect& rrect) = default;
13
14    enum Type {
15        kEmpty_Type,
16        kRect_Type,
17        kOval_Type,
18        kSimple_Type,
19        kNinePatch_Type,
20        kComplex_Type,
21        kLastType       = kComplex_Type,
22    };
23
24    Type getType() const;
25    Type type() const;
26    bool isEmpty() const;
27    bool isRect() const;
28    bool isOval() const;
29    bool isSimple() const;
30    bool isNinePatch() const;
31    bool isComplex() const;
32    SkScalar width() const;
33    SkScalar height() const;
34    SkVector getSimpleRadii() const;
35    void setEmpty();
36    void setRect(const SkRect& rect);
37    static SkRRect MakeEmpty();
38    static SkRRect MakeRect(const SkRect& r);
39    static SkRRect MakeOval(const SkRect& oval);
40    static SkRRect MakeRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad);
41    void setOval(const SkRect& oval);
42    void setRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad);
43    void setNinePatch(const SkRect& rect, SkScalar leftRad, SkScalar topRad,
44                      SkScalar rightRad, SkScalar bottomRad);
45    void setRectRadii(const SkRect& rect, const SkVector radii[4]);
46
47    enum Corner {
48        kUpperLeft_Corner,
49        kUpperRight_Corner,
50        kLowerRight_Corner,
51        kLowerLeft_Corner,
52    };
53
54    const SkRect& rect() const;
55    SkVector radii(Corner corner) const;
56    const SkRect& getBounds() const;
57    friend bool operator==(const SkRRect& a, const SkRRect& b);
58    friend bool operator!=(const SkRRect& a, const SkRRect& b);
59    void inset(SkScalar dx, SkScalar dy, SkRRect* dst) const;
60    void inset(SkScalar dx, SkScalar dy);
61    void outset(SkScalar dx, SkScalar dy, SkRRect* dst) const;
62    void outset(SkScalar dx, SkScalar dy);
63    void offset(SkScalar dx, SkScalar dy);
64    SkRRect makeOffset(SkScalar dx, SkScalar dy) const;
65    bool contains(const SkRect& rect) const;
66    bool isValid() const;
67
68    static constexpr size_t kSizeInMemory = 12 * sizeof(SkScalar);
69
70    size_t writeToMemory(void* buffer) const;
71    size_t readFromMemory(const void* buffer, size_t length);
72    bool transform(const SkMatrix& matrix, SkRRect* dst) const;
73    void dump(bool asHex) const;
74    void dump() const;
75    void dumpHex() const;
76};
77##
78
79SkRRect describes a rounded rectangle with a bounds and a pair of radii for each corner.
80The bounds and radii can be set so that SkRRect describes: a rectangle with sharp corners;
81a Circle; an Oval; or a rectangle with one or more rounded corners.
82
83SkRRect allows implementing CSS properties that describe rounded corners.
84SkRRect may have up to eight different radii, one for each axis on each of its four
85corners.
86
87SkRRect may modify the provided parameters when initializing bounds and radii.
88If either axis radii is zero or less: radii are stored as zero; corner is square.
89If corner curves overlap, radii are proportionally reduced to fit within bounds.
90
91# ------------------------------------------------------------------------------
92
93#Method SkRRect()
94#In Constructors
95#Line # creates with zeroed bounds and corner radii ##
96#Populate
97
98#Example
99#Height 60
100    SkRRect rrect;
101    SkPaint p;
102    p.setStyle(SkPaint::kStroke_Style);
103    p.setStrokeWidth(10);
104    canvas->drawRRect(rrect, p);
105    rrect.setRect({10, 10, 100, 50});
106    canvas->drawRRect(rrect, p);
107##
108
109#SeeAlso setEmpty isEmpty
110
111#Method ##
112
113# ------------------------------------------------------------------------------
114
115#Method SkRRect(const SkRRect& rrect)
116#In Constructors
117#Line # copies bounds and corner radii ##
118#Populate
119
120#Example
121#Height 60
122    SkRRect rrect = SkRRect::MakeRect({10, 10, 100, 50});
123    SkRRect rrect2(rrect);
124    rrect2.inset(20, 20);
125    SkPaint p;
126    p.setStyle(SkPaint::kStroke_Style);
127    p.setStrokeWidth(10);
128    canvas->drawRRect(rrect, p);
129    canvas->drawRRect(rrect2, p);
130##
131
132#SeeAlso operator=(const SkRRect& rrect) MakeRect
133
134#Method ##
135
136# ------------------------------------------------------------------------------
137
138#Method SkRRect& operator=(const SkRRect& rrect)
139#In Operators
140#Line # copies bounds and corner radii ##
141#Populate
142
143#Example
144#Height 110
145    SkRRect rrect = SkRRect::MakeRect({40, 40, 100, 70});
146    SkRRect rrect2 = rrect;
147    rrect2.inset(-20, -20);
148    SkPaint p;
149    p.setStyle(SkPaint::kStroke_Style);
150    p.setStrokeWidth(10);
151    canvas->drawRRect(rrect, p);
152    canvas->drawRRect(rrect2, p);
153##
154
155#SeeAlso SkRRect(const SkRRect& rrect) MakeRect
156
157#Method ##
158
159# ------------------------------------------------------------------------------
160#Subtopic Type
161#Line # specialization of Round_Rect geometry ##
162
163#PhraseDef list_of_rrect_types
164kEmpty_Type, kRect_Type, kOval_Type, kSimple_Type, kNinePatch_Type,
165kComplex_Type
166##
167
168#Enum Type
169#Line # specialization of Round_Rect geometry ##
170
171#Code
172    enum Type {
173        kEmpty_Type,
174        kRect_Type,
175        kOval_Type,
176        kSimple_Type,
177        kNinePatch_Type,
178        kComplex_Type,
179        kLastType = kComplex_Type,
180    };
181##
182
183Type describes possible specializations of Round_Rect. Each Type is
184exclusive; a Round_Rect may only have one type.
185
186Type members become progressively less restrictive; larger values of
187Type have more degrees of freedom than smaller values.
188
189#Const kEmpty_Type 0
190#Line # zero width or height ##
191Round_Rect has zero width or height. All radii are zero.
192##
193#Const kRect_Type 1
194#Line # non-zero width and height, and zeroed radii ##
195Round_Rect has width and height. All radii are zero.
196##
197#Const kOval_Type 2
198#Line # non-zero width and height filled with radii ##
199Round_Rect has width and height. All four x-radii are equal,
200and at least half the width. All four y-radii are equal,
201and at least half the height.
202##
203#Const kSimple_Type 3
204#Line # non-zero width and height with equal radii ##
205Round_Rect has width and height. All four x-radii are equal and
206greater than zero, and all four y-radii are equal and greater than
207zero. Either x-radii are less than half the width, or y-radii is
208less than half the height, or both.
209##
210#Const kNinePatch_Type 4
211#Line # non-zero width and height with axis-aligned radii ##
212Round_Rect has width and height. Left x-radii are equal, top
213y-radii are equal, right x-radii are equal, and bottom y-radii
214are equal. The radii do not describe Rect, Oval, or simple type.
215
216The centers of the corner ellipses form an axis-aligned rectangle
217that divides the Round_Rect into nine rectangular patches; an
218interior rectangle, four edges, and four corners.
219##
220#Const kComplex_Type 5
221#Line # non-zero width and height with arbitrary radii ##
222both radii are non-zero.
223##
224#Const kLastType 5
225#Line # largest Type value ##
226##
227
228#Example
229#Height 128
230    struct Radii { SkVector data[4]; };
231    auto drawRRectType = [=](const SkRect& rect, const Radii& radii) {
232        SkRRect rrect;
233        rrect.setRectRadii(rect, radii.data);
234        SkPaint paint;
235        paint.setAntiAlias(true);
236        const char* typeStr[] = { "empty", "rect", "oval", "simple", "nine patch", "complex" };
237        canvas->drawString(typeStr[(int) rrect.type()], rect.centerX(), rect.bottom() + 20, paint);
238        paint.setStyle(SkPaint::kStroke_Style);
239        canvas->drawRRect(rrect, paint);
240    };
241    drawRRectType({ 45,  30,  45,  30}, {{{ 5,  5}, { 5,  5}, { 5,  5}, { 5,  5}}});
242    drawRRectType({ 90,  10, 140,  30}, {{{ 0,  0}, { 0,  0}, { 0,  0}, { 0,  0}}});
243    drawRRectType({160,  10, 210,  30}, {{{25, 10}, {25, 10}, {25, 10}, {25, 10}}});
244    drawRRectType({ 20,  80,  70, 100}, {{{ 5,  5}, { 5,  5}, { 5,  5}, { 5,  5}}});
245    drawRRectType({ 90,  80, 140, 100}, {{{ 5,  5}, {10,  5}, {10,  5}, { 5,  5}}});
246    drawRRectType({160,  80, 210, 100}, {{{ 5,  5}, {10,  5}, { 5,  5}, { 5,  5}}});
247##
248
249#SeeAlso Rect Path
250
251#Enum ##
252
253# ------------------------------------------------------------------------------
254
255#Method Type getType() const
256#In Property
257#Line # returns Type ##
258
259Returns Type, one of: #list_of_rrect_types#.
260
261#Return Type ##
262
263#Example
264#Height 100
265#Description
266rrect2 is not a Rect; inset() has made it empty.
267##
268    SkRRect rrect = SkRRect::MakeRect({10, 10, 100, 50});
269    SkRRect rrect2(rrect);
270    rrect2.inset(20, 20);
271    SkPaint p;
272    p.setStyle(SkPaint::kStroke_Style);
273    p.setStrokeWidth(10);
274    std::string str("Type ");
275    str += SkRRect::kRect_Type == rrect2.getType() ? "=" : "!";
276    str += "= SkRRect::kRect_Type";
277    canvas->drawString(str.c_str(), 20, 80, SkPaint());
278    canvas->drawRRect(rrect2, p);
279##
280
281#SeeAlso Type type
282
283#Method ##
284
285# ------------------------------------------------------------------------------
286
287#Method Type type() const
288#In Property
289#Line # returns Type ##
290
291Returns Type, one of: #list_of_rrect_types#.
292
293#Return Type ##
294
295#Example
296#Height 100
297#Description
298inset() has made rrect2 empty.
299##
300    SkRRect rrect = SkRRect::MakeRect({10, 10, 100, 50});
301    SkRRect rrect2(rrect);
302    rrect2.inset(20, 20);
303    SkPaint p;
304    p.setStyle(SkPaint::kStroke_Style);
305    p.setStrokeWidth(10);
306    std::string str("Type ");
307    str += SkRRect::kEmpty_Type == rrect2.type() ? "=" : "!";
308    str += "= SkRRect::kEmpty_Type";
309    canvas->drawString(str.c_str(), 20, 80, SkPaint());
310    canvas->drawRRect(rrect2, p);
311##
312
313#SeeAlso Type getType
314
315#Method ##
316
317#Subtopic Type ##
318
319# ------------------------------------------------------------------------------
320
321#Method bool isEmpty() const
322#In Property
323#Line # returns true if width or height are zero ##
324#Populate
325
326#Example
327#Height 100
328    SkPaint paint;
329    paint.setAntiAlias(true);
330    paint.setTextSize(16);
331    SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 10, 5);
332    canvas->drawRRect(rrect, paint);
333    canvas->drawString(rrect.isEmpty() ? "empty" : "not empty", 64, 90, paint);
334    rrect.inset(40, 0);
335    canvas->translate(128, 0);
336    canvas->drawRRect(rrect, paint);
337    canvas->drawString(rrect.isEmpty() ? "empty" : "not empty", 64, 90, paint);
338##
339
340#SeeAlso SkRect::isEmpty height width
341
342#Method ##
343
344# ------------------------------------------------------------------------------
345
346#Method bool isRect() const
347#In Property
348#Line # returns true if not empty, and one radius at each corner is zero ##
349#Populate
350
351#Example
352#Height 100
353    SkPaint paint;
354    paint.setAntiAlias(true);
355    paint.setTextSize(16);
356    SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
357    canvas->drawRRect(rrect, paint);
358    canvas->drawString(rrect.isRect() ? "rect" : "not rect", 64, 90, paint);
359    SkVector radii[] = {{10, 10}, {0, 0}, {0, 0}, {0, 0}};
360    rrect.setRectRadii(rrect.getBounds(), radii);
361    canvas->translate(128, 0);
362    canvas->drawRRect(rrect, paint);
363    canvas->drawString(rrect.isRect() ? "rect" : "not rect", 64, 90, paint);
364##
365
366#SeeAlso isEmpty radii
367
368#Method ##
369
370# ------------------------------------------------------------------------------
371
372#Method bool isOval() const
373#In Property
374#Line # returns true if not empty, axes radii are equal, radii fill bounds ##
375#Populate
376
377#Example
378#Height 100
379#Description
380The first radii are scaled down proportionately until both x-axis and y-axis fit
381within the bounds. After scaling, x-axis radius is smaller than half the width;
382left Round_Rect is not an oval. The second radii are equal to half the
383dimensions; right Round_Rect is an oval.
384##
385    SkPaint paint;
386    paint.setAntiAlias(true);
387    paint.setTextSize(16);
388    SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 40, 30);
389    canvas->drawRRect(rrect, paint);
390    canvas->drawString(rrect.isOval() ? "oval" : "not oval", 64, 90, paint);
391    rrect.setRectXY(rrect.getBounds(), 35, 25);
392    canvas->translate(128, 0);
393    canvas->drawRRect(rrect, paint);
394    canvas->drawString(rrect.isOval() ? "oval" : "not oval", 64, 90, paint);
395##
396
397#SeeAlso isEmpty isSimple SkCanvas::drawOval
398
399#Method ##
400
401# ------------------------------------------------------------------------------
402
403#Method bool isSimple() const
404#In Property
405#Line # returns true if not empty, Rect or Oval; and axes radii are equal ##
406#Populate
407
408#Example
409#Height 100
410    SkPaint paint;
411    paint.setAntiAlias(true);
412    paint.setTextSize(16);
413    SkVector radii[] = {{40, 30}, {40, 30}, {40, 30}, {40, 30}};
414    SkRRect rrect;
415    rrect.setRectRadii({30, 10, 100, 60}, radii);
416    canvas->drawRRect(rrect, paint);
417    canvas->drawString(rrect.isSimple() ? "simple" : "not simple", 64, 90, paint);
418    radii[0].fX = 35;
419    rrect.setRectRadii(rrect.getBounds(), radii);
420    canvas->translate(128, 0);
421    canvas->drawRRect(rrect, paint);
422    canvas->drawString(rrect.isSimple() ? "simple" : "not simple", 64, 90, paint);
423##
424
425#SeeAlso isEmpty isRect isOval isNinePatch
426
427#Method ##
428
429# ------------------------------------------------------------------------------
430
431#Method bool isNinePatch() const
432#In Property
433#Line # returns true if not empty, Rect, Oval or simple; and radii are axis-aligned ##
434#Populate
435
436#Example
437#Height 100
438    SkPaint paint;
439    paint.setAntiAlias(true);
440    paint.setTextSize(16);
441    SkVector radii[] = {{20, 30}, {40, 30}, {40, 30}, {20, 30}};
442    SkRRect rrect;
443    rrect.setRectRadii({30, 10, 100, 60}, radii);
444    canvas->drawRRect(rrect, paint);
445    canvas->drawString(rrect.isNinePatch() ? "9 patch" : "not 9 patch", 64, 90, paint);
446    radii[0].fX = 35;
447    rrect.setRectRadii(rrect.getBounds(), radii);
448    canvas->translate(128, 0);
449    canvas->drawRRect(rrect, paint);
450    canvas->drawString(rrect.isNinePatch() ? "9 patch" : "not 9 patch", 64, 90, paint);
451##
452
453#SeeAlso isEmpty isRect isOval isSimple isComplex
454
455#Method ##
456
457# ------------------------------------------------------------------------------
458
459#Method bool isComplex() const
460#In Property
461#Line # returns true if not empty, Rect, Oval, simple, or nine-patch ##
462#Populate
463
464#Example
465#Height 100
466    SkPaint paint;
467    paint.setAntiAlias(true);
468    paint.setTextSize(16);
469    SkVector radii[] = {{25, 30}, {40, 30}, {40, 30}, {20, 30}};
470    SkRRect rrect;
471    rrect.setRectRadii({30, 10, 100, 60}, radii);
472    canvas->drawRRect(rrect, paint);
473    canvas->drawString(rrect.isComplex() ? "complex" : "not complex", 64, 90, paint);
474    radii[0].fX = 20;
475    rrect.setRectRadii(rrect.getBounds(), radii);
476    canvas->translate(128, 0);
477    canvas->drawRRect(rrect, paint);
478    canvas->drawString(rrect.isComplex() ? "complex" : "not complex", 64, 90, paint);
479##
480
481#SeeAlso isEmpty isRect isOval isSimple isNinePatch
482
483#Method ##
484
485# ------------------------------------------------------------------------------
486
487#Method SkScalar width() const
488#In Property
489#Line # returns span in x-axis ##
490#Populate
491
492#Example
493#Description
494SkRRect::MakeRect sorts its input, so width() is always zero or larger.
495##
496    SkRRect unsorted = SkRRect::MakeRect({ 15, 25, 10, 5 });
497    SkDebugf("unsorted width: %g\n", unsorted.width());
498    SkRRect large = SkRRect::MakeRect({ -FLT_MAX, 1, FLT_MAX, 2 });
499    SkDebugf("large width: %.0f\n", large.width());
500#StdOut
501unsorted width: 5
502large width: inf
503##
504##
505
506#SeeAlso SkRect::width height getBounds
507
508#Method ##
509
510# ------------------------------------------------------------------------------
511
512#Method SkScalar height() const
513#In Property
514#Line # returns span in y-axis ##
515#Populate
516
517#Example
518#Description
519SkRRect::MakeRect sorts its input, so height() is always zero or larger.
520##
521    SkRRect unsorted = SkRRect::MakeRect({ 15, 25, 10, 20 });
522    SkDebugf("unsorted height: %g\n", unsorted.height());
523    SkRRect large = SkRRect::MakeRect({ 1, -FLT_MAX, 2, FLT_MAX });
524    SkDebugf("large height: %.0f\n", large.height());
525#StdOut
526unsorted height: 5
527large height: inf
528##
529##
530
531#SeeAlso SkRect::height width getBounds
532
533#Method ##
534
535# ------------------------------------------------------------------------------
536
537#Method SkVector getSimpleRadii() const
538#In Property
539#Line # returns corner radii for simple types ##
540#Populate
541
542#Example
543#Height 100
544    auto drawDetails = [=](const SkRRect& rrect) {
545        SkPaint paint;
546        paint.setAntiAlias(true);
547        paint.setTextSize(12);
548        canvas->drawRRect(rrect, paint);
549        SkVector corner = rrect.getSimpleRadii();
550        std::string label = "corner: " + std::to_string(corner.fX).substr(0, 3) + ", " +
551                        std::to_string(corner.fY).substr(0, 3);
552        canvas->drawString(label.c_str(), 64, 90, paint);
553        canvas->translate(128, 0);
554    };
555    SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
556    drawDetails(rrect);
557    rrect.setRectXY(rrect.getBounds(), 5, 8);
558    drawDetails(rrect);
559##
560
561#SeeAlso radii getBounds getType isSimple
562
563#Method ##
564
565# ------------------------------------------------------------------------------
566
567#Method void setEmpty()
568#In Set
569#Line # zeroes width, height, and corner radii ##
570#Populate
571
572#Example
573#Height 80
574#Description
575Nothing blue is drawn because Round_Rect is set to empty.
576##
577    SkPaint paint;
578    SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
579    canvas->drawRRect(rrect, paint);
580    rrect.setEmpty();
581    paint.setColor(SK_ColorBLUE);
582    canvas->drawRRect(rrect, paint);
583##
584
585#SeeAlso MakeEmpty setRect
586
587#Method ##
588
589# ------------------------------------------------------------------------------
590
591#Method void setRect(const SkRect& rect)
592#In Set
593#Line # sets Round_Rect bounds with zeroed corners ##
594#Populate
595
596#Example
597#Height 90
598    SkPaint paint;
599    SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
600    canvas->drawRRect(rrect, paint);
601    rrect.setRect({60, 30, 120, 80});
602    paint.setColor(SK_ColorBLUE);
603    canvas->drawRRect(rrect, paint);
604##
605
606#SeeAlso MakeRect setRectXY
607
608#Method ##
609
610# ------------------------------------------------------------------------------
611
612#Method static SkRRect MakeEmpty()
613#In Constructors
614#Line # creates with zeroed bounds and corner radii ##
615#Populate
616
617#Example
618#Height 90
619    SkRRect rrect = SkRRect::MakeEmpty();
620    SkRRect rrect2(rrect);
621    rrect2.inset(-20, -20);
622    SkPaint p;
623    p.setStyle(SkPaint::kStroke_Style);
624    p.setStrokeWidth(10);
625    std::string str("Type ");
626    str += SkRRect::kEmpty_Type == rrect2.type() ? "=" : "!";
627    str += "= SkRRect::kEmpty_Type";
628    canvas->drawString(str.c_str(), 20, 80, SkPaint());
629    canvas->drawRRect(rrect2, p);
630##
631
632#SeeAlso SkRRect() SkRect::MakeEmpty
633
634#Method ##
635
636# ------------------------------------------------------------------------------
637
638#Method static SkRRect MakeRect(const SkRect& r)
639#In Constructors
640#Line # copies bounds and zeroes corner radii ##
641#Populate
642
643#Example
644#Height 70
645    SkPaint paint;
646    SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
647    canvas->drawRRect(rrect, paint);
648    rrect.setOval(rrect.getBounds());
649    paint.setColor(SK_ColorBLUE);
650    canvas->drawRRect(rrect, paint);
651##
652
653#SeeAlso setRect MakeOval MakeRectXY
654
655#Method ##
656
657# ------------------------------------------------------------------------------
658
659#Method static SkRRect MakeOval(const SkRect& oval)
660#In Constructors
661#Line # creates Oval to fit bounds ##
662#Populate
663
664#Example
665#Height 70
666    SkPaint paint;
667    SkRRect rrect = SkRRect::MakeOval({30, 10, 100, 60});
668    canvas->drawRRect(rrect, paint);
669    rrect.setRect(rrect.getBounds());
670    paint.setColor(SK_ColorBLUE);
671    paint.setBlendMode(SkBlendMode::kDifference);
672    canvas->drawRRect(rrect, paint);
673##
674
675#SeeAlso setOval MakeRect MakeRectXY
676
677#Method ##
678
679# ------------------------------------------------------------------------------
680
681#Method static SkRRect MakeRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad)
682#In Constructors
683#Line # creates rounded rectangle ##
684#Populate
685
686#Example
687#Height 70
688    SkPaint paint;
689    SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 20, 20);
690    canvas->drawRRect(rrect, paint);
691    rrect.setRect(rrect.getBounds());
692    paint.setColor(SK_ColorBLUE);
693    paint.setBlendMode(SkBlendMode::kModulate);
694    canvas->drawRRect(rrect, paint);
695##
696
697#SeeAlso setRectXY
698
699#Method ##
700
701# ------------------------------------------------------------------------------
702
703#Method void setOval(const SkRect& oval)
704#In Set
705#Line # replaces with Oval to fit bounds ##
706#Populate
707
708#Example
709#Height 70
710    SkPaint paint;
711    SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 20, 20);
712    canvas->drawRRect(rrect, paint);
713    rrect.setOval(rrect.getBounds());
714    paint.setColor(SK_ColorWHITE);
715    paint.setBlendMode(SkBlendMode::kExclusion);
716    canvas->drawRRect(rrect, paint);
717##
718
719#SeeAlso MakeOval
720
721#Method ##
722
723# ------------------------------------------------------------------------------
724
725#Method void setRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad)
726#In Set
727#Line # replaces with rounded rectangle ##
728#Populate
729
730#Example
731#Height 70
732    SkPaint paint;
733    SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 20, 20);
734    canvas->drawRRect(rrect, paint);
735    rrect.setRectXY(rrect.getBounds(), 5, 5);
736    paint.setColor(SK_ColorWHITE);
737    paint.setBlendMode(SkBlendMode::kExclusion);
738    canvas->drawRRect(rrect, paint);
739##
740
741#SeeAlso MakeRectXY SkPath::addRoundRect
742
743#Method ##
744
745# ------------------------------------------------------------------------------
746
747#Method void setNinePatch(const SkRect& rect, SkScalar leftRad, SkScalar topRad,
748                      SkScalar rightRad, SkScalar bottomRad)
749#In Set
750#Line # replaces with rounded rectangle ##
751#Populate
752
753#Example
754#Height 70
755    SkPaint paint;
756    paint.setAntiAlias(true);
757    SkRRect rrect;
758    rrect.setNinePatch({30, 10, 100, 60}, 10, 20, 20, 10);
759    canvas->drawRRect(rrect, paint);
760    paint.setColor(SK_ColorWHITE);
761    const SkRect r = rrect.getBounds();
762    canvas->drawLine(r.fLeft, r.fTop + rrect.radii(SkRRect::kUpperLeft_Corner).fY,
763                     r.fRight, r.fTop + rrect.radii(SkRRect::kUpperRight_Corner).fY, paint);
764    canvas->drawLine(r.fLeft, r.fBottom - rrect.radii(SkRRect::kLowerLeft_Corner).fY,
765                     r.fRight, r.fBottom - rrect.radii(SkRRect::kLowerRight_Corner).fY, paint);
766    canvas->drawLine(r.fLeft + rrect.radii(SkRRect::kUpperLeft_Corner).fX, r.fTop,
767                     r.fLeft + rrect.radii(SkRRect::kLowerLeft_Corner).fX, r.fBottom, paint);
768    canvas->drawLine(r.fRight - rrect.radii(SkRRect::kUpperRight_Corner).fX, r.fTop,
769                     r.fRight - rrect.radii(SkRRect::kLowerRight_Corner).fX, r.fBottom, paint);
770##
771
772#SeeAlso setRectRadii
773
774#Method ##
775
776# ------------------------------------------------------------------------------
777
778#Method void setRectRadii(const SkRect& rect, const SkVector radii[4])
779#In Set
780#Line # replaces with rounded rectangle ##
781#Populate
782
783#Example
784#Height 128
785    SkPaint paint;
786    paint.setStrokeWidth(15);
787    paint.setStrokeCap(SkPaint::kSquare_Cap);
788    paint.setAntiAlias(true);
789    float intervals[] = { 5, 21.75f };
790    paint.setStyle(SkPaint::kStroke_Style);
791    paint.setPathEffect(SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0));
792    SkPath path;
793    SkRRect rrect;
794    SkVector corners[] = {{15, 17}, {17, 19}, {19, 15}, {15, 15}};
795    rrect.setRectRadii({20, 20, 100, 100}, corners);
796    path.addRRect(rrect, SkPath::kCW_Direction);
797    canvas->drawPath(path, paint);
798    path.rewind();
799    path.addRRect(rrect, SkPath::kCCW_Direction, 1);
800    canvas->translate(120, 0);
801    canvas->drawPath(path, paint);
802##
803
804#SeeAlso setNinePatch SkPath::addRoundRect
805
806#Method ##
807
808# ------------------------------------------------------------------------------
809
810#Enum Corner
811#Line # corner radii order ##
812
813#Code
814    enum Corner {
815        kUpperLeft_Corner,
816        kUpperRight_Corner,
817        kLowerRight_Corner,
818        kLowerLeft_Corner,
819    };
820##
821
822The radii are stored: top-left, top-right, bottom-right, bottom-left.
823
824#Const kUpperLeft_Corner 0
825#Line # index of top-left corner radii ##
826##
827#Const kUpperRight_Corner 1
828#Line # index of top-right corner radii ##
829##
830#Const kLowerRight_Corner 2
831#Line # index of bottom-right corner radii ##
832##
833#Const kLowerLeft_Corner 3
834#Line # index of bottom-left corner radii ##
835##
836
837#Example
838#Height 70
839    SkPaint paint;
840    paint.setAntiAlias(true);
841    SkRRect rrect;
842    SkVector corners[] = {{25, 17}, {17, 19}, {19, 15}, {15, 15}};
843    rrect.setRectRadii({30, 10, 100, 60}, corners);
844    canvas->drawRRect(rrect, paint);
845    paint.setColor(SK_ColorWHITE);
846    const SkRect r = rrect.getBounds();
847    canvas->drawLine(r.fLeft, r.fTop + rrect.radii(SkRRect::kUpperLeft_Corner).fY,
848                     r.fRight, r.fTop + rrect.radii(SkRRect::kUpperRight_Corner).fY, paint);
849    canvas->drawLine(r.fLeft, r.fBottom - rrect.radii(SkRRect::kLowerLeft_Corner).fY,
850                     r.fRight, r.fBottom - rrect.radii(SkRRect::kLowerRight_Corner).fY, paint);
851    canvas->drawLine(r.fLeft + rrect.radii(SkRRect::kUpperLeft_Corner).fX, r.fTop,
852                     r.fLeft + rrect.radii(SkRRect::kLowerLeft_Corner).fX, r.fBottom, paint);
853    canvas->drawLine(r.fRight - rrect.radii(SkRRect::kUpperRight_Corner).fX, r.fTop,
854                     r.fRight - rrect.radii(SkRRect::kLowerRight_Corner).fX, r.fBottom, paint);
855##
856
857#SeeAlso radii
858
859#Enum ##
860
861# ------------------------------------------------------------------------------
862
863#Method const SkRect& rect() const
864#In Property
865#Line # returns bounds ##
866#Populate
867
868#Example
869    for (SkScalar left : { SK_ScalarNaN, SK_ScalarInfinity, 100.f, 50.f, 25.f} ) {
870        SkRRect rrect1 = SkRRect::MakeRectXY({left, 20, 60, 220}, 50, 200);
871        SkDebugf("left bounds: (%g) %g\n", left, rrect1.rect().fLeft);
872    }
873#StdOut
874left bounds: (nan) 0
875left bounds: (inf) 0
876left bounds: (100) 60
877left bounds: (50) 50
878left bounds: (25) 25
879##
880##
881
882#SeeAlso getBounds
883
884#Method ##
885
886# ------------------------------------------------------------------------------
887
888#Method SkVector radii(Corner corner) const
889#In Property
890#Line # returns x-axis and y-axis radii for one corner ##
891#Populate
892
893#Example
894#Description
895Finite values are scaled proportionately to fit; other values are set to zero.
896Scaled values cannot be larger than 25, half the bounding Round_Rect width.
897Small scaled values are halved to scale in proportion to the y-axis corner
898radius, which is twice the bounds height.
899##
900    for (SkScalar radiusX : { SK_ScalarNaN, SK_ScalarInfinity, 100.f, 50.f, 25.f} ) {
901        SkRRect rrect1 = SkRRect::MakeRectXY({10, 20, 60, 220}, radiusX, 200);
902        SkDebugf("left corner: (%g) %g\n", radiusX, rrect1.radii(SkRRect::kUpperLeft_Corner).fX);
903    }
904#StdOut
905left corner: (nan) 0
906left corner: (inf) 0
907left corner: (100) 25
908left corner: (50) 25
909left corner: (25) 12.5
910##
911##
912
913#SeeAlso Corner
914
915#Method ##
916
917# ------------------------------------------------------------------------------
918
919#Method const SkRect& getBounds() const
920#In Property
921#Line # returns bounds ##
922#Populate
923
924#Example
925#Height 120
926    SkPaint paint;
927    SkRRect rrect = SkRRect::MakeRectXY({20, 20, 220, 100}, 15, 15);
928    canvas->drawRRect(rrect, paint);
929    paint.setColor(SK_ColorWHITE);
930    rrect = SkRRect::MakeOval(rrect.getBounds());
931    canvas->drawRRect(rrect, paint);
932##
933
934#SeeAlso rect
935
936#Method ##
937
938# ------------------------------------------------------------------------------
939
940#Method bool operator==(const SkRRect& a, const SkRRect& b)
941#In Operators
942#Line # returns true if members are equal ##
943#Populate
944
945#Example
946    SkRRect rrect1 = SkRRect::MakeRectXY({10, 20, 60, 220}, 50, 200);
947    SkRRect rrect2 = SkRRect::MakeRectXY(rrect1.rect(), 25, 100);
948    SkRRect rrect3 = SkRRect::MakeOval(rrect1.rect());
949    canvas->drawRRect(rrect1, SkPaint());
950    std::string str = "rrect1 " + std::string(rrect1 == rrect2 ? "=" : "!") + "= rrect2";
951    canvas->drawString(str.c_str(), 10, 240, SkPaint());
952    canvas->translate(70, 0);
953    canvas->drawRRect(rrect2, SkPaint());
954    canvas->translate(70, 0);
955    canvas->drawRRect(rrect3, SkPaint());
956    str = "rrect2 " + std::string(rrect2 == rrect3 ? "=" : "!") + "= rrect3";
957    canvas->drawString(str.c_str(), -20, 240, SkPaint());
958##
959
960#SeeAlso operator!=(const SkRRect& a, const SkRRect& b)
961
962#Method ##
963
964# ------------------------------------------------------------------------------
965
966#Method bool operator!=(const SkRRect& a, const SkRRect& b)
967#In Operators
968#Line # returns true if members are unequal ##
969#Populate
970
971#Example
972    SkRRect rrect1 = SkRRect::MakeRectXY({10, 20, 60, 220}, 50, 100);
973    SkRRect rrect2 = SkRRect::MakeRectXY(rrect1.rect(), 50, 50);
974    SkRRect rrect3 = SkRRect::MakeOval(rrect1.rect());
975    canvas->drawRRect(rrect1, SkPaint());
976    std::string str = "rrect1 " + std::string(rrect1 == rrect2 ? "=" : "!") + "= rrect2";
977    canvas->drawString(str.c_str(), 10, 240, SkPaint());
978    canvas->translate(70, 0);
979    canvas->drawRRect(rrect2, SkPaint());
980    canvas->translate(70, 0);
981    canvas->drawRRect(rrect3, SkPaint());
982    str = "rrect2 " + std::string(rrect2 == rrect3 ? "=" : "!") + "= rrect3";
983    canvas->drawString(str.c_str(), -20, 240, SkPaint());
984##
985
986#SeeAlso operator==(const SkRRect& a, const SkRRect& b)
987
988#Method ##
989
990# ------------------------------------------------------------------------------
991
992#Method void inset(SkScalar dx, SkScalar dy, SkRRect* dst) const
993#In Inset_Outset_Offset
994#Line # insets bounds and radii ##
995#Populate
996
997#Example
998    SkPaint paint;
999    paint.setAntiAlias(true);
1000    paint.setStyle(SkPaint::kStroke_Style);
1001    SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
1002    for (int index = 0; index < 25; ++index) {
1003       canvas->drawRRect(rrect, paint);
1004       rrect.inset(-3, 3, &rrect);
1005    }
1006##
1007
1008#SeeAlso outset offset makeOffset
1009
1010#Method ##
1011
1012# ------------------------------------------------------------------------------
1013
1014#Method void inset(SkScalar dx, SkScalar dy)
1015#In Inset_Outset_Offset
1016#Line # insets bounds and radii ##
1017#Populate
1018
1019#Example
1020    SkPaint paint;
1021    paint.setAntiAlias(true);
1022    paint.setStyle(SkPaint::kStroke_Style);
1023    SkRRect rrect = SkRRect::MakeRectXY({10, 20, 180, 220}, 50, 100);
1024    for (int index = 0; index < 25; ++index) {
1025       canvas->drawRRect(rrect, paint);
1026       rrect.inset(3, 3);
1027    }
1028##
1029
1030#SeeAlso outset offset makeOffset
1031
1032
1033#Method ##
1034
1035# ------------------------------------------------------------------------------
1036
1037#Method void outset(SkScalar dx, SkScalar dy, SkRRect* dst) const
1038#In Inset_Outset_Offset
1039#Line # outsets bounds and radii ##
1040#Populate
1041
1042#Example
1043    SkPaint paint;
1044    paint.setAntiAlias(true);
1045    paint.setStyle(SkPaint::kStroke_Style);
1046    SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
1047    for (int index = 0; index < 25; ++index) {
1048       canvas->drawRRect(rrect, paint);
1049       rrect.outset(-3, 3, &rrect);
1050    }
1051##
1052
1053#SeeAlso inset offset makeOffset
1054
1055
1056#Method ##
1057
1058# ------------------------------------------------------------------------------
1059
1060#Method void outset(SkScalar dx, SkScalar dy)
1061#In Inset_Outset_Offset
1062#Line # outsets bounds and radii ##
1063#Populate
1064
1065#Example
1066    SkPaint paint;
1067    paint.setAntiAlias(true);
1068    paint.setStyle(SkPaint::kStroke_Style);
1069    SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
1070    for (int index = 0; index < 25; ++index) {
1071       canvas->drawRRect(rrect, paint);
1072       rrect.outset(3, 3);
1073    }
1074##
1075
1076#SeeAlso inset offset makeOffset
1077
1078#Method ##
1079
1080# ------------------------------------------------------------------------------
1081
1082#Method void offset(SkScalar dx, SkScalar dy)
1083#In Inset_Outset_Offset
1084#Line # offsets bounds and radii ##
1085#Populate
1086
1087#Example
1088    SkPaint paint;
1089    paint.setAntiAlias(true);
1090    paint.setStyle(SkPaint::kStroke_Style);
1091    SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
1092    for (int index = 0; index < 25; ++index) {
1093       canvas->drawRRect(rrect, paint);
1094       rrect.offset(3, 3);
1095    }
1096##
1097
1098#SeeAlso makeOffset inset outset
1099
1100#Method ##
1101
1102# ------------------------------------------------------------------------------
1103
1104#Method SkRRect makeOffset(SkScalar dx, SkScalar dy) const
1105#In Inset_Outset_Offset
1106#Line # offsets bounds and radii ##
1107#Populate
1108
1109#Example
1110    SkPaint paint;
1111    paint.setAntiAlias(true);
1112    paint.setStyle(SkPaint::kStroke_Style);
1113    SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
1114    for (int index = 0; index < 25; ++index) {
1115       canvas->drawRRect(rrect, paint);
1116       rrect = rrect.makeOffset(-3, 3);
1117    }
1118##
1119
1120#SeeAlso offset inset outset
1121
1122#Method ##
1123
1124# ------------------------------------------------------------------------------
1125
1126#Method bool contains(const SkRect& rect) const
1127#In Intersection
1128#Line # returns true if Rect is inside ##
1129#Populate
1130
1131#Example
1132#Height 110
1133    SkRect test = {10, 10, 110, 80};
1134    SkRRect rrect = SkRRect::MakeRect(test);
1135    SkRRect oval = SkRRect::MakeOval(test);
1136    test.inset(10, 10);
1137    SkPaint paint;
1138    paint.setAntiAlias(true);
1139    canvas->drawString(rrect.contains(test) ? "contains" : "does not contain", 55, 100, paint);
1140    canvas->drawString(oval.contains(test) ? "contains" : "does not contain", 185, 100, paint);
1141    paint.setStyle(SkPaint::kStroke_Style);
1142    canvas->drawRRect(rrect, paint);
1143    canvas->drawRect(test, paint);
1144    canvas->translate(120, 0);
1145    canvas->drawRRect(oval, paint);
1146    canvas->drawRect(test, paint);
1147##
1148
1149#SeeAlso SkRect::contains
1150
1151#Method ##
1152
1153# ------------------------------------------------------------------------------
1154
1155#Method bool isValid() const
1156#In Utility
1157#Line # returns if type() matches bounds and radii  ##
1158#Populate
1159
1160#Example
1161#Height 110
1162    SkRRect rrect = SkRRect::MakeRect({10, 10, 110, 80});
1163    SkRRect corrupt = rrect;
1164    *((float*) &corrupt) = 120;
1165    SkPaint paint;
1166    paint.setAntiAlias(true);
1167    canvas->drawString(rrect.isValid() ? "is valid" : "is corrupted", 55, 100, paint);
1168    canvas->drawString(corrupt.isValid() ? "is valid" : "is corrupted", 185, 100, paint);
1169    paint.setStyle(SkPaint::kStroke_Style);
1170    canvas->drawRRect(rrect, paint);
1171    canvas->translate(120, 0);
1172    canvas->drawRRect(corrupt, paint);
1173##
1174
1175#SeeAlso Type getType
1176
1177#Method ##
1178
1179# ------------------------------------------------------------------------------
1180
1181#Const kSizeInMemory 48
1182#Line # storage space for Round_Rect ##
1183
1184Space required to write the contents of SkRRect into a buffer; always a multiple of four.
1185
1186#Const ##
1187
1188# ------------------------------------------------------------------------------
1189
1190#Method size_t writeToMemory(void* buffer) const
1191#In Utility
1192#Line # writes Round_Rect to buffer ##
1193#Populate
1194
1195#Example
1196#Height 110
1197    SkRRect rrect = SkRRect::MakeRect({10, 10, 110, 80});
1198    char storage[SkRRect::kSizeInMemory];
1199    rrect.writeToMemory(storage);
1200    SkRRect copy;
1201    copy.readFromMemory(storage, sizeof(storage));
1202    SkPaint paint;
1203    paint.setAntiAlias(true);
1204    canvas->drawString("rrect", 55, 100, paint);
1205    canvas->drawString("copy", 185, 100, paint);
1206    paint.setStyle(SkPaint::kStroke_Style);
1207    canvas->drawRRect(rrect, paint);
1208    canvas->translate(120, 0);
1209    canvas->drawRRect(copy, paint);
1210##
1211
1212#SeeAlso readFromMemory
1213
1214#Method ##
1215
1216# ------------------------------------------------------------------------------
1217
1218#Method size_t readFromMemory(const void* buffer, size_t length)
1219#In Utility
1220#Line # reads Round_Rect from buffer ##
1221#Populate
1222
1223#Example
1224#Height 110
1225    SkVector radii[] = {{5, 5},  {10, 10}, {15, 15}, {5, 5}};
1226    SkRRect rrect;
1227    rrect.setRectRadii({10, 10, 110, 80}, radii);
1228    char storage[SkRRect::kSizeInMemory];
1229    rrect.writeToMemory(storage);
1230    SkRRect copy;
1231    copy.readFromMemory(storage, sizeof(storage));
1232    SkPaint paint;
1233    paint.setAntiAlias(true);
1234    canvas->drawString("rrect", 55, 100, paint);
1235    canvas->drawString("copy", 185, 100, paint);
1236    paint.setStyle(SkPaint::kStroke_Style);
1237    canvas->drawRRect(rrect, paint);
1238    canvas->translate(120, 0);
1239    canvas->drawRRect(copy, paint);
1240##
1241
1242#SeeAlso writeToMemory
1243
1244#Method ##
1245
1246# ------------------------------------------------------------------------------
1247
1248#Method bool transform(const SkMatrix& matrix, SkRRect* dst) const
1249#In Inset_Outset_Offset
1250#Line # scales and offsets into copy ##
1251#Populate
1252
1253#Example
1254#Height 110
1255    SkVector radii[] = {{5, 5},  {10, 10}, {15, 15}, {5, 5}};
1256    SkRRect rrect;
1257    rrect.setRectRadii({10, 10, 110, 80}, radii);
1258    SkRRect transformed;
1259    SkMatrix matrix = SkMatrix::MakeRectToRect(rrect.rect(), {140, 30, 220, 80},
1260                                               SkMatrix::kCenter_ScaleToFit);
1261    bool success = rrect.transform(matrix, &transformed);
1262    SkPaint paint;
1263    paint.setAntiAlias(true);
1264    canvas->drawString("rrect", 55, 100, paint);
1265    canvas->drawString(success ? "transformed" : "transform failed", 185, 100, paint);
1266    paint.setStyle(SkPaint::kStroke_Style);
1267    canvas->drawRRect(rrect, paint);
1268    canvas->drawRRect(transformed, paint);
1269##
1270
1271#SeeAlso SkPath::transform
1272
1273#Method ##
1274
1275# ------------------------------------------------------------------------------
1276
1277#Method void dump(bool asHex) const
1278#In Utility
1279#Line # sends text representation to standard output ##
1280#Populate
1281
1282#Example
1283SkRRect rrect = SkRRect::MakeRect({6.f / 7, 2.f / 3, 6.f / 7, 2.f / 3});
1284for (bool dumpAsHex : { false, true } ) {
1285    rrect.dump(dumpAsHex);
1286}
1287#StdOut
1288SkRect::MakeLTRB(0.857143f, 0.666667f, 0.857143f, 0.666667f);
1289const SkPoint corners[] = {
1290    { 0, 0 },
1291    { 0, 0 },
1292    { 0, 0 },
1293    { 0, 0 },
1294};
1295SkRect::MakeLTRB(SkBits2Float(0x3f5b6db7), /* 0.857143 */
1296                 SkBits2Float(0x3f2aaaab), /* 0.666667 */
1297                 SkBits2Float(0x3f5b6db7), /* 0.857143 */
1298                 SkBits2Float(0x3f2aaaab)  /* 0.666667 */);
1299const SkPoint corners[] = {
1300    { SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
1301    { SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
1302    { SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
1303    { SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
1304};
1305##
1306##
1307
1308#SeeAlso dumpHex SkRect::dump SkPath::dump SkPathMeasure::dump
1309
1310#Method ##
1311
1312# ------------------------------------------------------------------------------
1313
1314#Method void dump() const
1315#In Utility
1316#Line # sends text representation using floats to standard output ##
1317#Populate
1318
1319#Example
1320SkRRect rrect = SkRRect::MakeRect({6.f / 7, 2.f / 3, 6.f / 7, 2.f / 3});
1321rrect.dump();
1322SkRect bounds = SkRect::MakeLTRB(0.857143f, 0.666667f, 0.857143f, 0.666667f);
1323const SkPoint corners[] = {
1324    { 0, 0 },
1325    { 0, 0 },
1326    { 0, 0 },
1327    { 0, 0 },
1328};
1329SkRRect copy;
1330copy.setRectRadii(bounds, corners);
1331SkDebugf("rrect is " "%s" "equal to copy\n", rrect == copy ? "" : "not ");
1332#StdOut
1333SkRect::MakeLTRB(0.857143f, 0.666667f, 0.857143f, 0.666667f);
1334const SkPoint corners[] = {
1335    { 0, 0 },
1336    { 0, 0 },
1337    { 0, 0 },
1338    { 0, 0 },
1339};
1340rrect is not equal to copy
1341##
1342##
1343
1344#SeeAlso dumpHex SkRect::dump SkPath::dump SkPathMeasure::dump
1345
1346#Method ##
1347
1348# ------------------------------------------------------------------------------
1349
1350#Method void dumpHex() const
1351#In Utility
1352#Line # sends text representation using hexadecimal to standard output ##
1353#Populate
1354
1355#Example
1356SkRRect rrect = SkRRect::MakeRect({6.f / 7, 2.f / 3, 6.f / 7, 2.f / 3});
1357rrect.dumpHex();
1358SkRect bounds = SkRect::MakeLTRB(SkBits2Float(0x3f5b6db7), /* 0.857143 */
1359                 SkBits2Float(0x3f2aaaab), /* 0.666667 */
1360                 SkBits2Float(0x3f5b6db7), /* 0.857143 */
1361                 SkBits2Float(0x3f2aaaab)  /* 0.666667 */);
1362const SkPoint corners[] = {
1363    { SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
1364    { SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
1365    { SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
1366    { SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
1367};
1368SkRRect copy;
1369copy.setRectRadii(bounds, corners);
1370SkDebugf("rrect is " "%s" "equal to copy\n", rrect == copy ? "" : "not ");
1371#StdOut
1372SkRect::MakeLTRB(SkBits2Float(0x3f5b6db7), /* 0.857143 */
1373                 SkBits2Float(0x3f2aaaab), /* 0.666667 */
1374                 SkBits2Float(0x3f5b6db7), /* 0.857143 */
1375                 SkBits2Float(0x3f2aaaab)  /* 0.666667 */);
1376const SkPoint corners[] = {
1377    { SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
1378    { SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
1379    { SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
1380    { SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
1381};
1382rrect is equal to copy
1383##
1384##
1385
1386#SeeAlso dump SkRect::dumpHex SkPath::dumpHex
1387
1388#Method ##
1389
1390#Class SkRRect ##
1391
1392#Topic RRect ##
1393