/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

// XXX - add appropriate friendship relationships

#define private public

#include "qregion.h"

#undef private

#include "qpainterpath.h"

#include "qpolygon.h"

#include "qbuffer.h"

#include "qimage.h"

#include <qdebug.h>

#include "qbitmap.h"

#include <stdlib.h>

#include <qatomic.h>

#include <qsemaphore.h>

QT_BEGIN_NAMESPACE

class QFastMutex

{

    QAtomicInt contenders;

    QSemaphore semaphore;

public:

    inline QFastMutex()

        : contenders(0), semaphore(0)

    { }

    inline void lock()

    {

        if (contenders.fetchAndAddAcquire(1) != 0) {

            semaphore.acquire();

            contenders.deref();

        }

    }

    inline bool tryLock()

    {

        return contenders.testAndSetAcquire(0, 1);

    }

    inline void unlock()

    {

        if (!contenders.testAndSetRelease(1, 0))

            semaphore.release();

    }

};

/*

 *  1 if r1 contains r2

 *  0 if r1 does not completely contain r2

 */ 

#define CONTAINSCHECK(r1, r2) \

    ((r2).left() >= (r1).left() && (r2).right() <= (r1).right() && \

     (r2).top() >= (r1).top() && (r2).bottom() <= (r1).bottom())

/*

 *   clip region

 */

struct QRegionPrivate : public QRegion::QRegionData {

    enum { Single, Vector } mode;

    int numRects;

    QVector<QRect> rects;

    QRect single;

    QRect extents;

    QRect innerRect;

    union {

        int innerArea;

        QRegionPrivate *next;

    };

    inline void vector()

    {

        if(mode != Vector && numRects) {

            if(rects.size() < 1) rects.resize(1);

            rects[0] = single;

        }

        mode = Vector;

    }

    inline QRegionPrivate() : mode(Single), numRects(0), innerArea(-1) {}

    inline QRegionPrivate(const QRect &r) : mode(Single) {

        numRects = 1;

//        rects[0] = r;

        single = r;

        extents = r;

        innerRect = r;

        innerArea = r.width() * r.height();

    }

    inline QRegionPrivate(const QRegionPrivate &r) {

        mode = r.mode;

        rects = r.rects;

        single = r.single;

        numRects = r.numRects;

        extents = r.extents;

        innerRect = r.innerRect;

        innerArea = r.innerArea;

    }

    inline QRegionPrivate &operator=(const QRegionPrivate &r) {

        mode = r.mode;

        rects = r.rects;

        single = r.single;

        numRects = r.numRects;

        extents = r.extents;

        innerRect = r.innerRect;

        innerArea = r.innerArea;

        return *this;

    }

    /*

     * Returns true if r is guaranteed to be fully contained in this region.

     * A false return value does not guarantee the opposite.

     */

    inline bool contains(const QRegionPrivate &r) const {

        const QRect &r1 = innerRect;

        const QRect &r2 = r.extents;

        return CONTAINSCHECK(r1, r2);

    }

    inline void updateInnerRect(const QRect &rect) {

        const int area = rect.width() * rect.height();

        if (area > innerArea) {

            innerArea = area;

            innerRect = rect;

        }

    }

    void append(const QRegionPrivate *r);

    void prepend(const QRegionPrivate *r);

    inline bool canAppend(const QRegionPrivate *r) const;

    inline bool canPrepend(const QRegionPrivate *r) const;

};

static QRegionPrivate *qt_nextRegionPtr = 0;

static QFastMutex qt_nextRegionLock;

static QRegionPrivate *qt_allocRegionMemory()

{

    QRegionPrivate *rv = 0;

    qt_nextRegionLock.lock();

    if(qt_nextRegionPtr) {

        rv = qt_nextRegionPtr;

        qt_nextRegionPtr = rv->next;

    } else {

        qt_nextRegionPtr = 

            (QRegionPrivate *)malloc(256 * sizeof(QRegionPrivate));

        for(int ii = 0; ii < 256; ++ii) {

            if(ii == 255) {

                qt_nextRegionPtr[ii].next = 0;

            } else {

                qt_nextRegionPtr[ii].next = &qt_nextRegionPtr[ii + 1];

            }

        }

        rv = qt_nextRegionPtr;

        qt_nextRegionPtr = rv->next;

    }

    qt_nextRegionLock.unlock();

    return rv;

}

static void qt_freeRegionMemory(QRegionPrivate *rp)

{

    qt_nextRegionLock.lock();

    rp->next = qt_nextRegionPtr;

    qt_nextRegionPtr = rp;

    qt_nextRegionLock.unlock();

}

static QRegionPrivate *qt_allocRegion()

{

    QRegionPrivate *mem = qt_allocRegionMemory();

    return new (mem) QRegionPrivate;

}

static QRegionPrivate *qt_allocRegion(const QRect &r)

{

    QRegionPrivate *mem = qt_allocRegionMemory();

    return new (mem) QRegionPrivate(r);

}

static QRegionPrivate *qt_allocRegion(const QRegionPrivate &r)

{

    QRegionPrivate *mem = qt_allocRegionMemory();

    return new (mem) QRegionPrivate(r);

}

void qt_freeRegion(QRegionPrivate *rp)

{

    rp->~QRegionPrivate();

    qt_freeRegionMemory(rp);

//    delete rp;

}

static inline bool isEmptyHelper(const QRegionPrivate *preg)

{

    return !preg || preg->numRects == 0;

}

void QRegionPrivate::append(const QRegionPrivate *r)

{

    Q_ASSERT(!isEmptyHelper(r));

    vector();

    QRect *destRect = rects.data() + numRects;

    const QRect *srcRect = (r->mode==Vector)?r->rects.constData():&r->single;

    int numAppend = r->numRects;

    // test for merge in x direction

    {

        const QRect *rFirst = srcRect;

        QRect *myLast = rects.data() + (numRects - 1);

        if (rFirst->top() == myLast->top()

            && rFirst->height() == myLast->height()

            && rFirst->left() == (myLast->right() + 1))

        {

            myLast->setWidth(myLast->width() + rFirst->width());

            updateInnerRect(*myLast);

            ++srcRect;

            --numAppend;

        }

    }

    // append rectangles

    const int newNumRects = numRects + numAppend;

    if (newNumRects > rects.size()) {

        rects.resize(newNumRects);

        destRect = rects.data() + numRects;

    }

    memcpy(destRect, srcRect, numAppend * sizeof(QRect));

    // update inner rectangle

    if (innerArea < r->innerArea) {

        innerArea = r->innerArea;

        innerRect = r->innerRect;

    }

    // update extents

    destRect = &extents;

    srcRect = &r->extents;

    extents.setCoords(qMin(destRect->left(), srcRect->left()),

                      qMin(destRect->top(), srcRect->top()),

                      qMax(destRect->right(), srcRect->right()),

                      qMax(destRect->bottom(), srcRect->bottom()));

    numRects = newNumRects;

}

void QRegionPrivate::prepend(const QRegionPrivate *r)

{

#if 1

    Q_UNUSED(r);

#else

    // XXX ak: does not respect vectorization of region

    Q_ASSERT(!isEmpty(r));

    // move existing rectangles

    memmove(rects.data() + r->numRects, rects.constData(),

            numRects * sizeof(QRect));

    // prepend new rectangles

    memcpy(rects.data(), r->rects.constData(), r->numRects * sizeof(QRect));

    // update inner rectangle

    if (innerArea < r->innerArea) {

        innerArea = r->innerArea;

        innerRect = r->innerRect;

    }

    // update extents

    destRect = &extents;

    srcRect = &r->extents;

    extents.setCoords(qMin(destRect->left(), srcRect->left()),

                      qMin(destRect->top(), srcRect->top()),

                      qMax(destRect->right(), srcRect->right()),

                      qMax(destRect->bottom(), srcRect->bottom()));

    numRects = newNumRects;

#endif

}

bool QRegionPrivate::canAppend(const QRegionPrivate *r) const

{

    Q_ASSERT(!isEmptyHelper(r));

    const QRect *rFirst = (r->mode==Vector)?r->rects.constData():&r->single;

    const QRect *myLast = (mode==Vector)?(rects.constData() + (numRects - 1)):&single;

    // XXX: possible improvements:

    //   - nFirst->top() == myLast->bottom() + 1, must possibly merge bands

    if (rFirst->top() > (myLast->bottom() + 1)

        || (rFirst->top() == myLast->top()

            && rFirst->height() == myLast->height()

            && rFirst->left() > myLast->right()))

    {

        return true;

    }

    return false;

}

bool QRegionPrivate::canPrepend(const QRegionPrivate *r) const

{

#if 1

    Q_UNUSED(r);

    return false;

#else

    return r->canAppend(this);

#endif

}

#if defined(Q_WS_X11)

QT_BEGIN_INCLUDE_NAMESPACE

# include "qregion_x11.cpp"

QT_END_INCLUDE_NAMESPACE

#elif defined(Q_WS_MAC)

QT_BEGIN_INCLUDE_NAMESPACE

# include "qregion_mac.cpp"

QT_END_INCLUDE_NAMESPACE

#elif defined(Q_WS_QWS)

static QRegionPrivate qrp;

QRegion::QRegionData QRegion::shared_empty = {Q_BASIC_ATOMIC_INITIALIZER(1), &qrp};

#endif

typedef void (*OverlapFunc)(register QRegionPrivate &dest, register const QRect *r1, const QRect *r1End,

                            register const QRect *r2, const QRect *r2End, register int y1, register int y2);

typedef void (*NonOverlapFunc)(register QRegionPrivate &dest, register const QRect *r, const QRect *rEnd,

                               register int y1, register int y2);

static bool EqualRegion(const QRegionPrivate *r1, const QRegionPrivate *r2);

static void UnionRegion(const QRegionPrivate *reg1, const QRegionPrivate *reg2, QRegionPrivate &dest);

static void miRegionOp(register QRegionPrivate &dest, const QRegionPrivate *reg1, const QRegionPrivate *reg2,

                       OverlapFunc overlapFunc, NonOverlapFunc nonOverlap1Func,

                       NonOverlapFunc nonOverlap2Func);

#define RectangleOut 0

#define RectangleIn 1

#define RectanglePart 2

#define EvenOddRule 0

#define WindingRule 1

// START OF region.h extract

/* $XConsortium: region.h,v 11.14 94/04/17 20:22:20 rws Exp $ */

/************************************************************************

Copyright (c) 1987  X Consortium

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in

all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of the X Consortium shall not be

used in advertising or otherwise to promote the sale, use or other dealings

in this Software without prior written authorization from the X Consortium.

Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.

                        All Rights Reserved

Permission to use, copy, modify, and distribute this software and its

documentation for any purpose and without fee is hereby granted,

provided that the above copyright notice appear in all copies and that

both that copyright notice and this permission notice appear in

supporting documentation, and that the name of Digital not be

used in advertising or publicity pertaining to distribution of the

software without specific, written prior permission.

DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

SOFTWARE.

************************************************************************/

#ifndef _XREGION_H

#define _XREGION_H

QT_BEGIN_INCLUDE_NAMESPACE

#include <limits.h>

QT_END_INCLUDE_NAMESPACE

/*  1 if two BOXs overlap.

 *  0 if two BOXs do not overlap.

 *  Remember, x2 and y2 are not in the region

 */

#define EXTENTCHECK(r1, r2) \

        ((r1)->right() >= (r2)->left() && \

         (r1)->left() <= (r2)->right() && \

         (r1)->bottom() >= (r2)->top() && \

         (r1)->top() <= (r2)->bottom())

/*

 *  update region extents

 */

#define EXTENTS(r,idRect){\

            if((r)->left() < (idRect)->extents.left())\

              (idRect)->extents.setLeft((r)->left());\

            if((r)->top() < (idRect)->extents.top())\

              (idRect)->extents.setTop((r)->top());\

            if((r)->right() > (idRect)->extents.right())\

              (idRect)->extents.setRight((r)->right());\

            if((r)->bottom() > (idRect)->extents.bottom())\

              (idRect)->extents.setBottom((r)->bottom());\

        }

/*

 *   Check to see if there is enough memory in the present region.

 */

#define MEMCHECK(dest, rect, firstrect){\

        if ((dest).numRects >= ((dest).rects.size()-1)){\

          firstrect.resize(firstrect.size() * 2); \

          (rect) = (firstrect).data() + (dest).numRects;\

        }\

      }

/*

 * number of points to buffer before sending them off

 * to scanlines(): Must be an even number

 */

#define NUMPTSTOBUFFER 200

/*

 * used to allocate buffers for points and link

 * the buffers together

 */

typedef struct _POINTBLOCK {

    QPoint pts[NUMPTSTOBUFFER];

    struct _POINTBLOCK *next;

} POINTBLOCK;

#endif

// END OF region.h extract

// START OF Region.c extract

/* $XConsortium: Region.c /main/30 1996/10/22 14:21:24 kaleb $ */

/************************************************************************

Copyright (c) 1987, 1988  X Consortium

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in

all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of the X Consortium shall not be

used in advertising or otherwise to promote the sale, use or other dealings

in this Software without prior written authorization from the X Consortium.

Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.

                        All Rights Reserved

Permission to use, copy, modify, and distribute this software and its

documentation for any purpose and without fee is hereby granted,

provided that the above copyright notice appear in all copies and that

both that copyright notice and this permission notice appear in

supporting documentation, and that the name of Digital not be