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

**

** 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 <qmath.h>

#include <private/qpainterpath_p.h>

#include <private/qpaintbuffer_p.h>

//#include <private/qtextengine_p.h>

#include <private/qfontengine_p.h>

#include <private/qemulationpaintengine_p.h>

#include <private/qimage_p.h>

#include <qstatictext.h>

#include <private/qstatictext_p.h>

#include <QDebug>

// #define QPAINTBUFFER_DEBUG_DRAW

QT_BEGIN_NAMESPACE

Q_GUI_EXPORT extern int qt_defaultDpiX();

Q_GUI_EXPORT extern int qt_defaultDpiY();

extern void qt_format_text(const QFont &font,

                           const QRectF &_r, int tf, const QTextOption *option, const QString& str, QRectF *brect,

                           int tabstops, int* tabarray, int tabarraylen,

                           QPainter *painter);

QTextItemIntCopy::QTextItemIntCopy(const QTextItem &item)

    : m_item(static_cast<const QTextItemInt &>(item))

{

    QChar *chars = new QChar[m_item.num_chars];

    unsigned short *logClusters = new unsigned short[m_item.num_chars];

    memcpy(chars, m_item.chars, m_item.num_chars * sizeof(QChar));

    memcpy(logClusters, m_item.logClusters, m_item.num_chars * sizeof(unsigned short));

    m_item.chars = chars;

    m_item.logClusters = logClusters;

    const int size = QGlyphLayout::spaceNeededForGlyphLayout(m_item.glyphs.numGlyphs);

    char *glyphLayoutData = new char[size];

    QGlyphLayout glyphs(glyphLayoutData, m_item.glyphs.numGlyphs);

    memcpy(glyphs.offsets, m_item.glyphs.offsets, m_item.glyphs.numGlyphs * sizeof(QFixedPoint));

    memcpy(glyphs.glyphs, m_item.glyphs.glyphs, m_item.glyphs.numGlyphs * sizeof(HB_Glyph));

    memcpy(glyphs.advances_x, m_item.glyphs.advances_x, m_item.glyphs.numGlyphs * sizeof(QFixed));

    memcpy(glyphs.advances_y, m_item.glyphs.advances_y, m_item.glyphs.numGlyphs * sizeof(QFixed));

    memcpy(glyphs.justifications, m_item.glyphs.justifications, m_item.glyphs.numGlyphs * sizeof(QGlyphJustification));

    memcpy(glyphs.attributes, m_item.glyphs.attributes, m_item.glyphs.numGlyphs * sizeof(HB_GlyphAttributes));

    m_item.glyphs = glyphs;

    m_font = *m_item.f;

    m_item.f = &m_font;

    m_item.fontEngine->ref.ref(); // Increment reference count.

}

QTextItemIntCopy::~QTextItemIntCopy()

{

    delete m_item.chars;

    delete m_item.logClusters;

    delete m_item.glyphs.data();

    if (!m_item.fontEngine->ref.deref())

        delete m_item.fontEngine;

}

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

 *

 * QPaintBufferSignalProxy

 *

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

Q_GLOBAL_STATIC(QPaintBufferSignalProxy, theSignalProxy)

QPaintBufferSignalProxy *QPaintBufferSignalProxy::instance()

{

    return theSignalProxy();

}

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

 *

 * QPaintBufferPrivate

 *

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

QPaintBufferPrivate::QPaintBufferPrivate()

    : ref(1), engine(0), penWidthAdjustment(0)

    , calculateBoundingRect(true)

    , cache(0)

{

}

QPaintBufferPrivate::~QPaintBufferPrivate()

{

    QPaintBufferSignalProxy::instance()->emitAboutToDestroy(this);

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

        const QPaintBufferCommand &cmd = commands.at(i);

        if (cmd.id == QPaintBufferPrivate::Cmd_DrawTextItem)

            delete reinterpret_cast<QTextItemIntCopy *>(qVariantValue<void *>(variants.at(cmd.offset)));

    }

}

inline void QPaintBufferPrivate::updateBoundingRect(const QRectF &br)

{

    // transform to device coords and adjust for pen width

    Q_ASSERT(engine && engine->painter());

    QPainter *painter = engine->painter();

    const QTransform transform = painter->transform();

    QRectF devRect = transform.mapRect(br);

    if (penWidthAdjustment > 0) {

        devRect = devRect.adjusted(-penWidthAdjustment, -penWidthAdjustment,

                                   penWidthAdjustment, penWidthAdjustment);

    }

    if (boundingRect.isEmpty()) {

        boundingRect = devRect;

    } else {

        qreal min_x = qMin(devRect.left(), boundingRect.left());

        qreal min_y = qMin(devRect.top(), boundingRect.top());

        qreal max_x = qMax(devRect.right(), boundingRect.right());

        qreal max_y = qMax(devRect.bottom(), boundingRect.bottom());

        boundingRect = QRectF(min_x, min_y, max_x - min_x, max_y - min_y);

    }

    if (painter->hasClipping())

        boundingRect &= transform.mapRect(painter->clipRegion().boundingRect());

}

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

 *

 * QPaintBuffer

 *

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

QPaintBuffer::QPaintBuffer()

    : d_ptr(new QPaintBufferPrivate)

{

}

QPaintBuffer::~QPaintBuffer()

{

    if (!d_ptr->ref.deref())

        delete d_ptr;

}

QPaintBuffer::QPaintBuffer(const QPaintBuffer &other)

    : QPaintDevice(), d_ptr(other.d_ptr)

{

    d_ptr->ref.ref();

}

QPaintEngine *QPaintBuffer::paintEngine() const

{

    QPaintBufferPrivate *d = const_cast<QPaintBuffer *>(this)->d_ptr;

    if (!d->engine)

        d->engine = new QPaintBufferEngine(d);

    return d->engine;

}

int QPaintBuffer::metric(PaintDeviceMetric metric) const

{

    int val = 0;

    switch (metric) {

    case PdmWidth:

        val = qCeil(d_ptr->boundingRect.width());

        break;

    case PdmHeight:

        val = qCeil(d_ptr->boundingRect.height());

        break;

    case PdmDpiX:

    case PdmPhysicalDpiX:

        val = qt_defaultDpiX();

        break;

    case PdmDpiY:

    case PdmPhysicalDpiY:

        val = qt_defaultDpiY();

        break;

    default:

        val = QPaintDevice::metric(metric);

    }

    return val;

}

int QPaintBuffer::devType() const

{

    return QInternal::PaintBuffer;

}

QPaintBuffer &QPaintBuffer::operator=(const QPaintBuffer &other)

{

    if (other.d_ptr != d_ptr) {

        QPaintBufferPrivate *data = other.d_ptr;

        data->ref.ref();

        if (d_ptr->ref.deref())

            delete d_ptr;

        d_ptr = data;

    }

    return *this;

}

bool QPaintBuffer::isEmpty() const

{

    return d_ptr->commands.isEmpty();

}

void QPaintBuffer::draw(QPainter *painter, int frame) const

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBuffer::draw() --------------------------------";

    Q_D(const QPaintBuffer);

    printf("Float buffer:");

    for (int i=0; i<d->floats.size(); i++) {

        if ((i % 10) == 0) {

            printf("\n%4d-%4d: ", i, i+9);

        }

        printf("%4.2f  ", d->floats[i]);

    }

    printf("\n");

    printf("Int Buffer:");

    for (int i=0; i<d->ints.size(); i++) {

        if ((i % 10) == 0) {

            printf("\n%4d-%4d: ", i, i+10);

        }

        printf("%5d", d->ints[i]);

    }

    printf("\n");

#endif

    processCommands(painter, frameStartIndex(frame), frameEndIndex(frame));

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBuffer::draw() -------------------------------- DONE!";

#endif

}

int QPaintBuffer::frameStartIndex(int frame) const

{

    return (frame == 0) ? 0 : d_ptr->frames.at(frame - 1);

}

int QPaintBuffer::frameEndIndex(int frame) const

{

    return (frame == d_ptr->frames.size()) ? d_ptr->commands.size() : d_ptr->frames.at(frame);

}

int QPaintBuffer::processCommands(QPainter *painter, int begin, int end) const

{

    if (!painter || !painter->isActive())

        return 0;

    QPaintEngineEx *xengine = painter->paintEngine()->isExtended()

                              ? (QPaintEngineEx *) painter->paintEngine() : 0;

    if (xengine) {

        QPaintEngineExReplayer player;

        player.processCommands(*this, painter, begin, end);

    } else {

        QPainterReplayer player;

        player.processCommands(*this, painter, begin, end);

    }

    int depth = 0;

    for (int i = begin; i < end; ++i) {

        const QPaintBufferCommand &cmd = d_ptr->commands.at(i);

        if (cmd.id == QPaintBufferPrivate::Cmd_Save)

            ++depth;

        else if (cmd.id == QPaintBufferPrivate::Cmd_Restore)

            --depth;

    }

    return depth;

}

#ifndef QT_NO_DEBUG_STREAM

QString QPaintBuffer::commandDescription(int command) const

{

    QString desc;

    QDebug debug(&desc);

    const QPaintBufferCommand &cmd = d_ptr->commands.at(command);

    switch (cmd.id) {

    case QPaintBufferPrivate::Cmd_Save: {

        debug << "Cmd_Save";

        break; }

    case QPaintBufferPrivate::Cmd_Restore: {

        debug << "Cmd_Restore";

        break; }

    case QPaintBufferPrivate::Cmd_SetBrush: {

        QBrush brush = qVariantValue<QBrush>(d_ptr->variants.at(cmd.offset));

        debug << "Cmd_SetBrush: " << brush;

        break; }

    case QPaintBufferPrivate::Cmd_SetBrushOrigin: {

        debug << "Cmd_SetBrushOrigin: " << d_ptr->variants.at(cmd.offset).toPointF();

        break; }

    case QPaintBufferPrivate::Cmd_SetCompositionMode: {

        QPainter::CompositionMode mode = (QPainter::CompositionMode) cmd.extra;

        debug << "ExCmd_SetCompositionMode, mode: " << mode;

        break; }

    case QPaintBufferPrivate::Cmd_SetOpacity: {

        debug << "ExCmd_SetOpacity: " << d_ptr->variants.at(cmd.offset).toDouble();

        break; }

    case QPaintBufferPrivate::Cmd_DrawVectorPath: {

        debug << "ExCmd_DrawVectorPath: size: " << cmd.size

//                 << ", hints:" << d->ints[cmd.offset2+cmd.size]

                 << "pts/elms:" << cmd.offset << cmd.offset2;

        break; }

    case QPaintBufferPrivate::Cmd_StrokeVectorPath: {

        QPen pen = qVariantValue<QPen>(d_ptr->variants.at(cmd.extra));

        debug << "ExCmd_StrokeVectorPath: size: " << cmd.size

//                 << ", hints:" << d->ints[cmd.offset2+cmd.size]

                 << "pts/elms:" << cmd.offset << cmd.offset2 << pen;

        break; }

    case QPaintBufferPrivate::Cmd_FillVectorPath: {

        QBrush brush = qVariantValue<QBrush>(d_ptr->variants.at(cmd.extra));

        debug << "ExCmd_FillVectorPath: size: " << cmd.size

//                 << ", hints:" << d->ints[cmd.offset2+cmd.size]

                 << "pts/elms:" << cmd.offset << cmd.offset2 << brush;

        break; }

    case QPaintBufferPrivate::Cmd_FillRectBrush: {

        QBrush brush = qVariantValue<QBrush>(d_ptr->variants.at(cmd.extra));

        QRectF *rect = (QRectF *)(d_ptr->floats.constData() + cmd.offset);

        debug << "ExCmd_FillRectBrush, offset: " << cmd.offset << " rect: " << *rect << " brush: " << brush;

        break; }

    case QPaintBufferPrivate::Cmd_FillRectColor: {

        QColor color = qVariantValue<QColor>(d_ptr->variants.at(cmd.extra));

        QRectF *rect = (QRectF *)(d_ptr->floats.constData() + cmd.offset);

        debug << "ExCmd_FillRectBrush, offset: " << cmd.offset << " rect: " << *rect << " color: " << color;

        break; }

    case QPaintBufferPrivate::Cmd_DrawPolygonF: {

        debug << "ExCmd_DrawPolygonF, offset: " << cmd.offset << " size: " << cmd.size

                 << " mode: " << cmd.extra

                 << d_ptr->floats.at(cmd.offset)

                 << d_ptr->floats.at(cmd.offset+1);

        break; }

    case QPaintBufferPrivate::Cmd_DrawPolygonI: {

        debug << "ExCmd_DrawPolygonI, offset: " << cmd.offset << " size: " << cmd.size

                 << " mode: " << cmd.extra

                 << d_ptr->ints.at(cmd.offset)

                 << d_ptr->ints.at(cmd.offset+1);

        break; }

    case QPaintBufferPrivate::Cmd_DrawEllipseF: {

        debug << "ExCmd_DrawEllipseF, offset: " << cmd.offset;

        break; }

    case QPaintBufferPrivate::Cmd_DrawLineF: {

        debug << "ExCmd_DrawLineF, offset: " << cmd.offset << " size: " << cmd.size;

        break; }

    case QPaintBufferPrivate::Cmd_DrawLineI: {

        debug << "ExCmd_DrawLineI, offset: " << cmd.offset << " size: " << cmd.size;

        break; }

    case QPaintBufferPrivate::Cmd_DrawPointsF: {

        debug << "ExCmd_DrawPointsF, offset: " << cmd.offset << " size: " << cmd.size;

        break; }

    case QPaintBufferPrivate::Cmd_DrawPointsI: {

        debug << "ExCmd_DrawPointsI, offset: " << cmd.offset << " size: " << cmd.size;

        break; }

    case QPaintBufferPrivate::Cmd_DrawPolylineF: {

        debug << "ExCmd_DrawPolylineF, offset: " << cmd.offset << " size: " << cmd.size;

        break; }

    case QPaintBufferPrivate::Cmd_DrawPolylineI: {

        debug << "ExCmd_DrawPolylineI, offset: " << cmd.offset << " size: " << cmd.size;

        break; }

    case QPaintBufferPrivate::Cmd_DrawRectF: {

        debug << "ExCmd_DrawRectF, offset: " << cmd.offset << " size: " << cmd.size;

        break; }

    case QPaintBufferPrivate::Cmd_DrawRectI: {

        debug << "ExCmd_DrawRectI, offset: " << cmd.offset << " size: " << cmd.size;

        break; }

    case QPaintBufferPrivate::Cmd_SetClipEnabled: {

        bool clipEnabled = d_ptr->variants.at(cmd.offset).toBool();

        debug << "ExCmd_SetClipEnabled:" << clipEnabled;

        break; }

    case QPaintBufferPrivate::Cmd_ClipVectorPath: {

        QVectorPathCmd path(d_ptr, cmd);

        debug << "ExCmd_ClipVectorPath:" << path().elementCount();

        break; }

    case QPaintBufferPrivate::Cmd_ClipRect: {

        QRect rect(QPoint(d_ptr->ints.at(cmd.offset), d_ptr->ints.at(cmd.offset + 1)),

                   QPoint(d_ptr->ints.at(cmd.offset + 2), d_ptr->ints.at(cmd.offset + 3)));

        debug << "ExCmd_ClipRect:" << rect << cmd.extra;

        break; }

    case QPaintBufferPrivate::Cmd_ClipRegion: {

        QRegion region(d_ptr->variants.at(cmd.offset).value<QRegion>());

        debug << "ExCmd_ClipRegion:" << region.boundingRect() << cmd.extra;

        break; }

    case QPaintBufferPrivate::Cmd_SetPen: {

        QPen pen = qVariantValue<QPen>(d_ptr->variants.at(cmd.offset));

        debug << "Cmd_SetPen: " << pen;

        break; }

    case QPaintBufferPrivate::Cmd_SetTransform: {

        QTransform xform = qVariantValue<QTransform>(d_ptr->variants.at(cmd.offset));

        debug << "Cmd_SetTransform, offset: " << cmd.offset << xform;

        break; }

    case QPaintBufferPrivate::Cmd_SetRenderHints: {

        debug << "Cmd_SetRenderHints, hints: " << cmd.extra;

        break; }

    case QPaintBufferPrivate::Cmd_SetBackgroundMode: {

        debug << "Cmd_SetBackgroundMode: " << cmd.extra;

        break; }

    case QPaintBufferPrivate::Cmd_DrawConvexPolygonF: {

        debug << "Cmd_DrawConvexPolygonF, offset: " << cmd.offset << " size: " << cmd.size;

        break; }

    case QPaintBufferPrivate::Cmd_DrawConvexPolygonI: {

        debug << "Cmd_DrawConvexPolygonI, offset: " << cmd.offset << " size: " << cmd.size;

        break; }

    case QPaintBufferPrivate::Cmd_DrawEllipseI: {

        debug << "Cmd_DrawEllipseI, offset: " << cmd.offset;

        break; }

    case QPaintBufferPrivate::Cmd_DrawPixmapRect: {

        QPixmap pm(d_ptr->variants.at(cmd.offset).value<QPixmap>());

        QRectF r(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1),

                 d_ptr->floats.at(cmd.extra+2), d_ptr->floats.at(cmd.extra+3));

        QRectF sr(d_ptr->floats.at(cmd.extra+4), d_ptr->floats.at(cmd.extra+5),

                  d_ptr->floats.at(cmd.extra+6), d_ptr->floats.at(cmd.extra+7));

        debug << "Cmd_DrawPixmapRect:" << r << sr << pm.size();

        break; }

    case QPaintBufferPrivate::Cmd_DrawPixmapPos: {

        QPixmap pm(d_ptr->variants.at(cmd.offset).value<QPixmap>());

        QPointF pos(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1));

        debug << "Cmd_DrawPixmapPos:" << pos << pm.size();

        break; }

    case QPaintBufferPrivate::Cmd_DrawTiledPixmap: {

        QPixmap pm(d_ptr->variants.at(cmd.offset).value<QPixmap>());

        QRectF r(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1),

                 d_ptr->floats.at(cmd.extra+2), d_ptr->floats.at(cmd.extra+3));

        QPointF offset(d_ptr->floats.at(cmd.extra+4), d_ptr->floats.at(cmd.extra+5));

        debug << "Cmd_DrawTiledPixmap:" << r << offset << pm.size();

        break; }

    case QPaintBufferPrivate::Cmd_DrawImageRect: {

        QImage image(d_ptr->variants.at(cmd.offset).value<QImage>());

        QRectF r(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1),