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

**

** Copyright (C) 2009 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 <QDebug>

//#define QPAINTBUFFER_DEBUG_DRAW

QT_BEGIN_NAMESPACE

extern int qt_defaultDpiX();

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() --------------------------------";

//     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

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

        return;

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

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

    if (xengine) {

        QPaintEngineExReplayer player;

        player.draw(*this, painter, frame);

    } else {

        QPainterReplayer player;

        player.draw(*this, painter, frame);

    }

#ifdef QPAINTBUFFER_DEBUG_DRAW

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

#endif

}

QRectF QPaintBuffer::boundingRect() const

{

    return d_ptr->boundingRect;

}

void QPaintBuffer::setBoundingRect(const QRectF &rect)

{

    d_ptr->boundingRect = rect;

    d_ptr->calculateBoundingRect = false;

}

class QPaintBufferEnginePrivate : public QPaintEngineExPrivate

{

    Q_DECLARE_PUBLIC(QPaintBufferEngine)

public:

    void systemStateChanged() {

        Q_Q(QPaintBufferEngine);

        q->buffer->addCommand(QPaintBufferPrivate::Cmd_SystemStateChanged, QVariant(systemClip));

    }

};

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

 *

 * QPaintBufferEngine

 *

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

QPaintBufferEngine::QPaintBufferEngine(QPaintBufferPrivate *b)

    : QPaintEngineEx(*(new QPaintBufferEnginePrivate))

    , buffer(b)

    , m_begin_detected(false)

    , m_save_detected(false)

    , m_stream_raw_text_items(false)

{

}

bool QPaintBufferEngine::begin(QPaintDevice *)

{

    Q_D(QPaintBufferEngine);

    painter()->save();

    d->systemStateChanged();

    return true;

}

bool QPaintBufferEngine::end()

{

    painter()->restore();

    m_created_state = 0;

    return true;

}

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

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine: createState, orig=" << orig << ", current=" << state();

#endif

    Q_ASSERT(!m_begin_detected);

    Q_ASSERT(!m_save_detected);

    if (orig == 0) {

        m_begin_detected = true;

        return new QPainterState();

    } else {

        m_save_detected = true;

        return new QPainterState(orig);

    }

}

void QPaintBufferEngine::clip(const QVectorPath &path, Qt::ClipOperation op)

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine: clip vpath:" << path.elementCount() << "op:" << op;

#endif

    QPaintBufferCommand *cmd =

        buffer->addCommand(QPaintBufferPrivate::Cmd_ClipVectorPath, path);

    cmd->extra = op;

}

void QPaintBufferEngine::clip(const QRect &rect, Qt::ClipOperation op)

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine: clip rect:" << rect << "op:" << op;

#endif

    QPaintBufferCommand *cmd =

        buffer->addCommand(QPaintBufferPrivate::Cmd_ClipRect, (int *) &rect, 4, 1);

    cmd->extra = op;

}

void QPaintBufferEngine::clip(const QRegion &region, Qt::ClipOperation op)

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine: clip region br:" << region.boundingRect() << "op:" << op;

#endif

    QPaintBufferCommand *cmd =

        buffer->addCommand(QPaintBufferPrivate::Cmd_ClipRegion, QVariant(region));

    cmd->extra = op;

}

void QPaintBufferEngine::clip(const QPainterPath &path, Qt::ClipOperation op)

{

    // ### TODO

//     QPaintBufferCommand *cmd =

//         buffer->addCommand(QPaintBufferPrivate::Cmd_ClipPath, QVariant(path));

//     cmd->extra = op;

    QPaintEngineEx::clip(path, op);

}

void QPaintBufferEngine::clipEnabledChanged()

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine: clip enable change" << state()->clipEnabled;

#endif

    buffer->addCommand(QPaintBufferPrivate::Cmd_SetClipEnabled, state()->clipEnabled);

}

void QPaintBufferEngine::penChanged()

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine:" << state()->pen;

#endif

    const QPen &pen = state()->pen;

    if (!buffer->commands.isEmpty()

        && buffer->commands.last().id == QPaintBufferPrivate::Cmd_SetPen) {

        buffer->variants[buffer->commands.last().offset] = pen;

        return;

    }

    if (buffer->calculateBoundingRect) {

        if (pen.style() == Qt::NoPen) {

            buffer->penWidthAdjustment = 0;

        } else {

            qreal penWidth = (pen.widthF() == 0) ? 1 : pen.widthF();

            QPointF transformedWidth(penWidth, penWidth);

            if (!pen.isCosmetic())

                transformedWidth = painter()->transform().map(transformedWidth);

            buffer->penWidthAdjustment = transformedWidth.x() / 2.0;

        }

    }

    buffer->addCommand(QPaintBufferPrivate::Cmd_SetPen, pen);

}

void QPaintBufferEngine::brushChanged()

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine:" << state()->brush;

#endif

    const QBrush &brush = state()->brush;

    if (!buffer->commands.isEmpty()

        && buffer->commands.last().id == QPaintBufferPrivate::Cmd_SetBrush) {

        buffer->variants[buffer->commands.last().offset] = brush;

        return;

    }

    buffer->addCommand(QPaintBufferPrivate::Cmd_SetBrush, brush);

}

void QPaintBufferEngine::brushOriginChanged()

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine: brush origin changed" << state()->brushOrigin;

#endif

    buffer->addCommand(QPaintBufferPrivate::Cmd_SetBrushOrigin, state()->brushOrigin);

}

void QPaintBufferEngine::opacityChanged()

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine: opacity changed" << state()->opacity;

#endif

    buffer->addCommand(QPaintBufferPrivate::Cmd_SetOpacity, state()->opacity);

}

void QPaintBufferEngine::compositionModeChanged()

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine: composition mode" << state()->composition_mode;

#endif

    QPaintBufferCommand *cmd =

        buffer->addCommand(QPaintBufferPrivate::Cmd_SetCompositionMode);

    cmd->extra = state()->composition_mode;

}

void QPaintBufferEngine::renderHintsChanged()

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine: render hints changed" << state()->renderHints;

#endif

    QPaintBufferCommand *cmd =

        buffer->addCommand(QPaintBufferPrivate::Cmd_SetRenderHints);

    cmd->extra = state()->renderHints;

}

void QPaintBufferEngine::transformChanged()

{

    // ### accumulate, like in QBrush case...

    if (!buffer->commands.isEmpty()

        && buffer->commands.last().id == QPaintBufferPrivate::Cmd_SetTransform) {

#ifdef QPAINTBUFFER_DEBUG_DRAW

        qDebug() << "QPaintBufferEngine: compressing " << state()->matrix;

#endif

        buffer->variants[buffer->commands.last().offset] = state()->matrix;

        return;

    }

#ifdef QPAINTBUFFER_DEBUG_DRAW

        qDebug() << "QPaintBufferEngine: " << state()->matrix;

#endif

    buffer->addCommand(QPaintBufferPrivate::Cmd_SetTransform, state()->matrix);

}

void QPaintBufferEngine::backgroundModeChanged()

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintEngineBuffer: background mode changed" << state()->bgMode;

#endif

    QPaintBufferCommand *cmd = buffer->addCommand(QPaintBufferPrivate::Cmd_SetBackgroundMode);

    cmd->extra = state()->bgMode;

}

void QPaintBufferEngine::draw(const QVectorPath &path)

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine: draw vpath:" << path.elementCount();

#endif

    buffer->addCommand(QPaintBufferPrivate::Cmd_DrawVectorPath, path);

//     if (buffer->calculateBoundingRect) {

//         QRealRect r = path.controlPointRect();

//         buffer->updateBoundingRect(QRectF(r.x1, r.y1, r.x2 - r.x1, r.y2 - r.y1));

//     }

}

void QPaintBufferEngine::fill(const QVectorPath &path, const QBrush &brush)

{

#ifdef QPAINTBUFFER_DEBUG_DRAW

    qDebug() << "QPaintBufferEngine: fill vpath:" << path.elementCount() << brush;

#endif