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

**

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

#include "qpainter_p.h"

#include "qstroker_p.h"

#include "qbezier_p.h"

#include <private/qpainterpath_p.h>

#include <qvarlengtharray.h>

#include <qdebug.h>

QT_BEGIN_NAMESPACE

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

 *

 * class QVectorPath

 *

 */

QVectorPath::~QVectorPath()

{

    if (m_hints & ShouldUseCacheHint) {

        CacheEntry *e = m_cache;

        while (e) {

            if (e->data)

                e->cleanup(e->engine, e->data);

            CacheEntry *n = e->next;

            delete e;

            e = n;

        }

    }

}

QRectF QVectorPath::controlPointRect() const

{

    if (m_hints & ControlPointRect)

        return QRectF(QPointF(m_cp_rect.x1, m_cp_rect.y1), QPointF(m_cp_rect.x2, m_cp_rect.y2));

    if (m_count == 0) {

        m_cp_rect.x1 = m_cp_rect.x2 = m_cp_rect.y1 = m_cp_rect.y2 = 0;

        m_hints |= ControlPointRect;

        return QRectF(QPointF(m_cp_rect.x1, m_cp_rect.y1), QPointF(m_cp_rect.x2, m_cp_rect.y2));

    }

    Q_ASSERT(m_points && m_count > 0);

    const qreal *pts = m_points;

    m_cp_rect.x1 = m_cp_rect.x2 = *pts;

    ++pts;

    m_cp_rect.y1 = m_cp_rect.y2 = *pts;

    ++pts;

    const qreal *epts = m_points + (m_count << 1);

    while (pts < epts) {

        qreal x = *pts;

        if (x < m_cp_rect.x1) m_cp_rect.x1 = x;

        else if (x > m_cp_rect.x2) m_cp_rect.x2 = x;

        ++pts;

        qreal y = *pts;

        if (y < m_cp_rect.y1) m_cp_rect.y1 = y;

        else if (y > m_cp_rect.y2) m_cp_rect.y2 = y;

        ++pts;

    }

    m_hints |= ControlPointRect;

    return QRectF(QPointF(m_cp_rect.x1, m_cp_rect.y1), QPointF(m_cp_rect.x2, m_cp_rect.y2));

}

QVectorPath::CacheEntry *QVectorPath::addCacheData(QPaintEngineEx *engine, void *data,

                                                   qvectorpath_cache_cleanup cleanup) const{

    Q_ASSERT(!lookupCacheData(engine));

    if ((m_hints & IsCachedHint) == 0) {

        m_cache = 0;

        m_hints |= IsCachedHint;

    }

    CacheEntry *e = new CacheEntry;

    e->engine = engine;

    e->data = data;

    e->cleanup = cleanup;

    e->next = m_cache;

    m_cache = e;

    return m_cache;

}

const QVectorPath &qtVectorPathForPath(const QPainterPath &path)

{

    Q_ASSERT(path.d_func());

    return path.d_func()->vectorPath();

}

#ifndef QT_NO_DEBUG_STREAM

QDebug Q_GUI_EXPORT &operator<<(QDebug &s, const QVectorPath &path)

{

    QRectF rf = path.controlPointRect();

    s << "QVectorPath(size:" << path.elementCount()

      << " hints:" << hex << path.hints()

      << rf << ')';

    return s;

}

#endif

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

 *

 * class QPaintEngineExPrivate:

 *

 */

struct StrokeHandler {

    QDataBuffer<qreal> pts;

    QDataBuffer<QPainterPath::ElementType> types;

};

QPaintEngineExPrivate::QPaintEngineExPrivate()

    : dasher(&stroker),

      strokeHandler(0),

      activeStroker(0),

      strokerPen(Qt::NoPen)

{

}

QPaintEngineExPrivate::~QPaintEngineExPrivate()

{

    delete strokeHandler;

}

void QPaintEngineExPrivate::replayClipOperations()

{

    Q_Q(QPaintEngineEx);

    QPainter *p = q->painter();

    if (!p || !p->d_ptr)

        return;

    QList<QPainterClipInfo> clipInfo = p->d_ptr->state->clipInfo;

    QTransform transform = q->state()->matrix;

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

        const QPainterClipInfo &info = clipInfo.at(i);

        if (info.matrix != q->state()->matrix) {

            q->state()->matrix = info.matrix;

            q->transformChanged();

        }

        switch (info.clipType) {

        case QPainterClipInfo::RegionClip:

            q->clip(info.region, info.operation);

            break;

        case QPainterClipInfo::PathClip:

            q->clip(info.path, info.operation);

            break;

        case QPainterClipInfo::RectClip:

            q->clip(info.rect, info.operation);

            break;

        case QPainterClipInfo::RectFClip: {

            qreal right = info.rectf.x() + info.rectf.width();

            qreal bottom = info.rectf.y() + info.rectf.height();

            qreal pts[] = { info.rectf.x(), info.rectf.y(),

                            right, info.rectf.y(),

                            right, bottom,

                            info.rectf.x(), bottom };

            QVectorPath vp(pts, 4, 0, QVectorPath::RectangleHint);

            q->clip(vp, info.operation);

            break;

            }

        }

    }

    if (transform != q->state()->matrix) {

        q->state()->matrix = transform;

        q->transformChanged();

    }

}

bool QPaintEngineExPrivate::hasClipOperations() const

{

    Q_Q(const QPaintEngineEx);

    QPainter *p = q->painter();

    if (!p || !p->d_ptr)

        return false;

    QList<QPainterClipInfo> clipInfo = p->d_ptr->state->clipInfo;

    return !clipInfo.isEmpty();

}

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

 *

 * class QPaintEngineEx:

 *

 */

static QPainterPath::ElementType qpaintengineex_ellipse_types[] = {

    QPainterPath::MoveToElement,

    QPainterPath::CurveToElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::CurveToElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::CurveToElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::CurveToElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::CurveToDataElement

};

static QPainterPath::ElementType qpaintengineex_line_types_16[] = {

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement,

    QPainterPath::MoveToElement, QPainterPath::LineToElement

};

static QPainterPath::ElementType qpaintengineex_rect4_types_32[] = {

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 1

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 2

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 3

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 4

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 5

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 6

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 7

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 8

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 9

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 10

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 11

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 12

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 13

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 14

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 15

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 16

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 17

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 18

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 19

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 20

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 21

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 22

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 23

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 24

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 25

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 26

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 27

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 28

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 29

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 30

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 31

    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 32

};

static QPainterPath::ElementType qpaintengineex_roundedrect_types[] = {

    QPainterPath::MoveToElement,

    QPainterPath::LineToElement,

    QPainterPath::CurveToElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::LineToElement,

    QPainterPath::CurveToElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::LineToElement,

    QPainterPath::CurveToElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::LineToElement,

    QPainterPath::CurveToElement,

    QPainterPath::CurveToDataElement,

    QPainterPath::CurveToDataElement

};

static void qpaintengineex_moveTo(qreal x, qreal y, void *data) {

    ((StrokeHandler *) data)->pts.add(x);

    ((StrokeHandler *) data)->pts.add(y);

    ((StrokeHandler *) data)->types.add(QPainterPath::MoveToElement);

}

static void qpaintengineex_lineTo(qreal x, qreal y, void *data) {

    ((StrokeHandler *) data)->pts.add(x);

    ((StrokeHandler *) data)->pts.add(y);

    ((StrokeHandler *) data)->types.add(QPainterPath::LineToElement);

}

static void qpaintengineex_cubicTo(qreal c1x, qreal c1y, qreal c2x, qreal c2y, qreal ex, qreal ey, void *data) {

    ((StrokeHandler *) data)->pts.add(c1x);

    ((StrokeHandler *) data)->pts.add(c1y);

    ((StrokeHandler *) data)->types.add(QPainterPath::CurveToElement);

    ((StrokeHandler *) data)->pts.add(c2x);

    ((StrokeHandler *) data)->pts.add(c2y);

    ((StrokeHandler *) data)->types.add(QPainterPath::CurveToDataElement);

    ((StrokeHandler *) data)->pts.add(ex);

    ((StrokeHandler *) data)->pts.add(ey);

    ((StrokeHandler *) data)->types.add(QPainterPath::CurveToDataElement);

}

QPaintEngineEx::QPaintEngineEx()

    : QPaintEngine(*new QPaintEngineExPrivate, AllFeatures)

{

    extended = true;

}

QPaintEngineEx::QPaintEngineEx(QPaintEngineExPrivate &data)

    : QPaintEngine(data, AllFeatures)

{

    extended = true;

}

QPainterState *QPaintEngineEx::createState(QPainterState *orig) const

{

    if (!orig)

        return new QPainterState;

    return new QPainterState(orig);

}

extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp

void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)

{

#ifdef QT_DEBUG_DRAW

    qDebug() << "QPaintEngineEx::stroke()" << pen;

#endif

    Q_D(QPaintEngineEx);

    if (path.isEmpty())

        return;

    if (!d->strokeHandler) {

        d->strokeHandler = new StrokeHandler;

        d->stroker.setMoveToHook(qpaintengineex_moveTo);

        d->stroker.setLineToHook(qpaintengineex_lineTo);

        d->stroker.setCubicToHook(qpaintengineex_cubicTo);

    }

    if (!qpen_fast_equals(pen, d->strokerPen)) {

        d->strokerPen = pen;

        d->stroker.setJoinStyle(pen.joinStyle());

        d->stroker.setCapStyle(pen.capStyle());

        d->stroker.setMiterLimit(pen.miterLimit());

        qreal penWidth = pen.widthF();

        if (penWidth == 0)

            d->stroker.setStrokeWidth(1);

        else

            d->stroker.setStrokeWidth(penWidth);

        Qt::PenStyle style = pen.style();

        if (style == Qt::SolidLine) {

            d->activeStroker = &d->stroker;

        } else if (style == Qt::NoPen) {

            d->activeStroker = 0;

        } else {

            d->dasher.setDashPattern(pen.dashPattern());

            d->dasher.setDashOffset(pen.dashOffset());

            d->activeStroker = &d->dasher;

        }

    }

    if (!d->activeStroker) {

        return;

    }

    const QPainterPath::ElementType *types = path.elements();

    const qreal *points = path.points();

    int pointCount = path.elementCount();

    const qreal *lastPoint = points + (pointCount<<1);

    d->strokeHandler->types.reset();

    d->strokeHandler->pts.reset();

    // Some engines might decide to optimize for the non-shape hint later on...

    uint flags = QVectorPath::WindingFill;

    if (path.elementCount() > 2)

        flags |= QVectorPath::NonConvexShapeMask;

    if (d->stroker.capStyle() == Qt::RoundCap || d->stroker.joinStyle() == Qt::RoundJoin)

        flags |= QVectorPath::CurvedShapeMask;

    // ### Perspective Xforms are currently not supported...

    if (!pen.isCosmetic()) {

        // We include cosmetic pens in this case to avoid having to

        // change the current transform. Normal transformed,

        // non-cosmetic pens will be transformed as part of fill

        // later, so they are also covered here..

        d->activeStroker->begin(d->strokeHandler);

        if (types) {

            while (points < lastPoint) {

                switch (*types) {

                case QPainterPath::MoveToElement:

                    d->activeStroker->moveTo(points[0], points[1]);

                    points += 2;

                    ++types;

                    break;

                case QPainterPath::LineToElement:

                    d->activeStroker->lineTo(points[0], points[1]);

                    points += 2;

                    ++types;

                    break;

                case QPainterPath::CurveToElement:

                    d->activeStroker->cubicTo(points[0], points[1],

                                              points[2], points[3],

                                              points[4], points[5]);

                    points += 6;

                    types += 3;

                    flags |= QVectorPath::CurvedShapeMask;

                    break;

                default:

                    break;

                }

            }

            if (path.hasImplicitClose())

                d->activeStroker->lineTo(path.points()[0], path.points()[1]);

        } else {

            d->activeStroker->moveTo(points[0], points[1]);

            points += 2;

            ++types;

            while (points < lastPoint) {

                d->activeStroker->lineTo(points[0], points[1]);

                points += 2;

                ++types;

            }

            if (path.hasImplicitClose())

                d->activeStroker->lineTo(path.points()[0], path.points()[1]);

        }

        d->activeStroker->end();

        if (!d->strokeHandler->types.size()) // an empty path...

            return;

        QVectorPath strokePath(d->strokeHandler->pts.data(),

                               d->strokeHandler->types.size(),

                               d->strokeHandler->types.data(),

                               flags);

        fill(strokePath, pen.brush());

    } else {

        // For cosmetic pens we need a bit of trickery... We to process xform the input points

        if (state()->matrix.type() >= QTransform::TxProject) {

            QPainterPath painterPath = state()->matrix.map(path.convertToPainterPath());

            d->activeStroker->strokePath(painterPath, d->strokeHandler, QTransform());

        } else {

            d->activeStroker->begin(d->strokeHandler);

            if (types) {

                while (points < lastPoint) {

                    switch (*types) {

                    case QPainterPath::MoveToElement: {