include/core/SkRegion.h - skia - Git at Google

 /*
  * Copyright (C) 2005 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #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 SkRegion {
 public:
     typedef int32_t RunType;
     enum {
         kRunTypeSentinel = 0x7FFFFFFF
     };

     SkRegion();
     SkRegion(const SkRegion&);
     explicit SkRegion(const SkIRect&);
     ~SkRegion();

     SkRegion& operator=(const SkRegion&);

     friend int operator==(const SkRegion& a, const SkRegion& b);
     friend int operator!=(const SkRegion& a, const SkRegion& b) {
         return !(a == b);
     }

     /** 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 true if the region is non-empty, and if so, sets the specified
         path to the boundary(s) of the region.
     */
     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 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
     };

     /** 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);

     /** Returns the sequence of rectangles, sorted in Y and X, that make up
         this region.
     */
     class 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() { return fDone; }
         void next();
         const SkIRect& rect() const { return fRect; }

     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 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.
     */
     uint32_t flatten(void* buffer) const;
     /** Initialized the region from the buffer, returning the number
         of bytes actually read.
     */
     uint32_t unflatten(const void* buffer);

     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 {
         kRectRegionRuns = 6 // need to store a region of a rect [T B L R S S]
     };

     friend class android::Region;    // needed for marshalling efficiently
     void allocateRuns(int count); // allocate space for count runs

     struct RunHead;

     SkIRect     fBounds;
     RunHead*    fRunHead;

     void            freeRuns();
     const RunType*  getRuns(RunType tmpStorage[], int* count) const;
     bool            setRuns(RunType runs[], int count);

     int count_runtype_values(int* itop, int* ibot) const;

     static void BuildRectRuns(const SkIRect& bounds,
                               RunType runs[kRectRegionRuns]);
     // returns true if runs are just a rect
     static bool ComputeRunBounds(const RunType runs[], int count,
                                  SkIRect* bounds);

     friend struct RunHead;
     friend class Iterator;
     friend class Spanerator;
     friend class SkRgnBuilder;
     friend class SkFlatRegion;
 };


 #endif
	/*
	* Copyright (C) 2005 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#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 SkRegion {
	public:
	typedef int32_t RunType;
	enum {
	kRunTypeSentinel = 0x7FFFFFFF
	};

	SkRegion();
	SkRegion(const SkRegion&);
	explicit SkRegion(const SkIRect&);
	~SkRegion();

	SkRegion& operator=(const SkRegion&);

	friend int operator==(const SkRegion& a, const SkRegion& b);
	friend int operator!=(const SkRegion& a, const SkRegion& b) {
	return !(a == b);
	}

	/** 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 true if the region is non-empty, and if so, sets the specified
	path to the boundary(s) of the region.
	*/
	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 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
	};

	/** 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);

	/** Returns the sequence of rectangles, sorted in Y and X, that make up
	this region.
	*/
	class 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() { return fDone; }
	void next();
	const SkIRect& rect() const { return fRect; }

	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 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.
	*/
	uint32_t flatten(void* buffer) const;
	/** Initialized the region from the buffer, returning the number
	of bytes actually read.
	*/
	uint32_t unflatten(const void* buffer);

	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 {
	kRectRegionRuns = 6 // need to store a region of a rect [T B L R S S]
	};

	friend class android::Region; // needed for marshalling efficiently
	void allocateRuns(int count); // allocate space for count runs

	struct RunHead;

	SkIRect fBounds;
	RunHead* fRunHead;

	void freeRuns();
	const RunType* getRuns(RunType tmpStorage[], int* count) const;
	bool setRuns(RunType runs[], int count);

	int count_runtype_values(int* itop, int* ibot) const;

	static void BuildRectRuns(const SkIRect& bounds,
	RunType runs[kRectRegionRuns]);
	// returns true if runs are just a rect
	static bool ComputeRunBounds(const RunType runs[], int count,
	SkIRect* bounds);

	friend struct RunHead;
	friend class Iterator;
	friend class Spanerator;
	friend class SkRgnBuilder;
	friend class SkFlatRegion;
	};


	#endif