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

**

** Copyright (C) 2016 The Qt Company Ltd.

** Contact: https://www.qt.io/licensing/

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** Commercial License Usage

** Licensees holding valid commercial Qt licenses may use this file in

** accordance with the commercial license agreement provided with the

** Software or, alternatively, in accordance with the terms contained in

** a written agreement between you and The Qt Company. For licensing terms

** and conditions see https://www.qt.io/terms-conditions. For further

** information use the contact form at https://www.qt.io/contact-us.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 3 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL3 included in the

** packaging of this file. Please review the following information to

** ensure the GNU Lesser General Public License version 3 requirements

** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.

**

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU

** General Public License version 2.0 or (at your option) the GNU General

** Public license version 3 or any later version approved by the KDE Free

** Qt Foundation. The licenses are as published by the Free Software

** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3

** included in the packaging of this file. Please review the following

** information to ensure the GNU General Public License requirements will

** be met: https://www.gnu.org/licenses/gpl-2.0.html and

** https://www.gnu.org/licenses/gpl-3.0.html.

**

** $QT_END_LICENSE$

**

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

#include <QtCore/qglobal.h>

#include <QtCore/qmutex.h>

#define QT_FT_BEGIN_HEADER

#define QT_FT_END_HEADER

#include <private/qrasterdefs_p.h>

#include <private/qgrayraster_p.h>

#include <qpainterpath.h>

#include <qdebug.h>

#include <qbitmap.h>

#include <qmath.h>

#include <qrandom.h>

//   #include <private/qdatabuffer_p.h>

//   #include <private/qpainter_p.h>

#include <private/qtextengine_p.h>

#include <private/qfontengine_p.h>

#include <private/qpixmap_raster_p.h>

//   #include <private/qpolygonclipper_p.h>

//   #include <private/qrasterizer_p.h>

#include <private/qimage_p.h>

#include <private/qstatictext_p.h>

#include <private/qcosmeticstroker_p.h>

#include "qmemrotate_p.h"

#include "qrgba64_p.h"

#include "qpaintengine_raster_p.h"

//   #include "qbezier_p.h"

#include "qoutlinemapper_p.h"

#include <limits.h>

#include <algorithm>

#ifdef Q_OS_WIN

#  include <qvarlengtharray.h>

#  include <private/qfontengine_p.h>

#  include <qt_windows.h>

#ifdef Q_OS_WIN64

#    include <malloc.h>

#  endif

#endif

QT_BEGIN_NAMESPACE

class QRectVectorPath : public QVectorPath {

public:

    inline void set(const QRect &r) {

        qreal left = r.x();

        qreal right = r.x() + r.width();

        qreal top = r.y();

        qreal bottom = r.y() + r.height();

        pts[0] = left;

        pts[1] = top;

        pts[2] = right;

        pts[3] = top;

        pts[4] = right;

        pts[5] = bottom;

        pts[6] = left;

        pts[7] = bottom;

    }

    inline void set(const QRectF &r) {

        qreal left = r.x();

        qreal right = r.x() + r.width();

        qreal top = r.y();

        qreal bottom = r.y() + r.height();

        pts[0] = left;

        pts[1] = top;

        pts[2] = right;

        pts[3] = top;

        pts[4] = right;

        pts[5] = bottom;

        pts[6] = left;

        pts[7] = bottom;

    }

    inline QRectVectorPath(const QRect &r)

        : QVectorPath(pts, 4, nullptr, QVectorPath::RectangleHint | QVectorPath::ImplicitClose)

    {

        set(r);

    }

    inline QRectVectorPath(const QRectF &r)

        : QVectorPath(pts, 4, nullptr, QVectorPath::RectangleHint | QVectorPath::ImplicitClose)

    {

        set(r);

    }

    inline QRectVectorPath()

        : QVectorPath(pts, 4, nullptr, QVectorPath::RectangleHint | QVectorPath::ImplicitClose)

    { }

    qreal pts[8];

};

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

#define qreal_to_fixed_26_6(f) (int(f * 64))

#define qt_swap_int(x, y) { int tmp = (x); (x) = (y); (y) = tmp; }

#define qt_swap_qreal(x, y) { qreal tmp = (x); (x) = (y); (y) = tmp; }

// #define QT_DEBUG_DRAW

#ifdef QT_DEBUG_DRAW

void dumpClip(int width, int height, const QClipData *clip);

#endif

#define QT_FAST_SPANS

// A little helper macro to get a better approximation of dimensions.

// If we have a rect that starting at 0.5 of width 3.5 it should span

// 4 pixels.

#define int_dim(pos, dim) (int(pos+dim) - int(pos))

static const qreal aliasedCoordinateDelta = 0.5 - 0.015625;

#ifdef Q_OS_WIN

static inline bool winClearTypeFontsEnabled()

{

#ifdef Q_OS_WINRT

    return false;

#else // Q_OS_WINRT

    UINT result = 0;

#if !defined(SPI_GETFONTSMOOTHINGTYPE) // MinGW

#    define SPI_GETFONTSMOOTHINGTYPE  0x200A

#    define FE_FONTSMOOTHINGCLEARTYPE 0x002

#endif

    SystemParametersInfo(SPI_GETFONTSMOOTHINGTYPE, 0, &result, 0);

    return result == FE_FONTSMOOTHINGCLEARTYPE;

#endif // !Q_OS_WINRT

}

/*!

    \internal

 */

bool QRasterPaintEngine::clearTypeFontsEnabled()

{

    static const bool result = winClearTypeFontsEnabled();

    return result;

}

#endif // Q_OS_WIN

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

 * Span functions

 */

static void qt_span_fill_clipRect(int count, const QSpan *spans, void *userData);

static void qt_span_fill_clipped(int count, const QSpan *spans, void *userData);

static void qt_span_clip(int count, const QSpan *spans, void *userData);

struct ClipData

{

    QClipData *oldClip;

    QClipData *newClip;

    Qt::ClipOperation operation;

};

enum LineDrawMode {

    LineDrawClipped,

    LineDrawNormal,

    LineDrawIncludeLastPixel

};

static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip,

                                   ProcessSpans pen_func, ProcessSpans brush_func,

                                   QSpanData *pen_data, QSpanData *brush_data);

struct QRasterFloatPoint {

    qreal x;

    qreal y;

};

#ifdef QT_DEBUG_DRAW

static const QRectF boundingRect(const QPointF *points, int pointCount)

{

    const QPointF *e = points;

    const QPointF *last = points + pointCount;

    qreal minx, maxx, miny, maxy;

    minx = maxx = e->x();

    miny = maxy = e->y();

    while (++e < last) {

        if (e->x() < minx)

            minx = e->x();

        else if (e->x() > maxx)

            maxx = e->x();

        if (e->y() < miny)

            miny = e->y();

        else if (e->y() > maxy)

            maxy = e->y();

    }

    return QRectF(QPointF(minx, miny), QPointF(maxx, maxy));

}

#endif

static void qt_ft_outline_move_to(qfixed x, qfixed y, void *data)

{

    ((QOutlineMapper *) data)->moveTo(QPointF(qt_fixed_to_real(x), qt_fixed_to_real(y)));

}

static void qt_ft_outline_line_to(qfixed x, qfixed y, void *data)

{

    ((QOutlineMapper *) data)->lineTo(QPointF(qt_fixed_to_real(x), qt_fixed_to_real(y)));

}

static void qt_ft_outline_cubic_to(qfixed c1x, qfixed c1y,

                             qfixed c2x, qfixed c2y,

                             qfixed ex, qfixed ey,

                             void *data)

{

    ((QOutlineMapper *) data)->curveTo(QPointF(qt_fixed_to_real(c1x), qt_fixed_to_real(c1y)),

                                       QPointF(qt_fixed_to_real(c2x), qt_fixed_to_real(c2y)),

                                       QPointF(qt_fixed_to_real(ex), qt_fixed_to_real(ey)));

}

#if !defined(QT_NO_DEBUG) && 0

static void qt_debug_path(const QPainterPath &path)

{

    const char *names[] = {

        "MoveTo     ",

        "LineTo     ",

        "CurveTo    ",

        "CurveToData"

    };

    fprintf(stderr,"\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);

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

    }

}

#endif

// QRect::normalized() will change the width/height of the rectangle due to

// its incusive-integer definition of left/right vs width. This is not

// something we want to change in QRect as that would potentially introduce

// regressions all over the place, so we implement a straightforward

// normalized here. QRectF already does this, so QRectF::normalized() is ok to

// use.

static QRect qrect_normalized(const QRect &rect)

{

    int x, y, w, h;

    if (Q_UNLIKELY(rect.width() < 0)) {

        x = rect.x() + rect.width();

        w = -rect.width();

    } else {

        x = rect.x();

        w = rect.width();

    }

    if (Q_UNLIKELY(rect.height() < 0)) {

        y = rect.y() + rect.height();

        h = -rect.height();

    } else {

        y = rect.y();

        h = rect.height();

    }

    return QRect(x, y, w, h);

}

QRasterPaintEnginePrivate::QRasterPaintEnginePrivate() :

    QPaintEngineExPrivate(),

    cachedLines(0)

{

}

/*!

    \class QRasterPaintEngine

    \preliminary

    \ingroup qws

    \inmodule QtGui

    \since 4.2

    \brief The QRasterPaintEngine class enables hardware acceleration

    of painting operations in Qt for Embedded Linux.

    Note that this functionality is only available in

    Qt for Embedded Linux.

    In Qt for Embedded Linux, painting is a pure software

    implementation. But starting with Qt 4.2, it is

    possible to add an accelerated graphics driver to take advantage

    of available hardware resources.

    Hardware acceleration is accomplished by creating a custom screen

    driver, accelerating the copying from memory to the screen, and

    implementing a custom paint engine accelerating the various

    painting operations. Then a custom paint device and a custom

    window surface must be implemented to make

    Qt for Embedded Linux aware of the accelerated driver.

    \note The QRasterPaintEngine class does not support 8-bit images.

    Instead, they need to be converted to a supported format, such as

    QImage::Format_ARGB32_Premultiplied.

    \sa QPaintEngine

*/

/*!

    \fn QPaintEngine::Type QRasterPaintEngine::type() const

    \reimp

*/

/*!

    \typedef QSpan

    \relates QRasterPaintEngine

    A struct equivalent to QT_FT_Span, containing a position (x,

    y), the span's length in pixels and its color/coverage (a value

    ranging from 0 to 255).

*/

/*!

    \since 4.5

    Creates a raster based paint engine for operating on the given

    \a device, with the complete set of \l

    {QPaintEngine::PaintEngineFeature}{paint engine features and

    capabilities}.

*/

QRasterPaintEngine::QRasterPaintEngine(QPaintDevice *device)

    : QPaintEngineEx(*(new QRasterPaintEnginePrivate))

{

    d_func()->device = device;

    init();

}

/*!

    \internal

*/

QRasterPaintEngine::QRasterPaintEngine(QRasterPaintEnginePrivate &dd, QPaintDevice *device)

    : QPaintEngineEx(dd)

{

    d_func()->device = device;

    init();

}

void QRasterPaintEngine::init()

{

    Q_D(QRasterPaintEngine);

#ifdef Q_OS_WIN

    d->hdc = 0;

#endif

    // The antialiasing raster.

    d->grayRaster.reset(new QT_FT_Raster);

    Q_CHECK_PTR(d->grayRaster.data());

    if (qt_ft_grays_raster.raster_new(d->grayRaster.data()))

        QT_THROW(std::bad_alloc()); // an error creating the raster is caused by a bad malloc

    d->rasterizer.reset(new QRasterizer);

    d->rasterBuffer.reset(new QRasterBuffer());

    d->outlineMapper.reset(new QOutlineMapper);

    d->outlinemapper_xform_dirty = true;

    d->basicStroker.setMoveToHook(qt_ft_outline_move_to);

    d->basicStroker.setLineToHook(qt_ft_outline_line_to);

    d->basicStroker.setCubicToHook(qt_ft_outline_cubic_to);

    d->baseClip.reset(new QClipData(d->device->height()));

    d->baseClip->setClipRect(QRect(0, 0, d->device->width(), d->device->height()));

    d->image_filler.init(d->rasterBuffer.data(), this);

    d->image_filler.type = QSpanData::Texture;

    d->image_filler_xform.init(d->rasterBuffer.data(), this);

    d->image_filler_xform.type = QSpanData::Texture;

    d->solid_color_filler.init(d->rasterBuffer.data(), this);

    d->solid_color_filler.type = QSpanData::Solid;

    d->deviceDepth = d->device->depth();

    d->mono_surface = false;

    gccaps &= ~PorterDuff;

    QImage::Format format = QImage::Format_Invalid;

    switch (d->device->devType()) {

    case QInternal::Pixmap:

        qWarning("QRasterPaintEngine: unsupported for pixmaps...");

        break;

    case QInternal::Image:

        format = d->rasterBuffer->prepare(static_cast<QImage *>(d->device));

        break;

    default:

        qWarning("QRasterPaintEngine: unsupported target device %d\n", d->device->devType());

        d->device = nullptr;

        return;

    }

    switch (format) {

    case QImage::Format_MonoLSB:

    case QImage::Format_Mono:

        d->mono_surface = true;

        break;

    default:

        if (QImage::toPixelFormat(format).alphaUsage() == QPixelFormat::UsesAlpha)

            gccaps |= PorterDuff;

        break;

    }

}

/*!

    Destroys this paint engine.

*/

QRasterPaintEngine::~QRasterPaintEngine()

{

    Q_D(QRasterPaintEngine);

    qt_ft_grays_raster.raster_done(*d->grayRaster.data());

}

/*!

    \reimp

*/

bool QRasterPaintEngine::begin(QPaintDevice *device)

{

    Q_D(QRasterPaintEngine);

    if (device->devType() == QInternal::Pixmap) {

        QPixmap *pixmap = static_cast<QPixmap *>(device);

        QPlatformPixmap *pd = pixmap->handle();

        if (pd->classId() == QPlatformPixmap::RasterClass || pd->classId() == QPlatformPixmap::BlitterClass)

            d->device = pd->buffer();

    } else {

        d->device = device;

    }

    // Make sure QPaintEngine::paintDevice() returns the proper device.

    d->pdev = d->device;

    Q_ASSERT(d->device->devType() == QInternal::Image

             || d->device->devType() == QInternal::CustomRaster);

    d->systemStateChanged();

    QRasterPaintEngineState *s = state();

    ensureOutlineMapper();

    d->outlineMapper->m_clip_rect = d->deviceRect;

    if (d->outlineMapper->m_clip_rect.width() > QT_RASTER_COORD_LIMIT)

        d->outlineMapper->m_clip_rect.setWidth(QT_RASTER_COORD_LIMIT);

    if (d->outlineMapper->m_clip_rect.height() > QT_RASTER_COORD_LIMIT)

        d->outlineMapper->m_clip_rect.setHeight(QT_RASTER_COORD_LIMIT);

    d->rasterizer->setClipRect(d->deviceRect);

    s->penData.init(d->rasterBuffer.data(), this);

    s->penData.setup(s->pen.brush(), s->intOpacity, s->composition_mode);

    s->stroker = &d->basicStroker;

    d->basicStroker.setClipRect(d->deviceRect);

    s->brushData.init(d->rasterBuffer.data(), this);

    s->brushData.setup(s->brush, s->intOpacity, s->composition_mode);

    d->rasterBuffer->compositionMode = QPainter::CompositionMode_SourceOver;

    setDirty(DirtyBrushOrigin);

#ifdef QT_DEBUG_DRAW

    qDebug() << "QRasterPaintEngine::begin(" << (void *) device

             << ") devType:" << device->devType()

             << "devRect:" << d->deviceRect;

    if (d->baseClip) {

        dumpClip(d->rasterBuffer->width(), d->rasterBuffer->height(), &*d->baseClip);

    }

#endif

    if (d->mono_surface)

        d->glyphCacheFormat = QFontEngine::Format_Mono;

#if defined(Q_OS_WIN)

    else if (clearTypeFontsEnabled())

#else

    else if (false)

#endif

    {

        QImage::Format format = static_cast<QImage *>(d->device)->format();

        if (format == QImage::Format_ARGB32_Premultiplied || format == QImage::Format_RGB32)

            d->glyphCacheFormat = QFontEngine::Format_A32;

        else

            d->glyphCacheFormat = QFontEngine::Format_A8;

    } else

        d->glyphCacheFormat = QFontEngine::Format_A8;

    setActive(true);

    return true;

}

/*!

    \reimp

*/

bool QRasterPaintEngine::end()

{

#ifdef QT_DEBUG_DRAW

    Q_D(QRasterPaintEngine);

    qDebug() << "QRasterPaintEngine::end devRect:" << d->deviceRect;

    if (d->baseClip) {

        dumpClip(d->rasterBuffer->width(), d->rasterBuffer->height(), &*d->baseClip);

    }

#endif

    return true;

}

/*!

    \internal

*/

void QRasterPaintEngine::updateMatrix(const QTransform &matrix)

{

    QRasterPaintEngineState *s = state();

    // FALCON: get rid of this line, see drawImage call below.

    s->matrix = matrix;

    s->flags.tx_noshear = qt_scaleForTransform(s->matrix, &s->txscale);

    ensureOutlineMapper();

}

QRasterPaintEngineState::~QRasterPaintEngineState()

{

    if (flags.has_clip_ownership)

        delete clip;

}

QRasterPaintEngineState::QRasterPaintEngineState()

{

    stroker = nullptr;

    fillFlags = 0;

    strokeFlags = 0;

    pixmapFlags = 0;

    intOpacity = 256;

    txscale = 1.;

    flags.fast_pen = true;

    flags.non_complex_pen = false;

    flags.antialiased = false;

    flags.bilinear = false;

    flags.legacy_rounding = false;

    flags.fast_text = true;

    flags.tx_noshear = true;

    flags.fast_images = true;

    clip = nullptr;

    flags.has_clip_ownership = false;

    dirty = 0;

}

QRasterPaintEngineState::QRasterPaintEngineState(QRasterPaintEngineState &s)

    : QPainterState(s)

    , lastPen(s.lastPen)

    , penData(s.penData)

    , stroker(s.stroker)

    , strokeFlags(s.strokeFlags)

    , lastBrush(s.lastBrush)

    , brushData(s.brushData)

    , fillFlags(s.fillFlags)

    , pixmapFlags(s.pixmapFlags)

    , intOpacity(s.intOpacity)

    , txscale(s.txscale)

    , clip(s.clip)

    , dirty(s.dirty)

    , flag_bits(s.flag_bits)

{

    brushData.tempImage = nullptr;

    penData.tempImage = nullptr;

    flags.has_clip_ownership = false;

}

/*!

    \internal

*/

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

{

    QRasterPaintEngineState *s;

    if (!orig)

        s = new QRasterPaintEngineState();

    else

        s = new QRasterPaintEngineState(*static_cast<QRasterPaintEngineState *>(orig));

    return s;

}

/*!

    \internal

*/

void QRasterPaintEngine::setState(QPainterState *s)

{

    Q_D(QRasterPaintEngine);

    QPaintEngineEx::setState(s);

    QRasterPaintEngineState *t = state();

    if (t->clip && t->clip->enabled != t->clipEnabled) {

        // Since we do not "detach" clipdata when changing only enabled state, we need to resync state here

        t->clip->enabled = t->clipEnabled;

    }

    d->rasterBuffer->compositionMode = s->composition_mode;

}

/*!

    \fn QRasterPaintEngineState *QRasterPaintEngine::state()

    \internal

*/

/*!

    \fn const QRasterPaintEngineState *QRasterPaintEngine::state() const

    \internal

*/

/*!

    \internal

*/

void QRasterPaintEngine::penChanged()

{

#ifdef QT_DEBUG_DRAW

    qDebug() << "QRasterPaintEngine::penChanged():" << state()->pen;

#endif

    QRasterPaintEngineState *s = state();

    Q_ASSERT(s);

    s->strokeFlags |= DirtyPen;

    s->dirty |= DirtyPen;

}

/*!

    \internal

*/

void QRasterPaintEngine::updatePen(const QPen &pen)

{

    Q_D(QRasterPaintEngine);

    QRasterPaintEngineState *s = state();

#ifdef QT_DEBUG_DRAW

    qDebug() << "QRasterPaintEngine::updatePen():" << s->pen;

#endif

    Qt::PenStyle pen_style = qpen_style(pen);

    s->lastPen = pen;

    s->strokeFlags = 0;

    s->penData.clip = d->clip();

    s->penData.setup(pen_style == Qt::NoPen ? QBrush() : pen.brush(), s->intOpacity, s->composition_mode);

    if (s->strokeFlags & QRasterPaintEngine::DirtyTransform

        || pen.brush().transform().type() >= QTransform::TxNone) {

        d->updateMatrixData(&s->penData, pen.brush(), s->matrix);

    }

    // Slightly ugly handling of an uncommon case... We need to change

    // the pen because it is reused in draw_midpoint to decide dashed

    // or non-dashed.

    if (pen_style == Qt::CustomDashLine && pen.dashPattern().size() == 0) {

        pen_style = Qt::SolidLine;

        s->lastPen.setStyle(Qt::SolidLine);

    }

    d->basicStroker.setJoinStyle(qpen_joinStyle(pen));

    d->basicStroker.setCapStyle(qpen_capStyle(pen));

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

    qreal penWidth = qpen_widthf(pen);

    if (penWidth == 0)

        d->basicStroker.setStrokeWidth(1);

    else

        d->basicStroker.setStrokeWidth(penWidth);

    if(pen_style == Qt::SolidLine) {

        s->stroker = &d->basicStroker;

    } else if (pen_style != Qt::NoPen) {

        if (!d->dashStroker)

            d->dashStroker.reset(new QDashStroker(&d->basicStroker));

        if (qt_pen_is_cosmetic(pen, s->renderHints)) {

            d->dashStroker->setClipRect(d->deviceRect);

        } else {

            // ### I've seen this inverted devrect multiple places now...

            QRectF clipRect = s->matrix.inverted().mapRect(QRectF(d->deviceRect));

            d->dashStroker->setClipRect(clipRect);

        }

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

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

        s->stroker = d->dashStroker.data();

    } else {

        s->stroker = nullptr;

    }

    ensureRasterState(); // needed because of tx_noshear...

    bool cosmetic = qt_pen_is_cosmetic(pen, s->renderHints);

    s->flags.fast_pen = pen_style > Qt::NoPen

            && s->penData.blend

            && ((cosmetic && penWidth <= 1)

                || (!cosmetic && (s->flags.tx_noshear || !s->flags.antialiased) && penWidth * s->txscale <= 1));

    s->flags.non_complex_pen = qpen_capStyle(s->lastPen) <= Qt::SquareCap && s->flags.tx_noshear;

    s->strokeFlags = 0;

}

/*!

    \internal

*/

void QRasterPaintEngine::brushOriginChanged()

{

    QRasterPaintEngineState *s = state();

#ifdef QT_DEBUG_DRAW

    qDebug() << "QRasterPaintEngine::brushOriginChanged()" << s->brushOrigin;

#endif

    s->fillFlags |= DirtyBrushOrigin;

}

/*!

    \internal

*/

void QRasterPaintEngine::brushChanged()

{

    QRasterPaintEngineState *s = state();

#ifdef QT_DEBUG_DRAW

    qDebug() << "QRasterPaintEngine::brushChanged():" << s->brush;

#endif

    s->fillFlags |= DirtyBrush;

}

/*!

    \internal

*/

void QRasterPaintEngine::updateBrush(const QBrush &brush)

{

#ifdef QT_DEBUG_DRAW

    qDebug() << "QRasterPaintEngine::updateBrush()" << brush;

#endif

    Q_D(QRasterPaintEngine);

    QRasterPaintEngineState *s = state();

    // must set clip prior to setup, as setup uses it...

    s->brushData.clip = d->clip();

    s->brushData.setup(brush, s->intOpacity, s->composition_mode);

    if (s->fillFlags & DirtyTransform

        || brush.transform().type() >= QTransform::TxNone)

        d_func()->updateMatrixData(&s->brushData, brush, d->brushMatrix());

    s->lastBrush = brush;

    s->fillFlags = 0;

}

void QRasterPaintEngine::updateOutlineMapper()

{

    Q_D(QRasterPaintEngine);

    d->outlineMapper->setMatrix(state()->matrix);

}

void QRasterPaintEngine::updateRasterState()

{

    QRasterPaintEngineState *s = state();

    if (s->dirty & DirtyTransform)

        updateMatrix(s->matrix);

    if (s->dirty & (DirtyPen|DirtyCompositionMode|DirtyOpacity)) {

        const QPainter::CompositionMode mode = s->composition_mode;

        s->flags.fast_text = (s->penData.type == QSpanData::Solid)

                       && s->intOpacity == 256

                       && (mode == QPainter::CompositionMode_SourceOver

                           || (mode == QPainter::CompositionMode_Source

                               && s->penData.solidColor.isOpaque()));

    }

    s->dirty = 0;

}

/*!

    \internal

*/

void QRasterPaintEngine::opacityChanged()

{

    QRasterPaintEngineState *s = state();

#ifdef QT_DEBUG_DRAW

    qDebug() << "QRasterPaintEngine::opacityChanged()" << s->opacity;

#endif

    s->fillFlags |= DirtyOpacity;

    s->strokeFlags |= DirtyOpacity;

    s->pixmapFlags |= DirtyOpacity;

    s->dirty |= DirtyOpacity;

    s->intOpacity = (int) (s->opacity * 256);

}

/*!

    \internal

*/

void QRasterPaintEngine::compositionModeChanged()

{

    Q_D(QRasterPaintEngine);

    QRasterPaintEngineState *s = state();

#ifdef QT_DEBUG_DRAW

    qDebug() << "QRasterPaintEngine::compositionModeChanged()" << s->composition_mode;

#endif

    s->fillFlags |= DirtyCompositionMode;

    s->dirty |= DirtyCompositionMode;

    s->strokeFlags |= DirtyCompositionMode;

    d->rasterBuffer->compositionMode = s->composition_mode;

    d->recalculateFastImages();

}

/*!

    \internal

*/

void QRasterPaintEngine::renderHintsChanged()

{

    QRasterPaintEngineState *s = state();

#ifdef QT_DEBUG_DRAW

    qDebug() << "QRasterPaintEngine::renderHintsChanged()" << Qt::hex << s->renderHints;

#endif

    bool was_aa = s->flags.antialiased;

    bool was_bilinear = s->flags.bilinear;

    s->flags.antialiased = bool(s->renderHints & QPainter::Antialiasing);

#if QT_DEPRECATED_SINCE(5, 14)

QT_WARNING_PUSH

QT_WARNING_DISABLE_DEPRECATED

    if (s->renderHints & QPainter::HighQualityAntialiasing)

        s->flags.antialiased = true;

QT_WARNING_POP

#endif

    s->flags.bilinear = bool(s->renderHints & QPainter::SmoothPixmapTransform);

    s->flags.legacy_rounding = !bool(s->renderHints & QPainter::Antialiasing) && bool(s->renderHints & QPainter::Qt4CompatiblePainting);

    if (was_aa != s->flags.antialiased)

        s->strokeFlags |= DirtyHints;

    if (was_bilinear != s->flags.bilinear) {

        s->strokeFlags |= DirtyPen;

        s->fillFlags |= DirtyBrush;

    }

    Q_D(QRasterPaintEngine);

    d->recalculateFastImages();

}

/*!

    \internal

*/

void QRasterPaintEngine::transformChanged()

{

    QRasterPaintEngineState *s = state();

#ifdef QT_DEBUG_DRAW

    qDebug() << "QRasterPaintEngine::transformChanged()" << s->matrix;

#endif

    s->fillFlags |= DirtyTransform;

    s->strokeFlags |= DirtyTransform;

    s->dirty |= DirtyTransform;

    Q_D(QRasterPaintEngine);

    d->recalculateFastImages();

}

/*!

    \internal

*/

void QRasterPaintEngine::clipEnabledChanged()

{

    QRasterPaintEngineState *s = state();

#ifdef QT_DEBUG_DRAW

    qDebug() << "QRasterPaintEngine::clipEnabledChanged()" << s->clipEnabled;

#endif

    if (s->clip) {

        s->clip->enabled = s->clipEnabled;

        s->fillFlags |= DirtyClipEnabled;

        s->strokeFlags |= DirtyClipEnabled;

        s->pixmapFlags |= DirtyClipEnabled;

    }

}

void QRasterPaintEnginePrivate::drawImage(const QPointF &pt,

                                          const QImage &img,

                                          SrcOverBlendFunc func,

                                          const QRect &clip,

                                          int alpha,

                                          const QRect &sr)

{

    if (alpha == 0 || !clip.isValid())

        return;

    if (pt.x() > qreal(clip.right()) || pt.y() > qreal(clip.bottom()))

        return;

    if ((pt.x() + img.width()) < qreal(clip.left()) || (pt.y() + img.height()) < qreal(clip.top()))

        return;

    Q_ASSERT(img.depth() >= 8);

    qsizetype srcBPL = img.bytesPerLine();

    const uchar *srcBits = img.bits();

    int srcSize = img.depth() >> 3; // This is the part that is incompatible with lower than 8-bit..

    int iw = img.width();

    int ih = img.height();

    if (!sr.isEmpty()) {

        iw = sr.width();

        ih = sr.height();

        // Adjust the image according to the source offset...

        srcBits += ((sr.y() * srcBPL) + sr.x() * srcSize);

    }

    // adapt the x parameters

    int x = qRound(pt.x());

    int cx1 = clip.x();

    int cx2 = clip.x() + clip.width();

    if (x < cx1) {

        int d = cx1 - x;

        srcBits += srcSize * d;

        iw -= d;

        x = cx1;

    }

    if (x + iw > cx2) {

        int d = x + iw - cx2;

        iw -= d;

    }

    if (iw <= 0)

        return;

    // adapt the y paremeters...

    int cy1 = clip.y();

    int cy2 = clip.y() + clip.height();

    int y = qRound(pt.y());

    if (y < cy1) {

        int d = cy1 - y;

        srcBits += srcBPL * d;

        ih -= d;

        y = cy1;

    }

    if (y + ih > cy2) {

        int d = y + ih - cy2;

        ih -= d;

    }

    if (ih <= 0)

        return;

    // call the blend function...

    int dstSize = rasterBuffer->bytesPerPixel();

    qsizetype dstBPL = rasterBuffer->bytesPerLine();

    func(rasterBuffer->buffer() + x * dstSize + y * dstBPL, dstBPL,