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

**

** 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$

**

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

#include "qregion.h"

#include "qpainterpath.h"

#include "qpolygon.h"

#include "qbuffer.h"

#include "qdatastream.h"

#include "qvariant.h"

#include "qvarlengtharray.h"

#include <qdebug.h>

#if defined(Q_OS_UNIX) || defined(Q_WS_WIN)

#include "qimage.h"

#include "qbitmap.h"

#include <stdlib.h>

#endif

QT_BEGIN_NAMESPACE

/*!

    \class QRegion

    \brief The QRegion class specifies a clip region for a painter.

    \ingroup painting

    \ingroup shared

    QRegion is used with QPainter::setClipRegion() to limit the paint

    area to what needs to be painted. There is also a QWidget::repaint()

    function that takes a QRegion parameter. QRegion is the best tool for

    minimizing the amount of screen area to be updated by a repaint.

    This class is not suitable for constructing shapes for rendering, especially

    as outlines. Use QPainterPath to create paths and shapes for use with

    QPainter.

    QRegion is an \l{implicitly shared} class.

    \section1 Creating and Using Regions

    A region can be created from a rectangle, an ellipse, a polygon or

    a bitmap. Complex regions may be created by combining simple

    regions using united(), intersected(), subtracted(), or xored() (exclusive

    or). You can move a region using translate().

    You can test whether a region isEmpty() or if it

    contains() a QPoint or QRect. The bounding rectangle can be found

    with boundingRect().

    The function rects() gives a decomposition of the region into

    rectangles.

    Example of using complex regions:

    \snippet doc/src/snippets/code/src_gui_painting_qregion.cpp 0

    \section1 Additional License Information

    On Embedded Linux, Windows CE and X11 platforms, parts of this class rely on

    code obtained under the following licenses:

    \legalese

    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.

    \endlegalese

    \br

    \legalese

    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.

    \endlegalese

    \sa QPainter::setClipRegion(), QPainter::setClipRect(), QPainterPath

*/

/*!

    \enum QRegion::RegionType

    Specifies the shape of the region to be created.

    \value Rectangle  the region covers the entire rectangle.

    \value Ellipse  the region is an ellipse inside the rectangle.

*/

/*!

    \fn void QRegion::translate(const QPoint &point)

    \overload

    Translates the region \a{point}\e{.x()} along the x axis and

    \a{point}\e{.y()} along the y axis, relative to the current

    position. Positive values move the region to the right and down.

    Translates to the given \a point.

*/

/*!

    \fn Handle QRegion::handle() const

    Returns a platform-specific region handle. The \c Handle type is

    \c HRGN on Windows, \c Region on X11, and \c RgnHandle on Mac OS

    X. On \l{Qt for Embedded Linux} it is \c {void *}.

    \warning This function is not portable.

*/

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

  QRegion member functions

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

/*!

    \fn QRegion::QRegion()

    Constructs an empty region.

    \sa isEmpty()

*/

/*!

    \fn QRegion::QRegion(const QRect &r, RegionType t)

    \overload

    Create a region based on the rectange \a r with region type \a t.

    If the rectangle is invalid a null region will be created.

    \sa QRegion::RegionType

*/

/*!

    \fn QRegion::QRegion(const QPolygon &a, Qt::FillRule fillRule)

    Constructs a polygon region from the point array \a a with the fill rule

    specified by \a fillRule.

    If \a fillRule is \l{Qt::WindingFill}, the polygon region is defined

    using the winding algorithm; if it is \l{Qt::OddEvenFill}, the odd-even fill

    algorithm is used.

    \warning This constructor can be used to create complex regions that will

    slow down painting when used.

*/

/*!

    \fn QRegion::QRegion(const QRegion &r)

    Constructs a new region which is equal to region \a r.

*/

/*!

    \fn QRegion::QRegion(const QBitmap &bm)

    Constructs a region from the bitmap \a bm.

    The resulting region consists of the pixels in bitmap \a bm that

    are Qt::color1, as if each pixel was a 1 by 1 rectangle.

    This constructor may create complex regions that will slow down

    painting when used. Note that drawing masked pixmaps can be done

    much faster using QPixmap::setMask().

*/

/*!

    Constructs a rectangular or elliptic region.

    If \a t is \c Rectangle, the region is the filled rectangle (\a x,

    \a y, \a w, \a h). If \a t is \c Ellipse, the region is the filled

    ellipse with center at (\a x + \a w / 2, \a y + \a h / 2) and size

    (\a w ,\a h).

*/

QRegion::QRegion(int x, int y, int w, int h, RegionType t)

{

    QRegion tmp(QRect(x, y, w, h), t);

    tmp.d->ref.ref();

    d = tmp.d;

}

#ifdef QT3_SUPPORT

/*!

    Use the constructor tha takes a Qt::FillRule as the second

    argument instead.

*/

QRegion::QRegion(const QPolygon &pa, bool winding)

{

    new (this) QRegion(pa, winding ? Qt::WindingFill : Qt::OddEvenFill);

}

#endif

/*!

    \fn QRegion::~QRegion()

    \internal

    Destroys the region.

*/

void QRegion::detach()

{

    if (d->ref != 1)

        *this = copy();

#if defined(Q_WS_X11)

    else if (d->xrectangles) {

        free(d->xrectangles);

        d->xrectangles = 0;

    }

#endif

}

// duplicates in qregion_win.cpp and qregion_wce.cpp

#define QRGN_SETRECT          1                // region stream commands

#define QRGN_SETELLIPSE       2                //  (these are internal)

#define QRGN_SETPTARRAY_ALT   3

#define QRGN_SETPTARRAY_WIND  4

#define QRGN_TRANSLATE        5

#define QRGN_OR               6

#define QRGN_AND              7

#define QRGN_SUB              8

#define QRGN_XOR              9

#define QRGN_RECTS            10

#ifndef QT_NO_DATASTREAM

/*

    Executes region commands in the internal buffer and rebuilds the

    original region.

    We do this when we read a region from the data stream.

    If \a ver is non-0, uses the format version \a ver on reading the

    byte array.

*/

void QRegion::exec(const QByteArray &buffer, int ver, QDataStream::ByteOrder byteOrder)

{

    QByteArray copy = buffer;

    QDataStream s(&copy, QIODevice::ReadOnly);

    if (ver)

        s.setVersion(ver);

    s.setByteOrder(byteOrder);

    QRegion rgn;

#ifndef QT_NO_DEBUG

    int test_cnt = 0;

#endif

    while (!s.atEnd()) {

        qint32 id;

        if (s.version() == 1) {

            int id_int;

            s >> id_int;

            id = id_int;

        } else {

            s >> id;

        }

#ifndef QT_NO_DEBUG

        if (test_cnt > 0 && id != QRGN_TRANSLATE)

            qWarning("QRegion::exec: Internal error");

        test_cnt++;

#endif

        if (id == QRGN_SETRECT || id == QRGN_SETELLIPSE) {

            QRect r;

            s >> r;

            rgn = QRegion(r, id == QRGN_SETRECT ? Rectangle : Ellipse);

        } else if (id == QRGN_SETPTARRAY_ALT || id == QRGN_SETPTARRAY_WIND) {

            QPolygon a;

            s >> a;

            rgn = QRegion(a, id == QRGN_SETPTARRAY_WIND ? Qt::WindingFill : Qt::OddEvenFill);

        } else if (id == QRGN_TRANSLATE) {

            QPoint p;

            s >> p;

            rgn.translate(p.x(), p.y());

        } else if (id >= QRGN_OR && id <= QRGN_XOR) {

            QByteArray bop1, bop2;

            QRegion r1, r2;

            s >> bop1;

            r1.exec(bop1);

            s >> bop2;

            r2.exec(bop2);

            switch (id) {

                case QRGN_OR:

                    rgn = r1.united(r2);

                    break;

                case QRGN_AND:

                    rgn = r1.intersected(r2);

                    break;

                case QRGN_SUB:

                    rgn = r1.subtracted(r2);

                    break;

                case QRGN_XOR:

                    rgn = r1.xored(r2);

                    break;

            }

        } else if (id == QRGN_RECTS) {

            // (This is the only form used in Qt 2.0)

            quint32 n;

            s >> n;

            QRect r;

            for (int i=0; i<(int)n; i++) {

                s >> r;

                rgn = rgn.united(QRegion(r));

            }

        }

    }

    *this = rgn;

}

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

  QRegion stream functions

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

/*!

    \fn QRegion &QRegion::operator=(const QRegion &r)

    Assigns \a r to this region and returns a reference to the region.

*/

/*!

    \relates QRegion

    Writes the region \a r to the stream \a s and returns a reference

    to the stream.

    \sa \link datastreamformat.html Format of the QDataStream operators \endlink

*/

QDataStream &operator<<(QDataStream &s, const QRegion &r)

{

    QVector<QRect> a = r.rects();

    if (a.isEmpty()) {

        s << (quint32)0;

    } else {

        if (s.version() == 1) {

            int i;

            for (i = a.size() - 1; i > 0; --i) {

                s << (quint32)(12 + i * 24);

                s << (int)QRGN_OR;

            }

            for (i = 0; i < a.size(); ++i) {

                s << (quint32)(4+8) << (int)QRGN_SETRECT << a[i];

            }

        } else {

            s << (quint32)(4 + 4 + 16 * a.size()); // 16: storage size of QRect

            s << (qint32)QRGN_RECTS;

            s << a;

        }

    }

    return s;

}

/*!

    \relates QRegion

    Reads a region from the stream \a s into \a r and returns a

    reference to the stream.

    \sa \link datastreamformat.html Format of the QDataStream operators \endlink

*/

QDataStream &operator>>(QDataStream &s, QRegion &r)

{

    QByteArray b;

    s >> b;

    r.exec(b, s.version(), s.byteOrder());

    return s;

}

#endif //QT_NO_DATASTREAM

#ifndef QT_NO_DEBUG_STREAM

QDebug operator<<(QDebug s, const QRegion &r)

{

    QVector<QRect> rects = r.rects();

    s.nospace() << "QRegion(size=" << rects.size() << "), "

                << "bounds = " << r.boundingRect() << '\n';

    for (int i=0; i<rects.size(); ++i)

        s << "- " << i << rects.at(i) << '\n';

    return s;

}

#endif

// These are not inline - they can be implemented better on some platforms

//  (eg. Windows at least provides 3-variable operations).  For now, simple.

/*!

    Applies the united() function to this region and \a r. \c r1|r2 is

    equivalent to \c r1.united(r2).

    \sa united(), operator+()

*/

const QRegion QRegion::operator|(const QRegion &r) const

    { return united(r); }

/*!

    Applies the united() function to this region and \a r. \c r1+r2 is

    equivalent to \c r1.united(r2).

    \sa united(), operator|()

*/

const QRegion QRegion::operator+(const QRegion &r) const

    { return united(r); }

/*!

   \overload

   \since 4.4

 */

const QRegion QRegion::operator+(const QRect &r) const

    { return united(r); }

/*!

    Applies the intersected() function to this region and \a r. \c r1&r2

    is equivalent to \c r1.intersected(r2).

    \sa intersected()

*/

const QRegion QRegion::operator&(const QRegion &r) const

    { return intersected(r); }

/*!

   \overload

   \since 4.4

 */

const QRegion QRegion::operator&(const QRect &r) const

{

    return intersected(r);

}

/*!

    Applies the subtracted() function to this region and \a r. \c r1-r2

    is equivalent to \c r1.subtracted(r2).

    \sa subtracted()

*/

const QRegion QRegion::operator-(const QRegion &r) const

    { return subtracted(r); }

/*!

    Applies the xored() function to this region and \a r. \c r1^r2 is

    equivalent to \c r1.xored(r2).

    \sa xored()

*/

const QRegion QRegion::operator^(const QRegion &r) const

    { return xored(r); }

/*!

    Applies the united() function to this region and \a r and assigns

    the result to this region. \c r1|=r2 is equivalent to \c

    {r1 = r1.united(r2)}.

    \sa united()

*/