| |
| /* |
| * Copyright 2005 The Android Open Source Project |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| |
| #ifndef SkRegion_DEFINED |
| #define SkRegion_DEFINED |
| |
| #include "SkRect.h" |
| |
| class SkPath; |
| class SkRgnBuilder; |
| |
| namespace android { |
| class Region; |
| } |
| |
| #define SkRegion_gEmptyRunHeadPtr ((SkRegion::RunHead*)-1) |
| #define SkRegion_gRectRunHeadPtr 0 |
| |
| /** \class SkRegion |
| |
| The SkRegion class encapsulates the geometric region used to specify |
| clipping areas for drawing. |
| */ |
| class SK_API SkRegion { |
| public: |
| typedef int32_t RunType; |
| enum { |
| kRunTypeSentinel = 0x7FFFFFFF |
| }; |
| |
| SkRegion(); |
| SkRegion(const SkRegion&); |
| explicit SkRegion(const SkIRect&); |
| ~SkRegion(); |
| |
| SkRegion& operator=(const SkRegion&); |
| |
| /** |
| * Return true if the two regions are equal. i.e. The enclose exactly |
| * the same area. |
| */ |
| bool operator==(const SkRegion& other) const; |
| |
| /** |
| * Return true if the two regions are not equal. |
| */ |
| bool operator!=(const SkRegion& other) const { |
| return !(*this == other); |
| } |
| |
| /** |
| * Replace this region with the specified region, and return true if the |
| * resulting region is non-empty. |
| */ |
| bool set(const SkRegion& src) { |
| SkASSERT(&src); |
| *this = src; |
| return !this->isEmpty(); |
| } |
| |
| /** |
| * Swap the contents of this and the specified region. This operation |
| * is gauarenteed to never fail. |
| */ |
| void swap(SkRegion&); |
| |
| /** Return true if this region is empty */ |
| bool isEmpty() const { return fRunHead == SkRegion_gEmptyRunHeadPtr; } |
| |
| /** Return true if this region is a single, non-empty rectangle */ |
| bool isRect() const { return fRunHead == SkRegion_gRectRunHeadPtr; } |
| |
| /** Return true if this region consists of more than 1 rectangular area */ |
| bool isComplex() const { return !this->isEmpty() && !this->isRect(); } |
| |
| /** |
| * Return the bounds of this region. If the region is empty, returns an |
| * empty rectangle. |
| */ |
| const SkIRect& getBounds() const { return fBounds; } |
| |
| /** |
| * Returns a value that grows approximately linearly with the number of |
| * intervals comprised in the region. Empty region will return 0, Rect |
| * will return 1, Complex will return a value > 1. |
| * |
| * Use this to compare two regions, where the larger count likely |
| * indicates a more complex region. |
| */ |
| int computeRegionComplexity() const; |
| |
| /** |
| * Returns true if the region is non-empty, and if so, appends the |
| * boundary(s) of the region to the specified path. |
| * If the region is empty, returns false, and path is left unmodified. |
| */ |
| bool getBoundaryPath(SkPath* path) const; |
| |
| /** |
| * Set the region to be empty, and return false, since the resulting |
| * region is empty |
| */ |
| bool setEmpty(); |
| |
| /** |
| * If rect is non-empty, set this region to that rectangle and return true, |
| * otherwise set this region to empty and return false. |
| */ |
| bool setRect(const SkIRect&); |
| |
| /** |
| * If left < right and top < bottom, set this region to that rectangle and |
| * return true, otherwise set this region to empty and return false. |
| */ |
| bool setRect(int32_t left, int32_t top, int32_t right, int32_t bottom); |
| |
| /** |
| * Set this region to the union of an array of rects. This is generally |
| * faster than calling region.op(rect, kUnion_Op) in a loop. If count is |
| * 0, then this region is set to the empty region. |
| * @return true if the resulting region is non-empty |
| */ |
| bool setRects(const SkIRect rects[], int count); |
| |
| /** |
| * Set this region to the specified region, and return true if it is |
| * non-empty. |
| */ |
| bool setRegion(const SkRegion&); |
| |
| /** |
| * Set this region to the area described by the path, clipped. |
| * Return true if the resulting region is non-empty. |
| * This produces a region that is identical to the pixels that would be |
| * drawn by the path (with no antialiasing) with the specified clip. |
| */ |
| bool setPath(const SkPath&, const SkRegion& clip); |
| |
| /** |
| * Returns true if the specified rectangle has a non-empty intersection |
| * with this region. |
| */ |
| bool intersects(const SkIRect&) const; |
| |
| /** |
| * Returns true if the specified region has a non-empty intersection |
| * with this region. |
| */ |
| bool intersects(const SkRegion&) const; |
| |
| /** |
| * Return true if the specified x,y coordinate is inside the region. |
| */ |
| bool contains(int32_t x, int32_t y) const; |
| |
| /** |
| * Return true if the specified rectangle is completely inside the region. |
| * This works for simple (rectangular) and complex regions, and always |
| * returns the correct result. Note: if either this region or the rectangle |
| * is empty, contains() returns false. |
| */ |
| bool contains(const SkIRect&) const; |
| |
| /** |
| * Return true if the specified region is completely inside the region. |
| * This works for simple (rectangular) and complex regions, and always |
| * returns the correct result. Note: if either region is empty, contains() |
| * returns false. |
| */ |
| bool contains(const SkRegion&) const; |
| |
| /** |
| * Return true if this region is a single rectangle (not complex) and the |
| * specified rectangle is contained by this region. Returning false is not |
| * a guarantee that the rectangle is not contained by this region, but |
| * return true is a guarantee that the rectangle is contained by this region. |
| */ |
| bool quickContains(const SkIRect& r) const { |
| return this->quickContains(r.fLeft, r.fTop, r.fRight, r.fBottom); |
| } |
| |
| /** |
| * Return true if this region is a single rectangle (not complex) and the |
| * specified rectangle is contained by this region. Returning false is not |
| * a guarantee that the rectangle is not contained by this region, but |
| * return true is a guarantee that the rectangle is contained by this |
| * region. |
| */ |
| bool quickContains(int32_t left, int32_t top, int32_t right, |
| int32_t bottom) const { |
| SkASSERT(this->isEmpty() == fBounds.isEmpty()); // valid region |
| |
| return left < right && top < bottom && |
| fRunHead == SkRegion_gRectRunHeadPtr && // this->isRect() |
| /* fBounds.contains(left, top, right, bottom); */ |
| fBounds.fLeft <= left && fBounds.fTop <= top && |
| fBounds.fRight >= right && fBounds.fBottom >= bottom; |
| } |
| |
| /** |
| * Return true if this region is empty, or if the specified rectangle does |
| * not intersect the region. Returning false is not a guarantee that they |
| * intersect, but returning true is a guarantee that they do not. |
| */ |
| bool quickReject(const SkIRect& rect) const { |
| return this->isEmpty() || rect.isEmpty() || |
| !SkIRect::Intersects(fBounds, rect); |
| } |
| |
| /** |
| * Return true if this region, or rgn, is empty, or if their bounds do not |
| * intersect. Returning false is not a guarantee that they intersect, but |
| * returning true is a guarantee that they do not. |
| */ |
| bool quickReject(const SkRegion& rgn) const { |
| return this->isEmpty() || rgn.isEmpty() || |
| !SkIRect::Intersects(fBounds, rgn.fBounds); |
| } |
| |
| /** Translate the region by the specified (dx, dy) amount. */ |
| void translate(int dx, int dy) { this->translate(dx, dy, this); } |
| |
| /** |
| * Translate the region by the specified (dx, dy) amount, writing the |
| * resulting region into dst. Note: it is legal to pass this region as the |
| * dst parameter, effectively translating the region in place. If dst is |
| * null, nothing happens. |
| */ |
| void translate(int dx, int dy, SkRegion* dst) const; |
| |
| /** |
| * The logical operations that can be performed when combining two regions. |
| */ |
| enum Op { |
| kDifference_Op, //!< subtract the op region from the first region |
| kIntersect_Op, //!< intersect the two regions |
| kUnion_Op, //!< union (inclusive-or) the two regions |
| kXOR_Op, //!< exclusive-or the two regions |
| /** subtract the first region from the op region */ |
| kReverseDifference_Op, |
| kReplace_Op, //!< replace the dst region with the op region |
| |
| kLastOp = kReplace_Op |
| }; |
| |
| static const int kOpCnt = kLastOp + 1; |
| |
| /** |
| * Set this region to the result of applying the Op to this region and the |
| * specified rectangle: this = (this op rect). |
| * Return true if the resulting region is non-empty. |
| */ |
| bool op(const SkIRect& rect, Op op) { return this->op(*this, rect, op); } |
| |
| /** |
| * Set this region to the result of applying the Op to this region and the |
| * specified rectangle: this = (this op rect). |
| * Return true if the resulting region is non-empty. |
| */ |
| bool op(int left, int top, int right, int bottom, Op op) { |
| SkIRect rect; |
| rect.set(left, top, right, bottom); |
| return this->op(*this, rect, op); |
| } |
| |
| /** |
| * Set this region to the result of applying the Op to this region and the |
| * specified region: this = (this op rgn). |
| * Return true if the resulting region is non-empty. |
| */ |
| bool op(const SkRegion& rgn, Op op) { return this->op(*this, rgn, op); } |
| |
| /** |
| * Set this region to the result of applying the Op to the specified |
| * rectangle and region: this = (rect op rgn). |
| * Return true if the resulting region is non-empty. |
| */ |
| bool op(const SkIRect& rect, const SkRegion& rgn, Op); |
| |
| /** |
| * Set this region to the result of applying the Op to the specified |
| * region and rectangle: this = (rgn op rect). |
| * Return true if the resulting region is non-empty. |
| */ |
| bool op(const SkRegion& rgn, const SkIRect& rect, Op); |
| |
| /** |
| * Set this region to the result of applying the Op to the specified |
| * regions: this = (rgna op rgnb). |
| * Return true if the resulting region is non-empty. |
| */ |
| bool op(const SkRegion& rgna, const SkRegion& rgnb, Op op); |
| |
| #ifdef SK_BUILD_FOR_ANDROID |
| /** Returns a new char* containing the list of rectangles in this region |
| */ |
| char* toString(); |
| #endif |
| |
| /** |
| * Returns the sequence of rectangles, sorted in Y and X, that make up |
| * this region. |
| */ |
| class SK_API Iterator { |
| public: |
| Iterator() : fRgn(NULL), fDone(true) {} |
| Iterator(const SkRegion&); |
| // if we have a region, reset to it and return true, else return false |
| bool rewind(); |
| // reset the iterator, using the new region |
| void reset(const SkRegion&); |
| bool done() const { return fDone; } |
| void next(); |
| const SkIRect& rect() const { return fRect; } |
| // may return null |
| const SkRegion* rgn() const { return fRgn; } |
| |
| private: |
| const SkRegion* fRgn; |
| const RunType* fRuns; |
| SkIRect fRect; |
| bool fDone; |
| }; |
| |
| /** |
| * Returns the sequence of rectangles, sorted in Y and X, that make up |
| * this region intersected with the specified clip rectangle. |
| */ |
| class SK_API Cliperator { |
| public: |
| Cliperator(const SkRegion&, const SkIRect& clip); |
| bool done() { return fDone; } |
| void next(); |
| const SkIRect& rect() const { return fRect; } |
| |
| private: |
| Iterator fIter; |
| SkIRect fClip; |
| SkIRect fRect; |
| bool fDone; |
| }; |
| |
| /** |
| * Returns the sequence of runs that make up this region for the specified |
| * Y scanline, clipped to the specified left and right X values. |
| */ |
| class Spanerator { |
| public: |
| Spanerator(const SkRegion&, int y, int left, int right); |
| bool next(int* left, int* right); |
| |
| private: |
| const SkRegion::RunType* fRuns; |
| int fLeft, fRight; |
| bool fDone; |
| }; |
| |
| /** |
| * Write the region to the buffer, and return the number of bytes written. |
| * If buffer is NULL, it still returns the number of bytes. |
| */ |
| size_t writeToMemory(void* buffer) const; |
| /** |
| * Initializes the region from the buffer |
| * |
| * @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 |
| */ |
| size_t readFromMemory(const void* buffer, size_t length); |
| |
| /** |
| * Returns a reference to a global empty region. Just a convenience for |
| * callers that need a const empty region. |
| */ |
| static const SkRegion& GetEmptyRegion(); |
| |
| SkDEBUGCODE(void dump() const;) |
| SkDEBUGCODE(void validate() const;) |
| SkDEBUGCODE(static void UnitTest();) |
| |
| // expose this to allow for regression test on complex regions |
| SkDEBUGCODE(bool debugSetRuns(const RunType runs[], int count);) |
| |
| private: |
| enum { |
| kOpCount = kReplace_Op + 1 |
| }; |
| |
| enum { |
| // T |
| // [B N L R S] |
| // S |
| kRectRegionRuns = 7 |
| }; |
| |
| friend class android::Region; // needed for marshalling efficiently |
| |
| struct RunHead; |
| |
| // allocate space for count runs |
| void allocateRuns(int count); |
| void allocateRuns(int count, int ySpanCount, int intervalCount); |
| void allocateRuns(const RunHead& src); |
| |
| SkIRect fBounds; |
| RunHead* fRunHead; |
| |
| void freeRuns(); |
| |
| /** |
| * Return the runs from this region, consing up fake runs if the region |
| * is empty or a rect. In those 2 cases, we use tmpStorage to hold the |
| * run data. |
| */ |
| const RunType* getRuns(RunType tmpStorage[], int* intervals) const; |
| |
| // This is called with runs[] that do not yet have their interval-count |
| // field set on each scanline. That is computed as part of this call |
| // (inside ComputeRunBounds). |
| bool setRuns(RunType runs[], int count); |
| |
| int count_runtype_values(int* itop, int* ibot) const; |
| |
| static void BuildRectRuns(const SkIRect& bounds, |
| RunType runs[kRectRegionRuns]); |
| |
| // If the runs define a simple rect, return true and set bounds to that |
| // rect. If not, return false and ignore bounds. |
| static bool RunsAreARect(const SkRegion::RunType runs[], int count, |
| SkIRect* bounds); |
| |
| /** |
| * If the last arg is null, just return if the result is non-empty, |
| * else store the result in the last arg. |
| */ |
| static bool Oper(const SkRegion&, const SkRegion&, SkRegion::Op, SkRegion*); |
| |
| friend struct RunHead; |
| friend class Iterator; |
| friend class Spanerator; |
| friend class SkRgnBuilder; |
| friend class SkFlatRegion; |
| }; |
| |
| #endif |