FCL/sf/mw/qt: comparison src/gui/painting/qpaintengine

equal deleted inserted replaced

-:b72c6db6890b
+:5dc02b23752f
 #include <private/qfontengine_p.h>
 #include <private/qpixmap_raster_p.h>
 //   #include <private/qpolygonclipper_p.h>
 //   #include <private/qrasterizer_p.h>
 #include <private/qimage_p.h>
+#include <private/qstatictext_p.h>
 #include "qpaintengine_raster_p.h"
 //   #include "qbezier_p.h"
 #include "qoutlinemapper_p.h"
 fprintf(stderr," - %3d:: %s, (%.2f, %.2f)\n", i, names[e.type], e.x, e.y);
 }
 }
 #endif
+QRasterPaintEnginePrivate::QRasterPaintEnginePrivate() :
+QPaintEngineExPrivate(),
+cachedLines(0)
+{
+}
 /*!
 \class QRasterPaintEngine
 \preliminary
 #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;
 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());
 }
 /*!
 patternLength += pattern.at(i);
 if (patternLength > 0) {
 int n = qFloor(dashOffset / patternLength);
 dashOffset -= n * patternLength;
-while (dashOffset > pattern.at(dashIndex)) {
+while (dashOffset >= pattern.at(dashIndex)) {
 dashOffset -= pattern.at(dashIndex);
-dashIndex = (dashIndex + 1) % pattern.size();
+if (++dashIndex >= pattern.size())
+dashIndex = 0;
 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) {
-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())));
 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) {
+if (s->matrix.type() <= QTransform::TxScale && !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);
 // 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)
+void QRasterPaintEngine::drawCachedGlyphs(int numGlyphs, const glyph_t *glyphs,
+const QFixedPoint *positions, QFontEngine *fontEngine)
 {
 Q_D(QRasterPaintEngine);
 QRasterPaintEngineState *s = state();
-QVarLengthArray<QFixedPoint> positions;
+QFontEngineGlyphCache::Type glyphType = fontEngine->glyphFormat >= 0 ? QFontEngineGlyphCache::Type(fontEngine->glyphFormat) : d->glyphCacheType;
-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(0, glyphType, s->matrix);
+static_cast<QImageTextureGlyphCache *>(fontEngine->glyphCache(0, glyphType, s->matrix));
 if (!cache) {
 cache = new QImageTextureGlyphCache(glyphType, s->matrix);
-ti.fontEngine->setGlyphCache(0, cache);
+fontEngine->setGlyphCache(0, cache);
 }
-cache->populate(ti, glyphs, positions);
+cache->populate(fontEngine, numGlyphs, glyphs, positions);
 const QImage &image = cache->image();
 int bpl = image.bytesPerLine();
 int depth = image.depth();
 int margin = cache->glyphMargin();
 const QFixed offs = QFixed::fromReal(aliasedCoordinateDelta);
 const uchar *bits = image.bits();
-for (int i=0; i<glyphs.size(); ++i) {
+for (int i=0; i<numGlyphs; ++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",
 const int penWidth = s->flags.fast_pen ? 1 : qCeil(s->lastPen.widthF());
 return isUnclipped(rect, penWidth) ? data->unclipped_blend : data->blend;
 }
 /*!
+\reimp
+*/
+void QRasterPaintEngine::drawStaticTextItem(QStaticTextItem *textItem)
+{
+ensurePen();
+ensureState();
+drawCachedGlyphs(textItem->numGlyphs, textItem->glyphs, textItem->glyphPositions,
+textItem->fontEngine);
+}
+/*!
 \reimp
 */
 void QRasterPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
 {
 const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
 #else
 if (s->matrix.type() > QTransform::TxTranslate)
 drawCached = false;
 #endif
 if (drawCached) {
-drawCachedGlyphs(p, ti);
+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);
+drawCachedGlyphs(glyphs.size(), glyphs.constData(), positions.constData(), ti.fontEngine);
 return;
 }
 #elif defined (Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE) // Q_WS_WIN || Q_WS_MAC
 if (s->matrix.type() <= QTransform::TxTranslate
 Q_ASSERT(false);
 depth = 0;
 };
 for(int i = 0; i < glyphs.size(); i++) {
-QFontEngineFT::Glyph *glyph = gset->glyph_data.value(glyphs[i]);
+QFontEngineFT::Glyph *glyph = gset->getGlyph(glyphs[i]);
 if (!glyph || glyph->format != neededFormat) {
 if (!lockedFace)
 lockedFace = fe->lockFace();
 glyph = fe->loadGlyph(gset, glyphs[i], neededFormat);
 *dashOffset += dash / width;
 length = 0;
 } else {
 *dashOffset = 0;
 *inDash = !(*inDash);
-*dashIndex = (*dashIndex + 1) % pattern.size();
+if (++*dashIndex >= pattern.size())
+*dashIndex = 0;
 length -= dash;
 l.setLength(dash);
 line.setP1(l.p2());
 }
-if (rasterize && dash != 0)
+if (rasterize && dash > 0)
 rasterizer->rasterizeLine(l.p1(), l.p2(), width / dash, squareCap);
 }
 }
 /*!
 rasterizer->rasterize(outline, fillRule);
 return;
 }
+const int rasterPoolInitialSize = 8192;
+int rasterPoolSize = rasterPoolInitialSize;
+unsigned char *rasterPoolBase;
+#if defined(Q_WS_WIN64)
+rasterPoolBase =
+// 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 rasterPoolOnStack[rasterPoolInitialSize];
+rasterPoolBase = rasterPoolOnStack;
+#endif
+Q_CHECK_PTR(rasterPoolBase);
+qt_ft_grays_raster.raster_reset(*grayRaster.data(), rasterPoolBase, rasterPoolSize);
 void *data = userData;
 QT_FT_BBox clip_box = { deviceRect.x(),
 deviceRect.y(),
 deviceRect.x() + deviceRect.width(),
 // 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;
+break;
 }
 #if defined(Q_WS_WIN64)
 _aligned_free(rasterPoolBase);
 #else
-free(rasterPoolBase);
+if (rasterPoolBase != rasterPoolOnStack) // initially on the stack
+free(rasterPoolBase);
 #endif
 rasterPoolSize = new_size;
 rasterPoolBase =
 #if defined(Q_WS_WIN64)
 qt_ft_grays_raster.raster_reset(*grayRaster.data(), rasterPoolBase, rasterPoolSize);
 } else {
 done = true;
 }
 }
+#if defined(Q_WS_WIN64)
+_aligned_free(rasterPoolBase);
+#else
+if (rasterPoolBase != rasterPoolOnStack) // initially on the stack
+free(rasterPoolBase);
+#endif
 }
 void QRasterPaintEnginePrivate::recalculateFastImages()
 {
 Q_Q(QRasterPaintEngine);

changeset 30	5dc02b23752f
parent 22	79de32ba3296
child 33	3e2da88830cd