--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/painting/qpaintengine_raster.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,6151 @@
+/****************************************************************************
+**
+** 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 <QtCore/qglobal.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 <qhash.h>
+#include <qlabel.h>
+#include <qbitmap.h>
+#include <qmath.h>
+
+#if defined (Q_WS_X11)
+# include <private/qfontengine_ft_p.h>
+#endif
+
+// #include <private/qdatabuffer_p.h>
+// #include <private/qpainter_p.h>
+#include <private/qmath_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 "qpaintengine_raster_p.h"
+// #include "qbezier_p.h"
+#include "qoutlinemapper_p.h"
+
+#if defined(Q_WS_WIN)
+# include <qt_windows.h>
+# include <qvarlengtharray.h>
+# include <private/qfontengine_p.h>
+# if defined(Q_OS_WINCE)
+# include "qguifunctions_wince.h"
+# endif
+#elif defined(Q_WS_MAC)
+# include <private/qt_mac_p.h>
+# include <private/qpixmap_mac_p.h>
+# include <private/qpaintengine_mac_p.h>
+#elif defined(Q_WS_QWS)
+# if !defined(QT_NO_FREETYPE)
+# include <private/qfontengine_ft_p.h>
+# endif
+# if !defined(QT_NO_QWS_QPF2)
+# include <private/qfontengine_qpf_p.h>
+# endif
+# include <private/qabstractfontengine_p.h>
+#elif defined(Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE)
+# include <private/qfontengine_s60_p.h>
+#endif
+
+#if defined(Q_WS_WIN64)
+# include <malloc.h>
+#endif
+#include <limits.h>
+
+#if defined(QT_NO_FPU) || (_MSC_VER >= 1300 && _MSC_VER < 1400)
+# define FLOATING_POINT_BUGGY_OR_NO_FPU
+#endif
+
+QT_BEGIN_NAMESPACE
+
+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))
+
+// use the same rounding as in qrasterizer.cpp (6 bit fixed point)
+static const qreal aliasedCoordinateDelta = 0.5 - 0.015625;
+
+#ifdef Q_WS_WIN
+extern bool qt_cleartype_enabled;
+#endif
+
+#ifdef Q_WS_MAC
+extern bool qt_applefontsmoothing_enabled;
+#endif
+
+
+/********************************************************************************
+ * 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);
+static void qt_merge_clip(const QClipData *c1, const QClipData *c2, QClipData *result);
+
+struct ClipData
+{
+ QClipData *oldClip;
+ QClipData *newClip;
+ Qt::ClipOperation operation;
+};
+
+enum LineDrawMode {
+ LineDrawClipped,
+ LineDrawNormal,
+ LineDrawIncludeLastPixel
+};
+
+static void drawLine_midpoint_i(int x1, int y1, int x2, int y2, ProcessSpans span_func, QSpanData *data,
+ LineDrawMode style, const QIntRect &rect);
+static void drawLine_midpoint_dashed_i(int x1, int y1, int x2, int y2,
+ QPen *pen, ProcessSpans span_func, QSpanData *data,
+ LineDrawMode style, const QIntRect &devRect,
+ int *patternOffset);
+// static void drawLine_midpoint_f(qreal x1, qreal y1, qreal x2, qreal y2,
+// ProcessSpans span_func, QSpanData *data,
+// LineDrawMode style, const QRect &devRect);
+
+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
+
+template <typename T> static inline bool isRect(const T *pts, int elementCount) {
+ return (elementCount == 5 // 5-point polygon, check for closed rect
+ && pts[0] == pts[8] && pts[1] == pts[9] // last point == first point
+ && pts[0] == pts[6] && pts[2] == pts[4] // x values equal
+ && pts[1] == pts[3] && pts[5] == pts[7] // y values equal...
+ && pts[0] < pts[4] && pts[1] < pts[5]
+ ) ||
+ (elementCount == 4 // 4-point polygon, check for unclosed rect
+ && pts[0] == pts[6] && pts[2] == pts[4] // x values equal
+ && pts[1] == pts[3] && pts[5] == pts[7] // y values equal...
+ && pts[0] < pts[4] && pts[1] < pts[5]
+ );
+}
+
+
+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
+
+
+
+/*!
+ \class QRasterPaintEngine
+ \preliminary
+ \ingroup qws
+ \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
+ \l{Qt for Embedded Linux}.
+
+ In \l{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 (derived from the
+ QCustomRasterPaintDevice class) and a custom window surface
+ (derived from QWSWindowSurface) must be implemented to make
+ \l{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.
+
+ See the \l {Adding an Accelerated Graphics Driver to Qt for Embedded Linux}
+ documentation for details.
+
+ \sa QCustomRasterPaintDevice, QPaintEngine
+*/
+
+/*!
+ \fn 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_WS_WIN
+ d->hdc = 0;
+#endif
+
+ d->rasterPoolSize = 8192;
+ d->rasterPoolBase =
+#if defined(Q_WS_WIN64)
+ // We make use of setjmp and longjmp in qgrayraster.c which requires
+ // 16-byte alignment, hence we hardcode this requirement here..
+ (unsigned char *) _aligned_malloc(d->rasterPoolSize, sizeof(void*) * 2);
+#else
+ (unsigned char *) malloc(d->rasterPoolSize);
+#endif
+ Q_CHECK_PTR(d->rasterPoolBase);
+
+ // The antialiasing raster.
+ d->grayRaster.reset(new QT_FT_Raster);
+ Q_CHECK_PTR(d->grayRaster.data());
+ if (qt_ft_grays_raster.raster_new(0, d->grayRaster.data()))
+ QT_THROW(std::bad_alloc()); // an error creating the raster is caused by a bad malloc
+
+
+ qt_ft_grays_raster.raster_reset(*d->grayRaster.data(), d->rasterPoolBase, d->rasterPoolSize);
+
+ 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;
+#ifdef Q_WS_QWS
+ case QInternal::CustomRaster:
+ d->rasterBuffer->prepare(static_cast<QCustomRasterPaintDevice*>(d->device));
+ break;
+#endif
+ default:
+ qWarning("QRasterPaintEngine: unsupported target device %d\n", d->device->devType());
+ d->device = 0;
+ return;
+ }
+
+ switch (format) {
+ case QImage::Format_MonoLSB:
+ case QImage::Format_Mono:
+ d->mono_surface = true;
+ break;
+ case QImage::Format_ARGB8565_Premultiplied:
+ case QImage::Format_ARGB8555_Premultiplied:
+ case QImage::Format_ARGB6666_Premultiplied:
+ case QImage::Format_ARGB4444_Premultiplied:
+ case QImage::Format_ARGB32_Premultiplied:
+ case QImage::Format_ARGB32:
+ gccaps |= PorterDuff;
+ break;
+ case QImage::Format_RGB32:
+ case QImage::Format_RGB444:
+ case QImage::Format_RGB555:
+ case QImage::Format_RGB666:
+ case QImage::Format_RGB888:
+ case QImage::Format_RGB16:
+ break;
+ default:
+ break;
+ }
+}
+
+
+
+
+/*!
+ Destroys this paint engine.
+*/
+QRasterPaintEngine::~QRasterPaintEngine()
+{
+ Q_D(QRasterPaintEngine);
+
+#if defined(Q_WS_WIN64)
+ _aligned_free(d->rasterPoolBase);
+#else
+ free(d->rasterPoolBase);
+#endif
+
+ 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);
+ if (pixmap->data->classId() == QPixmapData::RasterClass)
+ d->device = pixmap->data->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.adjusted(-10, -10, 10, 10);
+ QRect bounds(-QT_RASTER_COORD_LIMIT, -QT_RASTER_COORD_LIMIT,
+ 2*QT_RASTER_COORD_LIMIT, 2*QT_RASTER_COORD_LIMIT);
+ d->outlineMapper->m_clip_rect = bounds.intersected(d->outlineMapper->m_clip_rect);
+
+
+ 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 defined(Q_WS_WIN)
+ d->isPlain45DegreeRotation = true;
+#endif
+
+ if (d->mono_surface)
+ d->glyphCacheType = QFontEngineGlyphCache::Raster_Mono;
+#if defined(Q_WS_WIN)
+ else if (qt_cleartype_enabled)
+#elif defined (Q_WS_MAC)
+ else if (qt_applefontsmoothing_enabled)
+#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->glyphCacheType = QFontEngineGlyphCache::Raster_RGBMask;
+ else
+ d->glyphCacheType = QFontEngineGlyphCache::Raster_A8;
+ } else
+ d->glyphCacheType = QFontEngineGlyphCache::Raster_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::releaseBuffer()
+{
+ Q_D(QRasterPaintEngine);
+ d->rasterBuffer.reset(new QRasterBuffer);
+}
+
+/*!
+ \internal
+*/
+QSize QRasterPaintEngine::size() const
+{
+ Q_D(const QRasterPaintEngine);
+ return QSize(d->rasterBuffer->width(), d->rasterBuffer->height());
+}
+
+/*!
+ \internal
+*/
+#ifndef QT_NO_DEBUG
+void QRasterPaintEngine::saveBuffer(const QString &s) const
+{
+ Q_D(const QRasterPaintEngine);
+ d->rasterBuffer->bufferImage().save(s, "PNG");
+}
+#endif
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::updateMatrix(const QTransform &matrix)
+{
+ QRasterPaintEngineState *s = state();
+ // FALCON: get rid of this line, see drawImage call below.
+ s->matrix = matrix;
+ QTransform::TransformationType txop = s->matrix.type();
+
+ switch (txop) {
+
+ case QTransform::TxNone:
+ s->flags.int_xform = true;
+ break;
+
+ case QTransform::TxTranslate:
+ s->flags.int_xform = qreal(int(s->matrix.dx())) == s->matrix.dx()
+ && qreal(int(s->matrix.dy())) == s->matrix.dy();
+ break;
+
+ case QTransform::TxScale:
+ s->flags.int_xform = qreal(int(s->matrix.dx())) == s->matrix.dx()
+ && qreal(int(s->matrix.dy())) == s->matrix.dy()
+ && qreal(int(s->matrix.m11())) == s->matrix.m11()
+ && qreal(int(s->matrix.m22())) == s->matrix.m22();
+ break;
+
+ default: // shear / perspective...
+ s->flags.int_xform = false;
+ break;
+ }
+
+ s->flags.tx_noshear = qt_scaleForTransform(s->matrix, &s->txscale);
+
+ ensureOutlineMapper();
+
+#ifdef Q_WS_WIN
+ Q_D(QRasterPaintEngine);
+ d->isPlain45DegreeRotation = false;
+ if (txop >= QTransform::TxRotate) {
+ d->isPlain45DegreeRotation =
+ (qFuzzyIsNull(matrix.m11())
+ && qFuzzyIsNull(matrix.m12() - qreal(1))
+ && qFuzzyIsNull(matrix.m21() + qreal(1))
+ && qFuzzyIsNull(matrix.m22())
+ )
+ ||
+ (qFuzzyIsNull(matrix.m11() + qreal(1))
+ && qFuzzyIsNull(matrix.m12())
+ && qFuzzyIsNull(matrix.m21())
+ && qFuzzyIsNull(matrix.m22() + qreal(1))
+ )
+ ||
+ (qFuzzyIsNull(matrix.m11())
+ && qFuzzyIsNull(matrix.m12() + qreal(1))
+ && qFuzzyIsNull(matrix.m21() - qreal(1))
+ && qFuzzyIsNull(matrix.m22())
+ )
+ ;
+ }
+#endif
+
+}
+
+
+
+QRasterPaintEngineState::~QRasterPaintEngineState()
+{
+ if (flags.has_clip_ownership)
+ delete clip;
+}
+
+
+QRasterPaintEngineState::QRasterPaintEngineState()
+{
+ stroker = 0;
+
+ fillFlags = 0;
+ strokeFlags = 0;
+ pixmapFlags = 0;
+
+ intOpacity = 256;
+
+ txscale = 1.;
+
+ flags.fast_pen = true;
+ flags.antialiased = false;
+ flags.bilinear = false;
+ flags.fast_text = true;
+ flags.int_xform = true;
+ flags.tx_noshear = true;
+ flags.fast_images = true;
+
+ clip = 0;
+ flags.has_clip_ownership = false;
+
+ dirty = 0;
+}
+
+QRasterPaintEngineState::QRasterPaintEngineState(QRasterPaintEngineState &s)
+ : QPainterState(s)
+{
+ stroker = s.stroker;
+
+ lastBrush = s.lastBrush;
+ brushData = s.brushData;
+ brushData.tempImage = 0;
+
+ lastPen = s.lastPen;
+ penData = s.penData;
+ penData.tempImage = 0;
+
+ fillFlags = s.fillFlags;
+ strokeFlags = s.strokeFlags;
+ pixmapFlags = s.pixmapFlags;
+
+ intOpacity = s.intOpacity;
+
+ txscale = s.txscale;
+
+ flag_bits = s.flag_bits;
+
+ clip = s.clip;
+ flags.has_clip_ownership = false;
+
+ dirty = s.dirty;
+}
+
+/*!
+ \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);
+ 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();
+ 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 (pen.isCosmetic()) {
+ 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 = 0;
+ }
+
+ s->flags.fast_pen = pen_style > Qt::NoPen
+ && s->penData.blend
+ && !s->flags.antialiased
+ && (penWidth == 0 || (penWidth <= 1
+ && (s->matrix.type() <= QTransform::TxTranslate
+ || pen.isCosmetic())));
+
+ ensureState(); // needed because of tx_noshear...
+ 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::updateState()
+{
+ QRasterPaintEngineState *s = state();
+
+ if (s->dirty & DirtyTransform)
+ updateMatrix(s->matrix);
+
+ if (s->dirty & (DirtyPen|DirtyCompositionMode)) {
+ const QPainter::CompositionMode mode = s->composition_mode;
+ s->flags.fast_text = (s->penData.type == QSpanData::Solid)
+ && (mode == QPainter::CompositionMode_Source
+ || (mode == QPainter::CompositionMode_SourceOver
+ && qAlpha(s->penData.solid.color) == 255));
+ }
+
+ 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->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()" << hex << s->renderHints;
+#endif
+
+ bool was_aa = s->flags.antialiased;
+ bool was_bilinear = s->flags.bilinear;
+
+ s->flags.antialiased = bool(s->renderHints & QPainter::Antialiasing);
+ s->flags.bilinear = bool(s->renderHints & QPainter::SmoothPixmapTransform);
+
+ 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;
+ }
+}
+
+#ifdef Q_WS_QWS
+void QRasterPaintEnginePrivate::prepare(QCustomRasterPaintDevice *device)
+{
+ rasterBuffer->prepare(device);
+}
+#endif
+
+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;
+
+ Q_ASSERT(img.depth() >= 8);
+
+ int 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();
+ int dstBPL = rasterBuffer->bytesPerLine();
+ func(rasterBuffer->buffer() + x * dstSize + y * dstBPL, dstBPL,
+ srcBits, srcBPL,
+ iw, ih,
+ alpha);
+}
+
+
+void QRasterPaintEnginePrivate::systemStateChanged()
+{
+ QRect clipRect(0, 0,
+ qMin(QT_RASTER_COORD_LIMIT, device->width()),
+ qMin(QT_RASTER_COORD_LIMIT, device->height()));
+
+ if (!systemClip.isEmpty()) {
+ QRegion clippedDeviceRgn = systemClip & clipRect;
+ deviceRect = clippedDeviceRgn.boundingRect();
+ baseClip->setClipRegion(clippedDeviceRgn);
+ } else {
+ deviceRect = clipRect;
+ baseClip->setClipRect(deviceRect);
+ }
+#ifdef QT_DEBUG_DRAW
+ qDebug() << "systemStateChanged" << this << "deviceRect" << deviceRect << clipRect << systemClip;
+#endif
+
+ exDeviceRect = deviceRect;
+
+ Q_Q(QRasterPaintEngine);
+ q->state()->strokeFlags |= QPaintEngine::DirtyClipRegion;
+ q->state()->fillFlags |= QPaintEngine::DirtyClipRegion;
+ q->state()->pixmapFlags |= QPaintEngine::DirtyClipRegion;
+}
+
+void QRasterPaintEnginePrivate::updateMatrixData(QSpanData *spanData, const QBrush &b, const QTransform &m)
+{
+ if (b.d->style == Qt::NoBrush || b.d->style == Qt::SolidPattern)
+ return;
+
+ Q_Q(QRasterPaintEngine);
+ bool bilinear = q->state()->flags.bilinear;
+
+ if (b.d->transform.type() > QTransform::TxNone) { // FALCON: optimise
+ spanData->setupMatrix(b.transform() * m, bilinear);
+ } else {
+ if (m.type() <= QTransform::TxTranslate) {
+ // specialize setupMatrix for translation matrices
+ // to avoid needless matrix inversion
+ spanData->m11 = 1;
+ spanData->m12 = 0;
+ spanData->m13 = 0;
+ spanData->m21 = 0;
+ spanData->m22 = 1;
+ spanData->m23 = 0;
+ spanData->m33 = 1;
+ spanData->dx = -m.dx();
+ spanData->dy = -m.dy();
+ spanData->txop = m.type();
+ spanData->bilinear = bilinear;
+ spanData->fast_matrix = qAbs(m.dx()) < 1e4 && qAbs(m.dy()) < 1e4;
+ spanData->adjustSpanMethods();
+ } else {
+ spanData->setupMatrix(m, bilinear);
+ }
+ }
+}
+
+// #define QT_CLIPPING_RATIOS
+
+#ifdef QT_CLIPPING_RATIOS
+int rectClips;
+int regionClips;
+int totalClips;
+
+static void checkClipRatios(QRasterPaintEnginePrivate *d)
+{
+ if (d->clip()->hasRectClip)
+ rectClips++;
+ if (d->clip()->hasRegionClip)
+ regionClips++;
+ totalClips++;
+
+ if ((totalClips % 5000) == 0) {
+ printf("Clipping ratio: rectangular=%f%%, region=%f%%, complex=%f%%\n",
+ rectClips * 100.0 / (qreal) totalClips,
+ regionClips * 100.0 / (qreal) totalClips,
+ (totalClips - rectClips - regionClips) * 100.0 / (qreal) totalClips);
+ totalClips = 0;
+ rectClips = 0;
+ regionClips = 0;
+ }
+
+}
+#endif
+
+static void qrasterpaintengine_state_setNoClip(QRasterPaintEngineState *s)
+{
+ if (s->flags.has_clip_ownership)
+ delete s->clip;
+ s->clip = 0;
+ s->flags.has_clip_ownership = false;
+}
+
+static void qrasterpaintengine_dirty_clip(QRasterPaintEnginePrivate *d, QRasterPaintEngineState *s)
+{
+ s->fillFlags |= QPaintEngine::DirtyClipPath;
+ s->strokeFlags |= QPaintEngine::DirtyClipPath;
+ s->pixmapFlags |= QPaintEngine::DirtyClipPath;
+
+ d->solid_color_filler.clip = d->clip();
+ d->solid_color_filler.adjustSpanMethods();
+
+#ifdef QT_DEBUG_DRAW
+ dumpClip(d->rasterBuffer->width(), d->rasterBuffer->height(), &*d->clip());
+#endif
+
+}
+
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << "QRasterPaintEngine::clip(): " << path << op;
+
+ if (path.elements()) {
+ for (int i=0; i<path.elementCount(); ++i) {
+ qDebug() << " - " << path.elements()[i]
+ << '(' << path.points()[i*2] << ", " << path.points()[i*2+1] << ')';
+ }
+ } else {
+ for (int i=0; i<path.elementCount(); ++i) {
+ qDebug() << " ---- "
+ << '(' << path.points()[i*2] << ", " << path.points()[i*2+1] << ')';
+ }
+ }
+#endif
+
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ const qreal *points = path.points();
+ const QPainterPath::ElementType *types = path.elements();
+
+ // There are some cases that are not supported by clip(QRect)
+ if (op != Qt::UniteClip && (op != Qt::IntersectClip || !s->clip
+ || s->clip->hasRectClip || s->clip->hasRegionClip)) {
+ if (s->matrix.type() <= QTransform::TxTranslate
+ && ((path.shape() == QVectorPath::RectangleHint)
+ || (isRect(points, path.elementCount())
+ && (!types || (types[0] == QPainterPath::MoveToElement
+ && types[1] == QPainterPath::LineToElement
+ && types[2] == QPainterPath::LineToElement
+ && types[3] == QPainterPath::LineToElement))))) {
+#ifdef QT_DEBUG_DRAW
+ qDebug() << " --- optimizing vector clip to rect clip...";
+#endif
+
+ QRectF r(points[0], points[1], points[4]-points[0], points[5]-points[1]);
+ clip(r.toRect(), op);
+ return;
+ }
+ }
+
+ if (op == Qt::NoClip) {
+ qrasterpaintengine_state_setNoClip(s);
+
+ } else {
+ QClipData *base = d->baseClip.data();
+
+ // Intersect with current clip when available...
+ if (op == Qt::IntersectClip && s->clip)
+ base = s->clip;
+
+ // We always intersect, except when there is nothing to
+ // intersect with, in which case we simplify the operation to
+ // a replace...
+ Qt::ClipOperation isectOp = Qt::IntersectClip;
+ if (base == 0)
+ isectOp = Qt::ReplaceClip;
+
+ QClipData *newClip = new QClipData(d->rasterBuffer->height());
+ newClip->initialize();
+ ClipData clipData = { base, newClip, isectOp };
+ ensureOutlineMapper();
+ d->rasterize(d->outlineMapper->convertPath(path), qt_span_clip, &clipData, 0);
+
+ newClip->fixup();
+
+ if (op == Qt::UniteClip) {
+ // merge clips
+ QClipData *result = new QClipData(d->rasterBuffer->height());
+ QClipData *current = s->clip ? s->clip : new QClipData(d->rasterBuffer->height());
+ qt_merge_clip(current, newClip, result);
+ result->fixup();
+ delete newClip;
+ if (!s->clip)
+ delete current;
+ newClip = result;
+ }
+
+ if (s->flags.has_clip_ownership)
+ delete s->clip;
+
+ s->clip = newClip;
+ s->flags.has_clip_ownership = true;
+ }
+ qrasterpaintengine_dirty_clip(d, s);
+}
+
+
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::clip(const QRect &rect, Qt::ClipOperation op)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << "QRasterPaintEngine::clip(): " << rect << op;
+#endif
+
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ if (op == Qt::NoClip) {
+ qrasterpaintengine_state_setNoClip(s);
+
+ } else if (op == Qt::UniteClip || s->matrix.type() > QTransform::TxScale) {
+ QPaintEngineEx::clip(rect, op);
+ return;
+
+ } else if (op == Qt::ReplaceClip || s->clip == 0) {
+
+ // No current clip, hence we intersect with sysclip and be
+ // done with it...
+ QRect clipRect = s->matrix.mapRect(rect) & d->deviceRect;
+ QRegion clipRegion = systemClip();
+ QClipData *clip = new QClipData(d->rasterBuffer->height());
+
+ if (clipRegion.isEmpty())
+ clip->setClipRect(clipRect);
+ else
+ clip->setClipRegion(clipRegion & clipRect);
+
+ if (s->flags.has_clip_ownership)
+ delete s->clip;
+
+ s->clip = clip;
+ s->clip->enabled = true;
+ s->flags.has_clip_ownership = true;
+
+ } else { // intersect clip with current clip
+ QClipData *base = s->clip;
+
+ Q_ASSERT(base);
+ if (base->hasRectClip || base->hasRegionClip) {
+ QRect clipRect = s->matrix.mapRect(rect) & d->deviceRect;
+ if (!s->flags.has_clip_ownership) {
+ s->clip = new QClipData(d->rasterBuffer->height());
+ s->flags.has_clip_ownership = true;
+ }
+ if (base->hasRectClip)
+ s->clip->setClipRect(base->clipRect & clipRect);
+ else
+ s->clip->setClipRegion(base->clipRegion & clipRect);
+ s->clip->enabled = true;
+ } else {
+ QPaintEngineEx::clip(rect, op);
+ return;
+ }
+ }
+ qrasterpaintengine_dirty_clip(d, s);
+}
+
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::clip(const QRegion ®ion, Qt::ClipOperation op)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << "QRasterPaintEngine::clip(): " << region << op;
+#endif
+
+ Q_D(QRasterPaintEngine);
+
+ if (region.numRects() == 1) {
+ clip(region.boundingRect(), op);
+ return;
+ }
+
+ QRasterPaintEngineState *s = state();
+ const QClipData *clip = d->clip();
+ const QClipData *baseClip = d->baseClip.data();
+
+ if (op == Qt::NoClip) {
+ qrasterpaintengine_state_setNoClip(s);
+ } else if (s->matrix.type() > QTransform::TxScale
+ || op == Qt::UniteClip
+ || (op == Qt::IntersectClip && !clip->hasRectClip && !clip->hasRegionClip)
+ || (op == Qt::ReplaceClip && !baseClip->hasRectClip && !baseClip->hasRegionClip)) {
+ QPaintEngineEx::clip(region, op);
+ } else {
+ const QClipData *curClip;
+ QClipData *newClip;
+
+ if (op == Qt::IntersectClip)
+ curClip = clip;
+ else
+ curClip = baseClip;
+
+ if (s->flags.has_clip_ownership) {
+ newClip = s->clip;
+ Q_ASSERT(newClip);
+ } else {
+ newClip = new QClipData(d->rasterBuffer->height());
+ s->clip = newClip;
+ s->flags.has_clip_ownership = true;
+ }
+
+ QRegion r = s->matrix.map(region);
+ if (curClip->hasRectClip)
+ newClip->setClipRegion(r & curClip->clipRect);
+ else if (curClip->hasRegionClip)
+ newClip->setClipRegion(r & curClip->clipRegion);
+
+ qrasterpaintengine_dirty_clip(d, s);
+ }
+}
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::fillPath(const QPainterPath &path, QSpanData *fillData)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << " --- fillPath, bounds=" << path.boundingRect();
+#endif
+
+ if (!fillData->blend)
+ return;
+
+ Q_D(QRasterPaintEngine);
+
+ const QRectF controlPointRect = path.controlPointRect();
+
+ QRasterPaintEngineState *s = state();
+ const QRect deviceRect = s->matrix.mapRect(controlPointRect).toRect();
+ ProcessSpans blend = d->getBrushFunc(deviceRect, fillData);
+ const bool do_clip = (deviceRect.left() < -QT_RASTER_COORD_LIMIT
+ || deviceRect.right() > QT_RASTER_COORD_LIMIT
+ || deviceRect.top() < -QT_RASTER_COORD_LIMIT
+ || deviceRect.bottom() > QT_RASTER_COORD_LIMIT);
+
+ if (!s->flags.antialiased && !do_clip) {
+ d->initializeRasterizer(fillData);
+ d->rasterizer->rasterize(path * s->matrix, path.fillRule());
+ return;
+ }
+
+ ensureOutlineMapper();
+ d->rasterize(d->outlineMapper->convertPath(path), blend, fillData, d->rasterBuffer.data());
+}
+
+static void fillRect_normalized(const QRect &r, QSpanData *data,
+ QRasterPaintEnginePrivate *pe)
+{
+ int x1, x2, y1, y2;
+
+ bool rectClipped = true;
+
+ if (data->clip) {
+ x1 = qMax(r.x(), data->clip->xmin);
+ x2 = qMin(r.x() + r.width(), data->clip->xmax);
+ y1 = qMax(r.y(), data->clip->ymin);
+ y2 = qMin(r.y() + r.height(), data->clip->ymax);
+ rectClipped = data->clip->hasRectClip;
+
+ } else if (pe) {
+ x1 = qMax(r.x(), pe->deviceRect.x());
+ x2 = qMin(r.x() + r.width(), pe->deviceRect.x() + pe->deviceRect.width());
+ y1 = qMax(r.y(), pe->deviceRect.y());
+ y2 = qMin(r.y() + r.height(), pe->deviceRect.y() + pe->deviceRect.height());
+ } else {
+ x1 = qMax(r.x(), 0);
+ x2 = qMin(r.x() + r.width(), data->rasterBuffer->width());
+ y1 = qMax(r.y(), 0);
+ y2 = qMin(r.y() + r.height(), data->rasterBuffer->height());
+ }
+
+ if (x2 <= x1 || y2 <= y1)
+ return;
+
+ const int width = x2 - x1;
+ const int height = y2 - y1;
+
+ bool isUnclipped = rectClipped
+ || (pe && pe->isUnclipped_normalized(QRect(x1, y1, width, height)));
+
+ if (pe && isUnclipped) {
+ const QPainter::CompositionMode mode = pe->rasterBuffer->compositionMode;
+
+ if (data->fillRect && (mode == QPainter::CompositionMode_Source
+ || (mode == QPainter::CompositionMode_SourceOver
+ && qAlpha(data->solid.color) == 255)))
+ {
+ data->fillRect(data->rasterBuffer, x1, y1, width, height,
+ data->solid.color);
+ return;
+ }
+ }
+
+ ProcessSpans blend = isUnclipped ? data->unclipped_blend : data->blend;
+
+ const int nspans = 256;
+ QT_FT_Span spans[nspans];
+
+ Q_ASSERT(data->blend);
+ int y = y1;
+ while (y < y2) {
+ int n = qMin(nspans, y2 - y);
+ int i = 0;
+ while (i < n) {
+ spans[i].x = x1;
+ spans[i].len = width;
+ spans[i].y = y + i;
+ spans[i].coverage = 255;
+ ++i;
+ }
+
+ blend(n, spans, data);
+ y += n;
+ }
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::drawRects(const QRect *rects, int rectCount)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug(" - QRasterPaintEngine::drawRect(), rectCount=%d", rectCount);
+#endif
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ // Fill
+ ensureBrush();
+ if (s->brushData.blend) {
+ if (!s->flags.antialiased && s->matrix.type() <= QTransform::TxTranslate) {
+ const QRect *r = rects;
+ const QRect *lastRect = rects + rectCount;
+
+ int offset_x = int(s->matrix.dx());
+ int offset_y = int(s->matrix.dy());
+ while (r < lastRect) {
+ QRect rect = r->normalized();
+ QRect rr = rect.translated(offset_x, offset_y);
+ fillRect_normalized(rr, &s->brushData, d);
+ ++r;
+ }
+ } else {
+ QRectVectorPath path;
+ for (int i=0; i<rectCount; ++i) {
+ path.set(rects[i]);
+ fill(path, s->brush);
+ }
+ }
+ }
+
+ ensurePen();
+ if (s->penData.blend) {
+ if (s->flags.fast_pen && s->lastPen.brush().isOpaque()) {
+ const QRect *r = rects;
+ const QRect *lastRect = rects + rectCount;
+ while (r < lastRect) {
+ int left = r->x();
+ int right = r->x() + r->width();
+ int top = r->y();
+ int bottom = r->y() + r->height();
+
+#ifdef Q_WS_MAC
+ int pts[] = { top, left,
+ top, right,
+ bottom, right,
+ bottom, left };
+#else
+ int pts[] = { left, top,
+ right, top,
+ right, bottom,
+ left, bottom };
+#endif
+
+ strokePolygonCosmetic((QPoint *) pts, 4, WindingMode);
+ ++r;
+ }
+ } else {
+ QRectVectorPath path;
+ for (int i = 0; i < rectCount; ++i) {
+ path.set(rects[i]);
+ stroke(path, s->pen);
+ }
+ }
+ }
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::drawRects(const QRectF *rects, int rectCount)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug(" - QRasterPaintEngine::drawRect(), rectCount=%d", rectCount);
+#endif
+#ifdef QT_FAST_SPANS
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ ensureState();
+
+ if (s->flags.tx_noshear) {
+ ensureBrush();
+ if (s->brushData.blend) {
+ d->initializeRasterizer(&s->brushData);
+ for (int i = 0; i < rectCount; ++i) {
+ const QRectF &rect = rects[i].normalized();
+ if (rect.isEmpty())
+ continue;
+ const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f);
+ const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f);
+ d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width());
+ }
+ }
+
+ ensurePen();
+ if (s->penData.blend) {
+ qreal width = s->pen.isCosmetic()
+ ? (s->lastPen.widthF() == 0 ? 1 : s->lastPen.widthF())
+ : s->lastPen.widthF() * s->txscale;
+
+ if (s->flags.fast_pen && s->lastPen.brush().isOpaque()) {
+ for (int i = 0; i < rectCount; ++i) {
+ const QRectF &r = rects[i];
+ qreal left = r.x();
+ qreal right = r.x() + r.width();
+ qreal top = r.y();
+ qreal bottom = r.y() + r.height();
+ qreal pts[] = { left, top,
+ right, top,
+ right, bottom,
+ left, bottom };
+ strokePolygonCosmetic((QPointF *) pts, 4, WindingMode);
+ }
+ } else if (width <= 1 && qpen_style(s->lastPen) == Qt::SolidLine) {
+ d->initializeRasterizer(&s->penData);
+
+ for (int i = 0; i < rectCount; ++i) {
+ const QRectF &rect = rects[i].normalized();
+ if (rect.isEmpty()) {
+ qreal pts[] = { rect.left(), rect.top(), rect.right(), rect.bottom() };
+ QVectorPath vp(pts, 2, 0, QVectorPath::LinesHint);
+ QPaintEngineEx::stroke(vp, s->lastPen);
+ } else {
+ const QPointF tl = s->matrix.map(rect.topLeft());
+ const QPointF tr = s->matrix.map(rect.topRight());
+ const QPointF bl = s->matrix.map(rect.bottomLeft());
+ const QPointF br = s->matrix.map(rect.bottomRight());
+ const qreal w = width / (rect.width() * s->txscale);
+ const qreal h = width / (rect.height() * s->txscale);
+ d->rasterizer->rasterizeLine(tl, tr, w); // top
+ d->rasterizer->rasterizeLine(bl, br, w); // bottom
+ d->rasterizer->rasterizeLine(bl, tl, h); // left
+ d->rasterizer->rasterizeLine(br, tr, h); // right
+ }
+ }
+ } else {
+ for (int i = 0; i < rectCount; ++i) {
+ const QRectF &r = rects[i];
+ qreal left = r.x();
+ qreal right = r.x() + r.width();
+ qreal top = r.y();
+ qreal bottom = r.y() + r.height();
+ qreal pts[] = { left, top,
+ right, top,
+ right, bottom,
+ left, bottom,
+ left, top };
+ QVectorPath vp(pts, 5, 0, QVectorPath::RectangleHint);
+ QPaintEngineEx::stroke(vp, s->lastPen);
+ }
+ }
+ }
+
+ return;
+ }
+#endif // QT_FAST_SPANS
+ QPaintEngineEx::drawRects(rects, rectCount);
+}
+
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
+{
+ QRasterPaintEngineState *s = state();
+ ensurePen(pen);
+ if (!s->penData.blend)
+ return;
+
+ if (s->flags.fast_pen && path.shape() <= QVectorPath::NonCurvedShapeHint
+ && s->lastPen.brush().isOpaque()) {
+ int count = path.elementCount();
+ QPointF *points = (QPointF *) path.points();
+ const QPainterPath::ElementType *types = path.elements();
+ if (types) {
+ int first = 0;
+ int last;
+ while (first < count) {
+ while (first < count && types[first] != QPainterPath::MoveToElement) ++first;
+ last = first + 1;
+ while (last < count && types[last] == QPainterPath::LineToElement) ++last;
+ strokePolygonCosmetic(points + first, last - first,
+ path.hasImplicitClose() && last == count // only close last one..
+ ? WindingMode
+ : PolylineMode);
+ first = last;
+ }
+ } else {
+ strokePolygonCosmetic(points, count,
+ path.hasImplicitClose()
+ ? WindingMode
+ : PolylineMode);
+ }
+
+ } else if (s->flags.non_complex_pen && path.shape() == QVectorPath::LinesHint) {
+ qreal width = s->lastPen.isCosmetic()
+ ? (qpen_widthf(s->lastPen) == 0 ? 1 : qpen_widthf(s->lastPen))
+ : qpen_widthf(s->lastPen) * s->txscale;
+ int dashIndex = 0;
+ qreal dashOffset = s->lastPen.dashOffset();
+ bool inDash = true;
+ qreal patternLength = 0;
+ const QVector<qreal> pattern = s->lastPen.dashPattern();
+ for (int i = 0; i < pattern.size(); ++i)
+ patternLength += pattern.at(i);
+
+ if (patternLength > 0) {
+ int n = qFloor(dashOffset / patternLength);
+ dashOffset -= n * patternLength;
+ while (dashOffset > pattern.at(dashIndex)) {
+ dashOffset -= pattern.at(dashIndex);
+ dashIndex = (dashIndex + 1) % pattern.size();
+ inDash = !inDash;
+ }
+ }
+
+ Q_D(QRasterPaintEngine);
+ d->initializeRasterizer(&s->penData);
+ int lineCount = path.elementCount() / 2;
+ const QLineF *lines = reinterpret_cast<const QLineF *>(path.points());
+
+ for (int i = 0; i < lineCount; ++i) {
+ if (path.shape() == QVectorPath::LinesHint)
+ dashOffset = s->lastPen.dashOffset();
+ if (lines[i].p1() == lines[i].p2()) {
+ if (s->lastPen.capStyle() != Qt::FlatCap) {
+ QPointF p = lines[i].p1();
+ QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*0.5, p.y()),
+ QPointF(p.x() + width*0.5, p.y())));
+ d->rasterizer->rasterizeLine(line.p1(), line.p2(), 1);
+ }
+ continue;
+ }
+
+ const QLineF line = s->matrix.map(lines[i]);
+ if (qpen_style(s->lastPen) == Qt::SolidLine) {
+ d->rasterizer->rasterizeLine(line.p1(), line.p2(),
+ width / line.length(),
+ s->lastPen.capStyle() == Qt::SquareCap);
+ } else {
+ d->rasterizeLine_dashed(line, width,
+ &dashIndex, &dashOffset, &inDash);
+ }
+ }
+ }
+ else
+ QPaintEngineEx::stroke(path, pen);
+}
+
+static inline QRect toNormalizedFillRect(const QRectF &rect)
+{
+ int x1 = qRound(rect.x() + aliasedCoordinateDelta);
+ int y1 = qRound(rect.y() + aliasedCoordinateDelta);
+ int x2 = qRound(rect.right() + aliasedCoordinateDelta);
+ int y2 = qRound(rect.bottom() + aliasedCoordinateDelta);
+
+ if (x2 < x1)
+ qSwap(x1, x2);
+ if (y2 < y1)
+ qSwap(y1, y2);
+
+ return QRect(x1, y1, x2 - x1, y2 - y1);
+}
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
+{
+ if (path.isEmpty())
+ return;
+#ifdef QT_DEBUG_DRAW
+ QRectF rf = path.controlPointRect();
+ qDebug() << "QRasterPaintEngine::fill(): "
+ << "size=" << path.elementCount()
+ << ", hints=" << hex << path.hints()
+ << rf << brush;
+#endif
+
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ ensureBrush(brush);
+ if (!s->brushData.blend)
+ return;
+
+ if (path.shape() == QVectorPath::RectangleHint) {
+ if (!s->flags.antialiased && s->matrix.type() <= QTransform::TxScale) {
+ const qreal *p = path.points();
+ QPointF tl = QPointF(p[0], p[1]) * s->matrix;
+ QPointF br = QPointF(p[4], p[5]) * s->matrix;
+ fillRect_normalized(toNormalizedFillRect(QRectF(tl, br)), &s->brushData, d);
+ return;
+ }
+ ensureState();
+ if (s->flags.tx_noshear) {
+ d->initializeRasterizer(&s->brushData);
+ // ### Is normalizing really nessesary here?
+ const qreal *p = path.points();
+ QRectF r = QRectF(p[0], p[1], p[2] - p[0], p[7] - p[1]).normalized();
+ if (!r.isEmpty()) {
+ const QPointF a = s->matrix.map((r.topLeft() + r.bottomLeft()) * 0.5f);
+ const QPointF b = s->matrix.map((r.topRight() + r.bottomRight()) * 0.5f);
+ d->rasterizer->rasterizeLine(a, b, r.height() / r.width());
+ }
+ return;
+ }
+ }
+
+ if (path.shape() == QVectorPath::EllipseHint) {
+ if (!s->flags.antialiased && s->matrix.type() <= QTransform::TxScale) {
+ const qreal *p = path.points();
+ QPointF tl = QPointF(p[0], p[1]) * s->matrix;
+ QPointF br = QPointF(p[4], p[5]) * s->matrix;
+ QRectF r = s->matrix.mapRect(QRectF(tl, br));
+
+ ProcessSpans penBlend = d->getPenFunc(r, &s->penData);
+ ProcessSpans brushBlend = d->getBrushFunc(r, &s->brushData);
+ const QRect brect = QRect(int(r.x()), int(r.y()),
+ int_dim(r.x(), r.width()),
+ int_dim(r.y(), r.height()));
+ if (brect == r) {
+ drawEllipse_midpoint_i(brect, d->deviceRect, penBlend, brushBlend,
+ &s->penData, &s->brushData);
+ return;
+ }
+ }
+ }
+
+ // ### Optimize for non transformed ellipses and rectangles...
+ QRectF cpRect = path.controlPointRect();
+ const QRect deviceRect = s->matrix.mapRect(cpRect).toRect();
+ ProcessSpans blend = d->getBrushFunc(deviceRect, &s->brushData);
+
+ // ### Falcon
+// const bool do_clip = (deviceRect.left() < -QT_RASTER_COORD_LIMIT
+// || deviceRect.right() > QT_RASTER_COORD_LIMIT
+// || deviceRect.top() < -QT_RASTER_COORD_LIMIT
+// || deviceRect.bottom() > QT_RASTER_COORD_LIMIT);
+
+ // ### Falonc: implement....
+// if (!s->flags.antialiased && !do_clip) {
+// d->initializeRasterizer(&s->brushData);
+// d->rasterizer->rasterize(path * d->matrix, path.fillRule());
+// return;
+// }
+
+ ensureOutlineMapper();
+ d->rasterize(d->outlineMapper->convertPath(path), blend, &s->brushData, d->rasterBuffer.data());
+}
+
+void QRasterPaintEngine::fillRect(const QRectF &r, QSpanData *data)
+{
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ if (!s->flags.antialiased) {
+ uint txop = s->matrix.type();
+ if (txop == QTransform::TxNone) {
+ fillRect_normalized(toNormalizedFillRect(r), data, d);
+ return;
+ } else if (txop == QTransform::TxTranslate) {
+ const QRect rr = toNormalizedFillRect(r.translated(s->matrix.dx(), s->matrix.dy()));
+ fillRect_normalized(rr, data, d);
+ return;
+ } else if (txop == QTransform::TxScale) {
+ const QRect rr = toNormalizedFillRect(s->matrix.mapRect(r));
+ fillRect_normalized(rr, data, d);
+ return;
+ }
+ }
+ ensureState();
+ if (s->flags.tx_noshear) {
+ d->initializeRasterizer(data);
+ QRectF nr = r.normalized();
+ if (!nr.isEmpty()) {
+ const QPointF a = s->matrix.map((nr.topLeft() + nr.bottomLeft()) * 0.5f);
+ const QPointF b = s->matrix.map((nr.topRight() + nr.bottomRight()) * 0.5f);
+ d->rasterizer->rasterizeLine(a, b, nr.height() / nr.width());
+ }
+ return;
+ }
+
+ QPainterPath path;
+ path.addRect(r);
+ ensureOutlineMapper();
+ fillPath(path, data);
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::fillRect(const QRectF &r, const QBrush &brush)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << "QRasterPaintEngine::fillRecct(): " << r << brush;
+#endif
+ QRasterPaintEngineState *s = state();
+
+ ensureBrush(brush);
+ if (!s->brushData.blend)
+ return;
+
+ fillRect(r, &s->brushData);
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::fillRect(const QRectF &r, const QColor &color)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << "QRasterPaintEngine::fillRect(): " << r << color;
+#endif
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ d->solid_color_filler.solid.color = PREMUL(ARGB_COMBINE_ALPHA(color.rgba(), s->intOpacity));
+ if ((d->solid_color_filler.solid.color & 0xff000000) == 0
+ && s->composition_mode == QPainter::CompositionMode_SourceOver) {
+ return;
+ }
+ d->solid_color_filler.clip = d->clip();
+ d->solid_color_filler.adjustSpanMethods();
+ fillRect(r, &d->solid_color_filler);
+}
+
+static inline bool isAbove(const QPointF *a, const QPointF *b)
+{
+ return a->y() < b->y();
+}
+
+static bool splitPolygon(const QPointF *points, int pointCount, QVector<QPointF> *upper, QVector<QPointF> *lower)
+{
+ Q_ASSERT(upper);
+ Q_ASSERT(lower);
+
+ Q_ASSERT(pointCount >= 2);
+
+ QVector<const QPointF *> sorted;
+ sorted.reserve(pointCount);
+
+ upper->reserve(pointCount * 3 / 4);
+ lower->reserve(pointCount * 3 / 4);
+
+ for (int i = 0; i < pointCount; ++i)
+ sorted << points + i;
+
+ qSort(sorted.begin(), sorted.end(), isAbove);
+
+ qreal splitY = sorted.at(sorted.size() / 2)->y();
+
+ const QPointF *end = points + pointCount;
+ const QPointF *last = end - 1;
+
+ QVector<QPointF> *bin[2] = { upper, lower };
+
+ for (const QPointF *p = points; p < end; ++p) {
+ int side = p->y() < splitY;
+ int lastSide = last->y() < splitY;
+
+ if (side != lastSide) {
+ if (qFuzzyCompare(p->y(), splitY)) {
+ bin[!side]->append(*p);
+ } else if (qFuzzyCompare(last->y(), splitY)) {
+ bin[side]->append(*last);
+ } else {
+ QPointF delta = *p - *last;
+ QPointF intersection(p->x() + delta.x() * (splitY - p->y()) / delta.y(), splitY);
+
+ bin[0]->append(intersection);
+ bin[1]->append(intersection);
+ }
+ }
+
+ bin[side]->append(*p);
+
+ last = p;
+ }
+
+ // give up if we couldn't reduce the point count
+ return upper->size() < pointCount && lower->size() < pointCount;
+}
+
+/*!
+ \internal
+ */
+void QRasterPaintEngine::fillPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ const int maxPoints = 0xffff;
+
+ // max amount of points that raster engine can reliably handle
+ if (pointCount > maxPoints) {
+ QVector<QPointF> upper, lower;
+
+ if (splitPolygon(points, pointCount, &upper, &lower)) {
+ fillPolygon(upper.constData(), upper.size(), mode);
+ fillPolygon(lower.constData(), lower.size(), mode);
+ } else
+ qWarning("Polygon too complex for filling.");
+
+ return;
+ }
+
+ // Compose polygon fill..,
+ QVectorPath vp((qreal *) points, pointCount, 0, QVectorPath::polygonFlags(mode));
+ ensureOutlineMapper();
+ QT_FT_Outline *outline = d->outlineMapper->convertPath(vp);
+
+ // scanconvert.
+ ProcessSpans brushBlend = d->getBrushFunc(d->outlineMapper->controlPointRect,
+ &s->brushData);
+ d->rasterize(outline, brushBlend, &s->brushData, d->rasterBuffer.data());
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+#ifdef QT_DEBUG_DRAW
+ qDebug(" - QRasterPaintEngine::drawPolygon(F), pointCount=%d", pointCount);
+ for (int i=0; i<pointCount; ++i)
+ qDebug() << " - " << points[i];
+#endif
+ Q_ASSERT(pointCount >= 2);
+
+ if (mode != PolylineMode && isRect((qreal *) points, pointCount)) {
+ QRectF r(points[0], points[2]);
+ drawRects(&r, 1);
+ return;
+ }
+
+ ensurePen();
+ ensureBrush();
+ if (mode != PolylineMode) {
+ // Do the fill...
+ if (s->brushData.blend) {
+ d->outlineMapper->setCoordinateRounding(s->penData.blend && s->flags.fast_pen && s->lastPen.brush().isOpaque());
+ fillPolygon(points, pointCount, mode);
+ d->outlineMapper->setCoordinateRounding(false);
+ }
+ }
+
+ // Do the outline...
+ if (s->penData.blend) {
+ if (s->flags.fast_pen && s->lastPen.brush().isOpaque())
+ strokePolygonCosmetic(points, pointCount, mode);
+ else {
+ QVectorPath vp((qreal *) points, pointCount, 0, QVectorPath::polygonFlags(mode));
+ QPaintEngineEx::stroke(vp, s->lastPen);
+ }
+ }
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
+{
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+#ifdef QT_DEBUG_DRAW
+ qDebug(" - QRasterPaintEngine::drawPolygon(I), pointCount=%d", pointCount);
+ for (int i=0; i<pointCount; ++i)
+ qDebug() << " - " << points[i];
+#endif
+ Q_ASSERT(pointCount >= 2);
+ if (mode != PolylineMode && isRect((int *) points, pointCount)) {
+ QRect r(points[0].x(),
+ points[0].y(),
+ points[2].x() - points[0].x(),
+ points[2].y() - points[0].y());
+ drawRects(&r, 1);
+ return;
+ }
+
+ ensureState();
+ ensurePen();
+ if (!(s->flags.int_xform && s->flags.fast_pen && (!s->penData.blend || s->pen.brush().isOpaque()))) {
+ // this calls the float version
+ QPaintEngineEx::drawPolygon(points, pointCount, mode);
+ return;
+ }
+
+ // Do the fill
+ if (mode != PolylineMode) {
+ ensureBrush();
+ if (s->brushData.blend) {
+ // Compose polygon fill..,
+ ensureOutlineMapper();
+ d->outlineMapper->setCoordinateRounding(s->penData.blend != 0);
+ d->outlineMapper->beginOutline(mode == WindingMode ? Qt::WindingFill : Qt::OddEvenFill);
+ d->outlineMapper->moveTo(*points);
+ const QPoint *p = points;
+ const QPoint *ep = points + pointCount - 1;
+ do {
+ d->outlineMapper->lineTo(*(++p));
+ } while (p < ep);
+ d->outlineMapper->endOutline();
+
+ // scanconvert.
+ ProcessSpans brushBlend = d->getBrushFunc(d->outlineMapper->controlPointRect,
+ &s->brushData);
+ d->rasterize(d->outlineMapper->outline(), brushBlend, &s->brushData, d->rasterBuffer.data());
+ d->outlineMapper->setCoordinateRounding(false);
+ }
+ }
+
+ // Do the outline...
+ if (s->penData.blend) {
+ if (s->flags.fast_pen && s->lastPen.brush().isOpaque())
+ strokePolygonCosmetic(points, pointCount, mode);
+ else {
+ int count = pointCount * 2;
+ QVarLengthArray<qreal> fpoints(count);
+#ifdef Q_WS_MAC
+ for (int i=0; i<count; i+=2) {
+ fpoints[i] = ((int *) points)[i+1];
+ fpoints[i+1] = ((int *) points)[i];
+ }
+#else
+ for (int i=0; i<count; ++i)
+ fpoints[i] = ((int *) points)[i];
+#endif
+ QVectorPath vp((qreal *) fpoints.data(), pointCount, 0, QVectorPath::polygonFlags(mode));
+ QPaintEngineEx::stroke(vp, s->lastPen);
+ }
+ }
+}
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::strokePolygonCosmetic(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ Q_ASSERT(s->penData.blend);
+ Q_ASSERT(s->flags.fast_pen);
+
+ bool needs_closing = mode != PolylineMode && points[0] != points[pointCount-1];
+
+ // Use fast path for 0 width / trivial pens.
+ QIntRect devRect;
+ devRect.set(d->deviceRect);
+
+ LineDrawMode mode_for_last = (s->lastPen.capStyle() != Qt::FlatCap
+ ? LineDrawIncludeLastPixel
+ : LineDrawNormal);
+ int dashOffset = int(s->lastPen.dashOffset());
+
+ const QPointF offs(aliasedCoordinateDelta, aliasedCoordinateDelta);
+
+ // Draw all the line segments.
+ for (int i=1; i<pointCount; ++i) {
+
+ QPointF lp1 = points[i-1] * s->matrix + offs;
+ QPointF lp2 = points[i] * s->matrix + offs;
+
+ const QRectF brect(lp1, lp2);
+ ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+ if (qpen_style(s->lastPen) == Qt::SolidLine) {
+ drawLine_midpoint_i(qFloor(lp1.x()), qFloor(lp1.y()),
+ qFloor(lp2.x()), qFloor(lp2.y()),
+ penBlend, &s->penData,
+ i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
+ devRect);
+ } else {
+ drawLine_midpoint_dashed_i(qFloor(lp1.x()), qFloor(lp1.y()),
+ qFloor(lp2.x()), qFloor(lp2.y()),
+ &s->lastPen,
+ penBlend, &s->penData,
+ i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
+ devRect, &dashOffset);
+ }
+ }
+
+ // Polygons are implicitly closed.
+ if (needs_closing) {
+ QPointF lp1 = points[pointCount-1] * s->matrix + offs;
+ QPointF lp2 = points[0] * s->matrix + offs;
+
+ const QRectF brect(lp1, lp2);
+ ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+ if (qpen_style(s->lastPen) == Qt::SolidLine) {
+ drawLine_midpoint_i(qFloor(lp1.x()), qFloor(lp1.y()),
+ qFloor(lp2.x()), qFloor(lp2.y()),
+ penBlend, &s->penData,
+ LineDrawIncludeLastPixel,
+ devRect);
+ } else {
+ drawLine_midpoint_dashed_i(qFloor(lp1.x()), qFloor(lp1.y()),
+ qFloor(lp2.x()), qFloor(lp2.y()),
+ &s->lastPen,
+ penBlend, &s->penData,
+ LineDrawIncludeLastPixel,
+ devRect, &dashOffset);
+ }
+ }
+
+}
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::strokePolygonCosmetic(const QPoint *points, int pointCount, PolygonDrawMode mode)
+{
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ // We assert here because this function is called from drawRects
+ // and drawPolygon and they already do ensurePen(), so we skip that
+ // here to avoid duplicate checks..
+ Q_ASSERT(s->penData.blend);
+
+ bool needs_closing = mode != PolylineMode && points[0] != points[pointCount-1];
+
+ QIntRect devRect;
+ devRect.set(d->deviceRect);
+
+ LineDrawMode mode_for_last = (s->lastPen.capStyle() != Qt::FlatCap
+ ? LineDrawIncludeLastPixel
+ : LineDrawNormal);
+
+ int m11 = int(s->matrix.m11());
+ int m22 = int(s->matrix.m22());
+ int dx = int(s->matrix.dx());
+ int dy = int(s->matrix.dy());
+ int m13 = int(s->matrix.m13());
+ int m23 = int(s->matrix.m23());
+ bool affine = !m13 && !m23;
+
+ int dashOffset = int(s->lastPen.dashOffset());
+
+ if (affine) {
+ // Draw all the line segments.
+ for (int i=1; i<pointCount; ++i) {
+ const QPoint lp1 = points[i-1] * s->matrix;
+ const QPoint lp2 = points[i] * s->matrix;
+ const QRect brect(lp1, lp2);
+ ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+
+ if (qpen_style(s->lastPen) == Qt::SolidLine)
+ drawLine_midpoint_i(lp1.x(), lp1.y(),
+ lp2.x(), lp2.y(),
+ penBlend, &s->penData,
+ i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
+ devRect);
+ else
+ drawLine_midpoint_dashed_i(lp1.x(), lp1.y(),
+ lp2.x(), lp2.y(),
+ &s->lastPen,
+ penBlend, &s->penData,
+ i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
+ devRect, &dashOffset);
+
+ }
+
+ // Polygons are implicitly closed.
+ if (needs_closing) {
+ const QPoint lp1 = points[pointCount - 1] * s->matrix;
+ const QPoint lp2 = points[0] * s->matrix;
+ const QRect brect(lp1, lp2);
+ ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+
+ if (qpen_style(s->lastPen) == Qt::SolidLine)
+ drawLine_midpoint_i(lp1.x(), lp1.y(),
+ lp2.x(), lp2.y(),
+ penBlend, &s->penData, LineDrawIncludeLastPixel,
+ devRect);
+ else
+ drawLine_midpoint_dashed_i(lp1.x(), lp1.y(),
+ lp2.x(), lp2.y(),
+ &s->lastPen,
+ penBlend, &s->penData, LineDrawIncludeLastPixel,
+ devRect, &dashOffset);
+ }
+ } else {
+ // Draw all the line segments.
+ for (int i=1; i<pointCount; ++i) {
+ int x1 = points[i-1].x() * m11 + dx;
+ int y1 = points[i-1].y() * m22 + dy;
+ qreal w = m13*points[i-1].x() + m23*points[i-1].y() + 1.;
+ w = 1/w;
+ x1 = int(x1*w);
+ y1 = int(y1*w);
+ int x2 = points[i].x() * m11 + dx;
+ int y2 = points[i].y() * m22 + dy;
+ w = m13*points[i].x() + m23*points[i].y() + 1.;
+ w = 1/w;
+ x2 = int(x2*w);
+ y2 = int(y2*w);
+
+ const QRect brect(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
+ ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+ if (qpen_style(s->lastPen) == Qt::SolidLine)
+ drawLine_midpoint_i(x1, y1, x2, y2,
+ penBlend, &s->penData,
+ i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
+ devRect);
+ else
+ drawLine_midpoint_dashed_i(x1, y1, x2, y2,
+ &s->lastPen,
+ penBlend, &s->penData,
+ i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
+ devRect, &dashOffset);
+
+ }
+
+ int x1 = points[pointCount-1].x() * m11 + dx;
+ int y1 = points[pointCount-1].y() * m22 + dy;
+ qreal w = m13*points[pointCount-1].x() + m23*points[pointCount-1].y() + 1.;
+ w = 1/w;
+ x1 = int(x1*w);
+ y1 = int(y1*w);
+ int x2 = points[0].x() * m11 + dx;
+ int y2 = points[0].y() * m22 + dy;
+ w = m13*points[0].x() + m23*points[0].y() + 1.;
+ w = 1/w;
+ x2 = int(x2 * w);
+ y2 = int(y2 * w);
+ // Polygons are implicitly closed.
+
+ if (needs_closing) {
+ const QRect brect(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
+ ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+ if (qpen_style(s->lastPen) == Qt::SolidLine)
+ drawLine_midpoint_i(x1, y1, x2, y2,
+ penBlend, &s->penData, LineDrawIncludeLastPixel,
+ devRect);
+ else
+ drawLine_midpoint_dashed_i(x1, y1, x2, y2,
+ &s->lastPen,
+ penBlend, &s->penData, LineDrawIncludeLastPixel,
+ devRect, &dashOffset);
+ }
+ }
+}
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::drawPixmap(const QPointF &pos, const QPixmap &pixmap)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << " - QRasterPaintEngine::drawPixmap(), pos=" << pos << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
+#endif
+
+ if (pixmap.data->classId() == QPixmapData::RasterClass) {
+ const QImage &image = static_cast<QRasterPixmapData *>(pixmap.data.data())->image;
+ if (image.depth() == 1) {
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+ if (s->matrix.type() <= QTransform::TxTranslate) {
+ ensurePen();
+ drawBitmap(pos + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
+ } else {
+ drawImage(pos, d->rasterBuffer->colorizeBitmap(image, s->pen.color()));
+ }
+ } else {
+ QRasterPaintEngine::drawImage(pos, image);
+ }
+ } else {
+ const QImage image = pixmap.toImage();
+ if (pixmap.depth() == 1) {
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+ if (s->matrix.type() <= QTransform::TxTranslate) {
+ ensurePen();
+ drawBitmap(pos + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
+ } else {
+ drawImage(pos, d->rasterBuffer->colorizeBitmap(image, s->pen.color()));
+ }
+ } else {
+ QRasterPaintEngine::drawImage(pos, image);
+ }
+ }
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pixmap, const QRectF &sr)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << " - QRasterPaintEngine::drawPixmap(), r=" << r << " sr=" << sr << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
+#endif
+
+ if (pixmap.data->classId() == QPixmapData::RasterClass) {
+ const QImage &image = static_cast<QRasterPixmapData *>(pixmap.data.data())->image;
+ if (image.depth() == 1) {
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+ if (s->matrix.type() <= QTransform::TxTranslate
+ && r.size() == sr.size()
+ && r.size() == pixmap.size()) {
+ ensurePen();
+ drawBitmap(r.topLeft() + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
+ return;
+ } else {
+ drawImage(r, d->rasterBuffer->colorizeBitmap(image, s->pen.color()), sr);
+ }
+ } else {
+ drawImage(r, image, sr);
+ }
+ } else {
+ const QImage image = pixmap.toImage();
+ if (image.depth() == 1) {
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+ if (s->matrix.type() <= QTransform::TxTranslate
+ && r.size() == sr.size()
+ && r.size() == pixmap.size()) {
+ ensurePen();
+ drawBitmap(r.topLeft() + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
+ return;
+ } else {
+ drawImage(r, d->rasterBuffer->colorizeBitmap(image, s->pen.color()), sr);
+ }
+ } else {
+ drawImage(r, image, sr);
+ }
+ }
+}
+
+// assumes that rect has positive width and height
+static inline const QRect toRect_normalized(const QRectF &rect)
+{
+ const int x = qRound(rect.x());
+ const int y = qRound(rect.y());
+ const int w = int(rect.width() + qreal(0.5));
+ const int h = int(rect.height() + qreal(0.5));
+
+ return QRect(x, y, w, h);
+}
+
+static inline int fast_ceil_positive(const qreal &v)
+{
+ const int iv = int(v);
+ if (v - iv == 0)
+ return iv;
+ else
+ return iv + 1;
+}
+
+static inline const QRect toAlignedRect_positive(const QRectF &rect)
+{
+ const int xmin = int(rect.x());
+ const int xmax = int(fast_ceil_positive(rect.right()));
+ const int ymin = int(rect.y());
+ const int ymax = int(fast_ceil_positive(rect.bottom()));
+ return QRect(xmin, ymin, xmax - xmin, ymax - ymin);
+}
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::drawImage(const QPointF &p, const QImage &img)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << " - QRasterPaintEngine::drawImage(), p=" << p << " image=" << img.size() << "depth=" << img.depth();
+#endif
+
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ if (s->matrix.type() > QTransform::TxTranslate) {
+ drawImage(QRectF(p.x(), p.y(), img.width(), img.height()),
+ img,
+ QRectF(0, 0, img.width(), img.height()));
+ } else {
+
+ const QClipData *clip = d->clip();
+ QPointF pt(p.x() + s->matrix.dx(), p.y() + s->matrix.dy());
+
+ if (s->flags.fast_images) {
+ SrcOverBlendFunc func = qBlendFunctions[d->rasterBuffer->format][img.format()];
+ if (func) {
+ if (!clip) {
+ d->drawImage(pt, img, func, d->deviceRect, s->intOpacity);
+ return;
+ } else if (clip->hasRectClip) {
+ d->drawImage(pt, img, func, clip->clipRect, s->intOpacity);
+ return;
+ }
+ }
+ }
+
+
+
+ d->image_filler.clip = clip;
+ d->image_filler.initTexture(&img, s->intOpacity, QTextureData::Plain, img.rect());
+ if (!d->image_filler.blend)
+ return;
+ d->image_filler.dx = -pt.x();
+ d->image_filler.dy = -pt.y();
+ QRect rr = img.rect().translated(qRound(pt.x()), qRound(pt.y()));
+
+ fillRect_normalized(rr, &d->image_filler, d);
+ }
+
+}
+
+QRectF qt_mapRect_non_normalizing(const QRectF &r, const QTransform &t)
+{
+ return QRectF(r.topLeft() * t, r.bottomRight() * t);
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRectF &sr,
+ Qt::ImageConversionFlags)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << " - QRasterPaintEngine::drawImage(), r=" << r << " sr=" << sr << " image=" << img.size() << "depth=" << img.depth();
+#endif
+
+ if (r.isEmpty())
+ return;
+
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+ int sr_l = qFloor(sr.left());
+ int sr_r = qCeil(sr.right()) - 1;
+ int sr_t = qFloor(sr.top());
+ int sr_b = qCeil(sr.bottom()) - 1;
+
+ if (!s->flags.antialiased && sr_l == sr_r && sr_t == sr_b) {
+ // as fillRect will apply the aliased coordinate delta we need to
+ // subtract it here as we don't use it for image drawing
+ QTransform old = s->matrix;
+ s->matrix = s->matrix * QTransform::fromTranslate(-aliasedCoordinateDelta, -aliasedCoordinateDelta);
+
+ // Do whatever fillRect() does, but without premultiplying the color if it's already premultiplied.
+ QRgb color = img.pixel(sr_l, sr_t);
+ switch (img.format()) {
+ case QImage::Format_ARGB32_Premultiplied:
+ case QImage::Format_ARGB8565_Premultiplied:
+ case QImage::Format_ARGB6666_Premultiplied:
+ case QImage::Format_ARGB8555_Premultiplied:
+ case QImage::Format_ARGB4444_Premultiplied:
+ // Combine premultiplied color with the opacity set on the painter.
+ d->solid_color_filler.solid.color =
+ ((((color & 0x00ff00ff) * s->intOpacity) >> 8) & 0x00ff00ff)
+ | ((((color & 0xff00ff00) >> 8) * s->intOpacity) & 0xff00ff00);
+ break;
+ default:
+ d->solid_color_filler.solid.color = PREMUL(ARGB_COMBINE_ALPHA(color, s->intOpacity));
+ break;
+ }
+
+ if ((d->solid_color_filler.solid.color & 0xff000000) == 0
+ && s->composition_mode == QPainter::CompositionMode_SourceOver) {
+ return;
+ }
+
+ d->solid_color_filler.clip = d->clip();
+ d->solid_color_filler.adjustSpanMethods();
+ fillRect(r, &d->solid_color_filler);
+
+ s->matrix = old;
+ return;
+ }
+
+ bool stretch_sr = r.width() != sr.width() || r.height() != sr.height();
+
+ const QClipData *clip = d->clip();
+
+ if (s->matrix.type() > QTransform::TxTranslate || stretch_sr) {
+
+ if (s->flags.fast_images) {
+ if (s->matrix.type() > QTransform::TxScale) {
+ SrcOverTransformFunc func = qTransformFunctions[d->rasterBuffer->format][img.format()];
+ if (func && (!clip || clip->hasRectClip)) {
+ func(d->rasterBuffer->buffer(), d->rasterBuffer->bytesPerLine(), img.bits(),
+ img.bytesPerLine(), r, sr, !clip ? d->deviceRect : clip->clipRect,
+ s->matrix, s->intOpacity);
+ return;
+ }
+ } else {
+ SrcOverScaleFunc func = qScaleFunctions[d->rasterBuffer->format][img.format()];
+ if (func && (!clip || clip->hasRectClip)) {
+ func(d->rasterBuffer->buffer(), d->rasterBuffer->bytesPerLine(),
+ img.bits(), img.bytesPerLine(),
+ qt_mapRect_non_normalizing(r, s->matrix), sr,
+ !clip ? d->deviceRect : clip->clipRect,
+ s->intOpacity);
+ return;
+ }
+ }
+ }
+
+ QTransform copy = s->matrix;
+ copy.translate(r.x(), r.y());
+ if (stretch_sr)
+ copy.scale(r.width() / sr.width(), r.height() / sr.height());
+ copy.translate(-sr.x(), -sr.y());
+
+ d->image_filler_xform.clip = clip;
+ d->image_filler_xform.initTexture(&img, s->intOpacity, QTextureData::Plain, toAlignedRect_positive(sr));
+ if (!d->image_filler_xform.blend)
+ return;
+ d->image_filler_xform.setupMatrix(copy, s->flags.bilinear);
+
+ if (!s->flags.antialiased && s->matrix.type() == QTransform::TxScale) {
+ QRectF rr = s->matrix.mapRect(r);
+
+ const int x1 = qRound(rr.x());
+ const int y1 = qRound(rr.y());
+ const int x2 = qRound(rr.right());
+ const int y2 = qRound(rr.bottom());
+
+ fillRect_normalized(QRect(x1, y1, x2-x1, y2-y1), &d->image_filler_xform, d);
+ return;
+ }
+
+#ifdef QT_FAST_SPANS
+ ensureState();
+ if (s->flags.tx_noshear || s->matrix.type() == QTransform::TxScale) {
+ d->initializeRasterizer(&d->image_filler_xform);
+ d->rasterizer->setAntialiased(s->flags.antialiased);
+
+ const QPointF offs = s->flags.antialiased ? QPointF() : QPointF(aliasedCoordinateDelta, aliasedCoordinateDelta);
+
+ const QRectF &rect = r.normalized();
+ const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f) - offs;
+ const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f) - offs;
+
+ if (s->flags.tx_noshear)
+ d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width());
+ else
+ d->rasterizer->rasterizeLine(a, b, qAbs((s->matrix.m22() * rect.height()) / (s->matrix.m11() * rect.width())));
+ return;
+ }
+#endif
+ const qreal offs = s->flags.antialiased ? qreal(0) : aliasedCoordinateDelta;
+ QPainterPath path;
+ path.addRect(r);
+ QTransform m = s->matrix;
+ s->matrix = QTransform(m.m11(), m.m12(), m.m13(),
+ m.m21(), m.m22(), m.m23(),
+ m.m31() - offs, m.m32() - offs, m.m33());
+ fillPath(path, &d->image_filler_xform);
+ s->matrix = m;
+ } else {
+
+ if (s->flags.fast_images) {
+ SrcOverBlendFunc func = qBlendFunctions[d->rasterBuffer->format][img.format()];
+ if (func) {
+ QPointF pt(r.x() + s->matrix.dx(), r.y() + s->matrix.dy());
+ if (!clip) {
+ d->drawImage(pt, img, func, d->deviceRect, s->intOpacity, sr.toRect());
+ return;
+ } else if (clip->hasRectClip) {
+ d->drawImage(pt, img, func, clip->clipRect, s->intOpacity, sr.toRect());
+ return;
+ }
+ }
+ }
+
+ d->image_filler.clip = clip;
+ d->image_filler.initTexture(&img, s->intOpacity, QTextureData::Plain, toAlignedRect_positive(sr));
+ if (!d->image_filler.blend)
+ return;
+ d->image_filler.dx = -(r.x() + s->matrix.dx()) + sr.x();
+ d->image_filler.dy = -(r.y() + s->matrix.dy()) + sr.y();
+
+ QRectF rr = r;
+ rr.translate(s->matrix.dx(), s->matrix.dy());
+
+ const int x1 = qRound(rr.x());
+ const int y1 = qRound(rr.y());
+ const int x2 = qRound(rr.right());
+ const int y2 = qRound(rr.bottom());
+
+ fillRect_normalized(QRect(x1, y1, x2-x1, y2-y1), &d->image_filler, d);
+ }
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &sr)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << " - QRasterPaintEngine::drawTiledPixmap(), r=" << r << "pixmap=" << pixmap.size();
+#endif
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ QImage image;
+
+ if (pixmap.data->classId() == QPixmapData::RasterClass) {
+ image = static_cast<QRasterPixmapData *>(pixmap.data.data())->image;
+ } else {
+ image = pixmap.toImage();
+ }
+
+ if (image.depth() == 1)
+ image = d->rasterBuffer->colorizeBitmap(image, s->pen.color());
+
+ if (s->matrix.type() > QTransform::TxTranslate) {
+ QTransform copy = s->matrix;
+ copy.translate(r.x(), r.y());
+ copy.translate(-sr.x(), -sr.y());
+ d->image_filler_xform.clip = d->clip();
+ d->image_filler_xform.initTexture(&image, s->intOpacity, QTextureData::Tiled);
+ if (!d->image_filler_xform.blend)
+ return;
+ d->image_filler_xform.setupMatrix(copy, s->flags.bilinear);
+
+#ifdef QT_FAST_SPANS
+ ensureState();
+ if (s->flags.tx_noshear || s->matrix.type() == QTransform::TxScale) {
+ d->initializeRasterizer(&d->image_filler_xform);
+ d->rasterizer->setAntialiased(s->flags.antialiased);
+
+ const QRectF &rect = r.normalized();
+ const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f);
+ const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f);
+ if (s->flags.tx_noshear)
+ d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width());
+ else
+ d->rasterizer->rasterizeLine(a, b, qAbs((s->matrix.m22() * rect.height()) / (s->matrix.m11() * rect.width())));
+ return;
+ }
+#endif
+ QPainterPath path;
+ path.addRect(r);
+ fillPath(path, &d->image_filler_xform);
+ } else {
+ d->image_filler.clip = d->clip();
+
+ d->image_filler.initTexture(&image, s->intOpacity, QTextureData::Tiled);
+ if (!d->image_filler.blend)
+ return;
+ d->image_filler.dx = -(r.x() + s->matrix.dx()) + sr.x();
+ d->image_filler.dy = -(r.y() + s->matrix.dy()) + sr.y();
+
+ QRectF rr = r;
+ rr.translate(s->matrix.dx(), s->matrix.dy());
+ fillRect_normalized(rr.toRect().normalized(), &d->image_filler, d);
+ }
+}
+
+
+//QWS hack
+static inline bool monoVal(const uchar* s, int x)
+{
+ return (s[x>>3] << (x&7)) & 0x80;
+}
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::alphaPenBlt(const void* src, int bpl, int depth, int rx,int ry,int w,int h)
+{
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ if (!s->penData.blend)
+ return;
+
+ QRasterBuffer *rb = d->rasterBuffer.data();
+
+ const QRect rect(rx, ry, w, h);
+ const QClipData *clip = d->clip();
+ bool unclipped = false;
+ if (clip) {
+ // inlined QRect::intersects
+ const bool intersects = qMax(clip->xmin, rect.left()) <= qMin(clip->xmax - 1, rect.right())
+ && qMax(clip->ymin, rect.top()) <= qMin(clip->ymax - 1, rect.bottom());
+
+ if (clip->hasRectClip) {
+ unclipped = rx > clip->xmin
+ && rx + w < clip->xmax
+ && ry > clip->ymin
+ && ry + h < clip->ymax;
+ }
+
+ if (!intersects)
+ return;
+ } else {
+ // inlined QRect::intersects
+ const bool intersects = qMax(0, rect.left()) <= qMin(rb->width() - 1, rect.right())
+ && qMax(0, rect.top()) <= qMin(rb->height() - 1, rect.bottom());
+ if (!intersects)
+ return;
+
+ // inlined QRect::contains
+ const bool contains = rect.left() >= 0 && rect.right() < rb->width()
+ && rect.top() >= 0 && rect.bottom() < rb->height();
+
+ unclipped = contains && d->isUnclipped_normalized(rect);
+ }
+
+ ProcessSpans blend = unclipped ? s->penData.unclipped_blend : s->penData.blend;
+ const uchar * scanline = static_cast<const uchar *>(src);
+
+ if (s->flags.fast_text) {
+ if (unclipped) {
+ if (depth == 1) {
+ if (s->penData.bitmapBlit) {
+ s->penData.bitmapBlit(rb, rx, ry, s->penData.solid.color,
+ scanline, w, h, bpl);
+ return;
+ }
+ } else if (depth == 8) {
+ if (s->penData.alphamapBlit) {
+ s->penData.alphamapBlit(rb, rx, ry, s->penData.solid.color,
+ scanline, w, h, bpl, 0);
+ return;
+ }
+ } else if (depth == 32) {
+ // (A)RGB Alpha mask where the alpha component is not used.
+ if (s->penData.alphaRGBBlit) {
+ s->penData.alphaRGBBlit(rb, rx, ry, s->penData.solid.color,
+ (const uint *) scanline, w, h, bpl / 4, 0);
+ return;
+ }
+ }
+ } else if (d->deviceDepth == 32 && (depth == 8 || depth == 32)) {
+ // (A)RGB Alpha mask where the alpha component is not used.
+ if (!clip) {
+ int nx = qMax(0, rx);
+ int ny = qMax(0, ry);
+
+ // Move scanline pointer to compensate for moved x and y
+ int xdiff = nx - rx;
+ int ydiff = ny - ry;
+ scanline += ydiff * bpl;
+ scanline += xdiff * (depth == 32 ? 4 : 1);
+
+ w -= xdiff;
+ h -= ydiff;
+
+ if (nx + w > d->rasterBuffer->width())
+ w = d->rasterBuffer->width() - nx;
+ if (ny + h > d->rasterBuffer->height())
+ h = d->rasterBuffer->height() - ny;
+
+ rx = nx;
+ ry = ny;
+ }
+ if (depth == 8 && s->penData.alphamapBlit) {
+ s->penData.alphamapBlit(rb, rx, ry, s->penData.solid.color,
+ scanline, w, h, bpl, clip);
+ } else if (depth == 32 && s->penData.alphaRGBBlit) {
+ s->penData.alphaRGBBlit(rb, rx, ry, s->penData.solid.color,
+ (const uint *) scanline, w, h, bpl / 4, clip);
+ }
+ return;
+ }
+ }
+
+ int x0 = 0;
+ if (rx < 0) {
+ x0 = -rx;
+ w -= x0;
+ }
+
+ int y0 = 0;
+ if (ry < 0) {
+ y0 = -ry;
+ scanline += bpl * y0;
+ h -= y0;
+ }
+
+ w = qMin(w, rb->width() - qMax(0, rx));
+ h = qMin(h, rb->height() - qMax(0, ry));
+
+ if (w <= 0 || h <= 0)
+ return;
+
+ const int NSPANS = 256;
+ QSpan spans[NSPANS];
+ int current = 0;
+
+ const int x1 = x0 + w;
+ const int y1 = y0 + h;
+
+ if (depth == 1) {
+ for (int y = y0; y < y1; ++y) {
+ for (int x = x0; x < x1; ) {
+ if (!monoVal(scanline, x)) {
+ ++x;
+ continue;
+ }
+
+ if (current == NSPANS) {
+ blend(current, spans, &s->penData);
+ current = 0;
+ }
+ spans[current].x = x + rx;
+ spans[current].y = y + ry;
+ spans[current].coverage = 255;
+ int len = 1;
+ ++x;
+ // extend span until we find a different one.
+ while (x < x1 && monoVal(scanline, x)) {
+ ++x;
+ ++len;
+ }
+ spans[current].len = len;
+ ++current;
+ }
+ scanline += bpl;
+ }
+ } else if (depth == 8) {
+ for (int y = y0; y < y1; ++y) {
+ for (int x = x0; x < x1; ) {
+ // Skip those with 0 coverage
+ if (scanline[x] == 0) {
+ ++x;
+ continue;
+ }
+
+ if (current == NSPANS) {
+ blend(current, spans, &s->penData);
+ current = 0;
+ }
+ int coverage = scanline[x];
+ spans[current].x = x + rx;
+ spans[current].y = y + ry;
+ spans[current].coverage = coverage;
+ int len = 1;
+ ++x;
+
+ // extend span until we find a different one.
+ while (x < x1 && scanline[x] == coverage) {
+ ++x;
+ ++len;
+ }
+ spans[current].len = len;
+ ++current;
+ }
+ scanline += bpl;
+ }
+ } else { // 32-bit alpha...
+ uint *sl = (uint *) src;
+ for (int y = y0; y < y1; ++y) {
+ for (int x = x0; x < x1; ) {
+ // Skip those with 0 coverage
+ if ((sl[x] & 0x00ffffff) == 0) {
+ ++x;
+ continue;
+ }
+
+ if (current == NSPANS) {
+ blend(current, spans, &s->penData);
+ current = 0;
+ }
+ uint rgbCoverage = sl[x];
+ int coverage = qGreen(rgbCoverage);
+ spans[current].x = x + rx;
+ spans[current].y = y + ry;
+ spans[current].coverage = coverage;
+ int len = 1;
+ ++x;
+
+ // extend span until we find a different one.
+ while (x < x1 && sl[x] == rgbCoverage) {
+ ++x;
+ ++len;
+ }
+ spans[current].len = len;
+ ++current;
+ }
+ sl += bpl / sizeof(uint);
+ }
+ }
+// qDebug() << "alphaPenBlt: num spans=" << current
+// << "span:" << spans->x << spans->y << spans->len << spans->coverage;
+ // Call span func for current set of spans.
+ if (current != 0)
+ blend(current, spans, &s->penData);
+}
+
+void QRasterPaintEngine::drawCachedGlyphs(const QPointF &p, const QTextItemInt &ti)
+{
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ QVarLengthArray<QFixedPoint> positions;
+ QVarLengthArray<glyph_t> glyphs;
+ QTransform matrix = s->matrix;
+ matrix.translate(p.x(), p.y());
+ ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+
+ QFontEngineGlyphCache::Type glyphType = ti.fontEngine->glyphFormat >= 0 ? QFontEngineGlyphCache::Type(ti.fontEngine->glyphFormat) : d->glyphCacheType;
+
+ QImageTextureGlyphCache *cache =
+ (QImageTextureGlyphCache *) ti.fontEngine->glyphCache(glyphType, s->matrix);
+ if (!cache) {
+ cache = new QImageTextureGlyphCache(glyphType, s->matrix);
+ ti.fontEngine->setGlyphCache(glyphType, cache);
+ }
+
+ cache->populate(ti, glyphs, positions);
+
+ const QImage &image = cache->image();
+ int bpl = image.bytesPerLine();
+
+ int depth = image.depth();
+ int rightShift = 0;
+ int leftShift = 0;
+ if (depth == 32)
+ leftShift = 2; // multiply by 4
+ else if (depth == 1)
+ rightShift = 3; // divide by 8
+
+ int margin = cache->glyphMargin();
+
+ const QFixed offs = QFixed::fromReal(aliasedCoordinateDelta);
+
+ const uchar *bits = image.bits();
+ for (int i=0; i<glyphs.size(); ++i) {
+ const QTextureGlyphCache::Coord &c = cache->coords.value(glyphs[i]);
+ int x = qFloor(positions[i].x + offs) + c.baseLineX - margin;
+ int y = qFloor(positions[i].y + offs) - c.baseLineY - margin;
+
+// printf("drawing [%d %d %d %d] baseline [%d %d], glyph: %d, to: %d %d, pos: %d %d\n",
+// c.x, c.y,
+// c.w, c.h,
+// c.baseLineX, c.baseLineY,
+// glyphs[i],
+// x, y,
+// positions[i].x.toInt(), positions[i].y.toInt());
+
+ alphaPenBlt(bits + ((c.x << leftShift) >> rightShift) + c.y * bpl, bpl, depth, x, y, c.w, c.h);
+ }
+
+ return;
+}
+
+#if defined(Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE)
+void QRasterPaintEngine::drawGlyphsS60(const QPointF &p, const QTextItemInt &ti)
+{
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ QFontEngine *fontEngine = ti.fontEngine;
+ if (fontEngine->type() != QFontEngine::S60FontEngine) {
+ QPaintEngineEx::drawTextItem(p, ti);
+ return;
+ }
+
+ QFontEngineS60 *fe = static_cast<QFontEngineS60 *>(fontEngine);
+
+ QVarLengthArray<QFixedPoint> positions;
+ QVarLengthArray<glyph_t> glyphs;
+ QTransform matrix = s->matrix;
+ matrix.translate(p.x(), p.y());
+ ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+
+ const QFixed aliasDelta = QFixed::fromReal(aliasedCoordinateDelta);
+
+ for (int i=0; i<glyphs.size(); ++i) {
+ TOpenFontCharMetrics tmetrics;
+ const TUint8 *glyphBitmapBytes;
+ TSize glyphBitmapSize;
+ fe->getCharacterData(glyphs[i], tmetrics, glyphBitmapBytes, glyphBitmapSize);
+ const glyph_metrics_t metrics = ti.fontEngine->boundingBox(glyphs[i]);
+ const int x = qFloor(positions[i].x + metrics.x + aliasDelta);
+ const int y = qFloor(positions[i].y + metrics.y + aliasDelta);
+
+ alphaPenBlt(glyphBitmapBytes, glyphBitmapSize.iWidth, 8, x, y, glyphBitmapSize.iWidth, glyphBitmapSize.iHeight);
+ }
+
+ return;
+}
+#endif // Q_OS_SYMBIAN && QT_NO_FREETYPE
+
+/*!
+ * Returns true if the rectangle is completly within the current clip
+ * state of the paint engine.
+ */
+bool QRasterPaintEnginePrivate::isUnclipped_normalized(const QRect &r) const
+{
+ const QClipData *cl = clip();
+ if (!cl) {
+ // inline contains() for performance (we know the rects are normalized)
+ const QRect &r1 = deviceRect;
+ return (r.left() >= r1.left() && r.right() <= r1.right()
+ && r.top() >= r1.top() && r.bottom() <= r1.bottom());
+ }
+
+
+ if (cl->hasRectClip) {
+ // currently all painting functions clips to deviceRect internally
+ if (cl->clipRect == deviceRect)
+ return true;
+
+ // inline contains() for performance (we know the rects are normalized)
+ const QRect &r1 = cl->clipRect;
+ return (r.left() >= r1.left() && r.right() <= r1.right()
+ && r.top() >= r1.top() && r.bottom() <= r1.bottom());
+ } else {
+ return qt_region_strictContains(cl->clipRegion, r);
+ }
+}
+
+bool QRasterPaintEnginePrivate::isUnclipped(const QRect &rect,
+ int penWidth) const
+{
+ Q_Q(const QRasterPaintEngine);
+ const QRasterPaintEngineState *s = q->state();
+ const QClipData *cl = clip();
+ if (!cl) {
+ QRect r = rect.normalized();
+ // inline contains() for performance (we know the rects are normalized)
+ const QRect &r1 = deviceRect;
+ return (r.left() >= r1.left() && r.right() <= r1.right()
+ && r.top() >= r1.top() && r.bottom() <= r1.bottom());
+ }
+
+
+ // currently all painting functions that call this function clip to deviceRect internally
+ if (cl->hasRectClip && cl->clipRect == deviceRect)
+ return true;
+
+ if (s->flags.antialiased)
+ ++penWidth;
+
+ QRect r = rect.normalized();
+ if (penWidth > 0) {
+ r.setX(r.x() - penWidth);
+ r.setY(r.y() - penWidth);
+ r.setWidth(r.width() + 2 * penWidth);
+ r.setHeight(r.height() + 2 * penWidth);
+ }
+
+ if (cl->hasRectClip) {
+ // inline contains() for performance (we know the rects are normalized)
+ const QRect &r1 = cl->clipRect;
+ return (r.left() >= r1.left() && r.right() <= r1.right()
+ && r.top() >= r1.top() && r.bottom() <= r1.bottom());
+ } else {
+ return qt_region_strictContains(cl->clipRegion, r);
+ }
+}
+
+inline bool QRasterPaintEnginePrivate::isUnclipped(const QRectF &rect,
+ int penWidth) const
+{
+ return isUnclipped(rect.normalized().toAlignedRect(), penWidth);
+}
+
+inline ProcessSpans
+QRasterPaintEnginePrivate::getBrushFunc(const QRect &rect,
+ const QSpanData *data) const
+{
+ return isUnclipped(rect, 0) ? data->unclipped_blend : data->blend;
+}
+
+inline ProcessSpans
+QRasterPaintEnginePrivate::getBrushFunc(const QRectF &rect,
+ const QSpanData *data) const
+{
+ return isUnclipped(rect, 0) ? data->unclipped_blend : data->blend;
+}
+
+inline ProcessSpans
+QRasterPaintEnginePrivate::getPenFunc(const QRect &rect,
+ const QSpanData *data) const
+{
+ Q_Q(const QRasterPaintEngine);
+ const QRasterPaintEngineState *s = q->state();
+
+ if (!s->flags.fast_pen && s->matrix.type() > QTransform::TxTranslate)
+ return data->blend;
+ const int penWidth = s->flags.fast_pen ? 1 : qCeil(s->pen.widthF());
+ return isUnclipped(rect, penWidth) ? data->unclipped_blend : data->blend;
+}
+
+inline ProcessSpans
+QRasterPaintEnginePrivate::getPenFunc(const QRectF &rect,
+ const QSpanData *data) const
+{
+ Q_Q(const QRasterPaintEngine);
+ const QRasterPaintEngineState *s = q->state();
+
+ if (!s->flags.fast_pen && s->matrix.type() > QTransform::TxTranslate)
+ return data->blend;
+ const int penWidth = s->flags.fast_pen ? 1 : qCeil(s->lastPen.widthF());
+ return isUnclipped(rect, penWidth) ? data->unclipped_blend : data->blend;
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
+ const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
+ QRasterPaintEngineState *s = state();
+
+#ifdef QT_DEBUG_DRAW
+ Q_D(QRasterPaintEngine);
+ fprintf(stderr," - QRasterPaintEngine::drawTextItem(), (%.2f,%.2f), string=%s ct=%d\n",
+ p.x(), p.y(), QString::fromRawData(ti.chars, ti.num_chars).toLatin1().data(),
+ d->glyphCacheType);
+#endif
+
+ ensurePen();
+ ensureState();
+
+#if defined (Q_WS_WIN) || defined(Q_WS_MAC)
+
+ bool drawCached = true;
+
+ if (s->matrix.type() >= QTransform::TxProject)
+ drawCached = false;
+
+ // don't try to cache huge fonts
+ if (ti.fontEngine->fontDef.pixelSize * qSqrt(s->matrix.determinant()) >= 64)
+ drawCached = false;
+
+ // ### Remove the TestFontEngine and Box engine crap, in these
+ // ### cases we should delegate painting to the font engine
+ // ### directly...
+
+#if defined(Q_WS_WIN) && !defined(Q_WS_WINCE)
+ QFontEngine::Type fontEngineType = ti.fontEngine->type();
+ // qDebug() << "type" << fontEngineType << s->matrix.type();
+ if ((fontEngineType == QFontEngine::Win && !((QFontEngineWin *) ti.fontEngine)->ttf && s->matrix.type() > QTransform::TxTranslate)
+ || (s->matrix.type() <= QTransform::TxTranslate
+ && (fontEngineType == QFontEngine::TestFontEngine
+ || fontEngineType == QFontEngine::Box))) {
+ drawCached = false;
+ }
+#else
+ if (s->matrix.type() > QTransform::TxTranslate)
+ drawCached = false;
+#endif
+ if (drawCached) {
+ drawCachedGlyphs(p, ti);
+ return;
+ }
+
+#elif defined (Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE) // Q_WS_WIN || Q_WS_MAC
+ if (s->matrix.type() <= QTransform::TxTranslate) {
+ drawGlyphsS60(p, ti);
+ return;
+ }
+#else // Q_WS_WIN || Q_WS_MAC
+
+ QFontEngine *fontEngine = ti.fontEngine;
+
+#if defined(Q_WS_QWS)
+ if (fontEngine->type() == QFontEngine::Box) {
+ fontEngine->draw(this, qFloor(p.x() + aliasedCoordinateDelta), qFloor(p.y() + aliasedCoordinateDelta), ti);
+ return;
+ }
+
+ if (s->matrix.type() < QTransform::TxScale
+ && (fontEngine->type() == QFontEngine::QPF1 || fontEngine->type() == QFontEngine::QPF2
+ || (fontEngine->type() == QFontEngine::Proxy
+ && !(static_cast<QProxyFontEngine *>(fontEngine)->drawAsOutline()))
+ )) {
+ fontEngine->draw(this, qFloor(p.x() + aliasedCoordinateDelta), qFloor(p.y() + aliasedCoordinateDelta), ti);
+ return;
+ }
+#endif // Q_WS_QWS
+
+#if (defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN)) && !defined(QT_NO_FREETYPE)
+
+#if defined(Q_WS_QWS) && !defined(QT_NO_QWS_QPF2)
+ if (fontEngine->type() == QFontEngine::QPF2) {
+ QFontEngine *renderingEngine = static_cast<QFontEngineQPF *>(fontEngine)->renderingEngine();
+ if (renderingEngine)
+ fontEngine = renderingEngine;
+ }
+#endif
+
+ if (fontEngine->type() != QFontEngine::Freetype) {
+ QPaintEngineEx::drawTextItem(p, ti);
+ return;
+ }
+
+ QFontEngineFT *fe = static_cast<QFontEngineFT *>(fontEngine);
+
+ QTransform matrix = s->matrix;
+ matrix.translate(p.x(), p.y());
+
+ QVarLengthArray<QFixedPoint> positions;
+ QVarLengthArray<glyph_t> glyphs;
+ fe->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+ if (glyphs.size() == 0)
+ return;
+
+ // only use subpixel antialiasing when drawing to widgets
+ QFontEngineFT::GlyphFormat neededFormat =
+ painter()->device()->devType() == QInternal::Widget
+ ? fe->defaultGlyphFormat()
+ : QFontEngineFT::Format_A8;
+
+ if (d_func()->mono_surface
+ || fe->isBitmapFont() // alphaPenBlt can handle mono, too
+ )
+ neededFormat = QFontEngineFT::Format_Mono;
+
+ if (neededFormat == QFontEngineFT::Format_None)
+ neededFormat = QFontEngineFT::Format_A8;
+
+ QFontEngineFT::QGlyphSet *gset = fe->defaultGlyphs();
+ if (s->matrix.type() >= QTransform::TxScale) {
+ if (s->matrix.isAffine())
+ gset = fe->loadTransformedGlyphSet(s->matrix);
+ else
+ gset = 0;
+
+ }
+
+ if (!gset || gset->outline_drawing
+ || !fe->loadGlyphs(gset, glyphs.data(), glyphs.size(), neededFormat))
+ {
+ QPaintEngine::drawTextItem(p, ti);
+ return;
+ }
+
+ QFixed offs = QFixed::fromReal(aliasedCoordinateDelta);
+ FT_Face lockedFace = 0;
+
+ int depth;
+ switch (neededFormat) {
+ case QFontEngineFT::Format_Mono:
+ depth = 1;
+ break;
+ case QFontEngineFT::Format_A8:
+ depth = 8;
+ break;
+ case QFontEngineFT::Format_A32:
+ depth = 32;
+ break;
+ default:
+ Q_ASSERT(false);
+ depth = 0;
+ };
+
+ for(int i = 0; i < glyphs.size(); i++) {
+ QFontEngineFT::Glyph *glyph = gset->glyph_data.value(glyphs[i]);
+
+ if (!glyph || glyph->format != neededFormat) {
+ if (!lockedFace)
+ lockedFace = fe->lockFace();
+ glyph = fe->loadGlyph(gset, glyphs[i], neededFormat);
+ }
+
+ if (!glyph || !glyph->data)
+ continue;
+
+ int pitch;
+ switch (neededFormat) {
+ case QFontEngineFT::Format_Mono:
+ pitch = ((glyph->width + 31) & ~31) >> 3;
+ break;
+ case QFontEngineFT::Format_A8:
+ pitch = (glyph->width + 3) & ~3;
+ break;
+ case QFontEngineFT::Format_A32:
+ pitch = glyph->width * 4;
+ break;
+ default:
+ Q_ASSERT(false);
+ pitch = 0;
+ };
+
+ alphaPenBlt(glyph->data, pitch, depth,
+ qFloor(positions[i].x + offs) + glyph->x,
+ qFloor(positions[i].y + offs) - glyph->y,
+ glyph->width, glyph->height);
+ }
+ if (lockedFace)
+ fe->unlockFace();
+ return;
+
+#endif
+#endif
+
+ QPaintEngineEx::drawTextItem(p, ti);
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::drawPoints(const QPointF *points, int pointCount)
+{
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ ensurePen();
+ qreal pw = s->lastPen.widthF();
+ if (!s->flags.fast_pen && (s->matrix.type() > QTransform::TxTranslate || pw > 1)) {
+ QPaintEngineEx::drawPoints(points, pointCount);
+
+ } else {
+ if (!s->penData.blend)
+ return;
+
+ QVarLengthArray<QT_FT_Span, 4096> array(pointCount);
+ QT_FT_Span span = { 0, 1, 0, 255 };
+ const QPointF *end = points + pointCount;
+ qreal trans_x, trans_y;
+ int x, y;
+ int left = d->deviceRect.x();
+ int right = left + d->deviceRect.width();
+ int top = d->deviceRect.y();
+ int bottom = top + d->deviceRect.height();
+ int count = 0;
+ while (points < end) {
+ s->matrix.map(points->x(), points->y(), &trans_x, &trans_y);
+ x = qFloor(trans_x);
+ y = qFloor(trans_y);
+ if (x >= left && x < right && y >= top && y < bottom) {
+ if (count > 0) {
+ const QT_FT_Span &last = array[count - 1];
+ // spans must be sorted on y (primary) and x (secondary)
+ if (y < last.y || (y == last.y && x < last.x)) {
+ s->penData.blend(count, array.constData(), &s->penData);
+ count = 0;
+ }
+ }
+
+ span.x = x;
+ span.y = y;
+ array[count++] = span;
+ }
+ ++points;
+ }
+
+ if (count > 0)
+ s->penData.blend(count, array.constData(), &s->penData);
+ }
+}
+
+
+void QRasterPaintEngine::drawPoints(const QPoint *points, int pointCount)
+{
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ ensurePen();
+ double pw = s->lastPen.widthF();
+ if (!s->flags.fast_pen && (s->matrix.type() > QTransform::TxTranslate || pw > 1)) {
+ QPaintEngineEx::drawPoints(points, pointCount);
+
+ } else {
+ if (!s->penData.blend)
+ return;
+
+ QVarLengthArray<QT_FT_Span, 4096> array(pointCount);
+ QT_FT_Span span = { 0, 1, 0, 255 };
+ const QPoint *end = points + pointCount;
+ qreal trans_x, trans_y;
+ int x, y;
+ int left = d->deviceRect.x();
+ int right = left + d->deviceRect.width();
+ int top = d->deviceRect.y();
+ int bottom = top + d->deviceRect.height();
+ int count = 0;
+ while (points < end) {
+ s->matrix.map(points->x(), points->y(), &trans_x, &trans_y);
+ x = qFloor(trans_x);
+ y = qFloor(trans_y);
+ if (x >= left && x < right && y >= top && y < bottom) {
+ if (count > 0) {
+ const QT_FT_Span &last = array[count - 1];
+ // spans must be sorted on y (primary) and x (secondary)
+ if (y < last.y || (y == last.y && x < last.x)) {
+ s->penData.blend(count, array.constData(), &s->penData);
+ count = 0;
+ }
+ }
+
+ span.x = x;
+ span.y = y;
+ array[count++] = span;
+ }
+ ++points;
+ }
+
+ if (count > 0)
+ s->penData.blend(count, array.constData(), &s->penData);
+ }
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::drawLines(const QLine *lines, int lineCount)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << " - QRasterPaintEngine::drawLine()";
+#endif
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ ensurePen();
+ if (s->flags.fast_pen) {
+ QIntRect bounds; bounds.set(d->deviceRect);
+ LineDrawMode mode = s->lastPen.capStyle() == Qt::FlatCap
+ ? LineDrawNormal
+ : LineDrawIncludeLastPixel;
+
+ int m11 = int(s->matrix.m11());
+ int m22 = int(s->matrix.m22());
+ int dx = qFloor(s->matrix.dx() + aliasedCoordinateDelta);
+ int dy = qFloor(s->matrix.dy() + aliasedCoordinateDelta);
+ for (int i=0; i<lineCount; ++i) {
+ int dashOffset = int(s->lastPen.dashOffset());
+ if (s->flags.int_xform) {
+ const QLine &l = lines[i];
+ int x1 = l.x1() * m11 + dx;
+ int y1 = l.y1() * m22 + dy;
+ int x2 = l.x2() * m11 + dx;
+ int y2 = l.y2() * m22 + dy;
+
+ const QRect brect(QPoint(x1, y1), QPoint(x2, y2));
+ ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+ if (qpen_style(s->lastPen) == Qt::SolidLine)
+ drawLine_midpoint_i(x1, y1, x2, y2,
+ penBlend, &s->penData, mode, bounds);
+ else
+ drawLine_midpoint_dashed_i(x1, y1, x2, y2,
+ &s->lastPen, penBlend,
+ &s->penData, mode, bounds,
+ &dashOffset);
+ } else {
+ QLineF line = lines[i] * s->matrix;
+ const QRectF brect(QPointF(line.x1(), line.y1()),
+ QPointF(line.x2(), line.y2()));
+ ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+ if (qpen_style(s->lastPen) == Qt::SolidLine)
+ drawLine_midpoint_i(int(line.x1()), int(line.y1()),
+ int(line.x2()), int(line.y2()),
+ penBlend, &s->penData, mode, bounds);
+ else
+ drawLine_midpoint_dashed_i(int(line.x1()), int(line.y1()),
+ int(line.x2()), int(line.y2()),
+ &s->lastPen, penBlend,
+ &s->penData, mode, bounds,
+ &dashOffset);
+ }
+ }
+ } else if (s->penData.blend) {
+ QPaintEngineEx::drawLines(lines, lineCount);
+ }
+}
+
+void QRasterPaintEnginePrivate::rasterizeLine_dashed(QLineF line,
+ qreal width,
+ int *dashIndex,
+ qreal *dashOffset,
+ bool *inDash)
+{
+ Q_Q(QRasterPaintEngine);
+ QRasterPaintEngineState *s = q->state();
+
+ const QPen &pen = s->lastPen;
+ const bool squareCap = (pen.capStyle() == Qt::SquareCap);
+ const QVector<qreal> pattern = pen.dashPattern();
+
+ qreal length = line.length();
+ Q_ASSERT(length > 0);
+ while (length > 0) {
+ const bool rasterize = *inDash;
+ qreal dash = (pattern.at(*dashIndex) - *dashOffset) * width;
+ QLineF l = line;
+
+ if (dash >= length) {
+ dash = length;
+ *dashOffset += dash / width;
+ length = 0;
+ } else {
+ *dashOffset = 0;
+ *inDash = !(*inDash);
+ *dashIndex = (*dashIndex + 1) % pattern.size();
+ length -= dash;
+ l.setLength(dash);
+ line.setP1(l.p2());
+ }
+
+ if (rasterize && dash != 0)
+ rasterizer->rasterizeLine(l.p1(), l.p2(), width / dash, squareCap);
+ }
+}
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::drawLines(const QLineF *lines, int lineCount)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << " - QRasterPaintEngine::drawLine()";
+#endif
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ ensurePen();
+ if (!s->penData.blend)
+ return;
+ if (s->flags.fast_pen) {
+ QIntRect bounds;
+ bounds.set(d->deviceRect);
+ LineDrawMode mode = s->lastPen.capStyle() == Qt::FlatCap
+ ? LineDrawNormal
+ : LineDrawIncludeLastPixel;
+
+ for (int i=0; i<lineCount; ++i) {
+ int dashOffset = int(s->lastPen.dashOffset());
+ QLineF line = (lines[i] * s->matrix).translated(aliasedCoordinateDelta, aliasedCoordinateDelta);
+ const QRectF brect(QPointF(line.x1(), line.y1()),
+ QPointF(line.x2(), line.y2()));
+ ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+ if (qpen_style(s->lastPen) == Qt::SolidLine)
+ drawLine_midpoint_i(int(line.x1()), int(line.y1()),
+ int(line.x2()), int(line.y2()),
+ penBlend, &s->penData, mode, bounds);
+ else
+ drawLine_midpoint_dashed_i(int(line.x1()), int(line.y1()),
+ int(line.x2()), int(line.y2()),
+ &s->lastPen,
+ penBlend, &s->penData, mode,
+ bounds, &dashOffset);
+ }
+ } else {
+ QPaintEngineEx::drawLines(lines, lineCount);
+ }
+}
+
+
+/*!
+ \reimp
+*/
+void QRasterPaintEngine::drawEllipse(const QRectF &rect)
+{
+ Q_D(QRasterPaintEngine);
+ QRasterPaintEngineState *s = state();
+
+ ensurePen();
+ if (((qpen_style(s->lastPen) == Qt::SolidLine && s->flags.fast_pen)
+ || (qpen_style(s->lastPen) == Qt::NoPen && !s->flags.antialiased))
+ && qMax(rect.width(), rect.height()) < QT_RASTER_COORD_LIMIT
+#ifdef FLOATING_POINT_BUGGY_OR_NO_FPU
+ && qMax(rect.width(), rect.height()) < 128 // integer math breakdown
+#endif
+ && s->matrix.type() <= QTransform::TxScale) // no shear
+ {
+ ensureBrush();
+ const QRectF r = s->matrix.mapRect(rect);
+ ProcessSpans penBlend = d->getPenFunc(r, &s->penData);
+ ProcessSpans brushBlend = d->getBrushFunc(r, &s->brushData);
+ const QRect brect = QRect(int(r.x()), int(r.y()),
+ int_dim(r.x(), r.width()),
+ int_dim(r.y(), r.height()));
+ if (brect == r) {
+ drawEllipse_midpoint_i(brect, d->deviceRect, penBlend, brushBlend,
+ &s->penData, &s->brushData);
+ return;
+ }
+ }
+ QPaintEngineEx::drawEllipse(rect);
+}
+
+/*!
+ \internal
+*/
+#ifdef Q_WS_MAC
+void QRasterPaintEngine::setCGContext(CGContextRef ctx)
+{
+ Q_D(QRasterPaintEngine);
+ d->cgContext = ctx;
+}
+
+/*!
+ \internal
+*/
+CGContextRef QRasterPaintEngine::getCGContext() const
+{
+ Q_D(const QRasterPaintEngine);
+ return d->cgContext;
+}
+#endif
+
+#ifdef Q_WS_WIN
+/*!
+ \internal
+*/
+void QRasterPaintEngine::setDC(HDC hdc) {
+ Q_D(QRasterPaintEngine);
+ d->hdc = hdc;
+}
+
+/*!
+ \internal
+*/
+HDC QRasterPaintEngine::getDC() const
+{
+ Q_D(const QRasterPaintEngine);
+ return d->hdc;
+}
+
+/*!
+ \internal
+*/
+void QRasterPaintEngine::releaseDC(HDC) const
+{
+}
+
+#endif
+
+/*!
+ \internal
+*/
+QPoint QRasterPaintEngine::coordinateOffset() const
+{
+ return QPoint(0, 0);
+}
+
+/*!
+ Draws the given color \a spans with the specified \a color. The \a
+ count parameter specifies the number of spans.
+
+ The default implementation does nothing; reimplement this function
+ to draw the given color \a spans with the specified \a color. Note
+ that this function \e must be reimplemented if the framebuffer is
+ not memory-mapped.
+
+ \sa drawBufferSpan()
+*/
+#if defined(Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)
+void QRasterPaintEngine::drawColorSpans(const QSpan *spans, int count, uint color)
+{
+ Q_UNUSED(spans);
+ Q_UNUSED(count);
+ Q_UNUSED(color);
+ qFatal("QRasterPaintEngine::drawColorSpans must be reimplemented on "
+ "a non memory-mapped device");
+}
+
+/*!
+ \fn void QRasterPaintEngine::drawBufferSpan(const uint *buffer, int size, int x, int y, int length, uint alpha)
+
+ Draws the given \a buffer.
+
+ The default implementation does nothing; reimplement this function
+ to draw a buffer that contains more than one color. Note that this
+ function \e must be reimplemented if the framebuffer is not
+ memory-mapped.
+
+ The \a size parameter specifies the total size of the given \a
+ buffer, while the \a length parameter specifies the number of
+ pixels to draw. The buffer's position is given by (\a x, \a
+ y). The provided \a alpha value is added to each pixel in the
+ buffer when drawing.
+
+ \sa drawColorSpans()
+*/
+void QRasterPaintEngine::drawBufferSpan(const uint *buffer, int bufsize,
+ int x, int y, int length, uint const_alpha)
+{
+ Q_UNUSED(buffer);
+ Q_UNUSED(bufsize);
+ Q_UNUSED(x);
+ Q_UNUSED(y);
+ Q_UNUSED(length);
+ Q_UNUSED(const_alpha);
+ qFatal("QRasterPaintEngine::drawBufferSpan must be reimplemented on "
+ "a non memory-mapped device");
+}
+#endif // Q_WS_QWS
+
+void QRasterPaintEngine::drawBitmap(const QPointF &pos, const QImage &image, QSpanData *fg)
+{
+ Q_ASSERT(fg);
+ if (!fg->blend)
+ return;
+ Q_D(QRasterPaintEngine);
+
+ Q_ASSERT(image.depth() == 1);
+
+ const int spanCount = 256;
+ QT_FT_Span spans[spanCount];
+ int n = 0;
+
+ // Boundaries
+ int w = image.width();
+ int h = image.height();
+ int ymax = qMin(qRound(pos.y() + h), d->rasterBuffer->height());
+ int ymin = qMax(qRound(pos.y()), 0);
+ int xmax = qMin(qRound(pos.x() + w), d->rasterBuffer->width());
+ int xmin = qMax(qRound(pos.x()), 0);
+
+ int x_offset = xmin - qRound(pos.x());
+
+ QImage::Format format = image.format();
+ for (int y = ymin; y < ymax; ++y) {
+ const uchar *src = image.scanLine(y - qRound(pos.y()));
+ if (format == QImage::Format_MonoLSB) {
+ for (int x = 0; x < xmax - xmin; ++x) {
+ int src_x = x + x_offset;
+ uchar pixel = src[src_x >> 3];
+ if (!pixel) {
+ x += 7 - (src_x%8);
+ continue;
+ }
+ if (pixel & (0x1 << (src_x & 7))) {
+ spans[n].x = xmin + x;
+ spans[n].y = y;
+ spans[n].coverage = 255;
+ int len = 1;
+ while (src_x < w-1 && src[(src_x+1) >> 3] & (0x1 << ((src_x+1) & 7))) {
+ ++src_x;
+ ++len;
+ }
+ spans[n].len = ((len + spans[n].x) > xmax) ? (xmax - spans[n].x) : len;
+ x += len;
+ ++n;
+ if (n == spanCount) {
+ fg->blend(n, spans, fg);
+ n = 0;
+ }
+ }
+ }
+ } else {
+ for (int x = 0; x < xmax - xmin; ++x) {
+ int src_x = x + x_offset;
+ uchar pixel = src[src_x >> 3];
+ if (!pixel) {
+ x += 7 - (src_x%8);
+ continue;
+ }
+ if (pixel & (0x80 >> (x & 7))) {
+ spans[n].x = xmin + x;
+ spans[n].y = y;
+ spans[n].coverage = 255;
+ int len = 1;
+ while (src_x < w-1 && src[(src_x+1) >> 3] & (0x80 >> ((src_x+1) & 7))) {
+ ++src_x;
+ ++len;
+ }
+ spans[n].len = ((len + spans[n].x) > xmax) ? (xmax - spans[n].x) : len;
+ x += len;
+ ++n;
+ if (n == spanCount) {
+ fg->blend(n, spans, fg);
+ n = 0;
+ }
+ }
+ }
+ }
+ }
+ if (n) {
+ fg->blend(n, spans, fg);
+ n = 0;
+ }
+}
+
+/*!
+ \enum QRasterPaintEngine::ClipType
+ \internal
+
+ \value RectClip Indicates that the currently set clip is a single rectangle.
+ \value ComplexClip Indicates that the currently set clip is a combination of several shapes.
+*/
+
+/*!
+ \internal
+ Returns the type of the clip currently set.
+*/
+QRasterPaintEngine::ClipType QRasterPaintEngine::clipType() const
+{
+ Q_D(const QRasterPaintEngine);
+
+ const QClipData *clip = d->clip();
+ if (!clip || clip->hasRectClip)
+ return RectClip;
+ else
+ return ComplexClip;
+}
+
+/*!
+ \internal
+ Returns the bounding rect of the currently set clip.
+*/
+QRect QRasterPaintEngine::clipBoundingRect() const
+{
+ Q_D(const QRasterPaintEngine);
+
+ const QClipData *clip = d->clip();
+
+ if (!clip)
+ return d->deviceRect;
+
+ if (clip->hasRectClip)
+ return clip->clipRect;
+
+ return QRect(clip->xmin, clip->ymin, clip->xmax - clip->xmin, clip->ymax - clip->ymin);
+}
+
+static void qt_merge_clip(const QClipData *c1, const QClipData *c2, QClipData *result)
+{
+ Q_ASSERT(c1->clipSpanHeight == c2->clipSpanHeight && c1->clipSpanHeight == result->clipSpanHeight);
+
+ QVarLengthArray<short, 4096> buffer;
+
+ QClipData::ClipLine *c1ClipLines = const_cast<QClipData *>(c1)->clipLines();
+ QClipData::ClipLine *c2ClipLines = const_cast<QClipData *>(c2)->clipLines();
+ result->initialize();
+
+ for (int y = 0; y < c1->clipSpanHeight; ++y) {
+ const QSpan *c1_spans = c1ClipLines[y].spans;
+ int c1_count = c1ClipLines[y].count;
+ const QSpan *c2_spans = c2ClipLines[y].spans;
+ int c2_count = c2ClipLines[y].count;
+
+ if (c1_count == 0 && c2_count == 0)
+ continue;
+ if (c1_count == 0) {
+ result->appendSpans(c2_spans, c2_count);
+ continue;
+ } else if (c2_count == 0) {
+ result->appendSpans(c1_spans, c1_count);
+ continue;
+ }
+
+ // we need to merge the two
+
+ // find required length
+ int max = qMax(c1_spans[c1_count - 1].x + c1_spans[c1_count - 1].len,
+ c2_spans[c2_count - 1].x + c2_spans[c2_count - 1].len);
+ buffer.resize(max);
+ memset(buffer.data(), 0, buffer.size() * sizeof(short));
+
+ // Fill with old spans.
+ for (int i = 0; i < c1_count; ++i) {
+ const QSpan *cs = c1_spans + i;
+ for (int j=cs->x; j<cs->x + cs->len; ++j)
+ buffer[j] = cs->coverage;
+ }
+
+ // Fill with new spans
+ for (int i = 0; i < c2_count; ++i) {
+ const QSpan *cs = c2_spans + i;
+ for (int j = cs->x; j < cs->x + cs->len; ++j) {
+ buffer[j] += cs->coverage;
+ if (buffer[j] > 255)
+ buffer[j] = 255;
+ }
+ }
+
+ int x = 0;
+ while (x<max) {
+
+ // Skip to next span
+ while (x < max && buffer[x] == 0) ++x;
+ if (x >= max) break;
+
+ int sx = x;
+ int coverage = buffer[x];
+
+ // Find length of span
+ while (x < max && buffer[x] == coverage)
+ ++x;
+
+ result->appendSpan(sx, x - sx, y, coverage);
+ }
+ }
+}
+
+void QRasterPaintEnginePrivate::initializeRasterizer(QSpanData *data)
+{
+ Q_Q(QRasterPaintEngine);
+ QRasterPaintEngineState *s = q->state();
+
+ rasterizer->setAntialiased(s->flags.antialiased);
+
+ QRect clipRect(deviceRect);
+ ProcessSpans blend;
+ // ### get from optimized rectbased QClipData
+
+ const QClipData *c = clip();
+ if (c) {
+ const QRect r(QPoint(c->xmin, c->ymin),
+ QSize(c->xmax - c->xmin, c->ymax - c->ymin));
+ clipRect = clipRect.intersected(r);
+ blend = data->blend;
+ } else {
+ blend = data->unclipped_blend;
+ }
+
+ rasterizer->setClipRect(clipRect);
+ rasterizer->initialize(blend, data);
+}
+
+void QRasterPaintEnginePrivate::rasterize(QT_FT_Outline *outline,
+ ProcessSpans callback,
+ QSpanData *spanData, QRasterBuffer *rasterBuffer)
+{
+ if (!callback || !outline)
+ return;
+
+ Q_Q(QRasterPaintEngine);
+ QRasterPaintEngineState *s = q->state();
+
+ if (!s->flags.antialiased) {
+ initializeRasterizer(spanData);
+
+ const Qt::FillRule fillRule = outline->flags == QT_FT_OUTLINE_NONE
+ ? Qt::WindingFill
+ : Qt::OddEvenFill;
+
+ rasterizer->rasterize(outline, fillRule);
+ return;
+ }
+
+ rasterize(outline, callback, (void *)spanData, rasterBuffer);
+}
+
+void QRasterPaintEnginePrivate::rasterize(QT_FT_Outline *outline,
+ ProcessSpans callback,
+ void *userData, QRasterBuffer *)
+{
+ if (!callback || !outline)
+ return;
+
+ Q_Q(QRasterPaintEngine);
+ QRasterPaintEngineState *s = q->state();
+
+ if (!s->flags.antialiased) {
+ rasterizer->setAntialiased(s->flags.antialiased);
+ rasterizer->setClipRect(deviceRect);
+ rasterizer->initialize(callback, userData);
+
+ const Qt::FillRule fillRule = outline->flags == QT_FT_OUTLINE_NONE
+ ? Qt::WindingFill
+ : Qt::OddEvenFill;
+
+ rasterizer->rasterize(outline, fillRule);
+ return;
+ }
+
+ void *data = userData;
+
+ QT_FT_BBox clip_box = { deviceRect.x(),
+ deviceRect.y(),
+ deviceRect.x() + deviceRect.width(),
+ deviceRect.y() + deviceRect.height() };
+
+ QT_FT_Raster_Params rasterParams;
+ rasterParams.target = 0;
+ rasterParams.source = outline;
+ rasterParams.flags = QT_FT_RASTER_FLAG_CLIP;
+ rasterParams.gray_spans = 0;
+ rasterParams.black_spans = 0;
+ rasterParams.bit_test = 0;
+ rasterParams.bit_set = 0;
+ rasterParams.user = data;
+ rasterParams.clip_box = clip_box;
+
+ bool done = false;
+ int error;
+
+ while (!done) {
+
+ rasterParams.flags |= (QT_FT_RASTER_FLAG_AA | QT_FT_RASTER_FLAG_DIRECT);
+ rasterParams.gray_spans = callback;
+ error = qt_ft_grays_raster.raster_render(*grayRaster.data(), &rasterParams);
+
+ // Out of memory, reallocate some more and try again...
+ if (error == -6) { // -6 is Result_err_OutOfMemory
+ int new_size = rasterPoolSize * 2;
+ if (new_size > 1024 * 1024) {
+ qWarning("QPainter: Rasterization of primitive failed");
+ return;
+ }
+
+#if defined(Q_WS_WIN64)
+ _aligned_free(rasterPoolBase);
+#else
+ free(rasterPoolBase);
+#endif
+
+ rasterPoolSize = new_size;
+ rasterPoolBase =
+#if defined(Q_WS_WIN64)
+ // We make use of setjmp and longjmp in qgrayraster.c which requires
+ // 16-byte alignment, hence we hardcode this requirement here..
+ (unsigned char *) _aligned_malloc(rasterPoolSize, sizeof(void*) * 2);
+#else
+ (unsigned char *) malloc(rasterPoolSize);
+#endif
+ Q_CHECK_PTR(rasterPoolBase); // note: we just freed the old rasterPoolBase. I hope it's not fatal.
+
+ qt_ft_grays_raster.raster_done(*grayRaster.data());
+ qt_ft_grays_raster.raster_new(0, grayRaster.data());
+ qt_ft_grays_raster.raster_reset(*grayRaster.data(), rasterPoolBase, rasterPoolSize);
+ } else {
+ done = true;
+ }
+ }
+}
+
+void QRasterPaintEnginePrivate::recalculateFastImages()
+{
+ Q_Q(QRasterPaintEngine);
+ QRasterPaintEngineState *s = q->state();
+
+ s->flags.fast_images = !(s->renderHints & QPainter::SmoothPixmapTransform)
+ && rasterBuffer->compositionMode == QPainter::CompositionMode_SourceOver
+ && s->matrix.type() <= QTransform::TxShear;
+}
+
+
+
+QImage QRasterBuffer::colorizeBitmap(const QImage &image, const QColor &color)
+{
+ Q_ASSERT(image.depth() == 1);
+
+ QImage sourceImage = image.convertToFormat(QImage::Format_MonoLSB);
+ QImage dest = QImage(sourceImage.size(), QImage::Format_ARGB32_Premultiplied);
+
+ QRgb fg = PREMUL(color.rgba());
+ QRgb bg = 0;
+
+ int height = sourceImage.height();
+ int width = sourceImage.width();
+ for (int y=0; y<height; ++y) {
+ uchar *source = sourceImage.scanLine(y);
+ QRgb *target = reinterpret_cast<QRgb *>(dest.scanLine(y));
+ if (!source || !target)
+ QT_THROW(std::bad_alloc()); // we must have run out of memory
+ for (int x=0; x < width; ++x)
+ target[x] = (source[x>>3] >> (x&7)) & 1 ? fg : bg;
+ }
+ return dest;
+}
+
+QRasterBuffer::~QRasterBuffer()
+{
+}
+
+void QRasterBuffer::init()
+{
+ compositionMode = QPainter::CompositionMode_SourceOver;
+ monoDestinationWithClut = false;
+ destColor0 = 0;
+ destColor1 = 0;
+}
+
+QImage::Format QRasterBuffer::prepare(QImage *image)
+{
+ m_buffer = (uchar *)image->bits();
+ m_width = qMin(QT_RASTER_COORD_LIMIT, image->width());
+ m_height = qMin(QT_RASTER_COORD_LIMIT, image->height());
+ bytes_per_pixel = image->depth()/8;
+ bytes_per_line = image->bytesPerLine();
+
+ format = image->format();
+ drawHelper = qDrawHelper + format;
+ if (image->depth() == 1 && image->colorTable().size() == 2) {
+ monoDestinationWithClut = true;
+ destColor0 = PREMUL(image->colorTable()[0]);
+ destColor1 = PREMUL(image->colorTable()[1]);
+ }
+
+ return format;
+}
+
+void QRasterBuffer::resetBuffer(int val)
+{
+ memset(m_buffer, val, m_height*bytes_per_line);
+}
+
+
+#if defined(Q_WS_QWS)
+void QRasterBuffer::prepare(QCustomRasterPaintDevice *device)
+{
+ m_buffer = reinterpret_cast<uchar*>(device->memory());
+ m_width = qMin(QT_RASTER_COORD_LIMIT, device->width());
+ m_height = qMin(QT_RASTER_COORD_LIMIT, device->height());
+ bytes_per_pixel = device->depth() / 8;
+ bytes_per_line = device->bytesPerLine();
+ format = device->format();
+#ifndef QT_NO_RASTERCALLBACKS
+ if (!m_buffer)
+ drawHelper = qDrawHelperCallback + format;
+ else
+#endif
+ drawHelper = qDrawHelper + format;
+}
+
+int QCustomRasterPaintDevice::metric(PaintDeviceMetric m) const
+{
+ switch (m) {
+ case PdmWidth:
+ return widget->frameGeometry().width();
+ case PdmHeight:
+ return widget->frameGeometry().height();
+ default:
+ break;
+ }
+
+ return qt_paint_device_metric(widget, m);
+}
+
+int QCustomRasterPaintDevice::bytesPerLine() const
+{
+ return (width() * depth() + 7) / 8;
+}
+
+#elif defined(Q_OS_SYMBIAN)
+
+void QRasterBuffer::prepareBuffer(int /* width */, int /* height */)
+{
+}
+
+#endif // Q_OS_SYMBIAN
+
+/*!
+ \class QCustomRasterPaintDevice
+ \preliminary
+ \ingroup qws
+ \since 4.2
+
+ \brief The QCustomRasterPaintDevice class is provided to activate
+ hardware accelerated paint engines in Qt for Embedded Linux.
+
+ Note that this class is only available in \l{Qt for Embedded Linux}.
+
+ In \l{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 (derived from the
+ QCustomRasterPaintDevice class) and a custom window surface
+ (derived from QWSWindowSurface) must be implemented to make
+ \l{Qt for Embedded Linux} aware of the accelerated driver.
+
+ See the \l {Adding an Accelerated Graphics Driver to Qt for Embedded Linux}
+ documentation for details.
+
+ \sa QRasterPaintEngine, QPaintDevice
+*/
+
+/*!
+ \fn QCustomRasterPaintDevice::QCustomRasterPaintDevice(QWidget *widget)
+
+ Constructs a custom raster based paint device for the given
+ top-level \a widget.
+*/
+
+/*!
+ \fn int QCustomRasterPaintDevice::bytesPerLine() const
+
+ Returns the number of bytes per line in the framebuffer. Note that
+ this number might be larger than the framebuffer width.
+*/
+
+/*!
+ \fn int QCustomRasterPaintDevice::devType() const
+ \internal
+*/
+
+/*!
+ \fn QImage::Format QCustomRasterPaintDevice::format() const
+
+ Returns the format of the device's memory buffet.
+
+ The default format is QImage::Format_ARGB32_Premultiplied. The
+ only other valid format is QImage::Format_RGB16.
+*/
+
+/*!
+ \fn void * QCustomRasterPaintDevice::memory () const
+
+ Returns a pointer to the paint device's memory buffer, or 0 if no
+ such buffer exists.
+*/
+
+/*!
+ \fn int QCustomRasterPaintDevice::metric ( PaintDeviceMetric m ) const
+ \reimp
+*/
+
+/*!
+ \fn QSize QCustomRasterPaintDevice::size () const
+ \internal
+*/
+
+
+QClipData::QClipData(int height)
+{
+ clipSpanHeight = height;
+ m_clipLines = 0;
+
+ allocated = 0;
+ m_spans = 0;
+ xmin = xmax = ymin = ymax = 0;
+ count = 0;
+
+ enabled = true;
+ hasRectClip = hasRegionClip = false;
+}
+
+QClipData::~QClipData()
+{
+ if (m_clipLines)
+ free(m_clipLines);
+ if (m_spans)
+ free(m_spans);
+}
+
+void QClipData::initialize()
+{
+ if (m_spans)
+ return;
+
+ if (!m_clipLines)
+ m_clipLines = (ClipLine *)calloc(sizeof(ClipLine), clipSpanHeight);
+
+ Q_CHECK_PTR(m_clipLines);
+ QT_TRY {
+ m_spans = (QSpan *)malloc(clipSpanHeight*sizeof(QSpan));
+ allocated = clipSpanHeight;
+ Q_CHECK_PTR(m_spans);
+
+ QT_TRY {
+ if (hasRectClip) {
+ int y = 0;
+ while (y < ymin) {
+ m_clipLines[y].spans = 0;
+ m_clipLines[y].count = 0;
+ ++y;
+ }
+
+ const int len = clipRect.width();
+ count = 0;
+ while (y < ymax) {
+ QSpan *span = m_spans + count;
+ span->x = xmin;
+ span->len = len;
+ span->y = y;
+ span->coverage = 255;
+ ++count;
+
+ m_clipLines[y].spans = span;
+ m_clipLines[y].count = 1;
+ ++y;
+ }
+
+ while (y < clipSpanHeight) {
+ m_clipLines[y].spans = 0;
+ m_clipLines[y].count = 0;
+ ++y;
+ }
+ } else if (hasRegionClip) {
+
+ const QVector<QRect> rects = clipRegion.rects();
+ const int numRects = rects.size();
+
+ { // resize
+ const int maxSpans = (ymax - ymin) * numRects;
+ if (maxSpans > allocated) {
+ m_spans = q_check_ptr((QSpan *)realloc(m_spans, maxSpans * sizeof(QSpan)));
+ allocated = maxSpans;
+ }
+ }
+
+ int y = 0;
+ int firstInBand = 0;
+ count = 0;
+ while (firstInBand < numRects) {
+ const int currMinY = rects.at(firstInBand).y();
+ const int currMaxY = currMinY + rects.at(firstInBand).height();
+
+ while (y < currMinY) {
+ m_clipLines[y].spans = 0;
+ m_clipLines[y].count = 0;
+ ++y;
+ }
+
+ int lastInBand = firstInBand;
+ while (lastInBand + 1 < numRects && rects.at(lastInBand+1).top() == y)
+ ++lastInBand;
+
+ while (y < currMaxY) {
+
+ m_clipLines[y].spans = m_spans + count;
+ m_clipLines[y].count = lastInBand - firstInBand + 1;
+
+ for (int r = firstInBand; r <= lastInBand; ++r) {
+ const QRect &currRect = rects.at(r);
+ QSpan *span = m_spans + count;
+ span->x = currRect.x();
+ span->len = currRect.width();
+ span->y = y;
+ span->coverage = 255;
+ ++count;
+ }
+ ++y;
+ }
+
+ firstInBand = lastInBand + 1;
+ }
+
+ Q_ASSERT(count <= allocated);
+
+ while (y < clipSpanHeight) {
+ m_clipLines[y].spans = 0;
+ m_clipLines[y].count = 0;
+ ++y;
+ }
+
+ }
+ } QT_CATCH(...) {
+ free(m_spans); // have to free m_spans again or someone might think that we were successfully initialized.
+ m_spans = 0;
+ QT_RETHROW;
+ }
+ } QT_CATCH(...) {
+ free(m_clipLines); // same for clipLines
+ m_clipLines = 0;
+ QT_RETHROW;
+ }
+}
+
+void QClipData::fixup()
+{
+ Q_ASSERT(m_spans);
+
+ if (count == 0) {
+ ymin = ymax = xmin = xmax = 0;
+ return;
+ }
+
+// qDebug("QClipData::fixup: count=%d",count);
+ int y = -1;
+ ymin = m_spans[0].y;
+ ymax = m_spans[count-1].y + 1;
+ xmin = INT_MAX;
+ xmax = 0;
+
+ bool isRect = true;
+ int left = m_spans[0].x;
+ int right = m_spans[0].x + m_spans[0].len;
+
+ for (int i = 0; i < count; ++i) {
+ if (m_spans[i].y != y) {
+ if (m_spans[i].y != y + 1 && y != -1) {
+ isRect = false;
+ }
+ y = m_spans[i].y;
+ m_clipLines[y].spans = m_spans+i;
+ m_clipLines[y].count = 0;
+// qDebug() << " new line: y=" << y;
+ }
+ ++m_clipLines[y].count;
+ int sl = (int) m_spans[i].x;
+ int sr = sl + m_spans[i].len;
+
+ xmin = qMin(xmin, (int)m_spans[i].x);
+ xmax = qMax(xmax, (int)m_spans[i].x + m_spans[i].len);
+
+ if (sl != left || sr != right)
+ isRect = false;
+ }
+// qDebug("xmin=%d,xmax=%d,ymin=%d,ymax=%d %s", xmin, xmax, ymin, ymax, isRect ? "rectangular" : "");
+
+ if (isRect) {
+ hasRectClip = true;
+ clipRect.setRect(xmin, ymin, xmax - xmin, ymax - ymin);
+ }
+}
+
+/*
+ Convert \a rect to clip spans.
+ */
+void QClipData::setClipRect(const QRect &rect)
+{
+ if (hasRectClip && rect == clipRect)
+ return;
+
+// qDebug() << "setClipRect" << clipSpanHeight << count << allocated << rect;
+ hasRectClip = true;
+ hasRegionClip = false;
+ clipRect = rect;
+
+ xmin = rect.x();
+ xmax = rect.x() + rect.width();
+ ymin = qMin(rect.y(), clipSpanHeight);
+ ymax = qMin(rect.y() + rect.height(), clipSpanHeight);
+
+ if (m_spans) {
+ free(m_spans);
+ m_spans = 0;
+ }
+
+// qDebug() << xmin << xmax << ymin << ymax;
+}
+
+/*
+ Convert \a region to clip spans.
+ */
+void QClipData::setClipRegion(const QRegion ®ion)
+{
+ if (region.numRects() == 1) {
+ setClipRect(region.rects().at(0));
+ return;
+ }
+
+ hasRegionClip = true;
+ hasRectClip = false;
+ clipRegion = region;
+
+ { // set bounding rect
+ const QRect rect = region.boundingRect();
+ xmin = rect.x();
+ xmax = rect.x() + rect.width();
+ ymin = rect.y();
+ ymax = rect.y() + rect.height();
+ }
+
+ if (m_spans) {
+ free(m_spans);
+ m_spans = 0;
+ }
+
+}
+
+/*!
+ \internal
+ spans must be sorted on y
+*/
+static const QSpan *qt_intersect_spans(const QClipData *clip, int *currentClip,
+ const QSpan *spans, const QSpan *end,
+ QSpan **outSpans, int available)
+{
+ const_cast<QClipData *>(clip)->initialize();
+
+ QSpan *out = *outSpans;
+
+ const QSpan *clipSpans = clip->m_spans + *currentClip;
+ const QSpan *clipEnd = clip->m_spans + clip->count;
+
+ while (available && spans < end ) {
+ if (clipSpans >= clipEnd) {
+ spans = end;
+ break;
+ }
+ if (clipSpans->y > spans->y) {
+ ++spans;
+ continue;
+ }
+ if (spans->y != clipSpans->y) {
+ if (spans->y < clip->count && clip->m_clipLines[spans->y].spans)
+ clipSpans = clip->m_clipLines[spans->y].spans;
+ else
+ ++clipSpans;
+ continue;
+ }
+ Q_ASSERT(spans->y == clipSpans->y);
+
+ int sx1 = spans->x;
+ int sx2 = sx1 + spans->len;
+ int cx1 = clipSpans->x;
+ int cx2 = cx1 + clipSpans->len;
+
+ if (cx1 < sx1 && cx2 < sx1) {
+ ++clipSpans;
+ continue;
+ } else if (sx1 < cx1 && sx2 < cx1) {
+ ++spans;
+ continue;
+ }
+ int x = qMax(sx1, cx1);
+ int len = qMin(sx2, cx2) - x;
+ if (len) {
+ out->x = qMax(sx1, cx1);
+ out->len = qMin(sx2, cx2) - out->x;
+ out->y = spans->y;
+ out->coverage = qt_div_255(spans->coverage * clipSpans->coverage);
+ ++out;
+ --available;
+ }
+ if (sx2 < cx2) {
+ ++spans;
+ } else {
+ ++clipSpans;
+ }
+ }
+
+ *outSpans = out;
+ *currentClip = clipSpans - clip->m_spans;
+ return spans;
+}
+
+static void qt_span_fill_clipped(int spanCount, const QSpan *spans, void *userData)
+{
+// qDebug() << "qt_span_fill_clipped" << spanCount;
+ QSpanData *fillData = reinterpret_cast<QSpanData *>(userData);
+
+ Q_ASSERT(fillData->blend && fillData->unclipped_blend);
+
+ const int NSPANS = 256;
+ QSpan cspans[NSPANS];
+ int currentClip = 0;
+ const QSpan *end = spans + spanCount;
+ while (spans < end) {
+ QSpan *clipped = cspans;
+ spans = qt_intersect_spans(fillData->clip, ¤tClip, spans, end, &clipped, NSPANS);
+// qDebug() << "processed " << processed << "clipped" << clipped-cspans
+// << "span:" << cspans->x << cspans->y << cspans->len << spans->coverage;
+
+ if (clipped - cspans)
+ fillData->unclipped_blend(clipped - cspans, cspans, fillData);
+ }
+}
+
+/*
+ \internal
+ Clip spans to \a{clip}-rectangle.
+ Returns number of unclipped spans
+*/
+static int qt_intersect_spans(QT_FT_Span *spans, int numSpans,
+ const QRect &clip)
+{
+ const short minx = clip.left();
+ const short miny = clip.top();
+ const short maxx = clip.right();
+ const short maxy = clip.bottom();
+
+ int n = 0;
+ for (int i = 0; i < numSpans; ++i) {
+ if (spans[i].y > maxy)
+ break;
+ if (spans[i].y < miny
+ || spans[i].x > maxx
+ || spans[i].x + spans[i].len <= minx) {
+ continue;
+ }
+ if (spans[i].x < minx) {
+ spans[n].len = qMin(spans[i].len - (minx - spans[i].x), maxx - minx + 1);
+ spans[n].x = minx;
+ } else {
+ spans[n].x = spans[i].x;
+ spans[n].len = qMin(spans[i].len, ushort(maxx - spans[n].x + 1));
+ }
+ if (spans[n].len == 0)
+ continue;
+ spans[n].y = spans[i].y;
+ spans[n].coverage = spans[i].coverage;
+ ++n;
+ }
+ return n;
+}
+
+
+static void qt_span_fill_clipRect(int count, const QSpan *spans,
+ void *userData)
+{
+ QSpanData *fillData = reinterpret_cast<QSpanData *>(userData);
+ Q_ASSERT(fillData->blend && fillData->unclipped_blend);
+
+ Q_ASSERT(fillData->clip);
+ Q_ASSERT(!fillData->clip->clipRect.isEmpty());
+
+ // hw: check if this const_cast<> is safe!!!
+ count = qt_intersect_spans(const_cast<QSpan*>(spans), count,
+ fillData->clip->clipRect);
+ if (count > 0)
+ fillData->unclipped_blend(count, spans, fillData);
+}
+
+static void qt_span_clip(int count, const QSpan *spans, void *userData)
+{
+ ClipData *clipData = reinterpret_cast<ClipData *>(userData);
+
+// qDebug() << " qt_span_clip: " << count << clipData->operation;
+// for (int i = 0; i < qMin(count, 10); ++i) {
+// qDebug() << " " << spans[i].x << spans[i].y << spans[i].len << spans[i].coverage;
+// }
+
+ switch (clipData->operation) {
+
+ case Qt::IntersectClip:
+ {
+ QClipData *newClip = clipData->newClip;
+ newClip->initialize();
+
+ int currentClip = 0;
+ const QSpan *end = spans + count;
+ while (spans < end) {
+ QSpan *newspans = newClip->m_spans + newClip->count;
+ spans = qt_intersect_spans(clipData->oldClip, ¤tClip, spans, end,
+ &newspans, newClip->allocated - newClip->count);
+ newClip->count = newspans - newClip->m_spans;
+ if (spans < end) {
+ newClip->m_spans = q_check_ptr((QSpan *)realloc(newClip->m_spans, newClip->allocated*2*sizeof(QSpan)));
+ newClip->allocated *= 2;
+ }
+ }
+ }
+ break;
+
+ case Qt::UniteClip:
+ case Qt::ReplaceClip:
+ clipData->newClip->appendSpans(spans, count);
+ break;
+ case Qt::NoClip:
+ break;
+ }
+}
+
+#ifndef QT_NO_DEBUG
+QImage QRasterBuffer::bufferImage() const
+{
+ QImage image(m_width, m_height, QImage::Format_ARGB32_Premultiplied);
+
+ for (int y = 0; y < m_height; ++y) {
+ uint *span = (uint *)const_cast<QRasterBuffer *>(this)->scanLine(y);
+
+ for (int x=0; x<m_width; ++x) {
+ uint argb = span[x];
+ image.setPixel(x, y, argb);
+ }
+ }
+ return image;
+}
+#endif
+
+
+void QRasterBuffer::flushToARGBImage(QImage *target) const
+{
+ int w = qMin(m_width, target->width());
+ int h = qMin(m_height, target->height());
+
+ for (int y=0; y<h; ++y) {
+ uint *sourceLine = (uint *)const_cast<QRasterBuffer *>(this)->scanLine(y);
+ QRgb *dest = (QRgb *) target->scanLine(y);
+ for (int x=0; x<w; ++x) {
+ QRgb pixel = sourceLine[x];
+ int alpha = qAlpha(pixel);
+ if (!alpha) {
+ dest[x] = 0;
+ } else {
+ dest[x] = (alpha << 24)
+ | ((255*qRed(pixel)/alpha) << 16)
+ | ((255*qGreen(pixel)/alpha) << 8)
+ | ((255*qBlue(pixel)/alpha) << 0);
+ }
+ }
+ }
+}
+
+
+class QGradientCache
+{
+ struct CacheInfo
+ {
+ inline CacheInfo(QGradientStops s, int op, QGradient::InterpolationMode mode) :
+ stops(s), opacity(op), interpolationMode(mode) {}
+ uint buffer[GRADIENT_STOPTABLE_SIZE];
+ QGradientStops stops;
+ int opacity;
+ QGradient::InterpolationMode interpolationMode;
+ };
+
+ typedef QMultiHash<quint64, CacheInfo> QGradientColorTableHash;
+
+public:
+ inline const uint *getBuffer(const QGradient &gradient, int opacity) {
+ quint64 hash_val = 0;
+
+ QGradientStops stops = gradient.stops();
+ for (int i = 0; i < stops.size() && i <= 2; i++)
+ hash_val += stops[i].second.rgba();
+
+ QGradientColorTableHash::const_iterator it = cache.constFind(hash_val);
+
+ if (it == cache.constEnd())
+ return addCacheElement(hash_val, gradient, opacity);
+ else {
+ do {
+ const CacheInfo &cache_info = it.value();
+ if (cache_info.stops == stops && cache_info.opacity == opacity && cache_info.interpolationMode == gradient.interpolationMode())
+ return cache_info.buffer;
+ ++it;
+ } while (it != cache.constEnd() && it.key() == hash_val);
+ // an exact match for these stops and opacity was not found, create new cache
+ return addCacheElement(hash_val, gradient, opacity);
+ }
+ }
+
+ inline int paletteSize() const { return GRADIENT_STOPTABLE_SIZE; }
+protected:
+ inline int maxCacheSize() const { return 60; }
+ inline void generateGradientColorTable(const QGradient& g,
+ uint *colorTable,
+ int size, int opacity) const;
+ uint *addCacheElement(quint64 hash_val, const QGradient &gradient, int opacity) {
+ if (cache.size() == maxCacheSize()) {
+ int elem_to_remove = qrand() % maxCacheSize();
+ cache.remove(cache.keys()[elem_to_remove]); // may remove more than 1, but OK
+ }
+ CacheInfo cache_entry(gradient.stops(), opacity, gradient.interpolationMode());
+ generateGradientColorTable(gradient, cache_entry.buffer, paletteSize(), opacity);
+ return cache.insert(hash_val, cache_entry).value().buffer;
+ }
+
+ QGradientColorTableHash cache;
+};
+
+void QGradientCache::generateGradientColorTable(const QGradient& gradient, uint *colorTable, int size, int opacity) const
+{
+ QGradientStops stops = gradient.stops();
+ int stopCount = stops.count();
+ Q_ASSERT(stopCount > 0);
+
+ bool colorInterpolation = (gradient.interpolationMode() == QGradient::ColorInterpolation);
+
+ uint current_color = ARGB_COMBINE_ALPHA(stops[0].second.rgba(), opacity);
+ if (stopCount == 1) {
+ current_color = PREMUL(current_color);
+ for (int i = 0; i < size; ++i)
+ colorTable[i] = current_color;
+ return;
+ }
+
+ // The position where the gradient begins and ends
+ qreal begin_pos = stops[0].first;
+ qreal end_pos = stops[stopCount-1].first;
+
+ int pos = 0; // The position in the color table.
+ uint next_color;
+
+ qreal incr = 1 / qreal(size); // the double increment.
+ qreal dpos = 1.5 * incr; // current position in gradient stop list (0 to 1)
+
+ // Up to first point
+ colorTable[pos++] = PREMUL(current_color);
+ while (dpos <= begin_pos) {
+ colorTable[pos] = colorTable[pos - 1];
+ ++pos;
+ dpos += incr;
+ }
+
+ int current_stop = 0; // We always interpolate between current and current + 1.
+
+ qreal t; // position between current left and right stops
+ qreal t_delta; // the t increment per entry in the color table
+
+ if (dpos < end_pos) {
+ // Gradient area
+ while (dpos > stops[current_stop+1].first)
+ ++current_stop;
+
+ if (current_stop != 0)
+ current_color = ARGB_COMBINE_ALPHA(stops[current_stop].second.rgba(), opacity);
+ next_color = ARGB_COMBINE_ALPHA(stops[current_stop+1].second.rgba(), opacity);
+
+ if (colorInterpolation) {
+ current_color = PREMUL(current_color);
+ next_color = PREMUL(next_color);
+ }
+
+ qreal diff = stops[current_stop+1].first - stops[current_stop].first;
+ qreal c = (diff == 0) ? qreal(0) : 256 / diff;
+ t = (dpos - stops[current_stop].first) * c;
+ t_delta = incr * c;
+
+ while (true) {
+ Q_ASSERT(current_stop < stopCount);
+
+ int dist = qRound(t);
+ int idist = 256 - dist;
+
+ if (colorInterpolation)
+ colorTable[pos] = INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist);
+ else
+ colorTable[pos] = PREMUL(INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist));
+
+ ++pos;
+ dpos += incr;
+
+ if (dpos >= end_pos)
+ break;
+
+ t += t_delta;
+
+ int skip = 0;
+ while (dpos > stops[current_stop+skip+1].first)
+ ++skip;
+
+ if (skip != 0) {
+ current_stop += skip;
+ if (skip == 1)
+ current_color = next_color;
+ else
+ current_color = ARGB_COMBINE_ALPHA(stops[current_stop].second.rgba(), opacity);
+ next_color = ARGB_COMBINE_ALPHA(stops[current_stop+1].second.rgba(), opacity);
+
+ if (colorInterpolation) {
+ if (skip != 1)
+ current_color = PREMUL(current_color);
+ next_color = PREMUL(next_color);
+ }
+
+ qreal diff = stops[current_stop+1].first - stops[current_stop].first;
+ qreal c = (diff == 0) ? qreal(0) : 256 / diff;
+ t = (dpos - stops[current_stop].first) * c;
+ t_delta = incr * c;
+ }
+ }
+ }
+
+ // After last point
+ current_color = PREMUL(ARGB_COMBINE_ALPHA(stops[stopCount - 1].second.rgba(), opacity));
+ while (pos < size - 1) {
+ colorTable[pos] = current_color;
+ ++pos;
+ }
+
+ // Make sure the last color stop is represented at the end of the table
+ colorTable[size - 1] = current_color;
+}
+
+Q_GLOBAL_STATIC(QGradientCache, qt_gradient_cache)
+
+
+void QSpanData::init(QRasterBuffer *rb, const QRasterPaintEngine *pe)
+{
+ rasterBuffer = rb;
+#ifdef Q_WS_QWS
+ rasterEngine = const_cast<QRasterPaintEngine *>(pe);
+#endif
+ type = None;
+ txop = 0;
+ bilinear = false;
+ m11 = m22 = m33 = 1.;
+ m12 = m13 = m21 = m23 = dx = dy = 0.0;
+ clip = pe ? pe->d_func()->clip() : 0;
+}
+
+extern QImage qt_imageForBrush(int brushStyle, bool invert);
+
+void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode compositionMode)
+{
+ Qt::BrushStyle brushStyle = qbrush_style(brush);
+ switch (brushStyle) {
+ case Qt::SolidPattern: {
+ type = Solid;
+ QColor c = qbrush_color(brush);
+ solid.color = PREMUL(ARGB_COMBINE_ALPHA(c.rgba(), alpha));
+ if ((solid.color & 0xff000000) == 0
+ && compositionMode == QPainter::CompositionMode_SourceOver) {
+ type = None;
+ }
+ break;
+ }
+
+ case Qt::LinearGradientPattern:
+ {
+ type = LinearGradient;
+ const QLinearGradient *g = static_cast<const QLinearGradient *>(brush.gradient());
+ gradient.alphaColor = !brush.isOpaque() || alpha != 256;
+ gradient.colorTable = const_cast<uint*>(qt_gradient_cache()->getBuffer(*g, alpha));
+ gradient.spread = g->spread();
+
+ QLinearGradientData &linearData = gradient.linear;
+
+ linearData.origin.x = g->start().x();
+ linearData.origin.y = g->start().y();
+ linearData.end.x = g->finalStop().x();
+ linearData.end.y = g->finalStop().y();
+ break;
+ }
+
+ case Qt::RadialGradientPattern:
+ {
+ type = RadialGradient;
+ const QRadialGradient *g = static_cast<const QRadialGradient *>(brush.gradient());
+ gradient.alphaColor = !brush.isOpaque() || alpha != 256;
+ gradient.colorTable = const_cast<uint*>(qt_gradient_cache()->getBuffer(*g, alpha));
+ gradient.spread = g->spread();
+
+ QRadialGradientData &radialData = gradient.radial;
+
+ QPointF center = g->center();
+ radialData.center.x = center.x();
+ radialData.center.y = center.y();
+ QPointF focal = g->focalPoint();
+ radialData.focal.x = focal.x();
+ radialData.focal.y = focal.y();
+ radialData.radius = g->radius();
+ }
+ break;
+
+ case Qt::ConicalGradientPattern:
+ {
+ type = ConicalGradient;
+ const QConicalGradient *g = static_cast<const QConicalGradient *>(brush.gradient());
+ gradient.alphaColor = !brush.isOpaque() || alpha != 256;
+ gradient.colorTable = const_cast<uint*>(qt_gradient_cache()->getBuffer(*g, alpha));
+ gradient.spread = QGradient::RepeatSpread;
+
+ QConicalGradientData &conicalData = gradient.conical;
+
+ QPointF center = g->center();
+ conicalData.center.x = center.x();
+ conicalData.center.y = center.y();
+ conicalData.angle = g->angle() * 2 * Q_PI / 360.0;
+ }
+ break;
+
+ case Qt::Dense1Pattern:
+ case Qt::Dense2Pattern:
+ case Qt::Dense3Pattern:
+ case Qt::Dense4Pattern:
+ case Qt::Dense5Pattern:
+ case Qt::Dense6Pattern:
+ case Qt::Dense7Pattern:
+ case Qt::HorPattern:
+ case Qt::VerPattern:
+ case Qt::CrossPattern:
+ case Qt::BDiagPattern:
+ case Qt::FDiagPattern:
+ case Qt::DiagCrossPattern:
+ type = Texture;
+ if (!tempImage)
+ tempImage = new QImage();
+ *tempImage = rasterBuffer->colorizeBitmap(qt_imageForBrush(brushStyle, true), brush.color());
+ initTexture(tempImage, alpha, QTextureData::Tiled);
+ break;
+ case Qt::TexturePattern:
+ type = Texture;
+ if (!tempImage)
+ tempImage = new QImage();
+
+ if (qHasPixmapTexture(brush) && brush.texture().isQBitmap())
+ *tempImage = rasterBuffer->colorizeBitmap(brush.textureImage(), brush.color());
+ else
+ *tempImage = brush.textureImage();
+ initTexture(tempImage, alpha, QTextureData::Tiled, tempImage->rect());
+ break;
+
+ case Qt::NoBrush:
+ default:
+ type = None;
+ break;
+ }
+ adjustSpanMethods();
+}
+
+void QSpanData::adjustSpanMethods()
+{
+ bitmapBlit = 0;
+ alphamapBlit = 0;
+ alphaRGBBlit = 0;
+
+ fillRect = 0;
+
+ switch(type) {
+ case None:
+ unclipped_blend = 0;
+ break;
+ case Solid:
+ unclipped_blend = rasterBuffer->drawHelper->blendColor;
+ bitmapBlit = rasterBuffer->drawHelper->bitmapBlit;
+ alphamapBlit = rasterBuffer->drawHelper->alphamapBlit;
+ alphaRGBBlit = rasterBuffer->drawHelper->alphaRGBBlit;
+ fillRect = rasterBuffer->drawHelper->fillRect;
+ break;
+ case LinearGradient:
+ case RadialGradient:
+ case ConicalGradient:
+ unclipped_blend = rasterBuffer->drawHelper->blendGradient;
+ break;
+ case Texture:
+#ifdef Q_WS_QWS
+#ifndef QT_NO_RASTERCALLBACKS
+ if (!rasterBuffer->buffer())
+ unclipped_blend = qBlendTextureCallback;
+ else
+#endif
+ unclipped_blend = qBlendTexture;
+#else
+ unclipped_blend = qBlendTexture;
+#endif
+ break;
+ }
+ // setup clipping
+ if (!unclipped_blend) {
+ blend = 0;
+ } else if (!clip) {
+ blend = unclipped_blend;
+ } else if (clip->hasRectClip) {
+ blend = clip->clipRect.isEmpty() ? 0 : qt_span_fill_clipRect;
+ } else {
+ blend = qt_span_fill_clipped;
+ }
+}
+
+void QSpanData::setupMatrix(const QTransform &matrix, int bilin)
+{
+ QTransform delta;
+ // make sure we round off correctly in qdrawhelper.cpp
+ delta.translate(1.0 / 65536, 1.0 / 65536);
+
+ QTransform inv = (delta * matrix).inverted();
+ m11 = inv.m11();
+ m12 = inv.m12();
+ m13 = inv.m13();
+ m21 = inv.m21();
+ m22 = inv.m22();
+ m23 = inv.m23();
+ m33 = inv.m33();
+ dx = inv.dx();
+ dy = inv.dy();
+ txop = inv.type();
+ bilinear = bilin;
+
+ const bool affine = !m13 && !m23;
+ fast_matrix = affine
+ && m11 * m11 + m21 * m21 < 1e4
+ && m12 * m12 + m22 * m22 < 1e4
+ && qAbs(dx) < 1e4
+ && qAbs(dy) < 1e4;
+
+ adjustSpanMethods();
+}
+
+extern const QVector<QRgb> *qt_image_colortable(const QImage &image);
+
+void QSpanData::initTexture(const QImage *image, int alpha, QTextureData::Type _type, const QRect &sourceRect)
+{
+ const QImageData *d = const_cast<QImage *>(image)->data_ptr();
+ if (!d || d->height == 0) {
+ texture.imageData = 0;
+ texture.width = 0;
+ texture.height = 0;
+ texture.x1 = 0;
+ texture.y1 = 0;
+ texture.x2 = 0;
+ texture.y2 = 0;
+ texture.bytesPerLine = 0;
+ texture.format = QImage::Format_Invalid;
+ texture.colorTable = 0;
+ texture.hasAlpha = alpha != 256;
+ } else {
+ texture.imageData = d->data;
+ texture.width = d->width;
+ texture.height = d->height;
+
+ if (sourceRect.isNull()) {
+ texture.x1 = 0;
+ texture.y1 = 0;
+ texture.x2 = texture.width;
+ texture.y2 = texture.height;
+ } else {
+ texture.x1 = sourceRect.x();
+ texture.y1 = sourceRect.y();
+ texture.x2 = qMin(texture.x1 + sourceRect.width(), d->width);
+ texture.y2 = qMin(texture.y1 + sourceRect.height(), d->height);
+ }
+
+ texture.bytesPerLine = d->bytes_per_line;
+
+ texture.format = d->format;
+ texture.colorTable = (d->format <= QImage::Format_Indexed8 && !d->colortable.isEmpty()) ? &d->colortable : 0;
+ texture.hasAlpha = image->hasAlphaChannel() || alpha != 256;
+ }
+ texture.const_alpha = alpha;
+ texture.type = _type;
+
+ adjustSpanMethods();
+}
+
+#ifdef Q_WS_WIN
+
+
+#endif
+
+
+/*!
+ \internal
+
+ Draws a line using the floating point midpoint algorithm. The line
+ \a line is already in device coords at this point.
+*/
+
+static void drawLine_midpoint_i(int x1, int y1, int x2, int y2, ProcessSpans span_func, QSpanData *data,
+ LineDrawMode style, const QIntRect &devRect)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << " - drawLine_midpoint_i" << QLine(QPoint(x1, y1), QPoint(x2, y2));
+#endif
+
+ int x, y;
+ int dx, dy, d, incrE, incrNE;
+
+ dx = x2 - x1;
+ dy = y2 - y1;
+
+ const int NSPANS = 256;
+ QT_FT_Span spans[NSPANS];
+ int current = 0;
+ bool ordered = true;
+
+ if (dy == 0) {
+ // specialcase horizontal lines
+ if (y1 >= devRect.y1 && y1 < devRect.y2) {
+ int start = qMax(devRect.x1, qMin(x1, x2));
+ int stop = qMax(x1, x2) + 1;
+ int stop_clipped = qMin(devRect.x2, stop);
+ int len = stop_clipped - start;
+ if (style == LineDrawNormal && stop == stop_clipped)
+ len--;
+ if (len > 0) {
+ spans[0].x = ushort(start);
+ spans[0].len = ushort(len);
+ spans[0].y = y1;
+ spans[0].coverage = 255;
+ span_func(1, spans, data);
+ }
+ }
+ return;
+ } else if (dx == 0) {
+ // specialcase vertical lines
+ if (x1 >= devRect.x1 && x1 < devRect.x2) {
+ int start = qMax(devRect.y1, qMin(y1, y2));
+ int stop = qMax(y1, y2) + 1;
+ int stop_clipped = qMin(devRect.y2, stop);
+ int len = stop_clipped - start;
+ if (style == LineDrawNormal && stop == stop_clipped)
+ len--;
+ // hw: create spans directly instead to possibly avoid clipping
+ if (len > 0)
+ fillRect_normalized(QRect(x1, start, 1, len).normalized(), data, 0);
+ }
+ return;
+ }
+
+
+ if (qAbs(dx) >= qAbs(dy)) { /* if x is the major axis: */
+
+ if (x2 < x1) { /* if coordinates are out of order */
+ qt_swap_int(x1, x2);
+ dx = -dx;
+
+ qt_swap_int(y1, y2);
+ dy = -dy;
+ }
+
+ int x_lower_limit = - 128;
+ if (x1 < x_lower_limit) {
+ int cy = dy * (x_lower_limit - x1) / dx + y1;
+ drawLine_midpoint_i(x_lower_limit, cy, x2, y2, span_func, data, style, devRect);
+ return;
+ }
+
+ if (style == LineDrawNormal)
+ --x2;
+
+ // In the loops below we increment before call the span function so
+ // we need to stop one pixel before
+ x2 = qMin(x2, devRect.x2 - 1);
+
+ // completely clipped, so abort
+ if (x2 <= x1) {
+ return;
+ }
+
+ int x = x1;
+ int y = y1;
+
+ if (y2 <= y1)
+ ordered = false;
+
+ {
+ const int index = (ordered ? current : NSPANS - 1 - current);
+ spans[index].coverage = 255;
+ spans[index].x = x;
+ spans[index].y = y;
+
+ if (x >= devRect.x1 && y >= devRect.y1 && y < devRect.y2)
+ spans[index].len = 1;
+ else
+ spans[index].len = 0;
+ }
+
+ if (y2 > y1) { // 315 -> 360 and 135 -> 180 (unit circle degrees)
+ y2 = qMin(y2, devRect.y2 - 1);
+
+ incrE = dy * 2;
+ d = incrE - dx;
+ incrNE = (dy - dx) * 2;
+
+ if (y > y2)
+ goto flush_and_return;
+
+ while (x < x2) {
+ ++x;
+ if (d > 0) {
+ if (spans[current].len > 0)
+ ++current;
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+
+ ++y;
+ d += incrNE;
+ if (y > y2)
+ goto flush_and_return;
+
+ spans[current].len = 0;
+ spans[current].coverage = 255;
+ spans[current].x = x;
+ spans[current].y = y;
+ } else {
+ d += incrE;
+ if (x == devRect.x1)
+ spans[current].x = devRect.x1;
+ }
+
+ if (x < devRect.x1 || y < devRect.y1)
+ continue;
+
+ Q_ASSERT(x<devRect.x2);
+ Q_ASSERT(y<devRect.y2);
+ Q_ASSERT(spans[current].y == y);
+ spans[current].len++;
+ }
+ if (spans[current].len > 0) {
+ ++current;
+ }
+ } else { // 0-45 and 180->225 (unit circle degrees)
+
+ y1 = qMin(y1, devRect.y2 - 1);
+
+ incrE = dy * 2;
+ d = incrE + dx;
+ incrNE = (dy + dx) * 2;
+
+ if (y < devRect.y1)
+ goto flush_and_return;
+
+ while (x < x2) {
+ ++x;
+ if (d < 0) {
+ if (spans[NSPANS - 1 - current].len > 0)
+ ++current;
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+
+ --y;
+ d += incrNE;
+ if (y < devRect.y1)
+ goto flush_and_return;
+
+ const int index = NSPANS - 1 - current;
+ spans[index].len = 0;
+ spans[index].coverage = 255;
+ spans[index].x = x;
+ spans[index].y = y;
+ } else {
+ d += incrE;
+ if (x == devRect.x1)
+ spans[NSPANS - 1 - current].x = devRect.x1;
+ }
+
+ if (x < devRect.x1 || y > y1)
+ continue;
+
+ Q_ASSERT(x<devRect.x2 && y<devRect.y2);
+ Q_ASSERT(spans[NSPANS - 1 - current].y == y);
+ spans[NSPANS - 1 - current].len++;
+ }
+ if (spans[NSPANS - 1 - current].len > 0) {
+ ++current;
+ }
+ }
+
+ } else {
+
+ // if y is the major axis:
+
+ if (y2 < y1) { /* if coordinates are out of order */
+ qt_swap_int(y1, y2);
+ dy = -dy;
+
+ qt_swap_int(x1, x2);
+ dx = -dx;
+ }
+
+ int y_lower_limit = - 128;
+ if (y1 < y_lower_limit) {
+ int cx = dx * (y_lower_limit - y1) / dy + x1;
+ drawLine_midpoint_i(cx, y_lower_limit, x2, y2, span_func, data, style, devRect);
+ return;
+ }
+
+ if (style == LineDrawNormal)
+ --y2;
+
+ // In the loops below we increment before call the span function so
+ // we need to stop one pixel before
+ y2 = qMin(y2, devRect.y2 - 1);
+
+ // completely clipped, so abort
+ if (y2 <= y1) {
+ return;
+ }
+
+ x = x1;
+ y = y1;
+
+ if (x>=devRect.x1 && y>=devRect.y1 && x < devRect.x2) {
+ Q_ASSERT(x >= devRect.x1 && y >= devRect.y1 && x < devRect.x2 && y < devRect.y2);
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+ spans[current].len = 1;
+ spans[current].coverage = 255;
+ spans[current].x = x;
+ spans[current].y = y;
+ ++current;
+ }
+
+ if (x2 > x1) { // 90 -> 135 and 270 -> 315 (unit circle degrees)
+ x2 = qMin(x2, devRect.x2 - 1);
+ incrE = dx * 2;
+ d = incrE - dy;
+ incrNE = (dx - dy) * 2;
+
+ if (x > x2)
+ goto flush_and_return;
+
+ while (y < y2) {
+ if (d > 0) {
+ ++x;
+ d += incrNE;
+ if (x > x2)
+ goto flush_and_return;
+ } else {
+ d += incrE;
+ }
+ ++y;
+ if (x < devRect.x1 || y < devRect.y1)
+ continue;
+ Q_ASSERT(x<devRect.x2 && y<devRect.y2);
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+ spans[current].len = 1;
+ spans[current].coverage = 255;
+ spans[current].x = x;
+ spans[current].y = y;
+ ++current;
+ }
+ } else { // 45 -> 90 and 225 -> 270 (unit circle degrees)
+ x1 = qMin(x1, devRect.x2 - 1);
+ incrE = dx * 2;
+ d = incrE + dy;
+ incrNE = (dx + dy) * 2;
+
+ if (x < devRect.x1)
+ goto flush_and_return;
+
+ while (y < y2) {
+ if (d < 0) {
+ --x;
+ d += incrNE;
+ if (x < devRect.x1)
+ goto flush_and_return;
+ } else {
+ d += incrE;
+ }
+ ++y;
+ if (y < devRect.y1 || x > x1)
+ continue;
+ Q_ASSERT(x>=devRect.x1 && x<devRect.x2 && y>=devRect.y1 && y<devRect.y2);
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+ spans[current].len = 1;
+ spans[current].coverage = 255;
+ spans[current].x = x;
+ spans[current].y = y;
+ ++current;
+ }
+ }
+ }
+flush_and_return:
+ if (current > 0)
+ span_func(current, ordered ? spans : spans + (NSPANS - current), data);
+}
+
+static void offset_pattern(int offset, bool *inDash, int *dashIndex, int *currentOffset, const QVarLengthArray<qreal> &pattern)
+{
+ while (offset--) {
+ if (--*currentOffset == 0) {
+ *inDash = !*inDash;
+ *dashIndex = ((*dashIndex + 1) % pattern.size());
+ *currentOffset = int(pattern[*dashIndex]);
+ }
+ }
+}
+
+static void drawLine_midpoint_dashed_i(int x1, int y1, int x2, int y2,
+ QPen *pen,
+ ProcessSpans span_func, QSpanData *data,
+ LineDrawMode style, const QIntRect &devRect,
+ int *patternOffset)
+{
+#ifdef QT_DEBUG_DRAW
+ qDebug() << " - drawLine_midpoint_dashed_i" << x1 << y1 << x2 << y2 << *patternOffset;
+#endif
+
+ int x, y;
+ int dx, dy, d, incrE, incrNE;
+
+ dx = x2 - x1;
+ dy = y2 - y1;
+
+ Q_ASSERT(*patternOffset >= 0);
+
+ const QVector<qreal> penPattern = pen->dashPattern();
+ QVarLengthArray<qreal> pattern(penPattern.size());
+
+ int patternLength = 0;
+ for (int i = 0; i < penPattern.size(); ++i)
+ patternLength += qMax<qreal>(1.0, (penPattern.at(i)));
+
+ // pattern must be reversed if coordinates are out of order
+ int reverseLength = -1;
+ if (dy == 0 && x1 > x2)
+ reverseLength = x1 - x2;
+ else if (dx == 0 && y1 > y2)
+ reverseLength = y1 - y2;
+ else if (qAbs(dx) >= qAbs(dy) && x2 < x1) // x major axis
+ reverseLength = qAbs(dx);
+ else if (qAbs(dy) >= qAbs(dx) && y2 < y1) // y major axis
+ reverseLength = qAbs(dy);
+
+ const bool reversed = (reverseLength > -1);
+ if (reversed) { // reverse pattern
+ for (int i = 0; i < penPattern.size(); ++i)
+ pattern[penPattern.size() - 1 - i] = qMax<qreal>(1.0, penPattern.at(i));
+
+ *patternOffset = (patternLength - 1 - *patternOffset);
+ *patternOffset += patternLength - (reverseLength % patternLength);
+ *patternOffset = *patternOffset % patternLength;
+ } else {
+ for (int i = 0; i < penPattern.size(); ++i)
+ pattern[i] = qMax<qreal>(1.0, penPattern.at(i));
+ }
+
+ int dashIndex = 0;
+ bool inDash = !reversed;
+ int currPattern = int(pattern[dashIndex]);
+
+ // adjust pattern for offset
+ offset_pattern(*patternOffset, &inDash, &dashIndex, &currPattern, pattern);
+
+ const int NSPANS = 256;
+ QT_FT_Span spans[NSPANS];
+ int current = 0;
+ bool ordered = true;
+
+ if (dy == 0) {
+ // specialcase horizontal lines
+ if (y1 >= devRect.y1 && y1 < devRect.y2) {
+ int start_unclipped = qMin(x1, x2);
+ int start = qMax(devRect.x1, start_unclipped);
+ int stop = qMax(x1, x2) + 1;
+ int stop_clipped = qMin(devRect.x2, stop);
+ int len = stop_clipped - start;
+ if (style == LineDrawNormal && stop == stop_clipped)
+ len--;
+
+ // adjust pattern for starting offset
+ offset_pattern(start - start_unclipped, &inDash, &dashIndex, &currPattern, pattern);
+
+ if (len > 0) {
+ int x = start;
+ while (x < stop_clipped) {
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+ const int dash = qMin(currPattern, stop_clipped - x);
+ if (inDash) {
+ spans[current].x = ushort(x);
+ spans[current].len = ushort(dash);
+ spans[current].y = y1;
+ spans[current].coverage = 255;
+ ++current;
+ }
+ if (dash < currPattern) {
+ currPattern -= dash;
+ } else {
+ dashIndex = (dashIndex + 1) % pattern.size();
+ currPattern = int(pattern[dashIndex]);
+ inDash = !inDash;
+ }
+ x += dash;
+ }
+ }
+ }
+ goto flush_and_return;
+ } else if (dx == 0) {
+ if (x1 >= devRect.x1 && x1 < devRect.x2) {
+ int start_unclipped = qMin(y1, y2);
+ int start = qMax(devRect.y1, start_unclipped);
+ int stop = qMax(y1, y2) + 1;
+ int stop_clipped = qMin(devRect.y2, stop);
+ if (style == LineDrawNormal && stop == stop_clipped)
+ --stop;
+ else
+ stop = stop_clipped;
+
+ // adjust pattern for starting offset
+ offset_pattern(start - start_unclipped, &inDash, &dashIndex, &currPattern, pattern);
+
+ // loop over dashes
+ int y = start;
+ while (y < stop) {
+ const int dash = qMin(currPattern, stop - y);
+ if (inDash) {
+ for (int i = 0; i < dash; ++i) {
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+ spans[current].x = x1;
+ spans[current].len = 1;
+ spans[current].coverage = 255;
+ spans[current].y = ushort(y + i);
+ ++current;
+ }
+ }
+ if (dash < currPattern) {
+ currPattern -= dash;
+ } else {
+ dashIndex = (dashIndex + 1) % pattern.size();
+ currPattern = int(pattern[dashIndex]);
+ inDash = !inDash;
+ }
+ y += dash;
+ }
+ }
+ goto flush_and_return;
+ }
+
+ if (qAbs(dx) >= qAbs(dy)) { /* if x is the major axis: */
+
+ if (x2 < x1) { /* if coordinates are out of order */
+ qt_swap_int(x1, x2);
+ dx = -dx;
+
+ qt_swap_int(y1, y2);
+ dy = -dy;
+ }
+
+ if (style == LineDrawNormal)
+ --x2;
+
+ // In the loops below we increment before call the span function so
+ // we need to stop one pixel before
+ x2 = qMin(x2, devRect.x2 - 1);
+
+ // completely clipped, so abort
+ if (x2 <= x1)
+ goto flush_and_return;
+
+ int x = x1;
+ int y = y1;
+
+ if (x >= devRect.x1 && y >= devRect.y1 && y < devRect.y2) {
+ Q_ASSERT(x < devRect.x2);
+ if (inDash) {
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+ spans[current].len = 1;
+ spans[current].coverage = 255;
+ spans[current].x = x;
+ spans[current].y = y;
+ ++current;
+ }
+ if (--currPattern <= 0) {
+ inDash = !inDash;
+ dashIndex = (dashIndex + 1) % pattern.size();
+ currPattern = int(pattern[dashIndex]);
+ }
+ }
+
+ if (y2 > y1) { // 315 -> 360 and 135 -> 180 (unit circle degrees)
+ y2 = qMin(y2, devRect.y2 - 1);
+
+ incrE = dy * 2;
+ d = incrE - dx;
+ incrNE = (dy - dx) * 2;
+
+ if (y > y2)
+ goto flush_and_return;
+
+ while (x < x2) {
+ if (d > 0) {
+ ++y;
+ d += incrNE;
+ if (y > y2)
+ goto flush_and_return;
+ } else {
+ d += incrE;
+ }
+ ++x;
+
+ const bool skip = x < devRect.x1 || y < devRect.y1;
+ Q_ASSERT(skip || (x < devRect.x2 && y < devRect.y2));
+ if (inDash && !skip) {
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+ spans[current].len = 1;
+ spans[current].coverage = 255;
+ spans[current].x = x;
+ spans[current].y = y;
+ ++current;
+ }
+ if (--currPattern <= 0) {
+ inDash = !inDash;
+ dashIndex = (dashIndex + 1) % pattern.size();
+ currPattern = int(pattern[dashIndex]);
+ }
+ }
+ } else { // 0-45 and 180->225 (unit circle degrees)
+ y1 = qMin(y1, devRect.y2 - 1);
+
+ incrE = dy * 2;
+ d = incrE + dx;
+ incrNE = (dy + dx) * 2;
+
+ if (y < devRect.y1)
+ goto flush_and_return;
+
+ while (x < x2) {
+ if (d < 0) {
+ if (current > 0) {
+ span_func(current, spans, data);
+ current = 0;
+ }
+
+ --y;
+ d += incrNE;
+ if (y < devRect.y1)
+ goto flush_and_return;
+ } else {
+ d += incrE;
+ }
+ ++x;
+
+ const bool skip = x < devRect.x1 || y > y1;
+ Q_ASSERT(skip || (x < devRect.x2 && y < devRect.y2));
+ if (inDash && !skip) {
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+ spans[current].len = 1;
+ spans[current].coverage = 255;
+ spans[current].x = x;
+ spans[current].y = y;
+ ++current;
+ }
+ if (--currPattern <= 0) {
+ inDash = !inDash;
+ dashIndex = (dashIndex + 1) % pattern.size();
+ currPattern = int(pattern[dashIndex]);
+ }
+ }
+ }
+ } else {
+
+ // if y is the major axis:
+
+ if (y2 < y1) { /* if coordinates are out of order */
+ qt_swap_int(y1, y2);
+ dy = -dy;
+
+ qt_swap_int(x1, x2);
+ dx = -dx;
+ }
+
+ if (style == LineDrawNormal)
+ --y2;
+
+ // In the loops below we increment before call the span function so
+ // we need to stop one pixel before
+ y2 = qMin(y2, devRect.y2 - 1);
+
+ // completely clipped, so abort
+ if (y2 <= y1)
+ goto flush_and_return;
+
+ x = x1;
+ y = y1;
+
+ if (x>=devRect.x1 && y>=devRect.y1 && x < devRect.x2) {
+ Q_ASSERT(x < devRect.x2);
+ if (inDash) {
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+ spans[current].len = 1;
+ spans[current].coverage = 255;
+ spans[current].x = x;
+ spans[current].y = y;
+ ++current;
+ }
+ if (--currPattern <= 0) {
+ inDash = !inDash;
+ dashIndex = (dashIndex + 1) % pattern.size();
+ currPattern = int(pattern[dashIndex]);
+ }
+ }
+
+ if (x2 > x1) { // 90 -> 135 and 270 -> 315 (unit circle degrees)
+ x2 = qMin(x2, devRect.x2 - 1);
+ incrE = dx * 2;
+ d = incrE - dy;
+ incrNE = (dx - dy) * 2;
+
+ if (x > x2)
+ goto flush_and_return;
+
+ while (y < y2) {
+ if (d > 0) {
+ ++x;
+ d += incrNE;
+ if (x > x2)
+ goto flush_and_return;
+ } else {
+ d += incrE;
+ }
+ ++y;
+ const bool skip = x < devRect.x1 || y < devRect.y1;
+ Q_ASSERT(skip || (x < devRect.x2 && y < devRect.y2));
+ if (inDash && !skip) {
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+ spans[current].len = 1;
+ spans[current].coverage = 255;
+ spans[current].x = x;
+ spans[current].y = y;
+ ++current;
+ }
+ if (--currPattern <= 0) {
+ inDash = !inDash;
+ dashIndex = (dashIndex + 1) % pattern.size();
+ currPattern = int(pattern[dashIndex]);
+ }
+ }
+ } else { // 45 -> 90 and 225 -> 270 (unit circle degrees)
+ x1 = qMin(x1, devRect.x2 - 1);
+ incrE = dx * 2;
+ d = incrE + dy;
+ incrNE = (dx + dy) * 2;
+
+ if (x < devRect.x1)
+ goto flush_and_return;
+
+ while (y < y2) {
+ if (d < 0) {
+ --x;
+ d += incrNE;
+ if (x < devRect.x1)
+ goto flush_and_return;
+ } else {
+ d += incrE;
+ }
+ ++y;
+ const bool skip = y < devRect.y1 || x > x1;
+ Q_ASSERT(skip || (x >= devRect.x1 && x < devRect.x2 && y < devRect.y2));
+ if (inDash && !skip) {
+ if (current == NSPANS) {
+ span_func(NSPANS, spans, data);
+ current = 0;
+ }
+ spans[current].len = 1;
+ spans[current].coverage = 255;
+ spans[current].x = x;
+ spans[current].y = y;
+ ++current;
+ }
+ if (--currPattern <= 0) {
+ inDash = !inDash;
+ dashIndex = (dashIndex + 1) % pattern.size();
+ currPattern = int(pattern[dashIndex]);
+ }
+ }
+ }
+ }
+flush_and_return:
+ if (current > 0)
+ span_func(current, ordered ? spans : spans + (NSPANS - current), data);
+
+ // adjust offset
+ if (reversed) {
+ *patternOffset = (patternLength - 1 - *patternOffset);
+ } else {
+ *patternOffset = 0;
+ for (int i = 0; i <= dashIndex; ++i)
+ *patternOffset += int(pattern[i]);
+ *patternOffset += patternLength - currPattern - 1;
+ *patternOffset = (*patternOffset % patternLength);
+ }
+}
+
+/*!
+ \internal
+ \a x and \a y is relative to the midpoint of \a rect.
+*/
+static inline void drawEllipsePoints(int x, int y, int length,
+ const QRect &rect,
+ const QRect &clip,
+ ProcessSpans pen_func, ProcessSpans brush_func,
+ QSpanData *pen_data, QSpanData *brush_data)
+{
+ if (length == 0)
+ return;
+
+ QT_FT_Span outline[4];
+ const int midx = rect.x() + (rect.width() + 1) / 2;
+ const int midy = rect.y() + (rect.height() + 1) / 2;
+
+ x = x + midx;
+ y = midy - y;
+
+ // topleft
+ outline[0].x = midx + (midx - x) - (length - 1) - (rect.width() & 0x1);
+ outline[0].len = qMin(length, x - outline[0].x);
+ outline[0].y = y;
+ outline[0].coverage = 255;
+
+ // topright
+ outline[1].x = x;
+ outline[1].len = length;
+ outline[1].y = y;
+ outline[1].coverage = 255;
+
+ // bottomleft
+ outline[2].x = outline[0].x;
+ outline[2].len = outline[0].len;
+ outline[2].y = midy + (midy - y) - (rect.height() & 0x1);
+ outline[2].coverage = 255;
+
+ // bottomright
+ outline[3].x = x;
+ outline[3].len = length;
+ outline[3].y = outline[2].y;
+ outline[3].coverage = 255;
+
+ if (brush_func && outline[0].x + outline[0].len < outline[1].x) {
+ QT_FT_Span fill[2];
+
+ // top fill
+ fill[0].x = outline[0].x + outline[0].len - 1;
+ fill[0].len = qMax(0, outline[1].x - fill[0].x);
+ fill[0].y = outline[1].y;
+ fill[0].coverage = 255;
+
+ // bottom fill
+ fill[1].x = outline[2].x + outline[2].len - 1;
+ fill[1].len = qMax(0, outline[3].x - fill[1].x);
+ fill[1].y = outline[3].y;
+ fill[1].coverage = 255;
+
+ int n = (fill[0].y >= fill[1].y ? 1 : 2);
+ n = qt_intersect_spans(fill, n, clip);
+ if (n > 0)
+ brush_func(n, fill, brush_data);
+ }
+ if (pen_func) {
+ int n = (outline[1].y >= outline[2].y ? 2 : 4);
+ n = qt_intersect_spans(outline, n, clip);
+ if (n > 0)
+ pen_func(n, outline, pen_data);
+ }
+}
+
+/*!
+ \internal
+ Draws an ellipse using the integer point midpoint algorithm.
+*/
+static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip,
+ ProcessSpans pen_func, ProcessSpans brush_func,
+ QSpanData *pen_data, QSpanData *brush_data)
+{
+#ifdef FLOATING_POINT_BUGGY_OR_NO_FPU // no fpu, so use fixed point
+ const QFixed a = QFixed(rect.width()) >> 1;
+ const QFixed b = QFixed(rect.height()) >> 1;
+ QFixed d = b*b - (a*a*b) + ((a*a) >> 2);
+#else
+ const qreal a = qreal(rect.width()) / 2;
+ const qreal b = qreal(rect.height()) / 2;
+ qreal d = b*b - (a*a*b) + 0.25*a*a;
+#endif
+
+ int x = 0;
+ int y = (rect.height() + 1) / 2;
+ int startx = x;
+
+ // region 1
+ while (a*a*(2*y - 1) > 2*b*b*(x + 1)) {
+ if (d < 0) { // select E
+ d += b*b*(2*x + 3);
+ ++x;
+ } else { // select SE
+ d += b*b*(2*x + 3) + a*a*(-2*y + 2);
+ drawEllipsePoints(startx, y, x - startx + 1, rect, clip,
+ pen_func, brush_func, pen_data, brush_data);
+ startx = ++x;
+ --y;
+ }
+ }
+ drawEllipsePoints(startx, y, x - startx + 1, rect, clip,
+ pen_func, brush_func, pen_data, brush_data);
+
+ // region 2
+#ifdef FLOATING_POINT_BUGGY_OR_NO_FPU
+ d = b*b*(x + (QFixed(1) >> 1))*(x + (QFixed(1) >> 1))
+ + a*a*((y - 1)*(y - 1) - b*b);
+#else
+ d = b*b*(x + 0.5)*(x + 0.5) + a*a*((y - 1)*(y - 1) - b*b);
+#endif
+ const int miny = rect.height() & 0x1;
+ while (y > miny) {
+ if (d < 0) { // select SE
+ d += b*b*(2*x + 2) + a*a*(-2*y + 3);
+ ++x;
+ } else { // select S
+ d += a*a*(-2*y + 3);
+ }
+ --y;
+ drawEllipsePoints(x, y, 1, rect, clip,
+ pen_func, brush_func, pen_data, brush_data);
+ }
+}
+
+/*!
+ \fn void QRasterPaintEngine::drawPoints(const QPoint *points, int pointCount)
+ \overload
+
+ Draws the first \a pointCount points in the buffer \a points
+
+ The default implementation converts the first \a pointCount QPoints in \a points
+ to QPointFs and calls the floating point version of drawPoints.
+*/
+
+/*!
+ \fn void QRasterPaintEngine::drawEllipse(const QRect &rect)
+ \overload
+
+ Reimplement this function to draw the largest ellipse that can be
+ contained within rectangle \a rect.
+*/
+
+#ifdef QT_DEBUG_DRAW
+void dumpClip(int width, int height, const QClipData *clip)
+{
+ QImage clipImg(width, height, QImage::Format_ARGB32_Premultiplied);
+ clipImg.fill(0xffff0000);
+
+ int x0 = width;
+ int x1 = 0;
+ int y0 = height;
+ int y1 = 0;
+
+ ((QClipData *) clip)->spans(); // Force allocation of the spans structure...
+
+ for (int i = 0; i < clip->count; ++i) {
+ const QSpan *span = ((QClipData *) clip)->spans() + i;
+ for (int j = 0; j < span->len; ++j)
+ clipImg.setPixel(span->x + j, span->y, 0xffffff00);
+ x0 = qMin(x0, int(span->x));
+ x1 = qMax(x1, int(span->x + span->len - 1));
+
+ y0 = qMin(y0, int(span->y));
+ y1 = qMax(y1, int(span->y));
+ }
+
+ static int counter = 0;
+
+ Q_ASSERT(y0 >= 0);
+ Q_ASSERT(x0 >= 0);
+ Q_ASSERT(y1 >= 0);
+ Q_ASSERT(x1 >= 0);
+
+ fprintf(stderr,"clip %d: %d %d - %d %d\n", counter, x0, y0, x1, y1);
+ clipImg.save(QString::fromLatin1("clip-%0.png").arg(counter++));
+}
+#endif
+
+
+QT_END_NAMESPACE