#Topic Region
#Alias Region_Reference ##
#Alias Regions ##

Region is a compressed one bit mask. Region describes an aliased clipping area
on integer boundaries. Region can also describe an array of integer rectangles.

Canvas uses Region to reduce the current clip. Region may be drawn to Canvas;
Paint determines if Region is filled or stroked, its Color, and so on.

Region may be constructed from IRect array or Path. Diagonal lines and curves
in Path become integer rectangle edges. Regions operators compute union,
intersection, difference, and so on. Canvas allows only intersection and
difference; successive clips can only reduce available Canvas area.

#PhraseDef list_of_op_types
kDifference_Op, kIntersect_Op, kUnion_Op, kXOR_Op, kReverseDifference_Op,
kReplace_Op
##

#Class SkRegion

#Code
#Populate
##

SkRegion describes the set of pixels used to clip Canvas. SkRegion is compact,
efficiently storing a single integer rectangle, or a run length encoded array
of rectangles. SkRegion may reduce the current Canvas_Clip, or may be drawn as
one or more integer rectangles. SkRegion iterator returns the scan lines or
rectangles contained by it, optionally intersecting a bounding rectangle.

# ------------------------------------------------------------------------------

#Class Iterator
#Line # iterator returning IRect  ##

#Code
    class Iterator {
    public:
        Iterator();
        Iterator(const SkRegion& region);
        bool rewind();
        void reset(const SkRegion& region);
        bool done() const;
        void next();
        const SkIRect& rect();
        const SkRegion* rgn();
    };
##

Returns sequence of rectangles, sorted along y-axis, then x-axis, that make
up Region.

# ------------------------------------------------------------------------------

#Method Iterator()
#Line # constructs Region iterator ##
#Populate

#Example
    SkRegion::Iterator iter;
    SkRegion region;
    region.setRect({1, 2, 3, 4});
    iter.reset(region);
    auto r = iter.rect();
    SkDebugf("rect={%d,%d,%d,%d}\n", r.fLeft, r.fTop, r.fRight, r.fBottom);
#StdOut
rect={1,2,3,4}
##
##

#SeeAlso reset SkRegion

#Method ##

# ------------------------------------------------------------------------------

#Method Iterator(const SkRegion& region)
#Line # constructs Region iterator ##
#Populate

#Example
    SkRegion region;
    region.setRect({1, 2, 3, 4});
    SkRegion::Iterator iter(region);
    auto r = iter.rect();
    SkDebugf("rect={%d,%d,%d,%d}\n", r.fLeft, r.fTop, r.fRight, r.fBottom);
#StdOut
rect={1,2,3,4}
##
##

#SeeAlso reset SkRegion Cliperator Spanerator

#Method ##

# ------------------------------------------------------------------------------

#Method bool rewind()
#Line # points Iterator to start ##
#Populate

#Example
#Bug 8186
    auto debugster = [](const char* label, SkRegion::Iterator& iter, bool addRewind) -> void {
        if (addRewind) {
            bool success = iter.rewind();
            SkDebugf("%14s rewind success=%s\n", label, success ? "true" : "false");
        }
        auto r = iter.rect();
        SkDebugf("%14s rect={%d,%d,%d,%d}\n", label, r.fLeft, r.fTop, r.fRight, r.fBottom);
    };
    SkRegion::Iterator iter;
    debugster("empty iter", iter, true);
    SkRegion region;
    iter.reset(region);
    debugster("empty region", iter, true);
    region.setRect({1, 2, 3, 4});
    iter.reset(region);
    debugster("after set rect", iter, false);
    debugster("after rewind", iter, true);
#StdOut
#Volatile
    empty iter rewind success=false
    empty iter rect={0,0,0,0}
  empty region rewind success=true
  empty region rect={0,0,0,0}
after set rect rect={1,2,3,4}
  after rewind rewind success=true
  after rewind rect={1,2,3,4}
##
##

#SeeAlso reset

#Method ##

# ------------------------------------------------------------------------------

#Method void reset(const SkRegion& region)
#Line # sets Region to iterate ##
#Populate

#Example
    auto debugster = [](const char* label, SkRegion::Iterator& iter) -> void {
        SkDebugf("%14s: done=%s\n", label, iter.done() ? "true" : "false");
    };
    SkRegion region;
    SkRegion::Iterator iter(region);
    debugster("empty region", iter);
    region.setRect({1, 2, 3, 4});
    debugster("after set rect", iter);
    iter.reset(region);
    debugster("after reset", iter);
#StdOut
  empty region: done=true
after set rect: done=true
   after reset: done=false
##
##

#SeeAlso rewind

#Method ##

# ------------------------------------------------------------------------------

#Method bool done() const
#Line # returns if data parsing is complete ##
#Populate

#Example
    SkRegion region;
    SkRegion::Iterator iter(region);
    SkDebugf("done=%s\n", iter.done() ? "true" : "false"); 
    region.setRect({1, 2, 3, 4});
    iter.rewind();
    SkDebugf("done=%s\n", iter.done() ? "true" : "false"); 
#StdOut
done=true
done=false
##
##

#SeeAlso next rect

#Method ##

# ------------------------------------------------------------------------------

#Method void next()
#Line # advances to next IRect ##
#Populate

#Example
    SkRegion region;
    SkIRect rects[] = {{1, 2, 3, 4}, {5, 6, 7, 8}};
    region.setRects(rects, SK_ARRAY_COUNT(rects));
    SkRegion::Iterator iter(region);
    do {
        auto r2 = iter.rect();
        SkDebugf("rect={%d,%d,%d,%d}\n", r2.fLeft, r2.fTop, r2.fRight, r2.fBottom);
        iter.next();
    } while (!iter.done());
#StdOut
rect={1,2,3,4}
rect={5,6,7,8}
##
##

#SeeAlso done rect

#Method ##

# ------------------------------------------------------------------------------

#Method const SkIRect& rect() const
#Line # returns part of Region as IRect ##
#Populate

#Example
#Bug 8186
    SkRegion region;
    SkRegion::Iterator iter(region);
    auto r1 = iter.rect();
    SkDebugf("rect={%d,%d,%d,%d}\n", r1.fLeft, r1.fTop, r1.fRight, r1.fBottom); 
    region.setRect({1, 2, 3, 4});
    iter.rewind();
    auto r2 = iter.rect();
    SkDebugf("rect={%d,%d,%d,%d}\n", r2.fLeft, r2.fTop, r2.fRight, r2.fBottom); 
#StdOut
#Volatile
rect={0,0,0,0}
rect={1,2,3,4}
##
##

#SeeAlso next done

#Method ##

# ------------------------------------------------------------------------------

#Method const SkRegion* rgn() const
#Line # returns original Region ##
#Populate

#Example
    SkRegion region;
    SkIRect rects[] = {{1, 2, 3, 4}, {3, 4, 5, 6}};
    region.setRects(rects, SK_ARRAY_COUNT(rects));
    SkRegion::Iterator iter(region);
    auto r = iter.rect();
    SkDebugf("rect={%d,%d,%d,%d}\n", r.fLeft, r.fTop, r.fRight, r.fBottom);
    auto b = iter.rgn()->getBounds();
    SkDebugf("bounds={%d,%d,%d,%d}\n", b.fLeft, b.fTop, b.fRight, b.fBottom);
##

#SeeAlso Iterator reset

#Method ##

#Class Iterator ##

# ------------------------------------------------------------------------------

#Class Cliperator
#Line # iterator returning IRect within clip ##

#Code
    class Cliperator {
    public:
        Cliperator(const SkRegion& region, const SkIRect& clip);
        bool done();
        void next();
        const SkIRect& rect() const;
    };
##

Returns the sequence of rectangles, sorted along y-axis, then x-axis, that make
up Region intersected with the specified clip rectangle.

# ------------------------------------------------------------------------------

#Method Cliperator(const SkRegion& region, const SkIRect& clip)
#Line # constructs Region iterator with clip ##
#Populate

#Example
    SkRegion region;
    region.setRect({1, 2, 3, 4});
    SkRegion::Cliperator clipper(region, {0, 0, 2, 3});
    auto r = clipper.rect();
    SkDebugf("rect={%d,%d,%d,%d}\n", r.fLeft, r.fTop, r.fRight, r.fBottom);
#StdOut
rect={1,2,2,3}
##
##

#SeeAlso SkRegion Iterator Spanerator

#Method ##

# ------------------------------------------------------------------------------

#Method bool done()
#Line # returns if data parsing is complete ##
#Populate

#Example
    auto debugster = [](const char* label, SkRegion& region) -> void {
        SkRegion::Cliperator clipper(region, {0, 0, 5, 5});
        SkDebugf("%14s done=%s\n", label, clipper.done() ? "true" : "false"); 
    };
    SkRegion region;
    debugster("empty region", region);
    region.setRect({1, 2, 3, 4});
    debugster("after add rect", region);
#StdOut
  empty region done=true
after add rect done=false
##
##

#SeeAlso next rect

#Method ##

# ------------------------------------------------------------------------------

#Method void  next()
#Line # advances to next IRect within clip ##
#Populate

#Example
    SkRegion region;
    SkIRect rects[] = {{1, 2, 3, 4}, {5, 6, 7, 8}};
    region.setRects(rects, SK_ARRAY_COUNT(rects));
    SkRegion::Cliperator clipper(region, {0, 3, 8, 7});
    do {
        auto r2 = clipper.rect();
        SkDebugf("rect={%d,%d,%d,%d}\n", r2.fLeft, r2.fTop, r2.fRight, r2.fBottom);
        clipper.next();
    } while (!clipper.done());
#StdOut
rect={1,3,3,4}
rect={5,6,7,7}
##
##

#SeeAlso done

#Method ##

# ------------------------------------------------------------------------------

#Method const SkIRect& rect() const
#Line # returns part of Region as IRect intersected with clip ##
#Populate

#Example
#Bug 8186
    auto debugster = [](const char* label, SkRegion& region) -> void {
        SkRegion::Cliperator clipper(region, {0, 0, 5, 3});
        auto r = clipper.rect();
        SkDebugf("%14s rect={%d,%d,%d,%d}\n", label, r.fLeft, r.fTop, r.fRight, r.fBottom); 
    };
    SkRegion region;
    debugster("empty region", region);
    region.setRect({1, 2, 3, 4});
    debugster("after set rect", region);
#StdOut
#Volatile
  empty region rect={1094713344,1065353216,0,-1}
after set rect rect={1,2,3,3}
##
##

#SeeAlso next done

#Method ##

#Class Cliperator ##

# ------------------------------------------------------------------------------

#Class Spanerator
#Line # horizontal line segment iterator ##

#Code
    class Spanerator {
    public:
        Spanerator(const SkRegion& region, int y, int left, int right);
        bool next(int* left, int* right);
    };
##

Returns the line segment ends within Region that intersect a horizontal line.

# ------------------------------------------------------------------------------

#Method Spanerator(const SkRegion& region, int y, int left, int right)
#Line # constructs Region iterator on scan line ##
#Populate

#Example
    SkRegion region;
    region.setRect({1, 2, 3, 4});
    SkRegion::Spanerator spanner(region, 3, 2, 4);
    int left, right;
    bool result = spanner.next(&left, &right);
    SkDebugf("result=%s left=%d right=%d\n", result ? "true" : "false", left, right);
##

#SeeAlso SkRegion Iterator Cliperator

#Method ##

# ------------------------------------------------------------------------------

#Method bool next(int* left, int* right)
#Line # advances to next span on horizontal line ##
#Populate

#Example
    auto debugster = [](const char* label, SkRegion& region) -> void {
        SkRegion::Spanerator spanner(region, 3, 2, 4);
        int left, right;
        bool result = spanner.next(&left, &right);
        SkDebugf("%14s: result=%s", label, result ? "true" : "false");
        if (result) SkDebugf(" left=%d right=%d", left, right);
        SkDebugf("\n");
    };
    SkRegion region;
    debugster("empty region", region);
    region.setRect({1, 2, 3, 4});
    debugster("after set rect", region);
#StdOut
  empty region: result=false
after set rect: result=true left=2 right=3
##
##

#SeeAlso done

#Method ##

#Class Spanerator ##

# ------------------------------------------------------------------------------

#Method SkRegion()
#In Constructors
#Line # constructs with default values ##
#Populate

#Example
SkRegion region;
SkIRect r = region.getBounds();
SkDebugf("region bounds: {%d, %d, %d, %d}\n", r.fLeft, r.fTop, r.fRight, r.fBottom);
#StdOut
region bounds: {0, 0, 0, 0}
##
##

#SeeAlso setEmpty

#Method ##

# ------------------------------------------------------------------------------

#Method SkRegion(const SkRegion& region)
#In Constructors
#Line # makes a shallow copy ##
#Populate

#Example
    auto debugster = [](const char* label, SkRegion& region) -> void {
        auto r = region.getBounds();
        SkDebugf("%14s: {%d,%d,%d,%d}\n", label, r.fLeft, r.fTop, r.fRight, r.fBottom);
    };
    SkRegion region({1, 2, 3, 4});
    SkRegion region2(region);
    debugster("region bounds", region);
    debugster("region2 bounds", region2);
    region.setEmpty();
    SkDebugf("    after region set empty:\n");
    debugster("region bounds", region);
    debugster("region2 bounds", region2);
#StdOut
 region bounds: {1,2,3,4}
region2 bounds: {1,2,3,4}
    after region set empty:
 region bounds: {0,0,0,0}
region2 bounds: {1,2,3,4}
##
##

#SeeAlso setRegion operator=(const SkRegion& region)

#Method ##

# ------------------------------------------------------------------------------

#Method explicit SkRegion(const SkIRect& rect)
#In Constructors
#Line # constructs Region matching IRect ##
#Populate

#Example
    SkRegion region({1, 2, 3, 4});
    SkRegion region2;
    region2.setRect({1, 2, 3, 4});
    SkDebugf("region %c= region2\n", region == region2 ? '=' : '!');
##

#SeeAlso setRect setRegion

#Method ##

# ------------------------------------------------------------------------------

#Method ~SkRegion()
#In Constructors
#Line # decreases Reference_Count of owned objects ##
#Populate

#Example
#Description
delete calls Region destructor, but copy of original in region2 is unaffected.
##
    SkRegion* region = new SkRegion({1, 2, 3, 4});
    SkRegion region2(*region);
    delete region;
    auto r = region2.getBounds();
    SkDebugf("region2 bounds: {%d,%d,%d,%d}\n", r.fLeft, r.fTop, r.fRight, r.fBottom);
#StdOut
region2 bounds: {1,2,3,4}
##
##

#SeeAlso SkRegion() SkRegion(const SkRegion& region) SkRegion(const SkIRect& rect) operator=(const SkRegion& region)

#Method ##

# ------------------------------------------------------------------------------

#Method SkRegion& operator=(const SkRegion& region)
#In Operators
#Line # makes a shallow copy ##
#Populate

#Example
    auto debugster = [](const char* label, SkRegion& region) -> void {
        auto r = region.getBounds();
        SkDebugf("%14s: {%d,%d,%d,%d}\n", label, r.fLeft, r.fTop, r.fRight, r.fBottom);
    };
    SkRegion region1({1, 2, 3, 4});
    SkRegion region2 = region1;
    debugster("region1 bounds", region1);
    debugster("region2 bounds", region2);
#StdOut
region1 bounds: {1,2,3,4}
region2 bounds: {1,2,3,4}
##
##

#SeeAlso set swap SkRegion(const SkRegion& region)

#Method ##

# ------------------------------------------------------------------------------

#Method bool operator==(const SkRegion& other) const
#In Operators
#Line # compares Regions for equality ##
#Populate

#Example
    auto debugster = [](const char* prefix, const SkRegion& a, const SkRegion& b) -> void {
                SkDebugf("%s one %c= two\n", prefix, a == b ? '=' : '!');
    };
    SkRegion one;
    SkRegion two;
    debugster("empty", one, two);
    one.setRect({1, 2, 3, 4});
    debugster("set rect", one, two);
    one.setEmpty();
    debugster("set empty", one, two);
#StdOut
empty one == two
set rect one != two
set empty one == two
##
##

#SeeAlso operator!=(const SkRegion& other) const operator=(const SkRegion& region)

#Method ##

# ------------------------------------------------------------------------------

#Method bool operator!=(const SkRegion& other) const
#In Operators
#Line # compares Regions for inequality ##
#Populate

#Example
    auto debugster = [](const char* prefix, const SkRegion& a, const SkRegion& b) -> void {
                SkDebugf("%s one %c= two\n", prefix, a != b ? '!' : '=');
    };
    SkRegion one;
    SkRegion two;
    debugster("empty", one, two);
    one.setRect({1, 2, 3, 4});
    two.setRect({1, 2, 3, 3});
    debugster("set rect", one, two);
    two.op({1, 3, 3, 4}, SkRegion::kUnion_Op);
    debugster("union rect", one, two);
#StdOut
empty one == two
set rect one != two
union rect one == two
##
##

#SeeAlso operator==(const SkRegion& other) const operator=(const SkRegion& region)

#Method ##

# ------------------------------------------------------------------------------

#Method bool set(const SkRegion& src)
#In Constructors
#Line # makes a shallow copy ##
#Populate

#Example
    auto debugster = [](const char* label, SkRegion& region) -> void {
        auto r = region.getBounds();
        SkDebugf("%14s: {%d,%d,%d,%d}\n", label, r.fLeft, r.fTop, r.fRight, r.fBottom);
    };
    SkRegion region1({1, 2, 3, 4});
    SkRegion region2;
    region2.set(region1);
    debugster("region1 bounds", region1);
    debugster("region2 bounds", region2);
#StdOut
region1 bounds: {1,2,3,4}
region2 bounds: {1,2,3,4}
##
##

#SeeAlso operator=(const SkRegion& region) swap SkRegion(const SkRegion& region)

#Method ##

# ------------------------------------------------------------------------------

#Method void swap(SkRegion& other)
#In Operators
#Line # exchanges Region pair ##
#Populate

#Example
    auto debugster = [](const char* label, SkRegion& region) -> void {
        auto r = region.getBounds();
        SkDebugf("%14s: {%d,%d,%d,%d}\n", label, r.fLeft, r.fTop, r.fRight, r.fBottom);
    };
    SkRegion region1({1, 2, 3, 4});
    SkRegion region2;
    region1.swap(region2);
    debugster("region1 bounds", region1);
    debugster("region2 bounds", region2);
#StdOut
region1 bounds: {0,0,0,0}
region2 bounds: {1,2,3,4}
##
##

#SeeAlso operator=(const SkRegion& region) set SkRegion(const SkRegion& region)

#Method ##

# ------------------------------------------------------------------------------

#Method bool isEmpty() const
#In Property
#Line # returns if bounds has no width or height ##
#Populate

#Example
    auto debugster = [](const char* label, SkRegion& region) -> void {
        SkDebugf("%14s: region is %s" "empty\n", label, region.isEmpty() ? "" : "not ");
    };
    SkRegion region;
    debugster("initial", region);
    region.setRect({1, 2, 3, 4});
    debugster("set rect", region);
    region.setEmpty();
    debugster("set empty", region);
#StdOut
       initial: region is empty
      set rect: region is not empty
     set empty: region is empty
##
##

#SeeAlso isRect isComplex operator==(const SkRegion& other) const

#Method ##

# ------------------------------------------------------------------------------

#Method bool isRect() const
#In Property
#Line # returns if Region contains one IRect ##
#Populate

#Example
    auto debugster = [](const char* label, const SkRegion& region) -> void {
                SkDebugf("%s: region is %s" "rect\n", label, region.isRect() ? "" : "not ");
    };
    SkRegion region;
    debugster("initial", region);
    region.setRect({1, 2, 3, 4});
    debugster("set rect", region);
    region.setEmpty();
    debugster("set empty", region);
#StdOut
initial: region is not rect
set rect: region is rect
set empty: region is not rect
##
##

#SeeAlso isEmpty isComplex

#Method ##

# ------------------------------------------------------------------------------

#Method bool isComplex() const
#In Property
#Line # returns true if Region contains more than one IRect ##
#Populate

#Example
    auto debugster = [](const char* label, const SkRegion& region) -> void {
                SkDebugf("%s: region is %s" "complex\n", label, region.isComplex() ? "" : "not ");
    };
    SkRegion region;
    debugster("initial", region);
    region.setRect({1, 2, 3, 4});
    debugster("set rect", region);
    region.op({2, 3, 4, 5}, SkRegion::kUnion_Op);
    debugster("op rect", region);
#StdOut
initial: region is not complex
set rect: region is not complex
op rect: region is complex
##
##

#SeeAlso isEmpty isRect

#Method ##

# ------------------------------------------------------------------------------

#Method const SkIRect& getBounds() const
#In Property
#Line # returns maximum and minimum of IRect array ##
#Populate

#Example
    SkRegion region({1, 2, 3, 4});
    region.op({2, 3, 4, 5}, SkRegion::kUnion_Op);
    auto r = region.getBounds();
    SkDebugf("bounds: {%d,%d,%d,%d}\n", r.fLeft, r.fTop, r.fRight, r.fBottom);
#StdOut
bounds: {1,2,4,5}
##
##

#SeeAlso isEmpty isRect

#Method ##

# ------------------------------------------------------------------------------

#Method int computeRegionComplexity() const
#In Property
#Line # returns relative complexity ##
#Populate

#Example
    auto debugster = [](const char* label, const SkRegion& region) -> void {
                SkDebugf("%s: region complexity %d\n", label, region.computeRegionComplexity());
    };
    SkRegion region;
    debugster("initial", region);
    region.setRect({1, 2, 3, 4});
    debugster("set rect", region);
    region.op({2, 3, 4, 5}, SkRegion::kUnion_Op);
    debugster("op rect", region);
#StdOut
initial: region complexity 0
set rect: region complexity 1
op rect: region complexity 3
##
##

#SeeAlso isRect isComplex

#Method ##

# ------------------------------------------------------------------------------

#Method bool getBoundaryPath(SkPath* path) const
#In Property
#Line # appends Region outline to Path ##
#Populate

#Example
#Height 100
    SkRegion region;
    region.setRect({10, 20, 90, 60});
    region.op({30, 40, 60, 80}, SkRegion::kXOR_Op);
    canvas->drawRegion(region, SkPaint());
    SkPath path;
    region.getBoundaryPath(&path);
    path.offset(100, 0);
    canvas->drawPath(path, SkPaint());
##

#SeeAlso isEmpty isComplex

#Method ##

# ------------------------------------------------------------------------------

#Method bool setEmpty()
#In Constructors
#Line # constructs with default values ##
#Populate

#Example
    auto debugster = [](const char* label, SkRegion& region) -> void {
        auto r = region.getBounds();
        SkDebugf("%14s: {%d,%d,%d,%d}\n", label, r.fLeft, r.fTop, r.fRight, r.fBottom);
    };
    SkRegion region({1, 2, 3, 4});
    debugster("region bounds", region);
    region.setEmpty();
    SkDebugf("    after region set empty:\n");
    debugster("region bounds", region);
#StdOut
 region bounds: {1,2,3,4}
    after region set empty:
 region bounds: {0,0,0,0}
##
##

#SeeAlso SkRegion()

#Method ##

# ------------------------------------------------------------------------------

#Method bool setRect(const SkIRect& rect)
#In Constructors
#Line # constructs Region matching IRect ##
#Populate

#Example
    SkRegion region({1, 2, 3, 4});
    SkDebugf("region is %s" "empty\n", region.isEmpty() ? "" : "not ");
    bool setEmpty = region.setRect({1, 2, 1, 4});
    SkDebugf("region is %s" "empty\n", region.isEmpty() ? "" : "not ");
    SkDebugf("setEmpty: %s\n", setEmpty ? "true" : "false");
#StdOut
region is not empty
region is empty
setEmpty: false
##
##

#SeeAlso SkRegion(const SkIRect& rect)

#Method ##

# ------------------------------------------------------------------------------

#Method bool setRect(int32_t left, int32_t top, int32_t right, int32_t bottom)
#In Constructors
#Line # constructs Region matching bounds ##
#Populate

#Example
    auto debugster = [](const char* label, bool success, SkRegion& region) -> void {
        auto r = region.getBounds();
        SkDebugf("%14s: success:%s {%d,%d,%d,%d}\n", label, success ? "true" : "false",
                 r.fLeft, r.fTop, r.fRight, r.fBottom);
    };
    SkRegion region;
    bool success = region.setRect(1, 2, 3, 4);
    debugster("set to: 1,2,3,4", success, region);
    success = region.setRect(3, 2, 1, 4);
    debugster("set to: 3,2,1,4", success, region);
#StdOut
set to: 1,2,3,4: success:true {1,2,3,4}
set to: 3,2,1,4: success:false {0,0,0,0}
##
##

#SeeAlso SkRegion(const SkIRect& rect)

#Method ##

# ------------------------------------------------------------------------------

#Method bool setRects(const SkIRect rects[], int count)
#In Constructors
#Line # sets IRect array ##
#Populate

#Example
#Height 70
    SkIRect rects[] = { {10, 10, 40, 40}, {20, 20, 50, 50}, {30, 30, 60, 60} };
    SkRegion region;
    region.setRects(rects, SK_ARRAY_COUNT(rects));
    canvas->drawRegion(region, SkPaint());
    region.setEmpty();
    for (auto add : rects) {
        region.op(add, SkRegion::kUnion_Op);
    }
    region.translate(100, 0);
    canvas->drawRegion(region, SkPaint());
##

#SeeAlso setRect op

#Method ##

# ------------------------------------------------------------------------------

#Method bool setRegion(const SkRegion& region)
#In Constructors
#Line # copies Region ##
#Populate

#Example
    auto debugster = [](const char* label, SkRegion& region) -> void {
        auto r = region.getBounds();
        SkDebugf("%14s: {%d,%d,%d,%d}\n", label, r.fLeft, r.fTop, r.fRight, r.fBottom);
    };
    SkRegion region({1, 2, 3, 4});
    SkRegion region2;
    region2.setRegion(region);
    debugster("region bounds", region);
    debugster("region2 bounds", region2);
    region2.setEmpty();
    SkDebugf("    after region set empty:\n");
    debugster("region bounds", region);
    debugster("region2 bounds", region2);
#StdOut
 region bounds: {1,2,3,4}
region2 bounds: {1,2,3,4}
    after region set empty:
 region bounds: {1,2,3,4}
region2 bounds: {0,0,0,0}
##
##

#SeeAlso SkRegion(const SkRegion& region)

#Method ##

# ------------------------------------------------------------------------------

#Method bool setPath(const SkPath& path, const SkRegion& clip)
#In Constructors
#Line # constructs Region from clipped Path ##
#Populate

#Example
#Height 120
    SkPaint paint;
    paint.setTextSize(128);
    SkPath textPath;
    paint.getTextPath("Q", 1, 0, 110, &textPath);
    SkIRect clipRect = {20, 20, 100, 120};
    SkRegion clipRegion(clipRect);
    SkRegion region;
    region.setPath(textPath, clipRegion);
    canvas->drawRegion(region, SkPaint());
    clipRect.offset(100, 0);
    textPath.offset(100, 0);
    canvas->clipRect(SkRect::Make(clipRect), false);
    canvas->drawPath(textPath, SkPaint());
##

#SeeAlso setRects op

#Method ##

# ------------------------------------------------------------------------------

#Method bool intersects(const SkIRect& rect) const
#In Intersection
#Line # returns true if areas overlap ##
#Populate

#Example
#Duration 4
#Height 128
    SkPaint paint;
    paint.setTextSize(128);
    SkPath textPath;
    paint.getTextPath("W", 1, 20, 110, &textPath);
    SkRegion region;
    region.setPath(textPath, SkRegion({0, 0, 256, 256}));
    canvas->drawRegion(region, SkPaint());
    SkIRect iRect = SkIRect::MakeXYWH(frame * 160, 55, 10, 10);
    paint.setColor(region.intersects(iRect) ? SK_ColorBLUE : SK_ColorRED);
    canvas->drawRect(SkRect::Make(iRect), paint);
##

#SeeAlso contains SkRect::intersects

#Method ##

# ------------------------------------------------------------------------------

#Method bool intersects(const SkRegion& other) const
#Populate

#Example
#Duration 4
#Height 128
    SkPaint paint;
    paint.setTextSize(128);
    SkPath hPath, dotPath;
    paint.getTextPath("H", 1, 40, 110, &hPath);
    paint.getTextPath(",", 1, frame * 180, 95, &dotPath);
    SkRegion hRegion, dotRegion;
    hRegion.setPath(hPath, SkRegion({0, 0, 256, 256}));
    dotRegion.setPath(dotPath, SkRegion({0, 0, 256, 256}));
    canvas->drawRegion(hRegion, paint);
    paint.setColor(hRegion.intersects(dotRegion) ? SK_ColorBLUE : SK_ColorRED);
    canvas->drawRegion(dotRegion, paint);
##

#SeeAlso contains SkRect::intersects

#Method ##

# ------------------------------------------------------------------------------

#Method bool contains(int32_t x, int32_t y) const
#In Intersection
#Line # returns true if points are equal or inside ##
#Populate

#Example
#Height 128
    SkPaint paint;
    paint.setTextSize(128);
    SkPath xPath;
    paint.getTextPath("X", 1, 20, 110, &xPath);
    SkRegion xRegion;
    xRegion.setPath(xPath, SkRegion({0, 0, 256, 256}));
    canvas->drawRegion(xRegion, paint);
    for (int y = 0; y < 128; y += 8) {
        for (int x = 0; x < 128; x += 8) {
           paint.setColor(xRegion.contains(x, y) ? SK_ColorWHITE : SK_ColorRED);
           canvas->drawPoint(x, y, paint);
        }
    }
##

#SeeAlso intersects SkRect::contains

#Method ##

# ------------------------------------------------------------------------------

#Method bool contains(const SkIRect& other) const
#Populate

#Example
#Height 128
#Duration 4
    SkPaint paint;
    paint.setTextSize(128);
    SkPath xPath;
    paint.getTextPath("X", 1, 20, 110, &xPath);
    SkRegion xRegion;
    SkIRect drawBounds = {0, 0, 128, 128};
    xRegion.setPath(xPath, SkRegion(drawBounds));
    xRegion.op(drawBounds, SkRegion::kReverseDifference_Op);
    canvas->drawRegion(xRegion, paint);
    SkIRect test = SkIRect::MakeXYWH(frame* 128, 64, 5, 5);
    if (xRegion.contains(test)) {
        paint.setColor(SK_ColorYELLOW);
        canvas->drawRect(SkRect::Make(test), paint);
    }
##

#SeeAlso intersects SkRect::contains

#Method ##

# ------------------------------------------------------------------------------

#Method bool contains(const SkRegion& other) const
#Populate

#Example
#Height 128
#Duration 4
    SkPaint paint;
    paint.setTextSize(128);
    SkPath xPath, testPath;
    paint.getTextPath("X", 1, 20, 110, &xPath);
    paint.getTextPath("`", 1, frame * 150 - 40, 150, &testPath);
    SkRegion xRegion, testRegion;
    SkIRect drawBounds = {0, 0, 128, 128};
    xRegion.setPath(xPath, SkRegion(drawBounds));
    testRegion.setPath(testPath, SkRegion(drawBounds));
    xRegion.op(drawBounds, SkRegion::kReverseDifference_Op);
    canvas->drawRegion(xRegion, paint);
    if (xRegion.contains(testRegion)) {
        paint.setColor(SK_ColorYELLOW);
        canvas->drawRegion(testRegion, paint);
    }
##

#SeeAlso intersects SkRect::contains

#Method ##

# ------------------------------------------------------------------------------

#Method bool quickContains(const SkIRect& r) const
#In Intersection
#Line # returns true quickly if points are equal or inside ##
#Populate

#Example
    SkRegion region({1, 2, 3, 4});
    SkIRect test = {2, 2, 3, 3};
    SkDebugf("quickContains 1: %s\n", region.quickContains(test) ? "true" : "false");
    region.op({1, 4, 3, 6}, SkRegion::kUnion_Op);
    SkDebugf("quickContains 2: %s\n", region.quickContains(test) ? "true" : "false");
    region.op({1, 7, 3, 8}, SkRegion::kUnion_Op);
    SkDebugf("quickContains 3: %s\n", region.quickContains(test) ? "true" : "false");
#StdOut
quickContains 1: true
quickContains 2: true
quickContains 3: false
##
##

#SeeAlso contains quickReject intersects

#Method ##

# ------------------------------------------------------------------------------

#Method bool quickContains(int32_t left, int32_t top, int32_t right,
                       int32_t bottom) const
#Populate

#Example
    auto debugster = [](const char* label, SkRegion& region) -> void {
        SkDebugf("%s: %s\n", label, region.quickContains(2, 2, 3, 3) ? "true" : "false");
    };
    SkRegion region({1, 2, 3, 4});
    debugster("quickContains 1", region);
    region.op({1, 4, 3, 6}, SkRegion::kUnion_Op);
    debugster("quickContains 2", region);
    region.op({1, 7, 3, 8}, SkRegion::kUnion_Op);
    debugster("quickContains 3", region);
#StdOut
quickContains 1: true
quickContains 2: true
quickContains 3: false
##
##

#SeeAlso contains quickReject intersects

#Method ##

# ------------------------------------------------------------------------------

#Method bool quickReject(const SkIRect& rect) const
#In Intersection
#Line # returns true quickly if points are outside ##
#Populate

#Example
    SkRegion region({1, 2, 3, 4});
    SkIRect test = {4, 2, 5, 3};
    SkDebugf("quickReject 1: %s\n", region.quickReject(test) ? "true" : "false");
    region.op({1, 4, 3, 6}, SkRegion::kUnion_Op);
    SkDebugf("quickReject 2: %s\n", region.quickReject(test) ? "true" : "false");
    region.op({4, 7, 5, 8}, SkRegion::kUnion_Op);
    SkDebugf("quickReject 3: %s\n", region.quickReject(test) ? "true" : "false");
#StdOut
quickReject 1: true
quickReject 2: true
quickReject 3: false
##
##

#SeeAlso quickContains contains intersects

#Method ##

# ------------------------------------------------------------------------------

#Method bool quickReject(const SkRegion& rgn) const
#Populate

#Example
    SkRegion region({1, 2, 3, 4});
    SkRegion test;
    SkIRect rects[] = {{4, 2, 5, 3}, {7, 2, 8, 3}};
    test.setRects(rects, SK_ARRAY_COUNT(rects));
    SkDebugf("quickReject 1: %s\n", region.quickReject(test) ? "true" : "false");
    region.op({1, 4, 3, 6}, SkRegion::kUnion_Op);
    SkDebugf("quickReject 2: %s\n", region.quickReject(test) ? "true" : "false");
    region.op({4, 7, 5, 8}, SkRegion::kUnion_Op);
    SkDebugf("quickReject 3: %s\n", region.quickReject(test) ? "true" : "false");
#StdOut
quickReject 1: true
quickReject 2: true
quickReject 3: false
##
##

#SeeAlso quickContains contains intersects

#Method ##

# ------------------------------------------------------------------------------

#Method void translate(int dx, int dy)
#In Transform
#Line # translates IPoints in Region ##
#Populate

#Example
#Height 90
    SkRegion test;
    SkIRect rects[] = {{40, 20, 50, 30}, {70, 40, 80, 50}, { 60, 10, 70, 20}};
    test.setRects(rects, SK_ARRAY_COUNT(rects));
    SkPaint paint;
    for (auto color :  { SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN, SK_ColorMAGENTA } ) {
        paint.setColor(color);
        canvas->drawRegion(test, paint);
        test.translate(10, 10);
    }
##

#SeeAlso SkCanvas::translate SkIRect::offset SkPath::offset

#Method ##

# ------------------------------------------------------------------------------

#Method void translate(int dx, int dy, SkRegion* dst) const
#Populate

#Example
    SkRegion test;
    SkIRect rects[] = {{40, 20, 50, 30}, {70, 40, 80, 50}, { 60, 10, 70, 20}};
    test.setRects(rects, SK_ARRAY_COUNT(rects));
    SkPaint paint;
    for (auto color :  { SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN, SK_ColorMAGENTA } ) {
        paint.setColor(color);
        canvas->drawRegion(test, paint);
        SkRegion second;
        test.translate(10, test.getBounds().fBottom, &second);
        test.op(second, SkRegion::kXOR_Op);
        test.translate(30, 0);
    }
##

#SeeAlso SkCanvas::translate SkIRect::offset SkPath::offset

#Method ##

# ------------------------------------------------------------------------------

#Enum Op
#Line # binary operator combining Regions ##

#Code
    enum Op {
        kDifference_Op,
        kIntersect_Op,
        kUnion_Op,
        kXOR_Op,
        kReverseDifference_Op,
        kReplace_Op,
        kLastOp = kReplace_Op,
    };
##

The logical operations that can be performed when combining two Regions.

#Const kDifference_Op 0
#Line # target minus operand ##
Subtracts operand Region from target Region.
##
#Const kIntersect_Op 1
#Line # target intersected with operand ##
Intersects operand Region and target Region.
##
#Const kUnion_Op 2
#Line # target unioned with operand ##
Unions operand Region and target Region.
##
#Const kXOR_Op 3
#Line # target exclusive or with operand ##
Replaces target Region with area exclusive to both Regions.
##
#Const kReverseDifference_Op 4
#Line # operand minus target ##
Subtracts target Region from operand Region.
##
#Const kReplace_Op 5
#Line # replace target with operand ##
Replaces target Region with operand Region.
##
#Const kLastOp 5
#Line # last operator ##
##

#Example
    SkRegion operand({35, 35, 85, 85});
    const char* labels[] = {"difference", "intersect", "union", "xor", "reverse diff", "replace"};
    int index = 0;
    SkPaint paint;
    for (auto op : { SkRegion::kDifference_Op, SkRegion::kIntersect_Op, SkRegion::kUnion_Op,
                     SkRegion::kXOR_Op, SkRegion::kReverseDifference_Op, SkRegion::kReplace_Op } ) {
        SkRegion target({10, 10, 60, 60});
        target.op(operand, op);
        canvas->drawRegion(target, paint);
        canvas->drawString(labels[index++], 40, 100, paint);
        canvas->translate(80, 0);
        if (SkRegion::kUnion_Op == op) {
            canvas->translate(-240, 120);
        }
    }
##

#SeeAlso SkPathOp

#Enum ##

# ------------------------------------------------------------------------------

#Const kOpCnt 6
#Line # number of operators defined ##
May be used to verify that Op is a legal value.
#Const ##

# ------------------------------------------------------------------------------

#Method bool op(const SkIRect& rect, Op op)
#In Transform
#Line # applies binary operator ##
#Populate

#Example
#Height 128
    SkPaint paint;
    paint.setTextSize(128);
    SkPath xPath;
    paint.getTextPath("X", 1, 20, 110, &xPath);
    SkRegion xRegion;
    SkIRect drawBounds = {0, 0, 128, 128};
    xRegion.setPath(xPath, SkRegion(drawBounds));
    xRegion.op(drawBounds, SkRegion::kReverseDifference_Op);
    canvas->drawRegion(xRegion, paint);
##

#SeeAlso setRects Op

#Method ##

# ------------------------------------------------------------------------------

#Method bool op(int left, int top, int right, int bottom, Op op)
#Populate

#Example
#Duration 4
#Height 128
    SkPaint paint;
    paint.setTextSize(128);
    SkPath xPath;
    paint.getTextPath("X", 1, 20, 110, &xPath);
    SkRegion xRegion;
    SkIRect drawBounds = {0, 0, 128, 128};
    xRegion.setPath(xPath, SkRegion(drawBounds));
    xRegion.op(drawBounds.fLeft + frame * drawBounds.width(), drawBounds.fTop,
               drawBounds.fRight, drawBounds.fBottom, SkRegion::kReverseDifference_Op);
    canvas->drawRegion(xRegion, paint);
##

#SeeAlso setRects Op

#Method ##

# ------------------------------------------------------------------------------

#Method bool op(const SkRegion& rgn, Op op)
#Populate

#Example
#Duration 4
#Height 128
    SkPaint paint;
    paint.setTextSize(128);
    SkPath xPath, opPath;
    paint.getTextPath("X", 1, 20, 110, &xPath);
    opPath.addCircle(64, 64, frame * 64);
    SkRegion xRegion, opRegion;
    SkIRect drawBounds = {0, 0, 128, 128};
    opRegion.setPath(opPath, SkRegion(drawBounds));
    xRegion.setPath(xPath, SkRegion(drawBounds));
    xRegion.op(opRegion, SkRegion::kReverseDifference_Op);
    canvas->drawRegion(xRegion, paint);
##

#SeeAlso setRects Op

#Method ##

# ------------------------------------------------------------------------------

#Method bool op(const SkIRect& rect, const SkRegion& rgn, Op op)
#Populate

#Example
#Duration 4
#Height 128
    SkPaint paint;
    paint.setTextSize(128);
    SkPath xPath, opPath;
    paint.getTextPath("X", 1, 20, 110, &xPath);
    opPath.addCircle(64, 64, frame * 64);
    SkRegion xRegion, opRegion, rectRegion;
    SkIRect drawBounds = {0, 0, 128, 128};
    opRegion.setPath(opPath, SkRegion(drawBounds));
    xRegion.setPath(xPath, SkRegion(drawBounds));
    drawBounds.inset(frame * drawBounds.width() / 2, 0);    
    rectRegion.op(drawBounds, opRegion, SkRegion::kIntersect_Op);
    xRegion.op(rectRegion, SkRegion::kReverseDifference_Op);
    canvas->drawRegion(xRegion, paint);
##

#SeeAlso setRects Op

#Method ##

# ------------------------------------------------------------------------------

#Method bool op(const SkRegion& rgn, const SkIRect& rect, Op op)
#Populate

#Example
#Duration 4
#Height 128
    SkPaint paint;
    paint.setTextSize(128);
    SkPath xPath, opPath;
    paint.getTextPath("X", 1, 20, 110, &xPath);
    opPath.addCircle(64, 64, frame * 64);
    SkRegion xRegion, opRegion, rectRegion;
    SkIRect drawBounds = {0, 0, 128, 128};
    opRegion.setPath(opPath, SkRegion(drawBounds));
    xRegion.setPath(xPath, SkRegion(drawBounds));
    drawBounds.inset(frame * drawBounds.width() / 2, 0);    
    rectRegion.op(opRegion, drawBounds, SkRegion::kUnion_Op);
    xRegion.op(rectRegion, SkRegion::kReverseDifference_Op);
    canvas->drawRegion(xRegion, paint);
##

#SeeAlso setRects Op

#Method ##

# ------------------------------------------------------------------------------

#Method bool op(const SkRegion& rgna, const SkRegion& rgnb, Op op)
#Populate

#Example
#Duration 4
#Height 128
    SkPaint paint;
    paint.setTextSize(128);
    SkPath xPath, opPath;
    paint.getTextPath("X", 1, 20, 110, &xPath);
    xPath.setFillType(SkPath::kInverseWinding_FillType);
    opPath.addCircle(64, 64, frame * 64);
    opPath.setFillType(SkPath::kInverseWinding_FillType);
    SkRegion xRegion, opRegion, rectRegion;
    SkIRect drawBounds = {0, 0, 128, 128};
    opRegion.setPath(opPath, SkRegion(drawBounds));
    xRegion.setPath(xPath, SkRegion(drawBounds));
    drawBounds.inset(frame * drawBounds.width() / 2, 0);
    rectRegion.setRect(drawBounds);    
    rectRegion.op(xRegion, SkRegion::kIntersect_Op);
    xRegion.op(rectRegion, opRegion, SkRegion::kReverseDifference_Op);
    canvas->drawRegion(xRegion, paint);
##

#SeeAlso setRects Op

#Method ##

# ------------------------------------------------------------------------------

#Method size_t writeToMemory(void* buffer) const
#In Utility
#Line # writes to buffer ##
#Populate

#Example
#Height 128
    SkPaint paint;
    paint.setTextSize(128);
    SkPath xPath;
    paint.getTextPath("X", 1, 20, 110, &xPath);
    SkIRect drawBounds = {0, 0, 128, 128};
    SkRegion xRegion;
    xRegion.setPath(xPath, SkRegion(drawBounds));
    size_t size = xRegion.writeToMemory(nullptr);
    sk_sp<SkData> data = SkData::MakeUninitialized(size);
    xRegion.writeToMemory(data->writable_data());
    SkRegion copy;
    copy.readFromMemory(data->data(), data->size());
    canvas->drawRegion(copy, paint);
##

#SeeAlso readFromMemory

#Method ##

# ------------------------------------------------------------------------------

#Method size_t readFromMemory(const void* buffer, size_t length)
#In Utility
#Line # reads from buffer ##
#Populate

#Example
#Height 100
    SkRegion region({20, 20, 80, 80});
    size_t size = region.writeToMemory(nullptr);
    sk_sp<SkData> data = SkData::MakeUninitialized(size);
    region.writeToMemory(data->writable_data());
    SkRegion copy;
    copy.readFromMemory(data->data(), data->size());
    canvas->drawRegion(copy, SkPaint());
##

#SeeAlso writeToMemory

#Method ##

#Class SkRegion ##

#Topic Region ##