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

**

** 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 "qpainterpath.h"

#include "qpainterpath_p.h"

#include <qbitmap.h>

#include <qdebug.h>

#include <qiodevice.h>

#include <qlist.h>

#include <qmatrix.h>

#include <qpen.h>

#include <qpolygon.h>

#include <qtextlayout.h>

#include <qvarlengtharray.h>

#include <qmath.h>

#include <private/qbezier_p.h>

#include <private/qfontengine_p.h>

#include <private/qnumeric_p.h>

#include <private/qobject_p.h>

#include <private/qpathclipper_p.h>

#include <private/qstroker_p.h>

#include <private/qtextengine_p.h>

#include <limits.h>

#if 0

#include <performance.h>

#else

#define PM_INIT

#define PM_MEASURE(x)

#define PM_DISPLAY

#endif

QT_BEGIN_NAMESPACE

struct QPainterPathPrivateDeleter

{

    static inline void cleanup(QPainterPathPrivate *d)

    {

        // note - we must up-cast to QPainterPathData since QPainterPathPrivate

        // has a non-virtual destructor!

        if (d && !d->ref.deref())

            delete static_cast<QPainterPathData *>(d);

    }

};

// This value is used to determine the length of control point vectors

// when approximating arc segments as curves. The factor is multiplied

// with the radius of the circle.

// #define QPP_DEBUG

// #define QPP_STROKE_DEBUG

//#define QPP_FILLPOLYGONS_DEBUG

QPainterPath qt_stroke_dash(const QPainterPath &path, qreal *dashes, int dashCount);

void qt_find_ellipse_coords(const QRectF &r, qreal angle, qreal length,

                            QPointF* startPoint, QPointF *endPoint)

{

    if (r.isNull()) {

        if (startPoint)

            *startPoint = QPointF();

        if (endPoint)

            *endPoint = QPointF();

        return;

    }

    qreal w2 = r.width() / 2;

    qreal h2 = r.height() / 2;

    qreal angles[2] = { angle, angle + length };

    QPointF *points[2] = { startPoint, endPoint };

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

        if (!points[i])

            continue;

        qreal theta = angles[i] - 360 * qFloor(angles[i] / 360);

        qreal t = theta / 90;

        // truncate

        int quadrant = int(t);

        t -= quadrant;

        t = qt_t_for_arc_angle(90 * t);

        // swap x and y?

        if (quadrant & 1)

            t = 1 - t;

        qreal a, b, c, d;

        QBezier::coefficients(t, a, b, c, d);

        QPointF p(a + b + c*QT_PATH_KAPPA, d + c + b*QT_PATH_KAPPA);

        // left quadrants

        if (quadrant == 1 || quadrant == 2)

            p.rx() = -p.x();

        // top quadrants

        if (quadrant == 0 || quadrant == 1)

            p.ry() = -p.y();

        *points[i] = r.center() + QPointF(w2 * p.x(), h2 * p.y());

    }

}

#ifdef QPP_DEBUG

static void qt_debug_path(const QPainterPath &path)

{

    const char *names[] = {

        "MoveTo     ",

        "LineTo     ",

        "CurveTo    ",

        "CurveToData"

    };

    printf("\nQPainterPath: elementCount=%d\n", path.elementCount());

    for (int i=0; i<path.elementCount(); ++i) {

        const QPainterPath::Element &e = path.elementAt(i);

        Q_ASSERT(e.type >= 0 && e.type <= QPainterPath::CurveToDataElement);

        printf(" - %3d:: %s, (%.2f, %.2f)\n", i, names[e.type], e.x, e.y);

    }

}

#endif

/*!

    \class QPainterPath

    \ingroup painting

    \ingroup shared

    \brief The QPainterPath class provides a container for painting operations,

    enabling graphical shapes to be constructed and reused.

    A painter path is an object composed of a number of graphical

    building blocks, such as rectangles, ellipses, lines, and curves.

    Building blocks can be joined in closed subpaths, for example as a

    rectangle or an ellipse. A closed path has coinciding start and

    end points. Or they can exist independently as unclosed subpaths,

    such as lines and curves.

    A QPainterPath object can be used for filling, outlining, and

    clipping. To generate fillable outlines for a given painter path,

    use the QPainterPathStroker class.  The main advantage of painter

    paths over normal drawing operations is that complex shapes only

    need to be created once; then they can be drawn many times using

    only calls to the QPainter::drawPath() function.

    QPainterPath provides a collection of functions that can be used

    to obtain information about the path and its elements. In addition

    it is possible to reverse the order of the elements using the

    toReversed() function. There are also several functions to convert

    this painter path object into a polygon representation.

    \tableofcontents

    \section1 Composing a QPainterPath

    A QPainterPath object can be constructed as an empty path, with a

    given start point, or as a copy of another QPainterPath object.

    Once created, lines and curves can be added to the path using the

    lineTo(), arcTo(), cubicTo() and quadTo() functions. The lines and

    curves stretch from the currentPosition() to the position passed

    as argument.

    The currentPosition() of the QPainterPath object is always the end

    position of the last subpath that was added (or the initial start

    point). Use the moveTo() function to move the currentPosition()

    without adding a component. The moveTo() function implicitly

    starts a new subpath, and closes the previous one.  Another way of

    starting a new subpath is to call the closeSubpath() function

    which closes the current path by adding a line from the

    currentPosition() back to the path's start position. Note that the

    new path will have (0, 0) as its initial currentPosition().

    QPainterPath class also provides several convenience functions to

    add closed subpaths to a painter path: addEllipse(), addPath(),

    addRect(), addRegion() and addText(). The addPolygon() function

    adds an \e unclosed subpath. In fact, these functions are all

    collections of moveTo(), lineTo() and cubicTo() operations.

    In addition, a path can be added to the current path using the

    connectPath() function. But note that this function will connect

    the last element of the current path to the first element of given

    one by adding a line.

    Below is a code snippet that shows how a QPainterPath object can

    be used:

    \table 100%

    \row

    \o \inlineimage qpainterpath-construction.png

    \o

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

    \endtable

    The painter path is initially empty when constructed. We first add

    a rectangle, which is a closed subpath. Then we add two bezier

    curves which together form a closed subpath even though they are

    not closed individually. Finally we draw the entire path. The path

    is filled using the default fill rule, Qt::OddEvenFill. Qt

    provides two methods for filling paths:

    \table

    \row

    \o \inlineimage qt-fillrule-oddeven.png

    \o \inlineimage qt-fillrule-winding.png

    \header

    \o Qt::OddEvenFill

    \o Qt::WindingFill

    \endtable

    See the Qt::FillRule documentation for the definition of the

    rules. A painter path's currently set fill rule can be retrieved

    using the fillRule() function, and altered using the setFillRule()

    function.

    \section1 QPainterPath Information

    The QPainterPath class provides a collection of functions that

    returns information about the path and its elements.

    The currentPosition() function returns the end point of the last

    subpath that was added (or the initial start point). The

    elementAt() function can be used to retrieve the various subpath

    elements, the \e number of elements can be retrieved using the

    elementCount() function, and the isEmpty() function tells whether

    this QPainterPath object contains any elements at all.

    The controlPointRect() function returns the rectangle containing

    all the points and control points in this path. This function is

    significantly faster to compute than the exact boundingRect()

    which returns the bounding rectangle of this painter path with

    floating point precision.

    Finally, QPainterPath provides the contains() function which can

    be used to determine whether a given point or rectangle is inside

    the path, and the intersects() function which determines if any of

    the points inside a given rectangle also are inside this path.

    \section1 QPainterPath Conversion

    For compatibility reasons, it might be required to simplify the

    representation of a painter path: QPainterPath provides the

    toFillPolygon(), toFillPolygons() and toSubpathPolygons()

    functions which convert the painter path into a polygon. The

    toFillPolygon() returns the painter path as one single polygon,

    while the two latter functions return a list of polygons.

    The toFillPolygons() and toSubpathPolygons() functions are

    provided because it is usually faster to draw several small

    polygons than to draw one large polygon, even though the total

    number of points drawn is the same. The difference between the two

    is the \e number of polygons they return: The toSubpathPolygons()

    creates one polygon for each subpath regardless of intersecting

    subpaths (i.e. overlapping bounding rectangles), while the

    toFillPolygons() functions creates only one polygon for

    overlapping subpaths.

    The toFillPolygon() and toFillPolygons() functions first convert

    all the subpaths to polygons, then uses a rewinding technique to

    make sure that overlapping subpaths can be filled using the

    correct fill rule. Note that rewinding inserts additional lines in

    the polygon so the outline of the fill polygon does not match the

    outline of the path.

    \section1 Examples

    Qt provides the \l {painting/painterpaths}{Painter Paths Example}

    and the \l {demos/deform}{Vector Deformation Demo} which are

    located in Qt's example and demo directories respectively.

    The \l {painting/painterpaths}{Painter Paths Example} shows how

    painter paths can be used to build complex shapes for rendering

    and lets the user experiment with the filling and stroking.  The

    \l {demos/deform}{Vector Deformation Demo} shows how to use

    QPainterPath to draw text.

    \table

    \row

    \o \inlineimage qpainterpath-example.png

    \o \inlineimage qpainterpath-demo.png

    \header

    \o \l {painting/painterpaths}{Painter Paths Example}

    \o \l {demos/deform}{Vector Deformation Demo}

    \endtable

    \sa QPainterPathStroker, QPainter, QRegion, {Painter Paths Example}

*/

/*!

    \enum QPainterPath::ElementType

    This enum describes the types of elements used to connect vertices

    in subpaths.

    Note that elements added as closed subpaths using the

    addEllipse(), addPath(), addPolygon(), addRect(), addRegion() and

    addText() convenience functions, is actually added to the path as

    a collection of separate elements using the moveTo(), lineTo() and

    cubicTo() functions.

    \value MoveToElement          A new subpath. See also moveTo().

    \value LineToElement            A line. See also lineTo().

    \value CurveToElement         A curve. See also cubicTo() and quadTo().

    \value CurveToDataElement  The extra data required to describe a curve in

                                               a CurveToElement element.

    \sa elementAt(),  elementCount()

*/

/*!

    \class QPainterPath::Element

    \brief The QPainterPath::Element class specifies the position and

    type of a subpath.

    Once a QPainterPath object is constructed, subpaths like lines and

    curves can be added to the path (creating

    QPainterPath::LineToElement and QPainterPath::CurveToElement

    components).

    The lines and curves stretch from the currentPosition() to the

    position passed as argument. The currentPosition() of the

    QPainterPath object is always the end position of the last subpath

    that was added (or the initial start point). The moveTo() function

    can be used to move the currentPosition() without adding a line or

    curve, creating a QPainterPath::MoveToElement component.

    \sa QPainterPath

*/

/*!

    \variable QPainterPath::Element::x

    \brief the x coordinate of the element's position.

    \sa {operator QPointF()}

*/

/*!

    \variable QPainterPath::Element::y

    \brief the y coordinate of the element's position.

    \sa {operator QPointF()}

*/

/*!

    \variable QPainterPath::Element::type

    \brief the type of element

    \sa isCurveTo(), isLineTo(), isMoveTo()

*/

/*!

    \fn bool QPainterPath::Element::operator==(const Element &other) const

    \since 4.2

    Returns true if this element is equal to \a other;

    otherwise returns false.

    \sa operator!=()

*/

/*!

    \fn bool QPainterPath::Element::operator!=(const Element &other) const

    \since 4.2

    Returns true if this element is not equal to \a other;

    otherwise returns false.

    \sa operator==()

*/

/*!

    \fn bool QPainterPath::Element::isCurveTo () const

    Returns true if the element is a curve, otherwise returns false.

    \sa type, QPainterPath::CurveToElement

*/

/*!

    \fn bool QPainterPath::Element::isLineTo () const

    Returns true if the element is a line, otherwise returns false.

    \sa type, QPainterPath::LineToElement

*/

/*!

    \fn bool QPainterPath::Element::isMoveTo () const

    Returns true if the element is moving the current position,

    otherwise returns false.

    \sa type, QPainterPath::MoveToElement

*/

/*!

    \fn QPainterPath::Element::operator QPointF () const

    Returns the element's position.

    \sa x, y

*/

/*!

    \fn void QPainterPath::addEllipse(qreal x, qreal y, qreal width, qreal height)

    \overload

    Creates an ellipse within the bounding rectangle defined by its top-left

    corner at (\a x, \a y), \a width and \a height, and adds it to the

    painter path as a closed subpath.

*/

/*!

    \since 4.4

    \fn void QPainterPath::addEllipse(const QPointF &center, qreal rx, qreal ry)

    \overload

    Creates an ellipse positioned at \a{center} with radii \a{rx} and \a{ry},

    and adds it to the painter path as a closed subpath.

*/

/*!

    \fn void QPainterPath::addText(qreal x, qreal y, const QFont &font, const QString &text)

    \overload

    Adds the given \a text to this path as a set of closed subpaths created

    from the \a font supplied. The subpaths are positioned so that the left

    end of the text's baseline lies at the point specified by (\a x, \a y).

*/

/*!

    \fn int QPainterPath::elementCount() const

    Returns the number of path elements in the painter path.

    \sa ElementType, elementAt(), isEmpty()

*/

/*!

    \fn const QPainterPath::Element &QPainterPath::elementAt(int index) const

    Returns the element at the given \a index in the painter path.

    \sa ElementType, elementCount(), isEmpty()

*/

/*!

    \fn void QPainterPath::setElementPositionAt(int index, qreal x, qreal y)

    \since 4.2

    Sets the x and y coordinate of the element at index \a index to \a

    x and \a y.

*/

/*###

    \fn QPainterPath &QPainterPath::operator +=(const QPainterPath &other)

    Appends the \a other painter path to this painter path and returns a

    reference to the result.

*/

/*!

    Constructs an empty QPainterPath object.

*/

QPainterPath::QPainterPath()

    : d_ptr(0)

{

}

/*!

    \fn QPainterPath::QPainterPath(const QPainterPath &path)

    Creates a QPainterPath object that is a copy of the given \a path.

    \sa operator=()

*/

QPainterPath::QPainterPath(const QPainterPath &other)

    : d_ptr(other.d_ptr.data())

{

    if (d_ptr)

        d_ptr->ref.ref();

}

/*!

    Creates a QPainterPath object with the given \a startPoint as its

    current position.