1 /*
2 * Copyright 2012 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include <cmath>
9 #include "SkRRectPriv.h"
10 #include "SkScopeExit.h"
11 #include "SkBuffer.h"
12 #include "SkMalloc.h"
13 #include "SkMatrix.h"
14 #include "SkScaleToSides.h"
15
16 ///////////////////////////////////////////////////////////////////////////////
17
setRectXY(const SkRect & rect,SkScalar xRad,SkScalar yRad)18 void SkRRect::setRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad) {
19 if (!this->initializeRect(rect)) {
20 return;
21 }
22
23 if (!SkScalarsAreFinite(xRad, yRad)) {
24 xRad = yRad = 0; // devolve into a simple rect
25 }
26 if (xRad <= 0 || yRad <= 0) {
27 // all corners are square in this case
28 this->setRect(rect);
29 return;
30 }
31
32 if (fRect.width() < xRad+xRad || fRect.height() < yRad+yRad) {
33 SkScalar scale = SkMinScalar(fRect.width() / (xRad + xRad), fRect.height() / (yRad + yRad));
34 SkASSERT(scale < SK_Scalar1);
35 xRad *= scale;
36 yRad *= scale;
37 }
38
39 for (int i = 0; i < 4; ++i) {
40 fRadii[i].set(xRad, yRad);
41 }
42 fType = kSimple_Type;
43 if (xRad >= SkScalarHalf(fRect.width()) && yRad >= SkScalarHalf(fRect.height())) {
44 fType = kOval_Type;
45 // TODO: assert that all the x&y radii are already W/2 & H/2
46 }
47
48 SkASSERT(this->isValid());
49 }
50
setNinePatch(const SkRect & rect,SkScalar leftRad,SkScalar topRad,SkScalar rightRad,SkScalar bottomRad)51 void SkRRect::setNinePatch(const SkRect& rect, SkScalar leftRad, SkScalar topRad,
52 SkScalar rightRad, SkScalar bottomRad) {
53 if (!this->initializeRect(rect)) {
54 return;
55 }
56
57 const SkScalar array[4] = { leftRad, topRad, rightRad, bottomRad };
58 if (!SkScalarsAreFinite(array, 4)) {
59 this->setRect(rect); // devolve into a simple rect
60 return;
61 }
62
63 leftRad = SkMaxScalar(leftRad, 0);
64 topRad = SkMaxScalar(topRad, 0);
65 rightRad = SkMaxScalar(rightRad, 0);
66 bottomRad = SkMaxScalar(bottomRad, 0);
67
68 SkScalar scale = SK_Scalar1;
69 if (leftRad + rightRad > fRect.width()) {
70 scale = fRect.width() / (leftRad + rightRad);
71 }
72 if (topRad + bottomRad > fRect.height()) {
73 scale = SkMinScalar(scale, fRect.height() / (topRad + bottomRad));
74 }
75
76 if (scale < SK_Scalar1) {
77 leftRad *= scale;
78 topRad *= scale;
79 rightRad *= scale;
80 bottomRad *= scale;
81 }
82
83 if (leftRad == rightRad && topRad == bottomRad) {
84 if (leftRad >= SkScalarHalf(fRect.width()) && topRad >= SkScalarHalf(fRect.height())) {
85 fType = kOval_Type;
86 } else if (0 == leftRad || 0 == topRad) {
87 // If the left and (by equality check above) right radii are zero then it is a rect.
88 // Same goes for top/bottom.
89 fType = kRect_Type;
90 leftRad = 0;
91 topRad = 0;
92 rightRad = 0;
93 bottomRad = 0;
94 } else {
95 fType = kSimple_Type;
96 }
97 } else {
98 fType = kNinePatch_Type;
99 }
100
101 fRadii[kUpperLeft_Corner].set(leftRad, topRad);
102 fRadii[kUpperRight_Corner].set(rightRad, topRad);
103 fRadii[kLowerRight_Corner].set(rightRad, bottomRad);
104 fRadii[kLowerLeft_Corner].set(leftRad, bottomRad);
105
106 SkASSERT(this->isValid());
107 }
108
109 // These parameters intentionally double. Apropos crbug.com/463920, if one of the
110 // radii is huge while the other is small, single precision math can completely
111 // miss the fact that a scale is required.
compute_min_scale(double rad1,double rad2,double limit,double curMin)112 static double compute_min_scale(double rad1, double rad2, double limit, double curMin) {
113 if ((rad1 + rad2) > limit) {
114 return SkTMin(curMin, limit / (rad1 + rad2));
115 }
116 return curMin;
117 }
118
setRectRadii(const SkRect & rect,const SkVector radii[4])119 void SkRRect::setRectRadii(const SkRect& rect, const SkVector radii[4]) {
120 if (!this->initializeRect(rect)) {
121 return;
122 }
123
124 if (!SkScalarsAreFinite(&radii[0].fX, 8)) {
125 this->setRect(rect); // devolve into a simple rect
126 return;
127 }
128
129 memcpy(fRadii, radii, sizeof(fRadii));
130
131 bool allCornersSquare = true;
132
133 // Clamp negative radii to zero
134 for (int i = 0; i < 4; ++i) {
135 if (fRadii[i].fX <= 0 || fRadii[i].fY <= 0) {
136 // In this case we are being a little fast & loose. Since one of
137 // the radii is 0 the corner is square. However, the other radii
138 // could still be non-zero and play in the global scale factor
139 // computation.
140 fRadii[i].fX = 0;
141 fRadii[i].fY = 0;
142 } else {
143 allCornersSquare = false;
144 }
145 }
146
147 if (allCornersSquare) {
148 this->setRect(rect);
149 return;
150 }
151
152 this->scaleRadii();
153 }
154
initializeRect(const SkRect & rect)155 bool SkRRect::initializeRect(const SkRect& rect) {
156 // Check this before sorting because sorting can hide nans.
157 if (!rect.isFinite()) {
158 *this = SkRRect();
159 return false;
160 }
161 fRect = rect.makeSorted();
162 if (fRect.isEmpty()) {
163 memset(fRadii, 0, sizeof(fRadii));
164 fType = kEmpty_Type;
165 return false;
166 }
167 return true;
168 }
169
170 // If we can't distinguish one of the radii relative to the other, force it to zero so it
171 // doesn't confuse us later. See crbug.com/850350
172 //
flush_to_zero(SkScalar & a,SkScalar & b)173 static void flush_to_zero(SkScalar& a, SkScalar& b) {
174 SkASSERT(a >= 0);
175 SkASSERT(b >= 0);
176 if (a + b == a) {
177 b = 0;
178 } else if (a + b == b) {
179 a = 0;
180 }
181 }
182
scaleRadii()183 void SkRRect::scaleRadii() {
184
185 // Proportionally scale down all radii to fit. Find the minimum ratio
186 // of a side and the radii on that side (for all four sides) and use
187 // that to scale down _all_ the radii. This algorithm is from the
188 // W3 spec (http://www.w3.org/TR/css3-background/) section 5.5 - Overlapping
189 // Curves:
190 // "Let f = min(Li/Si), where i is one of { top, right, bottom, left },
191 // Si is the sum of the two corresponding radii of the corners on side i,
192 // and Ltop = Lbottom = the width of the box,
193 // and Lleft = Lright = the height of the box.
194 // If f < 1, then all corner radii are reduced by multiplying them by f."
195 double scale = 1.0;
196
197 // The sides of the rectangle may be larger than a float.
198 double width = (double)fRect.fRight - (double)fRect.fLeft;
199 double height = (double)fRect.fBottom - (double)fRect.fTop;
200 scale = compute_min_scale(fRadii[0].fX, fRadii[1].fX, width, scale);
201 scale = compute_min_scale(fRadii[1].fY, fRadii[2].fY, height, scale);
202 scale = compute_min_scale(fRadii[2].fX, fRadii[3].fX, width, scale);
203 scale = compute_min_scale(fRadii[3].fY, fRadii[0].fY, height, scale);
204
205 flush_to_zero(fRadii[0].fX, fRadii[1].fX);
206 flush_to_zero(fRadii[1].fY, fRadii[2].fY);
207 flush_to_zero(fRadii[2].fX, fRadii[3].fX);
208 flush_to_zero(fRadii[3].fY, fRadii[0].fY);
209
210 if (scale < 1.0) {
211 SkScaleToSides::AdjustRadii(width, scale, &fRadii[0].fX, &fRadii[1].fX);
212 SkScaleToSides::AdjustRadii(height, scale, &fRadii[1].fY, &fRadii[2].fY);
213 SkScaleToSides::AdjustRadii(width, scale, &fRadii[2].fX, &fRadii[3].fX);
214 SkScaleToSides::AdjustRadii(height, scale, &fRadii[3].fY, &fRadii[0].fY);
215 }
216
217 // At this point we're either oval, simple, or complex (not empty or rect).
218 this->computeType();
219
220 SkASSERT(this->isValid());
221 }
222
223 // This method determines if a point known to be inside the RRect's bounds is
224 // inside all the corners.
checkCornerContainment(SkScalar x,SkScalar y) const225 bool SkRRect::checkCornerContainment(SkScalar x, SkScalar y) const {
226 SkPoint canonicalPt; // (x,y) translated to one of the quadrants
227 int index;
228
229 if (kOval_Type == this->type()) {
230 canonicalPt.set(x - fRect.centerX(), y - fRect.centerY());
231 index = kUpperLeft_Corner; // any corner will do in this case
232 } else {
233 if (x < fRect.fLeft + fRadii[kUpperLeft_Corner].fX &&
234 y < fRect.fTop + fRadii[kUpperLeft_Corner].fY) {
235 // UL corner
236 index = kUpperLeft_Corner;
237 canonicalPt.set(x - (fRect.fLeft + fRadii[kUpperLeft_Corner].fX),
238 y - (fRect.fTop + fRadii[kUpperLeft_Corner].fY));
239 SkASSERT(canonicalPt.fX < 0 && canonicalPt.fY < 0);
240 } else if (x < fRect.fLeft + fRadii[kLowerLeft_Corner].fX &&
241 y > fRect.fBottom - fRadii[kLowerLeft_Corner].fY) {
242 // LL corner
243 index = kLowerLeft_Corner;
244 canonicalPt.set(x - (fRect.fLeft + fRadii[kLowerLeft_Corner].fX),
245 y - (fRect.fBottom - fRadii[kLowerLeft_Corner].fY));
246 SkASSERT(canonicalPt.fX < 0 && canonicalPt.fY > 0);
247 } else if (x > fRect.fRight - fRadii[kUpperRight_Corner].fX &&
248 y < fRect.fTop + fRadii[kUpperRight_Corner].fY) {
249 // UR corner
250 index = kUpperRight_Corner;
251 canonicalPt.set(x - (fRect.fRight - fRadii[kUpperRight_Corner].fX),
252 y - (fRect.fTop + fRadii[kUpperRight_Corner].fY));
253 SkASSERT(canonicalPt.fX > 0 && canonicalPt.fY < 0);
254 } else if (x > fRect.fRight - fRadii[kLowerRight_Corner].fX &&
255 y > fRect.fBottom - fRadii[kLowerRight_Corner].fY) {
256 // LR corner
257 index = kLowerRight_Corner;
258 canonicalPt.set(x - (fRect.fRight - fRadii[kLowerRight_Corner].fX),
259 y - (fRect.fBottom - fRadii[kLowerRight_Corner].fY));
260 SkASSERT(canonicalPt.fX > 0 && canonicalPt.fY > 0);
261 } else {
262 // not in any of the corners
263 return true;
264 }
265 }
266
267 // A point is in an ellipse (in standard position) if:
268 // x^2 y^2
269 // ----- + ----- <= 1
270 // a^2 b^2
271 // or :
272 // b^2*x^2 + a^2*y^2 <= (ab)^2
273 SkScalar dist = SkScalarSquare(canonicalPt.fX) * SkScalarSquare(fRadii[index].fY) +
274 SkScalarSquare(canonicalPt.fY) * SkScalarSquare(fRadii[index].fX);
275 return dist <= SkScalarSquare(fRadii[index].fX * fRadii[index].fY);
276 }
277
AllCornersCircular(const SkRRect & rr,SkScalar tolerance)278 bool SkRRectPriv::AllCornersCircular(const SkRRect& rr, SkScalar tolerance) {
279 return SkScalarNearlyEqual(rr.fRadii[0].fX, rr.fRadii[0].fY, tolerance) &&
280 SkScalarNearlyEqual(rr.fRadii[1].fX, rr.fRadii[1].fY, tolerance) &&
281 SkScalarNearlyEqual(rr.fRadii[2].fX, rr.fRadii[2].fY, tolerance) &&
282 SkScalarNearlyEqual(rr.fRadii[3].fX, rr.fRadii[3].fY, tolerance);
283 }
284
contains(const SkRect & rect) const285 bool SkRRect::contains(const SkRect& rect) const {
286 if (!this->getBounds().contains(rect)) {
287 // If 'rect' isn't contained by the RR's bounds then the
288 // RR definitely doesn't contain it
289 return false;
290 }
291
292 if (this->isRect()) {
293 // the prior test was sufficient
294 return true;
295 }
296
297 // At this point we know all four corners of 'rect' are inside the
298 // bounds of of this RR. Check to make sure all the corners are inside
299 // all the curves
300 return this->checkCornerContainment(rect.fLeft, rect.fTop) &&
301 this->checkCornerContainment(rect.fRight, rect.fTop) &&
302 this->checkCornerContainment(rect.fRight, rect.fBottom) &&
303 this->checkCornerContainment(rect.fLeft, rect.fBottom);
304 }
305
radii_are_nine_patch(const SkVector radii[4])306 static bool radii_are_nine_patch(const SkVector radii[4]) {
307 return radii[SkRRect::kUpperLeft_Corner].fX == radii[SkRRect::kLowerLeft_Corner].fX &&
308 radii[SkRRect::kUpperLeft_Corner].fY == radii[SkRRect::kUpperRight_Corner].fY &&
309 radii[SkRRect::kUpperRight_Corner].fX == radii[SkRRect::kLowerRight_Corner].fX &&
310 radii[SkRRect::kLowerLeft_Corner].fY == radii[SkRRect::kLowerRight_Corner].fY;
311 }
312
313 // There is a simplified version of this method in setRectXY
computeType()314 void SkRRect::computeType() {
315 SK_AT_SCOPE_EXIT(SkASSERT(this->isValid()));
316
317 if (fRect.isEmpty()) {
318 SkASSERT(fRect.isSorted());
319 for (size_t i = 0; i < SK_ARRAY_COUNT(fRadii); ++i) {
320 SkASSERT((fRadii[i] == SkVector{0, 0}));
321 }
322 fType = kEmpty_Type;
323 return;
324 }
325
326 bool allRadiiEqual = true; // are all x radii equal and all y radii?
327 bool allCornersSquare = 0 == fRadii[0].fX || 0 == fRadii[0].fY;
328
329 for (int i = 1; i < 4; ++i) {
330 if (0 != fRadii[i].fX && 0 != fRadii[i].fY) {
331 // if either radius is zero the corner is square so both have to
332 // be non-zero to have a rounded corner
333 allCornersSquare = false;
334 }
335 if (fRadii[i].fX != fRadii[i-1].fX || fRadii[i].fY != fRadii[i-1].fY) {
336 allRadiiEqual = false;
337 }
338 }
339
340 if (allCornersSquare) {
341 fType = kRect_Type;
342 return;
343 }
344
345 if (allRadiiEqual) {
346 if (fRadii[0].fX >= SkScalarHalf(fRect.width()) &&
347 fRadii[0].fY >= SkScalarHalf(fRect.height())) {
348 fType = kOval_Type;
349 } else {
350 fType = kSimple_Type;
351 }
352 return;
353 }
354
355 if (radii_are_nine_patch(fRadii)) {
356 fType = kNinePatch_Type;
357 } else {
358 fType = kComplex_Type;
359 }
360 }
361
matrix_only_scale_and_translate(const SkMatrix & matrix)362 static bool matrix_only_scale_and_translate(const SkMatrix& matrix) {
363 const SkMatrix::TypeMask m = (SkMatrix::TypeMask) (SkMatrix::kAffine_Mask
364 | SkMatrix::kPerspective_Mask);
365 return (matrix.getType() & m) == 0;
366 }
367
transform(const SkMatrix & matrix,SkRRect * dst) const368 bool SkRRect::transform(const SkMatrix& matrix, SkRRect* dst) const {
369 if (nullptr == dst) {
370 return false;
371 }
372
373 // Assert that the caller is not trying to do this in place, which
374 // would violate const-ness. Do not return false though, so that
375 // if they know what they're doing and want to violate it they can.
376 SkASSERT(dst != this);
377
378 if (matrix.isIdentity()) {
379 *dst = *this;
380 return true;
381 }
382
383 // If transform supported 90 degree rotations (which it could), we could
384 // use SkMatrix::rectStaysRect() to check for a valid transformation.
385 if (!matrix_only_scale_and_translate(matrix)) {
386 return false;
387 }
388
389 SkRect newRect;
390 if (!matrix.mapRect(&newRect, fRect)) {
391 return false;
392 }
393
394 // The matrix may have scaled us to zero (or due to float madness, we now have collapsed
395 // some dimension of the rect, so we need to check for that. Note that matrix must be
396 // scale and translate and mapRect() produces a sorted rect. So an empty rect indicates
397 // loss of precision.
398 if (!newRect.isFinite() || newRect.isEmpty()) {
399 return false;
400 }
401
402 // At this point, this is guaranteed to succeed, so we can modify dst.
403 dst->fRect = newRect;
404
405 // Since the only transforms that were allowed are scale and translate, the type
406 // remains unchanged.
407 dst->fType = fType;
408
409 if (kRect_Type == fType) {
410 SkASSERT(dst->isValid());
411 return true;
412 }
413 if (kOval_Type == fType) {
414 for (int i = 0; i < 4; ++i) {
415 dst->fRadii[i].fX = SkScalarHalf(newRect.width());
416 dst->fRadii[i].fY = SkScalarHalf(newRect.height());
417 }
418 SkASSERT(dst->isValid());
419 return true;
420 }
421
422 // Now scale each corner
423 SkScalar xScale = matrix.getScaleX();
424 const bool flipX = xScale < 0;
425 if (flipX) {
426 xScale = -xScale;
427 }
428 SkScalar yScale = matrix.getScaleY();
429 const bool flipY = yScale < 0;
430 if (flipY) {
431 yScale = -yScale;
432 }
433
434 // Scale the radii without respecting the flip.
435 for (int i = 0; i < 4; ++i) {
436 dst->fRadii[i].fX = fRadii[i].fX * xScale;
437 dst->fRadii[i].fY = fRadii[i].fY * yScale;
438 }
439
440 // Now swap as necessary.
441 if (flipX) {
442 if (flipY) {
443 // Swap with opposite corners
444 SkTSwap(dst->fRadii[kUpperLeft_Corner], dst->fRadii[kLowerRight_Corner]);
445 SkTSwap(dst->fRadii[kUpperRight_Corner], dst->fRadii[kLowerLeft_Corner]);
446 } else {
447 // Only swap in x
448 SkTSwap(dst->fRadii[kUpperRight_Corner], dst->fRadii[kUpperLeft_Corner]);
449 SkTSwap(dst->fRadii[kLowerRight_Corner], dst->fRadii[kLowerLeft_Corner]);
450 }
451 } else if (flipY) {
452 // Only swap in y
453 SkTSwap(dst->fRadii[kUpperLeft_Corner], dst->fRadii[kLowerLeft_Corner]);
454 SkTSwap(dst->fRadii[kUpperRight_Corner], dst->fRadii[kLowerRight_Corner]);
455 }
456
457 if (!AreRectAndRadiiValid(dst->fRect, dst->fRadii)) {
458 return false;
459 }
460
461 dst->scaleRadii();
462 dst->isValid();
463
464 return true;
465 }
466
467 ///////////////////////////////////////////////////////////////////////////////
468
inset(SkScalar dx,SkScalar dy,SkRRect * dst) const469 void SkRRect::inset(SkScalar dx, SkScalar dy, SkRRect* dst) const {
470 SkRect r = fRect.makeInset(dx, dy);
471 bool degenerate = false;
472 if (r.fRight <= r.fLeft) {
473 degenerate = true;
474 r.fLeft = r.fRight = SkScalarAve(r.fLeft, r.fRight);
475 }
476 if (r.fBottom <= r.fTop) {
477 degenerate = true;
478 r.fTop = r.fBottom = SkScalarAve(r.fTop, r.fBottom);
479 }
480 if (degenerate) {
481 dst->fRect = r;
482 memset(dst->fRadii, 0, sizeof(dst->fRadii));
483 dst->fType = kEmpty_Type;
484 return;
485 }
486 if (!r.isFinite()) {
487 *dst = SkRRect();
488 return;
489 }
490
491 SkVector radii[4];
492 memcpy(radii, fRadii, sizeof(radii));
493 for (int i = 0; i < 4; ++i) {
494 if (radii[i].fX) {
495 radii[i].fX -= dx;
496 }
497 if (radii[i].fY) {
498 radii[i].fY -= dy;
499 }
500 }
501 dst->setRectRadii(r, radii);
502 }
503
504 ///////////////////////////////////////////////////////////////////////////////
505
writeToMemory(void * buffer) const506 size_t SkRRect::writeToMemory(void* buffer) const {
507 // Serialize only the rect and corners, but not the derived type tag.
508 memcpy(buffer, this, kSizeInMemory);
509 return kSizeInMemory;
510 }
511
writeToBuffer(SkWBuffer * buffer) const512 void SkRRect::writeToBuffer(SkWBuffer* buffer) const {
513 // Serialize only the rect and corners, but not the derived type tag.
514 buffer->write(this, kSizeInMemory);
515 }
516
readFromMemory(const void * buffer,size_t length)517 size_t SkRRect::readFromMemory(const void* buffer, size_t length) {
518 if (length < kSizeInMemory) {
519 return 0;
520 }
521
522 SkRRect raw;
523 memcpy(&raw, buffer, kSizeInMemory);
524 this->setRectRadii(raw.fRect, raw.fRadii);
525 return kSizeInMemory;
526 }
527
readFromBuffer(SkRBuffer * buffer)528 bool SkRRect::readFromBuffer(SkRBuffer* buffer) {
529 if (buffer->available() < kSizeInMemory) {
530 return false;
531 }
532 SkRRect storage;
533 return buffer->read(&storage, kSizeInMemory) &&
534 (this->readFromMemory(&storage, kSizeInMemory) == kSizeInMemory);
535 }
536
537 #include "SkString.h"
538 #include "SkStringUtils.h"
539
dump(bool asHex) const540 void SkRRect::dump(bool asHex) const {
541 SkScalarAsStringType asType = asHex ? kHex_SkScalarAsStringType : kDec_SkScalarAsStringType;
542
543 fRect.dump(asHex);
544 SkString line("const SkPoint corners[] = {\n");
545 for (int i = 0; i < 4; ++i) {
546 SkString strX, strY;
547 SkAppendScalar(&strX, fRadii[i].x(), asType);
548 SkAppendScalar(&strY, fRadii[i].y(), asType);
549 line.appendf(" { %s, %s },", strX.c_str(), strY.c_str());
550 if (asHex) {
551 line.appendf(" /* %f %f */", fRadii[i].x(), fRadii[i].y());
552 }
553 line.append("\n");
554 }
555 line.append("};");
556 SkDebugf("%s\n", line.c_str());
557 }
558
559 ///////////////////////////////////////////////////////////////////////////////
560
561 /**
562 * We need all combinations of predicates to be true to have a "safe" radius value.
563 */
are_radius_check_predicates_valid(SkScalar rad,SkScalar min,SkScalar max)564 static bool are_radius_check_predicates_valid(SkScalar rad, SkScalar min, SkScalar max) {
565 return (min <= max) && (rad <= max - min) && (min + rad <= max) && (max - rad >= min) &&
566 rad >= 0;
567 }
568
isValid() const569 bool SkRRect::isValid() const {
570 if (!AreRectAndRadiiValid(fRect, fRadii)) {
571 return false;
572 }
573
574 bool allRadiiZero = (0 == fRadii[0].fX && 0 == fRadii[0].fY);
575 bool allCornersSquare = (0 == fRadii[0].fX || 0 == fRadii[0].fY);
576 bool allRadiiSame = true;
577
578 for (int i = 1; i < 4; ++i) {
579 if (0 != fRadii[i].fX || 0 != fRadii[i].fY) {
580 allRadiiZero = false;
581 }
582
583 if (fRadii[i].fX != fRadii[i-1].fX || fRadii[i].fY != fRadii[i-1].fY) {
584 allRadiiSame = false;
585 }
586
587 if (0 != fRadii[i].fX && 0 != fRadii[i].fY) {
588 allCornersSquare = false;
589 }
590 }
591 bool patchesOfNine = radii_are_nine_patch(fRadii);
592
593 if (fType < 0 || fType > kLastType) {
594 return false;
595 }
596
597 switch (fType) {
598 case kEmpty_Type:
599 if (!fRect.isEmpty() || !allRadiiZero || !allRadiiSame || !allCornersSquare) {
600 return false;
601 }
602 break;
603 case kRect_Type:
604 if (fRect.isEmpty() || !allRadiiZero || !allRadiiSame || !allCornersSquare) {
605 return false;
606 }
607 break;
608 case kOval_Type:
609 if (fRect.isEmpty() || allRadiiZero || !allRadiiSame || allCornersSquare) {
610 return false;
611 }
612
613 for (int i = 0; i < 4; ++i) {
614 if (!SkScalarNearlyEqual(fRadii[i].fX, SkScalarHalf(fRect.width())) ||
615 !SkScalarNearlyEqual(fRadii[i].fY, SkScalarHalf(fRect.height()))) {
616 return false;
617 }
618 }
619 break;
620 case kSimple_Type:
621 if (fRect.isEmpty() || allRadiiZero || !allRadiiSame || allCornersSquare) {
622 return false;
623 }
624 break;
625 case kNinePatch_Type:
626 if (fRect.isEmpty() || allRadiiZero || allRadiiSame || allCornersSquare ||
627 !patchesOfNine) {
628 return false;
629 }
630 break;
631 case kComplex_Type:
632 if (fRect.isEmpty() || allRadiiZero || allRadiiSame || allCornersSquare ||
633 patchesOfNine) {
634 return false;
635 }
636 break;
637 }
638
639 return true;
640 }
641
AreRectAndRadiiValid(const SkRect & rect,const SkVector radii[4])642 bool SkRRect::AreRectAndRadiiValid(const SkRect& rect, const SkVector radii[4]) {
643 if (!rect.isFinite() || !rect.isSorted()) {
644 return false;
645 }
646 for (int i = 0; i < 4; ++i) {
647 if (!are_radius_check_predicates_valid(radii[i].fX, rect.fLeft, rect.fRight) ||
648 !are_radius_check_predicates_valid(radii[i].fY, rect.fTop, rect.fBottom)) {
649 return false;
650 }
651 }
652 return true;
653 }
654 ///////////////////////////////////////////////////////////////////////////////
655