| /* |
| * Copyright 2012 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #ifndef SkRRect_DEFINED |
| #define SkRRect_DEFINED |
| |
| #include "include/core/SkPoint.h" |
| #include "include/core/SkRect.h" |
| |
| class SkPath; |
| class SkMatrix; |
| |
| /** \class SkRRect |
| SkRRect describes a rounded rectangle with a bounds and a pair of radii for each corner. |
| The bounds and radii can be set so that SkRRect describes: a rectangle with sharp corners; |
| a circle; an oval; or a rectangle with one or more rounded corners. |
| |
| SkRRect allows implementing CSS properties that describe rounded corners. |
| SkRRect may have up to eight different radii, one for each axis on each of its four |
| corners. |
| |
| SkRRect may modify the provided parameters when initializing bounds and radii. |
| If either axis radii is zero or less: radii are stored as zero; corner is square. |
| If corner curves overlap, radii are proportionally reduced to fit within bounds. |
| */ |
| class SK_API SkRRect { |
| public: |
| |
| /** 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 SkRRect |
| */ |
| SkRRect() = default; |
| |
| /** Initializes to copy of rrect bounds and corner radii. |
| |
| @param rrect bounds and corner to copy |
| @return copy of rrect |
| */ |
| SkRRect(const SkRRect& rrect) = default; |
| |
| /** Copies rrect bounds and corner radii. |
| |
| @param rrect bounds and corner to copy |
| @return copy of rrect |
| */ |
| SkRRect& operator=(const SkRRect& rrect) = default; |
| |
| /** \enum SkRRect::Type |
| Type describes possible specializations of SkRRect. Each Type is |
| exclusive; a SkRRect may only have one type. |
| |
| Type members become progressively less restrictive; larger values of |
| Type have more degrees of freedom than smaller values. |
| */ |
| enum Type { |
| kEmpty_Type, //!< zero width or height |
| kRect_Type, //!< non-zero width and height, and zeroed radii |
| kOval_Type, //!< non-zero width and height filled with radii |
| kSimple_Type, //!< non-zero width and height with equal radii |
| kNinePatch_Type, //!< non-zero width and height with axis-aligned radii |
| kComplex_Type, //!< non-zero width and height with arbitrary radii |
| kLastType = kComplex_Type, //!< largest Type value |
| }; |
| |
| /** Returns SkRRect::Type, one of: |
| kEmpty_Type, kRect_Type, kOval_Type, kSimple_Type, kNinePatch_Type, |
| kComplex_Type. |
| |
| @return SkRRect::Type |
| */ |
| Type getType() const { |
| SkASSERT(this->isValid()); |
| return static_cast<Type>(fType); |
| } |
| |
| /** Returns SkRRect::Type, one of: |
| kEmpty_Type, kRect_Type, kOval_Type, kSimple_Type, kNinePatch_Type, |
| kComplex_Type. |
| |
| @return SkRRect::Type |
| */ |
| Type type() const { return this->getType(); } |
| |
| inline bool isEmpty() const { return kEmpty_Type == this->getType(); } |
| inline bool isRect() const { return kRect_Type == this->getType(); } |
| inline bool isOval() const { return kOval_Type == this->getType(); } |
| inline bool isSimple() const { return kSimple_Type == this->getType(); } |
| inline bool isNinePatch() const { return kNinePatch_Type == this->getType(); } |
| inline bool isComplex() const { return kComplex_Type == this->getType(); } |
| |
| /** Returns span on the x-axis. This does not check if result fits in 32-bit float; |
| result may be infinity. |
| |
| @return rect().fRight minus rect().fLeft |
| */ |
| SkScalar width() const { return fRect.width(); } |
| |
| /** Returns span on the y-axis. This does not check if result fits in 32-bit float; |
| result may be infinity. |
| |
| @return rect().fBottom minus rect().fTop |
| */ |
| SkScalar height() const { return fRect.height(); } |
| |
| /** Returns top-left corner 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 |
| */ |
| SkVector getSimpleRadii() const { |
| return fRadii[0]; |
| } |
| |
| /** Sets bounds to zero width and height at (0, 0), the origin. Sets |
| corner radii to zero and sets type to kEmpty_Type. |
| */ |
| void setEmpty() { *this = SkRRect(); } |
| |
| /** 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 |
| */ |
| void setRect(const SkRect& rect) { |
| if (!this->initializeRect(rect)) { |
| return; |
| } |
| |
| memset(fRadii, 0, sizeof(fRadii)); |
| fType = kRect_Type; |
| |
| SkASSERT(this->isValid()); |
| } |
| |
| /** 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 SkRRect |
| */ |
| static SkRRect MakeEmpty() { return SkRRect(); } |
| |
| /** Initializes to copy of r bounds and zeroes corner radii. |
| |
| @param r bounds to copy |
| @return copy of r |
| */ |
| static SkRRect MakeRect(const SkRect& r) { |
| SkRRect rr; |
| rr.setRect(r); |
| return rr; |
| } |
| |
| /** Sets bounds to oval, x-axis radii to half oval.width(), and all y-axis radii |
| to half oval.height(). If oval bounds is empty, sets to kEmpty_Type. |
| Otherwise, sets to kOval_Type. |
| |
| @param oval bounds of oval |
| @return oval |
| */ |
| static SkRRect MakeOval(const SkRect& oval) { |
| SkRRect rr; |
| rr.setOval(oval); |
| return rr; |
| } |
| |
| /** 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 |
| */ |
| static SkRRect MakeRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad) { |
| SkRRect rr; |
| rr.setRectXY(rect, xRad, yRad); |
| return rr; |
| } |
| |
| /** Sets bounds to oval, x-axis radii to half oval.width(), and all y-axis radii |
| to half oval.height(). If oval bounds is empty, sets to kEmpty_Type. |
| Otherwise, sets to kOval_Type. |
| |
| @param oval bounds of oval |
| */ |
| void setOval(const SkRect& oval) { |
| if (!this->initializeRect(oval)) { |
| return; |
| } |
| |
| SkScalar xRad = SkScalarHalf(fRect.width()); |
| SkScalar yRad = SkScalarHalf(fRect.height()); |
| |
| for (int i = 0; i < 4; ++i) { |
| fRadii[i].set(xRad, yRad); |
| } |
| fType = kOval_Type; |
| |
| SkASSERT(this->isValid()); |
| } |
| |
| /** 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 |
| */ |
| void setRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad); |
| |
| /** 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 |
| */ |
| void setNinePatch(const SkRect& rect, SkScalar leftRad, SkScalar topRad, |
| SkScalar rightRad, SkScalar bottomRad); |
| |
| /** 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 |
| */ |
| void setRectRadii(const SkRect& rect, const SkVector radii[4]); |
| |
| /** \enum SkRRect::Corner |
| The radii are stored: top-left, top-right, bottom-right, bottom-left. |
| */ |
| enum Corner { |
| kUpperLeft_Corner, //!< index of top-left corner radii |
| kUpperRight_Corner, //!< index of top-right corner radii |
| kLowerRight_Corner, //!< index of bottom-right corner radii |
| kLowerLeft_Corner, //!< index of bottom-left corner radii |
| }; |
| |
| /** 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 |
| */ |
| const SkRect& rect() const { return fRect; } |
| |
| /** 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 |
| */ |
| SkVector radii(Corner corner) const { return fRadii[corner]; } |
| |
| /** 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 |
| */ |
| const SkRect& getBounds() const { return fRect; } |
| |
| /** 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 with different signs. |
| |
| @param a SkRect bounds and radii to compare |
| @param b SkRect bounds and radii to compare |
| @return true if members are equal |
| */ |
| friend bool operator==(const SkRRect& a, const SkRRect& b) { |
| return a.fRect == b.fRect && SkScalarsEqual(&a.fRadii[0].fX, &b.fRadii[0].fX, 8); |
| } |
| |
| /** 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 with different signs. |
| |
| @param a SkRect bounds and radii to compare |
| @param b SkRect bounds and radii to compare |
| @return true if members are not equal |
| */ |
| friend bool operator!=(const SkRRect& a, const SkRRect& b) { |
| return a.fRect != b.fRect || !SkScalarsEqual(&a.fRadii[0].fX, &b.fRadii[0].fX, 8); |
| } |
| |
| /** Copies SkRRect to dst, then insets dst bounds by dx and dy, and adjusts dst |
| radii by dx and dy. dx and dy may be positive, negative, or zero. dst may be |
| SkRRect. |
| |
| If either corner radius is zero, the corner has no curvature and is unchanged. |
| Otherwise, if adjusted radius becomes negative, pins radius to zero. |
| If dx exceeds half dst bounds width, dst bounds left and right are set to |
| bounds x-axis center. If dy exceeds half dst bounds height, dst bounds top and |
| bottom are set to bounds y-axis center. |
| |
| If dx or dy cause the bounds to become infinite, dst bounds is zeroed. |
| |
| @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 |
| */ |
| void inset(SkScalar dx, SkScalar dy, SkRRect* dst) const; |
| |
| /** Insets bounds by dx and dy, and adjusts radii by dx and dy. dx and dy may be |
| positive, negative, or zero. |
| |
| If either corner radius is zero, the corner has no curvature and is unchanged. |
| Otherwise, if adjusted radius becomes negative, pins radius to zero. |
| If dx exceeds half bounds width, bounds left and right are set to |
| bounds x-axis center. If dy exceeds half bounds height, bounds top and |
| bottom are set to bounds y-axis center. |
| |
| If dx or dy cause the bounds to become infinite, bounds is zeroed. |
| |
| @param dx added to rect().fLeft, and subtracted from rect().fRight |
| @param dy added to rect().fTop, and subtracted from rect().fBottom |
| */ |
| void inset(SkScalar dx, SkScalar dy) { |
| this->inset(dx, dy, this); |
| } |
| |
| /** Outsets dst bounds by dx and dy, and adjusts radii by dx and dy. dx and dy may be |
| positive, negative, or zero. |
| |
| If either corner radius is zero, the corner has no curvature and is unchanged. |
| Otherwise, if adjusted radius becomes negative, pins radius to zero. |
| If dx exceeds half dst bounds width, dst bounds left and right are set to |
| bounds x-axis center. If dy exceeds half dst bounds height, dst bounds top and |
| bottom are set to bounds y-axis center. |
| |
| If dx or dy cause the bounds to become infinite, dst bounds is zeroed. |
| |
| @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 |
| */ |
| void outset(SkScalar dx, SkScalar dy, SkRRect* dst) const { |
| this->inset(-dx, -dy, dst); |
| } |
| |
| /** Outsets bounds by dx and dy, and adjusts radii by dx and dy. dx and dy may be |
| positive, negative, or zero. |
| |
| If either corner radius is zero, the corner has no curvature and is unchanged. |
| Otherwise, if adjusted radius becomes negative, pins radius to zero. |
| If dx exceeds half bounds width, bounds left and right are set to |
| bounds x-axis center. If dy exceeds half bounds height, bounds top and |
| bottom are set to bounds y-axis center. |
| |
| If dx or dy cause the bounds to become infinite, bounds is zeroed. |
| |
| @param dx subtracted from rect().fLeft, and added to rect().fRight |
| @param dy subtracted from rect().fTop, and added to rect().fBottom |
| */ |
| void outset(SkScalar dx, SkScalar dy) { |
| this->inset(-dx, -dy, this); |
| } |
| |
| /** Translates SkRRect by (dx, dy). |
| |
| @param dx offset added to rect().fLeft and rect().fRight |
| @param dy offset added to rect().fTop and rect().fBottom |
| */ |
| void offset(SkScalar dx, SkScalar dy) { |
| fRect.offset(dx, dy); |
| } |
| |
| /** Returns SkRRect translated by (dx, dy). |
| |
| @param dx offset added to rect().fLeft and rect().fRight |
| @param dy offset added to rect().fTop and rect().fBottom |
| @return SkRRect bounds offset by (dx, dy), with unchanged corner radii |
| */ |
| SkRRect SK_WARN_UNUSED_RESULT makeOffset(SkScalar dx, SkScalar dy) const { |
| return SkRRect(fRect.makeOffset(dx, dy), fRadii, fType); |
| } |
| |
| /** Returns true if rect is inside the bounds and corner radii, and if |
| SkRRect and rect are not empty. |
| |
| @param rect area tested for containment |
| @return true if SkRRect contains rect |
| */ |
| bool contains(const SkRect& rect) const; |
| |
| /** Returns true if bounds and radii values are finite and describe a SkRRect |
| SkRRect::Type that matches getType(). All SkRRect methods construct valid types, |
| even if the input values are not valid. Invalid SkRRect data can only |
| be generated by corrupting memory. |
| |
| @return true if bounds and radii match type() |
| */ |
| bool isValid() const; |
| |
| static constexpr size_t kSizeInMemory = 12 * sizeof(SkScalar); |
| |
| /** Writes SkRRect to buffer. Writes kSizeInMemory bytes, and returns |
| kSizeInMemory, the number of bytes written. |
| |
| @param buffer storage for SkRRect |
| @return bytes written, kSizeInMemory |
| */ |
| size_t writeToMemory(void* buffer) const; |
| |
| /** Reads SkRRect from buffer, reading kSizeInMemory bytes. |
| Returns kSizeInMemory, bytes read if length is at least kSizeInMemory. |
| Otherwise, returns zero. |
| |
| @param buffer memory to read from |
| @param length size of buffer |
| @return bytes read, or 0 if length is less than kSizeInMemory |
| */ |
| size_t readFromMemory(const void* buffer, size_t length); |
| |
| /** Transforms by SkRRect by matrix, storing result in dst. |
| Returns true if SkRRect transformed can be represented by another SkRRect. |
| Returns false if matrix contains transformations that are not axis aligned. |
| |
| Asserts in debug builds if SkRRect equals dst. |
| |
| @param matrix SkMatrix specifying the transform |
| @param dst SkRRect to store the result |
| @return true if transformation succeeded. |
| */ |
| bool transform(const SkMatrix& matrix, SkRRect* dst) const; |
| |
| /** Writes text representation of SkRRect 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 |
| */ |
| void dump(bool asHex) const; |
| |
| /** Writes text representation of SkRRect 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 |
| SkRRect from output. |
| */ |
| void dump() const { this->dump(false); } |
| |
| /** Writes text representation of SkRRect 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 SkRRect. |
| */ |
| void dumpHex() const { this->dump(true); } |
| |
| private: |
| static bool AreRectAndRadiiValid(const SkRect&, const SkVector[4]); |
| |
| SkRRect(const SkRect& rect, const SkVector radii[4], int32_t type) |
| : fRect(rect) |
| , fRadii{radii[0], radii[1], radii[2], radii[3]} |
| , fType(type) {} |
| |
| /** |
| * Initializes fRect. If the passed in rect is not finite or empty the rrect will be fully |
| * initialized and false is returned. Otherwise, just fRect is initialized and true is returned. |
| */ |
| bool initializeRect(const SkRect&); |
| |
| void computeType(); |
| bool checkCornerContainment(SkScalar x, SkScalar y) const; |
| void scaleRadii(const SkRect& rect); |
| |
| SkRect fRect = SkRect::MakeEmpty(); |
| // Radii order is UL, UR, LR, LL. Use Corner enum to index into fRadii[] |
| SkVector fRadii[4] = {{0, 0}, {0, 0}, {0,0}, {0,0}}; |
| // use an explicitly sized type so we're sure the class is dense (no uninitialized bytes) |
| int32_t fType = kEmpty_Type; |
| // TODO: add padding so we can use memcpy for flattening and not copy uninitialized data |
| |
| // to access fRadii directly |
| friend class SkPath; |
| friend class SkRRectPriv; |
| }; |
| |
| #endif |
