Wt::Region Class Reference

Region specifies a 'working area' of the screen. More...

#include <region.h>

Collaboration diagram for Wt::Region:

[legend]List of all members.

Public Member Functions
bool	isEmpty () const
	true if region empty
bool	contains (const Point &p) const
	check if a region contains a point
bool	contains (const Rect &r) const
	Check if a region contains/overlaps a rectangle.
void	translate (int dx, int dy)
	Move a region by dx, dy.
Region	unite (const Region &r) const
Region	intersect (const Region &r) const
Region	subtract (const Region &r) const
Region	eor (const Region &r) const
const Rect &	boundingRect () const
const RectArray &	rects () const
	returns the array of rectangles composing the region
Region	operator| (const Region &r) const
Region	operator+ (const Region &r) const
Region	operator & (const Region &r) const
Region	operator- (const Region &r) const
Region	operator^ (const Region &r) const
Region &	operator|= (const Region &r)
Region &	operator+= (const Region &r)
Region &	operator &= (const Region &r)
Region &	operator-= (const Region &r)
Region &	operator^= (const Region &r)
bool	operator== (const Region &r) const
	compare two regions
bool	operator!= (const Region &r) const
	compare two regions
Contructors
	Region ()
	Create a new empty region.
	Region (const Rect &rect)
	Region from rectangle.
	Region (const Point &p)
	Region from point.
Protected Member Functions
void	detach ()
Private Types
typedef boost::shared_ptr< RectArray >	RectArrayPtr
typedef void(Region::*)	overlapFunc (const RectArray &ra1, int start1, int end1, const RectArray &ra2, int start2, int end2, int y1, int y2)
typedef void(Region::*)	nonOverlapFunc (const RectArray &ra, int start, int end, int y1, int y2)
Private Member Functions
void	merge_rect (const RectArray &ra, int index, int y1, int y2)
void	calc_extents ()
int	coalesce (int prevStart, int curStart)
void	regionOp (const Region &other, overlapFunc overlapFn, nonOverlapFunc nonOverlap1Fn, nonOverlapFunc nonOverlap2Fn)
void	unionNonO (const RectArray &ra, int start, int end, int y1, int y2)
void	unionO (const RectArray &ra1, int start1, int end1, const RectArray &ra2, int start2, int end2, int y1, int y2)
void	intersectO (const RectArray &ra1, int start1, int end1, const RectArray &ra2, int start2, int end2, int y1, int y2)
void	subtractNonO (const RectArray &ra, int start, int end, int y1, int y2)
void	subtractO (const RectArray &ra1, int start1, int end1, const RectArray &ra2, int start2, int end2, int y1, int y2)
Private Attributes
RectArrayPtr	rects_
Rect	extents

---

Detailed Description

Region specifies a 'working area' of the screen.

pixels outside the region are always ignored

Definition at line 19 of file region.h.

---

Member Typedef Documentation

typedef void(Region::*) Wt::Region::nonOverlapFunc(const RectArray &ra, int start, int end, int y1, int y2) [private]

Definition at line 97 of file region.h.

typedef void(Region::*) Wt::Region::overlapFunc(const RectArray &ra1, int start1, int end1, const RectArray &ra2, int start2, int end2, int y1, int y2) [private]

Definition at line 94 of file region.h.

typedef boost::shared_ptr<RectArray> Wt::Region::RectArrayPtr [private]

Definition at line 89 of file region.h.

---

Constructor & Destructor Documentation

Wt::Region::Region

(

)

Create a new empty region.

Definition at line 80 of file region.cpp.

        : rects_(new RectArray),
extents(0, 0, 0, 0) {}

Wt::Region::Region

(

const Rect &

rect

)

Region from rectangle.

Definition at line 84 of file region.cpp.

        : rects_(new RectArray(1, rect)),
extents(rect) {}

Wt::Region::Region

(

const Point &

p

)

Region from point.

Definition at line 88 of file region.cpp.

        : rects_(new RectArray(1, Rect(p.x(), p.y(), 1, 1))),
extents(rects()[0]) {}

---

Member Function Documentation

const Rect& Wt::Region::boundingRect

(

)

const [inline]

Definition at line 57 of file region.h.

References extents.

Referenced by Wt::Widget::mapToGlobal(), Wt::Widget::mapToParent(), and Wt::operator<<().

                                     {
        return extents;
    }

void Wt::Region::calc_extents

(

)

[private]

Definition at line 375 of file region.cpp.

References Wt::SDLRect::bottom(), extents, Wt::Rect::isValid(), Wt::SDLRect::left(), rects(), Wt::SDLRect::right(), Wt::Rect::setCoords(), Wt::SDLRect::setRect(), and Wt::SDLRect::top().

Referenced by intersect(), and subtract().

                          {
    const int n = rects().size();

    if (!n) {
        extents.setRect(0, 0, 0, 0);
        return;
    }

    const RectArray& ra = rects();
    /*
     * Since pBox is the first rectangle in the region, it must have the
     * smallest y1 and since pBoxEnd is the last rectangle in the region,
     * it must have the largest y2, because of banding. Initialize x1 and
     * x2 from  pBox and pBoxEnd, resp., as good things to initialize them
     * to...
     */
    extents.setCoords(ra[0].x(), ra[0].y(), ra[0].right(), ra[n - 1].bottom());

    assert(extents.isValid());
    for (int i = 1; i < n; i++) {
        extents.setCoords(std::min(ra[i].left(), extents.left()), extents.top(),
                          std::max(ra[i].right(), extents.right()), extents.bottom());
    }
    assert(extents.isValid());
}

Here is the call graph for this function:

int Wt::Region::coalesce	(	int	prevStart,
		int	curStart
	)			[private]

Definition at line 423 of file region.cpp.

References rects_.

Referenced by regionOp().

{
    int curNumRects = 0; /* Number of rectangles in current band */
    int prevNumRects = curStart - prevStart;

    RectArray& ra = *rects_;
    const int n = ra.size();
    int numRects = n;

    int bandY1 = ra[curStart].top(); /* Y1 coordinate for current band */
    int current;
    int current_prev = prevStart;
    int current_end = n;

    /*
     * Figure out how many rectangles are in the current band. Have to do
     * this because multiple bands could have been added in miRegionOp
     * at the end when one region has been exhausted.
     */
    for (current = curStart; current < n
            && ra[current].top() == bandY1; current++) {
        curNumRects++;
    }

    if (current != current_end) {
        /*
         * If more than one band was added, we have to find the start
         * of the last band added so the next coalescing job can start
         * at the right place... (given when multiple bands are added,
         * this may be pointless -- see above).
         */
        current_end--;
        while (ra[current_end - 1].top() == ra[current_end].top()) {
            current_end--;
        }
        curStart = current_end;
        current_end = n;
    }

    if ((curNumRects == prevNumRects) && (curNumRects != 0)) {
        current -= curNumRects;

        /*
         * The bands may only be coalesced if the bottom of the previous
         * matches the top scanline of the current.
         */
        if (ra[current_prev].bottom() == ra[current].top() - 1) {
            //if (pPrevBox->bottom() == pCurBox->top() - 1) {
            /*
             * Make sure the bands have boxes in the same places. This
             * assumes that boxes have been added in such a way that they
             * cover the most area possible. I.e. two boxes in a band must
             * have some horizontal space between them.
             */

            do {
                if ((ra[current_prev].left() != ra[current].left()) ||
                        (ra[current_prev].right() != ra[current].right())) {
                    /*
                     * The bands don't line up so they can't be coalesced.
                     */
                    return curStart;
                }
                current_prev++;
                current++;
                prevNumRects -= 1;
            } while (prevNumRects != 0);

            numRects -= curNumRects;
            rects_->resize(numRects);
            current -= curNumRects;
            current_prev -= curNumRects;

            /*
             * The bands may be merged, so set the bottom y of each box
             * in the previous band to that of the corresponding box in
             * the current band.
             */

            do {
                ra[current_prev].setBottom(ra[current].bottom());
                current_prev++;
                current++;
                curNumRects--;
            } while (curNumRects != 0);

            /*
             * If only one band was added to the region, we have to backup
             * curStart to the start of the previous band.
             *
             * If more than one band was added to the region, copy the
             * other bands down. The assumption here is that the other bands
             * came from the same region as the current one and no further
             * coalescing can be done on them since it's all been done
             * already... curStart is already in the right place.
             */
            if (current == current_end) {
                curStart = prevStart;
            } else {
                do {
                    ra[current_prev] = ra[current];
                    current_prev++;
                    current++;
                } while (current != current_end);
            }
        }
    }
    return curStart;
}

bool Wt::Region::contains

(

const Rect &

r

)

const

Check if a region contains/overlaps a rectangle.

Definition at line 107 of file region.cpp.

References Wt::SDLRect::bottom(), extents, Wt::SDLRect::intersects(), Wt::SDLRect::left(), rects(), Wt::SDLRect::right(), Wt::SDLRect::x(), and Wt::SDLRect::y().

                                            {
    const int n = rects().size();

    /* this is (just) a useful optimization */
    if (!n || !extents.intersects(rect))
        return false;

    bool partIn = false;
    bool partOut = false;
    int rx = rect.x();
    int ry = rect.y();
    const RectArray& ra = rects();

    /* can stop when both partOut and partIn are TRUE, or we reach prect->y2 */
    for (int i = 0; i < n; i++) {
        const Rect& pbox = ra[i];

        if (pbox.bottom() < ry)
            continue;   /* getting up to speed or skipping remainder of band */

        if (pbox.top() > ry) {
            partOut = true; /* missed part of rectangle above */
            if (partIn || (pbox.top() > rect.bottom()))
                break;
            ry = pbox.top();    /* x guaranteed to be == prect->x1 */
        }

        if (pbox.right() < rx)
            continue;       /* not far enough over yet */

        if (pbox.left() > rx) {
            partOut = true; /* missed part of rectangle to left */
            if (partIn)
                break;
        }

        if (pbox.left() <= rect.right()) {
            partIn = true;  /* definitely overlap */
            if (partOut)
                break;
        }

        if (pbox.right() >= rect.right()) {
            ry = pbox.bottom() + 1; /* finished with this band */
            if (ry > rect.bottom())
                break;
            rx = rect.left();   /* reset x out to left again */
        } else {
            /*
             * Because boxes in a band are maximal width, if the first box
             * to overlap the rectangle doesn't completely cover it in that
             * band, the rectangle must be partially out, since some of it
             * will be uncovered in that band. partIn will have been set true
             * by now...
             */
            break;
        }
    }

    return (partIn ? ((ry <= rect.bottom()) ? false: true) : false);
}

Here is the call graph for this function:

bool Wt::Region::contains

(

const Point &

p

)

const

check if a region contains a point

Definition at line 92 of file region.cpp.

References Wt::Rect::contains(), extents, and rects().

                                          {
    const int n = rects().size();
    if (!n)
        return false;
    if (!extents.contains(p))
        return false;

    const RectArray& ra = rects();
    for (int i=0; i < n; i++) {
        if (ra[i].contains(p))
            return true;
    }
    return false;
}

Here is the call graph for this function:

void Wt::Region::detach

(

)

[protected]

Definition at line 353 of file region.cpp.

References rects_.

Referenced by intersect(), operator &=(), operator+=(), operator-=(), operator^=(), operator|=(), subtract(), translate(), and unite().

                    {
    //avoid detaching if we are the only client for this surface
    if (!rects_.unique()) {
        rects_.reset(new RectArray(*rects_));
    }
}

Region Wt::Region::eor

(

const Region &

r

)

const

Definition at line 274 of file region.cpp.

Referenced by operator^().

                                        {
    Region r1(*this);
    Region temp(r - r1);

    r1 -= r;

    return r1 |= temp;
}

Region Wt::Region::intersect

(

const Region &

r

)

const

Definition at line 227 of file region.cpp.

References calc_extents(), detach(), extents, intersectO(), Wt::SDLRect::intersects(), rects(), rects_, and regionOp().

Referenced by operator &().

                                              {
    const int n = rects().size();
    const int rn = r.rects().size();
    Region r1(*this);
    r1.detach();

    /* check for trivial reject */
    if (!n || !rn || !r1.extents.intersects(r.extents))
        r1.rects_->clear();
    else
        r1.regionOp(r, &Region::intersectO, 0, 0);

    /*
     * Can't alter region's extents before miRegionOp depends on the
     * extents of the regions being unchanged. Besides, this way there's
     * no checking against rectangles that will be nuked due to
     * coalescing, so we have to examine fewer rectangles.
     */
    r1.calc_extents();

    return r1;
}

Here is the call graph for this function:

void Wt::Region::intersectO	(	const RectArray &	ra1,
		int	start1,
		int	end1,
		const RectArray &	ra2,
		int	start2,
		int	end2,
		int	y1,
		int	y2
	)			[private]

Definition at line 847 of file region.cpp.

References rects_.

Referenced by intersect().

                                        {
    while ((i1 != end1) && (i2 != end2)) {
        int x1 = std::max (ra1[i1].left(), ra2[i2].left());
        int x2 = std::min (ra1[i1].right(), ra2[i2].right());

        /*
         * If there's any overlap between the two rectangles, add that
         * overlap to the new region.
         * There's no need to check for subsumption because the only way
         * such a need could arise is if some region has two rectangles
         * right next to each other. Since that should never happen...
         */
        if (x1 <= x2) {
            assert (y1 <= y2);
            rects_->push_back(Rect(x1, y1, x2 - x1 + 1, y2 - y1 + 1));
        }

        /*
         * Need to advance the pointers. Shift the one that extends
         * to the right the least, since the other still has a chance to
         * overlap with that region's next rectangle, if you see what I mean.
         */
        if (ra1[i1].right() < ra2[i2].right()) {
            i1++;
        } else if (ra2[i2].right() < ra1[i1].right()) {
            i2++;
        } else {
            i1++;
            i2++;
        }
    }
}

bool Wt::Region::isEmpty

(

)

const [inline]

true if region empty

Note:

the defauly copy constructor, assignment operator and destructor should be ok

Definition at line 38 of file region.h.

References rects_.

Referenced by Wt::RootWindow::blit_region_ex(), and Wt::Application::postEvent().

                         {
        return rects_->size() == 0;
    }

void Wt::Region::merge_rect	(	const RectArray &	ra,
		int	index,
		int	y1,
		int	y2
	)			[private]

Definition at line 774 of file region.cpp.

References rects_.

Referenced by unionO().

                                                                  {
    RectArray& lra = *rects_;
    const int total = lra.size();

    if ((total != 0) &&
            (lra[total - 1].top() == y1) &&
            (lra[total - 1].bottom() == y2) &&
            (lra[total - 1].right() + 1 >= ra[i].left())) {

        lra[total - 1].setRight(std::max(lra[total - 1].right(), ra[i].right()));
        assert(lra[total - 1].left() <= lra[total - 1].right());
    } else {
        lra.push_back(Rect(ra[i].left(), y1,
                           ra[i].width(), y2 - y1 + 1));
    }
}

Region Wt::Region::operator &

(

const Region &

r

)

const

Definition at line 291 of file region.cpp.

References intersect().

                                              {
    return this->intersect(r);
}

Here is the call graph for this function:

Region & Wt::Region::operator &=

(

const Region &

r

)

Definition at line 315 of file region.cpp.

References detach().

                                          {
    detach();
    *this = *this & r;
    return *this;
}

Here is the call graph for this function:

bool Wt::Region::operator!=

(

const Region &

r

)

const [inline]

compare two regions

Definition at line 81 of file region.h.

References operator==().

                                           {
        return !operator==(r);
    }

Here is the call graph for this function:

Region Wt::Region::operator+

(

const Region &

r

)

const

Definition at line 287 of file region.cpp.

References unite().

                                              {
    return this->unite(r);
}

Here is the call graph for this function:

Region & Wt::Region::operator+=

(

const Region &

r

)

Definition at line 309 of file region.cpp.

References detach().

                                          {
    detach();
    *this = *this + r;
    return *this;
}

Here is the call graph for this function:

Region Wt::Region::operator-

(

const Region &

r

)

const

Definition at line 295 of file region.cpp.

References subtract().

                                              {
    return this->subtract(r);
}

Here is the call graph for this function:

Region & Wt::Region::operator-=

(

const Region &

r

)

Definition at line 321 of file region.cpp.

References detach().

                                          {
    detach();
    *this = *this - r;
    return *this;
}

Here is the call graph for this function:

bool Wt::Region::operator==

(

const Region &

r

)

const

compare two regions

Definition at line 333 of file region.cpp.

References extents, and rects().

Referenced by operator!=().

                                                 {
    const int n = rects().size();
    const int other_n = other.rects().size();
    if (n!= other_n)
        return false;
    else if (!n)
        return true;
    else if (extents != other.extents)
        return false;
    else {
        const RectArray& ra = rects();
        const RectArray& other_ra = other.rects();
        for (int i = 0; i < n; i++) {
            if (ra[i] != other_ra[i])
                return false;
        }
    }
    return true;
}

Here is the call graph for this function:

Region Wt::Region::operator^

(

const Region &

r

)

const

Definition at line 299 of file region.cpp.

References eor().

                                              {
    return this->eor(r);
}

Here is the call graph for this function:

Region & Wt::Region::operator^=

(

const Region &

r

)

Definition at line 327 of file region.cpp.

References detach().

                                          {
    detach();
    *this = *this ^ r;
    return *this;
}

Here is the call graph for this function:

Region Wt::Region::operator|

(

const Region &

r

)

const

Definition at line 283 of file region.cpp.

References unite().

                                              {
    return this->unite(r);
}

Here is the call graph for this function:

Region & Wt::Region::operator|=

(

const Region &

r

)

Definition at line 303 of file region.cpp.

References detach().

                                          {
    detach();
    *this = *this | r;
    return *this;
}

Here is the call graph for this function:

const RectArray& Wt::Region::rects

(

)

const [inline]

returns the array of rectangles composing the region

Definition at line 62 of file region.h.

References rects_.

Referenced by Wt::PixmapOf< Wt::SDLSurface >::blend(), calc_extents(), contains(), Wt::Widget::erase(), Wt::PixmapOf< Wt::SDLSurface >::fill(), intersect(), Wt::operator<<(), operator==(), regionOp(), subtract(), unite(), and Wt::Display::update().

                                   {
        return *rects_;
    }

void Wt::Region::regionOp	(	const Region &	other,
		overlapFunc	overlapFn,
		nonOverlapFunc	nonOverlap1Fn,
		nonOverlapFunc	nonOverlap2Fn
	)			[private]

Definition at line 561 of file region.cpp.

References coalesce(), extents, rects(), rects_, and Wt::SDLRect::top().

Referenced by intersect(), subtract(), and unite().

{
    int ybot;           /* Bottom of intersection */
    int ytop;           /* Top of intersection */
    unsigned int prevBand;  /* Index of start of previous band in newReg */
    unsigned int curBand;   /* Index of start of current band in newReg */
    int top;            /* Top of non-overlapping band */
    int bot;            /* Bottom of non-overlapping band */

    /*
     * Initialization:
     *  set r1, r2, r1End and r2End appropriately, preserve the important
     * parts of the destination region until the end in case it's one of
     * the two source regions, then mark the "new" region empty, allocating
     * another array of rectangles for it to use.
     */
    const RectArray& ra1 = rects();
    const int n1 = ra1.size();
    int i1 = 0;
    const RectArray& ra2 = other.rects();
    const int n2 = ra2.size();
    int i2 = 0;
    // keep one copy
    RectArrayPtr old_rects_ = rects_;
    int band_1_end;
    int band_2_end;

    /*
     * Allocate a reasonable number of rectangles for the new region. The idea
     * is to allocate enough so the individual functions don't need to
     * reallocate and copy the array, which is time consuming, yet we don't
     * have to worry about using too much memory. I hope to be able to
     * nuke the Xrealloc() at the end of this function eventually.
     */
    rects_.reset(new RectArray);
    rects_->reserve(std::max(n1, n2) * 2);

    /*
     * Initialize ybot and ytop.
     * In the upcoming loop, ybot and ytop serve different functions depending
     * on whether the band being handled is an overlapping or non-overlapping
     * band.
     *  In the case of a non-overlapping band (only one of the regions
     * has points in the band), ybot is the bottom of the most recent
     * intersection and thus clips the top of the rectangles in that band.
     * ytop is the top of the next intersection between the two regions and
     * serves to clip the bottom of the rectangles in the current band.
     *  For an overlapping band (where the two regions intersect), ytop clips
     * the top of the rectangles of both regions and ybot clips the bottoms.
     */
    //ybot = std::min(reg1->extents.top(), reg2->extents.top()) - 1;
    ybot = std::min(extents.top(), other.extents.top()) - 1;

    /*
     * prevBand serves to mark the start of the previous band so rectangles
     * can be coalesced into larger rectangles. qv. miCoalesce, above.
     * In the beginning, there is no previous band, so prevBand == curBand
     * (curBand is set later on, of course, but the first band will always
     * start at index 0). prevBand and curBand must be indices because of
     * the possible expansion, and resultant moving, of the new region's
     * array of rectangles.
     */
    prevBand = 0;

    do {
        curBand = rects().size();

        /*
         * This algorithm proceeds one source-band (as opposed to a
         * destination band, which is determined by where the two regions
         * intersect) at a time. r1BandEnd and r2BandEnd serve to mark the
         * rectangle after the last one in the current band for their
         * respective regions.
         */
        for (band_1_end = i1; band_1_end < n1 &&
            ra1[band_1_end].top() == ra1[i1].top(); band_1_end++) {}

        for (band_2_end = i2; band_2_end < n2 &&
            ra2[band_2_end].top() == ra2[i2].top(); band_2_end++) {}

        /*
         * First handle the band that doesn't intersect, if any.
         *
         * Note that attention is restricted to one band in the
         * non-intersecting region at once, so if a region has n
         * bands between the current position and the next place it overlaps
         * the other, this entire loop will be passed through n times.
         */
        if (ra1[i1].top() < ra2[i2].top()) {
            top = std::max (ra1[i1].top(), ybot + 1);
            bot = std::min (ra1[i1].bottom(), ra2[i2].top() - 1);

            if ((top != bot + 1) && (nonOverlap1Fn != 0)) {
                (this->*nonOverlap1Fn)(ra1, i1, band_1_end, top, bot);
            }

            ytop = ra2[i2].top();
        } else if (ra2[i2].top() < ra1[i1].top()) {
            top = std::max (ra2[i2].top(), ybot + 1);
            bot = std::min (ra2[i2].bottom(), ra1[i1].top() - 1);

            if ((top != bot + 1) && (nonOverlap2Fn != 0)) {
                (this->*nonOverlap2Fn)(ra2, i2, band_2_end, top, bot);
            }

            ytop = ra1[i1].top();
        } else {
            ytop = ra1[i1].top();
        }

        /*
         * If any rectangles got added to the region, try and coalesce them
         * with rectangles from the previous band. Note we could just do
         * this test in miCoalesce, but some machines incur a not
         * inconsiderable cost for function calls, so...
         */
        if (rects().size() != curBand) {
            prevBand = coalesce(prevBand, curBand);
        }

        /*
         * Now see if we've hit an intersecting band. The two bands only
         * intersect if ybot > ytop
         */
        ybot = std::min(ra1[i1].bottom(), ra2[i2].bottom());
        curBand = rects().size();
        if (ybot >= ytop) {
            (this->*overlapFn)(ra1, i1, band_1_end, ra2,
                               i2, band_2_end, ytop, ybot);
        }

        if (rects().size() != curBand) {
            prevBand = coalesce(prevBand, curBand);
        }

        /*
         * If we've finished with a band (y2 == ybot) we skip forward
         * in the region to the next band.
         */
        if (ra1[i1].bottom() == ybot) {
            i1 = band_1_end;
        }
        if (ra2[i2].bottom() == ybot) {
            i2 = band_2_end;
        }
    } while ((i1 != n1) && (i2 != n2));

    /*
     * Deal with whichever region still has rectangles left.
     */
    curBand = rects().size();
    if (i1 != n1 && nonOverlap1Fn) {
        do {
            for (band_1_end = i1; band_1_end < n1 &&
                ra1[band_1_end].top() == ra1[i1].top(); band_1_end++) {}

            (this->*nonOverlap1Fn)(ra1, i1, band_1_end,
                                   std::max(ra1[i1].top(), ybot + 1),
                                   ra1[i1].bottom());
            i1 = band_1_end;
        } while (i1 != n1);
    } else if (i2 != n2 && nonOverlap2Fn) {
        do {
            for (band_2_end = i2; band_2_end < n2 &&
                ra2[band_2_end].top() == ra2[i2].top(); band_2_end++) {}

            (this->*nonOverlap2Fn)(ra2, i2, band_2_end,
                                   std::max(ra2[i2].top(), ybot + 1),
                                   ra2[i2].bottom());
            i2 = band_2_end;
        } while (i2 != n2);
    }

    if (rects().size() != curBand) {
        coalesce(prevBand, curBand);
    }
}

Here is the call graph for this function:

Region Wt::Region::subtract

(

const Region &

r

)

const

Definition at line 250 of file region.cpp.

References calc_extents(), detach(), extents, Wt::SDLRect::intersects(), rects(), regionOp(), subtractNonO(), and subtractO().

Referenced by operator-().

                                             {
    const int n = rects().size();
    const int rn = r.rects().size();

    /* check for trivial reject */
    if (!n || !rn || !extents.intersects(r.extents))
        return *this;

    Region r1(*this);
    r1.detach();

    r1.regionOp(r, &Region::subtractO, &Region::subtractNonO, 0);

    /*
     * Can't alter region's extents before we call miRegionOp because miRegionOp
     * depends on the extents of those regions being the unaltered. Besides, this
     * way there's no checking against rectangles that will be nuked
     * due to coalescing, so we have to examine fewer rectangles.
     */
    r1.calc_extents ();

    return r1;
}

Here is the call graph for this function:

void Wt::Region::subtractNonO	(	const RectArray &	ra,
		int	start,
		int	end,
		int	y1,
		int	y2
	)			[private]

Definition at line 898 of file region.cpp.

References rects_.

Referenced by subtract().

                                                         {
    assert(y1 <= y2);

    for (int i = start; i < end; i++) {
        assert(ra[i].left() <= ra[i].right());
        rects_->push_back(Rect(ra[i].left(), y1,
                               ra[i].width(), y2 - y1 + 1));
    }
}

void Wt::Region::subtractO	(	const RectArray &	ra1,
		int	start1,
		int	end1,
		const RectArray &	ra2,
		int	start2,
		int	end2,
		int	y1,
		int	y2
	)			[private]

Definition at line 923 of file region.cpp.

References rects_.

Referenced by subtract().

                                       {
    int x1 = ra1[i1].left();

    assert(y1 <= y2);

    while ((i1 != end1) && (i2 != end2)) {
        if (ra2[i2].right() < x1) {
            /*
             * Subtrahend missed the boat: go to next subtrahend.
             */
            i2++;
        } else if (ra2[i2].left() <= x1) {
            /*
             * Subtrahend preceeds minuend: nuke left edge of minuend.
             */
            x1 = ra2[i2].right() + 1;
            if (x1 > ra1[i1].right()) {
                /*
                 * Minuend completely covered: advance to next minuend and
                 * reset left fence to edge of new minuend.
                 */
                i1++;
                if (i1 != end1)
                    x1 = ra1[i1].left();
            } else {
                /*
                 * Subtrahend now used up since it doesn't extend beyond
                 * minuend
                 */
                i2++;
            }
        } else if (ra2[i2].left() <= ra1[i1].right()) {
            /*
             * Left part of subtrahend covers part of minuend: add uncovered
             * part of minuend to region and skip to next subtrahend.
             */
            assert(x1 < ra2[i2].left());
            rects_->push_back(Rect(x1, y1, ra2[i2].left() - x1, y2 - y1 + 1));

            x1 = ra2[i2].right() + 1;
            if (x1 > ra1[i1].right()) {
                /*
                 * Minuend used up: advance to new...
                 */
                i1++;
                if (i1 != end1)
                    x1 = ra1[i1].left();
            } else {
                /*
                 * Subtrahend used up
                 */
                i2++;
            }
        } else {
            /*
             * Minuend used up: add any remaining piece before advancing.
             */
            if (ra1[i1].right() >= x1) {
                rects_->push_back(Rect(x1, y1,
                                       ra1[i1].right() - x1 + 1, y2 - y1 + 1));
            }
            i1++;
            if (i1 != end1)
                x1 = ra1[i1].left();
        }
    }

    /*
       * Add remaining minuend rectangles to region.
       */
    while(i1 != end1) {
        assert(x1 <= ra1[i1].right());
        rects_->push_back(Rect(x1, y1,
                               ra1[i1].right() - x1 + 1, y2 - y1 + 1));

        i1++;
        if (i1 != end1)
            x1 = ra1[i1].left();
    }
}

void Wt::Region::translate	(	int	dx,
		int	dy
	)

Move a region by dx, dy.

Definition at line 173 of file region.cpp.

References detach(), extents, Wt::SDLRect::moveBy(), and rects_.

Referenced by Wt::Widget::mapToGlobal(), and Wt::Widget::mapToParent().

                                     {
    const int n = rects_->size();
    if (!n)
        return;

    detach();
    RectArray& ra = *rects_;
    for (int i = 0; i < n; i++) {
        ra[i].moveBy(dx, dy);
    }

    extents.moveBy(dx, dy);
}

Here is the call graph for this function:

void Wt::Region::unionNonO	(	const RectArray &	ra,
		int	start,
		int	end,
		int	y1,
		int	y2
	)			[private]

Definition at line 763 of file region.cpp.

References rects_.

Referenced by unite().

                                                           {
    assert(y1 <= y2);

    for (int i = start; i < end; i++) {
        assert(ra[i].left() <= ra[i].right());
        rects_->push_back(Rect(ra[i].left(), y1,
                               ra[i].width(), y2 - y1 + 1));
    }
}

void Wt::Region::unionO	(	const RectArray &	ra1,
		int	start1,
		int	end1,
		const RectArray &	ra2,
		int	start2,
		int	end2,
		int	y1,
		int	y2
	)			[private]

Definition at line 807 of file region.cpp.

References merge_rect().

Referenced by unite().

                                    {
    assert (y1 <= y2);
    while ((i1 != end1) && (i2 != end2)) {
        if (ra1[i1].left() < ra2[i2].left()) {
            merge_rect(ra1, i1, y1, y2);
            i1++;
        } else {
            merge_rect(ra2, i2, y1, y2);
            i2++;
        }
    }

    while (i1 != end1) {
        merge_rect(ra1, i1, y1, y2);
        i1++;
    }
    while (i2 != end2) {
        merge_rect(ra2, i2, y1, y2);
        i2++;
    }
}

Here is the call graph for this function:

Region Wt::Region::unite

(

const Region &

r

)

const

unite

Definition at line 188 of file region.cpp.

References Wt::SDLRect::bottom(), Wt::Rect::contains(), detach(), extents, Wt::SDLRect::left(), rects(), regionOp(), Wt::SDLRect::right(), Wt::Rect::setCoords(), Wt::SDLRect::top(), unionNonO(), and unionO().

Referenced by operator+(), and operator|().

                                          {
    const int n = rects().size();
    /*  checks all the simple cases */

    /*
     * region is empty
     */
    if (!n) {
        return r;
    }

    const int rn = r.rects().size();
    /*
     * region and other are the same or other is empty
     */
    if ( (this == &r) || !rn )
        return *this;

    // region completely subsumes other
    if ((n == 1) && extents.contains(r.extents))
        return *this;

    // other completely subsumes region
    if ((rn == 1) && r.extents.contains(extents))
        return r;

    Region r1(*this);
    r1.detach();

    r1.regionOp(r, &Region::unionO,
                &Region::unionNonO, &Region::unionNonO);
    r1.extents.setCoords(std::min(extents.left(), r.extents.left()),
                         std::min(extents.top(), r.extents.top()),
                         std::max(extents.right(), r.extents.right()),
                         std::max(extents.bottom(), r.extents.bottom()));

    return r1;
}

Here is the call graph for this function:

---

Member Data Documentation

Rect Wt::Region::extents [private]

Definition at line 91 of file region.h.

Referenced by boundingRect(), calc_extents(), contains(), intersect(), operator==(), regionOp(), subtract(), translate(), and unite().

RectArrayPtr Wt::Region::rects_ [private]

Definition at line 90 of file region.h.

Referenced by coalesce(), detach(), intersect(), intersectO(), isEmpty(), merge_rect(), rects(), regionOp(), subtractNonO(), subtractO(), translate(), and unionNonO().

---

The documentation for this class was generated from the following files:

• region.h
• region.cpp

---

Generated Fri Jul 28 19:31:34 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.