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

**

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

**

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

// QtCore

#include <qdebug.h>

#include <qmath.h>

#include <qmutex.h>

// QtGui

#include "qbitmap.h"

#include "qimage.h"

#include "qpaintdevice.h"

#include "qpaintengine.h"

#include "qpainter.h"

#include "qpainter_p.h"

#include "qpainterpath.h"

#include "qpicture.h"

#include "qpixmapcache.h"

#include "qpolygon.h"

#include "qtextlayout.h"

#include "qwidget.h"

#include "qapplication.h"

#include "qstyle.h"

#include "qthread.h"

#include "qvarlengtharray.h"

#include <private/qfontengine_p.h>

#include <private/qpaintengine_p.h>

#include <private/qemulationpaintengine_p.h>

#include <private/qpainterpath_p.h>

#include <private/qtextengine_p.h>

#include <private/qwidget_p.h>

#include <private/qpaintengine_raster_p.h>

#include <private/qmath_p.h>

QT_BEGIN_NAMESPACE

#define QGradient_StretchToDevice 0x10000000

#define QPaintEngine_OpaqueBackground 0x40000000

// #define QT_DEBUG_DRAW

#ifdef QT_DEBUG_DRAW

bool qt_show_painter_debug_output = true;

#endif

extern QPixmap qt_pixmapForBrush(int style, bool invert);

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

static inline QGradient::CoordinateMode coordinateMode(const QBrush &brush)

{

    switch (brush.style()) {

    case Qt::LinearGradientPattern:

    case Qt::RadialGradientPattern:

    case Qt::ConicalGradientPattern:

        return brush.gradient()->coordinateMode();

    default:

        ;

    }

    return QGradient::LogicalMode;

}

/* Returns true if the gradient requires stretch to device...*/

static inline bool check_gradient(const QBrush &brush)

{

    return coordinateMode(brush) == QGradient::StretchToDeviceMode;

}

extern bool qHasPixmapTexture(const QBrush &);

static inline bool is_brush_transparent(const QBrush &brush) {

    Qt::BrushStyle s = brush.style();

    bool brushBitmap = qHasPixmapTexture(brush)

                       ? brush.texture().isQBitmap()

                       : (brush.textureImage().depth() == 1);

    return ((s >= Qt::Dense1Pattern && s <= Qt::DiagCrossPattern)

            || (s == Qt::TexturePattern && brushBitmap));

}

static inline bool is_pen_transparent(const QPen &pen) {

    return pen.style() > Qt::SolidLine || is_brush_transparent(pen.brush());

}

/* Discards the emulation flags that are not relevant for line drawing

   and returns the result

*/

static inline uint line_emulation(uint emulation)

{

    return emulation & (QPaintEngine::PrimitiveTransform

                        | QPaintEngine::AlphaBlend

                        | QPaintEngine::Antialiasing

                        | QPaintEngine::BrushStroke

                        | QPaintEngine::ConstantOpacity

                        | QGradient_StretchToDevice

                        | QPaintEngine::ObjectBoundingModeGradients

                        | QPaintEngine_OpaqueBackground);

}

#ifndef QT_NO_DEBUG

static bool qt_painter_thread_test(int devType, const char *what, bool extraCondition = false)

{

    switch (devType) {

    case QInternal::Image:

    case QInternal::Printer:

    case QInternal::Picture:

        // can be drawn onto these devices safely from any thread

#ifndef Q_WS_WIN

        if (extraCondition)

#endif

            break;

    default:

        if (!extraCondition && QThread::currentThread() != qApp->thread()) {

            qWarning("QPainter: It is not safe to use %s outside the GUI thread", what);

            return false;

        }

        break;

    }

    return true;

}

#endif

void QPainterPrivate::checkEmulation()

{

    Q_ASSERT(extended);

    if (extended->flags() & QPaintEngineEx::DoNotEmulate)

        return;

    bool doEmulation = false;

    if (state->bgMode == Qt::OpaqueMode)

        doEmulation = true;

    const QGradient *bg = state->brush.gradient();

    if (bg && bg->coordinateMode() > QGradient::LogicalMode)

        doEmulation = true;

    const QGradient *pg = qpen_brush(state->pen).gradient();

    if (pg && pg->coordinateMode() > QGradient::LogicalMode)

        doEmulation = true;

    if (doEmulation) {

        if (extended != emulationEngine) {

            if (!emulationEngine)

                emulationEngine = new QEmulationPaintEngine(extended);

            extended = emulationEngine;

            extended->setState(state);

        }

    } else if (emulationEngine == extended) {

        extended = emulationEngine->real_engine;

    }

}

QPainterPrivate::~QPainterPrivate()

{

    delete emulationEngine;

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

        delete states.at(i);

    if (dummyState)

        delete dummyState;

}

QTransform QPainterPrivate::viewTransform() const

{

    if (state->VxF) {

        qreal scaleW = qreal(state->vw)/qreal(state->ww);

        qreal scaleH = qreal(state->vh)/qreal(state->wh);

        return QTransform(scaleW, 0, 0, scaleH,

                          state->vx - state->wx*scaleW, state->vy - state->wy*scaleH);

    }

    return QTransform();

}

/*

   \internal

   Returns true if using a shared painter; otherwise false.

*/

bool QPainterPrivate::attachPainterPrivate(QPainter *q, QPaintDevice *pdev)

{

    Q_ASSERT(q);

    Q_ASSERT(pdev);

    if (pdev->devType() != QInternal::Widget)

        return false;

    QWidget *widget = static_cast<QWidget *>(pdev);

    Q_ASSERT(widget);

    // Someone either called QPainter::setRedirected in the widget's paint event

    // right before this painter was created (or begin was called) or

    // sent a paint event directly to the widget.

    if (!widget->d_func()->redirectDev)

        return false;

    QPainter *sp = widget->d_func()->sharedPainter();

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

        return false;

    if (sp->paintEngine()->paintDevice() != widget->d_func()->redirectDev)

        return false;

    // Check if we're attempting to paint outside a paint event.

    if (!sp->d_ptr->engine->hasFeature(QPaintEngine::PaintOutsidePaintEvent)

        && !widget->testAttribute(Qt::WA_PaintOutsidePaintEvent)

        && !widget->testAttribute(Qt::WA_WState_InPaintEvent)) {

        qWarning("QPainter::begin: Widget painting can only begin as a result of a paintEvent");

        return false;

    }

    // Save the current state of the shared painter and assign

    // the current d_ptr to the shared painter's d_ptr.

    sp->save();

    if (!sp->d_ptr->d_ptrs) {

        // Allocate space for 4 d-pointers (enough for up to 4 sub-sequent

        // redirections within the same paintEvent(), which should be enough

        // in 99% of all cases). E.g: A renders B which renders C which renders D.

        sp->d_ptr->d_ptrs_size = 4;

        sp->d_ptr->d_ptrs = (QPainterPrivate **)malloc(4 * sizeof(QPainterPrivate *));

        Q_CHECK_PTR(sp->d_ptr->d_ptrs);

    } else if (sp->d_ptr->refcount - 1 == sp->d_ptr->d_ptrs_size) {

        // However, to support corner cases we grow the array dynamically if needed.

        sp->d_ptr->d_ptrs_size <<= 1;

        const int newSize = sp->d_ptr->d_ptrs_size * sizeof(QPainterPrivate *);

        sp->d_ptr->d_ptrs = q_check_ptr((QPainterPrivate **)realloc(sp->d_ptr->d_ptrs, newSize));

    }

    sp->d_ptr->d_ptrs[++sp->d_ptr->refcount - 2] = q->d_ptr.data();

    q->d_ptr.take();

    q->d_ptr.reset(sp->d_ptr.data());

    Q_ASSERT(q->d_ptr->state);

    // Now initialize the painter with correct widget properties.

    q->initFrom(widget);

    QPoint offset;

    widget->d_func()->redirected(&offset);

    offset += q->d_ptr->engine->coordinateOffset();

    // Update system rect.

    q->d_ptr->state->ww = q->d_ptr->state->vw = widget->width();

    q->d_ptr->state->wh = q->d_ptr->state->vh = widget->height();

    // Update matrix.

    if (q->d_ptr->state->WxF) {

        q->d_ptr->state->redirectionMatrix = q->d_ptr->state->matrix;

        q->d_ptr->state->redirectionMatrix.translate(-offset.x(), -offset.y());

        q->d_ptr->state->worldMatrix = QTransform();

        q->d_ptr->state->WxF = false;

    } else {

        q->d_ptr->state->redirectionMatrix = QTransform::fromTranslate(-offset.x(), -offset.y());

    }

    q->d_ptr->updateMatrix();

    QPaintEnginePrivate *enginePrivate = q->d_ptr->engine->d_func();

    if (enginePrivate->currentClipWidget == widget) {

        enginePrivate->systemStateChanged();

        return true;

    }

    // Update system transform and clip.

    enginePrivate->currentClipWidget = widget;

    enginePrivate->setSystemTransform(q->d_ptr->state->matrix);

    return true;

}

void QPainterPrivate::detachPainterPrivate(QPainter *q)

{

    Q_ASSERT(refcount > 1);

    Q_ASSERT(q);

    QPainterPrivate *original = d_ptrs[--refcount - 1];

    if (inDestructor) {

        inDestructor = false;

        if (original)

            original->inDestructor = true;

    } else if (!original) {

        original = new QPainterPrivate(q);

    }

    d_ptrs[refcount - 1] = 0;

    q->restore();

    q->d_ptr.take();

    q->d_ptr.reset(original);

    if (emulationEngine) {

        extended = emulationEngine->real_engine;

        delete emulationEngine;

        emulationEngine = 0;

    }

}

void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperation op)

{

#ifdef QT_DEBUG_DRAW

    if (qt_show_painter_debug_output) {

        printf("QPainter::drawHelper\n");

    }

#endif

    if (originalPath.isEmpty())

        return;

    QPaintEngine::PaintEngineFeatures gradientStretch =

        QPaintEngine::PaintEngineFeatures(QGradient_StretchToDevice

                                          | QPaintEngine::ObjectBoundingModeGradients);

    const bool mustEmulateObjectBoundingModeGradients = extended

                                                        || ((state->emulationSpecifier & QPaintEngine::ObjectBoundingModeGradients)

                                                            && !engine->hasFeature(QPaintEngine::PatternTransform));

    if (!(state->emulationSpecifier & ~gradientStretch)

        && !mustEmulateObjectBoundingModeGradients) {

        drawStretchedGradient(originalPath, op);

        return;

    } else if (state->emulationSpecifier & QPaintEngine_OpaqueBackground) {

        drawOpaqueBackground(originalPath, op);

        return;

    }

    Q_Q(QPainter);

    qreal strokeOffsetX = 0, strokeOffsetY = 0;

    QPainterPath path = originalPath * state->matrix;

    QRectF pathBounds = path.boundingRect();

    QRectF strokeBounds;

    bool doStroke = (op & StrokeDraw) && (state->pen.style() != Qt::NoPen);

    if (doStroke) {

        qreal penWidth = state->pen.widthF();

        if (penWidth == 0) {

            strokeOffsetX = 1;

            strokeOffsetY = 1;

        } else {

            // In case of complex xform

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

                QPainterPathStroker stroker;

                stroker.setWidth(penWidth);

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

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

                QPainterPath stroke = stroker.createStroke(originalPath);

                strokeBounds = (stroke * state->matrix).boundingRect();

            } else {

                strokeOffsetX = qAbs(penWidth * state->matrix.m11() / 2.0);

                strokeOffsetY = qAbs(penWidth * state->matrix.m22() / 2.0);

            }

        }

    }

    QRect absPathRect;

    if (!strokeBounds.isEmpty()) {

        absPathRect = strokeBounds.intersected(QRectF(0, 0, device->width(), device->height())).toAlignedRect();

    } else {

        absPathRect = pathBounds.adjusted(-strokeOffsetX, -strokeOffsetY, strokeOffsetX, strokeOffsetY)

            .intersected(QRectF(0, 0, device->width(), device->height())).toAlignedRect();

    }

    if (q->hasClipping()) {

        bool hasPerspectiveTransform = false;

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

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

            if (info.matrix.type() == QTransform::TxProject) {

                hasPerspectiveTransform = true;

                break;

            }

        }

        // avoid mapping QRegions with perspective transforms

        if (!hasPerspectiveTransform) {

            // The trick with txinv and invMatrix is done in order to

            // avoid transforming the clip to logical coordinates, and

            // then back to device coordinates. This is a problem with

            // QRegion/QRect based clips, since they use integer

            // coordinates and converting to/from logical coordinates will

            // lose precision.

            bool old_txinv = txinv;

            QTransform old_invMatrix = invMatrix;

            txinv = true;

            invMatrix = QTransform();

            QPainterPath clipPath = q->clipPath();

            QRectF r = clipPath.boundingRect().intersected(absPathRect);

            absPathRect = r.toAlignedRect();

            txinv = old_txinv;

            invMatrix = old_invMatrix;

        }

    }

//     qDebug("\nQPainterPrivate::draw_helper(), x=%d, y=%d, w=%d, h=%d",

//            devMinX, devMinY, device->width(), device->height());

//     qDebug() << " - matrix" << state->matrix;

//     qDebug() << " - originalPath.bounds" << originalPath.boundingRect();

//     qDebug() << " - path.bounds" << path.boundingRect();

    if (absPathRect.width() <= 0 || absPathRect.height() <= 0)

        return;

    QImage image(absPathRect.width(), absPathRect.height(), QImage::Format_ARGB32_Premultiplied);

    image.fill(0);

    QPainter p(&image);

    p.d_ptr->helper_device = helper_device;

    p.setOpacity(state->opacity);

    p.translate(-absPathRect.x(), -absPathRect.y());

    p.setTransform(state->matrix, true);

    p.setPen(doStroke ? state->pen : QPen(Qt::NoPen));

    p.setBrush((op & FillDraw) ? state->brush : QBrush(Qt::NoBrush));

    p.setBackground(state->bgBrush);

    p.setBackgroundMode(state->bgMode);

    p.setBrushOrigin(state->brushOrigin);

    p.setRenderHint(QPainter::Antialiasing, state->renderHints & QPainter::Antialiasing);

    p.setRenderHint(QPainter::SmoothPixmapTransform,

                    state->renderHints & QPainter::SmoothPixmapTransform);

    p.drawPath(originalPath);

#ifndef QT_NO_DEBUG

    static bool do_fallback_overlay = qgetenv("QT_PAINT_FALLBACK_OVERLAY").size() > 0;

    if (do_fallback_overlay) {

        QImage block(8, 8, QImage::Format_ARGB32_Premultiplied);

        QPainter pt(&block);

        pt.fillRect(0, 0, 8, 8, QColor(196, 0, 196));

        pt.drawLine(0, 0, 8, 8);

        pt.end();

        p.resetTransform();

        p.setCompositionMode(QPainter::CompositionMode_SourceAtop);

        p.setOpacity(0.5);

        p.fillRect(0, 0, image.width(), image.height(), QBrush(block));

    }

#endif

    p.end();

    q->save();

    state->matrix = QTransform();

    state->dirtyFlags |= QPaintEngine::DirtyTransform;

    updateState(state);

    engine->drawImage(absPathRect,

                 image,

                 QRectF(0, 0, absPathRect.width(), absPathRect.height()),

                 Qt::OrderedDither | Qt::OrderedAlphaDither);

    q->restore();

}

void QPainterPrivate::drawOpaqueBackground(const QPainterPath &path, DrawOperation op)

{

    Q_Q(QPainter);

    q->setBackgroundMode(Qt::TransparentMode);

    if (op & FillDraw && state->brush.style() != Qt::NoBrush) {

        q->fillPath(path, state->bgBrush.color());

        q->fillPath(path, state->brush);

    }

    if (op & StrokeDraw && state->pen.style() != Qt::NoPen) {

        q->strokePath(path, QPen(state->bgBrush.color(), state->pen.width()));

        q->strokePath(path, state->pen);

    }

    q->setBackgroundMode(Qt::OpaqueMode);

}

static inline QBrush stretchGradientToUserSpace(const QBrush &brush, const QRectF &boundingRect)

{

    Q_ASSERT(brush.style() >= Qt::LinearGradientPattern

             && brush.style() <= Qt::ConicalGradientPattern);

    QTransform gradientToUser(boundingRect.width(), 0, 0, boundingRect.height(),

                              boundingRect.x(), boundingRect.y());

    QGradient g = *brush.gradient();

    g.setCoordinateMode(QGradient::LogicalMode);

    QBrush b(g);

    b.setTransform(gradientToUser * b.transform());

    return b;

}

void QPainterPrivate::drawStretchedGradient(const QPainterPath &path, DrawOperation op)

{

    Q_Q(QPainter);

    const qreal sw = helper_device->width();

    const qreal sh = helper_device->height();