FCL/sf/mw/qt: comparison src/openvg/qpaintengine

equal deleted inserted replaced

-:93b982ccede2
+:5daf16870df6
 #include "qpixmapdata_vg_p.h"
 #include "qpixmapfilter_vg_p.h"
 #include "qvgcompositionhelper_p.h"
 #include "qvgimagepool_p.h"
 #if !defined(QT_NO_EGL)
-#include <QtGui/private/qegl_p.h>
+#include <QtGui/private/qeglcontext_p.h>
 #include "qwindowsurface_vgegl_p.h"
 #endif
 #include <QtCore/qvarlengtharray.h>
 #include <QtGui/private/qdrawhelper_p.h>
-#include <QtGui/private/qtextureglyphcache_p.h>
 #include <QtGui/private/qtextengine_p.h>
 #include <QtGui/private/qfontengine_p.h>
 #include <QtGui/private/qpainterpath_p.h>
+#include <QtGui/private/qstatictext_p.h>
 #include <QDebug>
 #include <QSet>
 QT_BEGIN_NAMESPACE
 {
 public:
 QVGFontGlyphCache();
 ~QVGFontGlyphCache();
-void cacheGlyphs(QVGPaintEnginePrivate *d,
+void cacheGlyphs(QVGPaintEnginePrivate *d, QFontEngine *fontEngine, const glyph_t *g, int count);
-const QTextItemInt &ti,
-const QVarLengthArray<glyph_t> &glyphs);
+void setScaleFromText(const QFont &font, QFontEngine *fontEngine);
-void setScaleFromText(const QTextItemInt &ti);
 VGFont font;
 VGfloat scaleX;
 VGfloat scaleY;
 uint cachedGlyphsMask[256 / 32];
 QSet<glyph_t> cachedGlyphs;
 };
 typedef QHash<QFontEngine*, QVGFontGlyphCache*> QVGFontCache;
 };
 class QVGPaintEnginePrivate : public QPaintEngineExPrivate
 {
 public:
+// Extra blending modes from VG_KHR_advanced_blending extension.
+// Use the QT_VG prefix to avoid conflicts with any definitions
+// that may come in via <VG/vgext.h>.
+enum AdvancedBlending {
+QT_VG_BLEND_OVERLAY_KHR       = 0x2010,
+QT_VG_BLEND_HARDLIGHT_KHR     = 0x2011,
+QT_VG_BLEND_SOFTLIGHT_SVG_KHR = 0x2012,
+QT_VG_BLEND_SOFTLIGHT_KHR     = 0x2013,
+QT_VG_BLEND_COLORDODGE_KHR    = 0x2014,
+QT_VG_BLEND_COLORBURN_KHR     = 0x2015,
+QT_VG_BLEND_DIFFERENCE_KHR    = 0x2016,
+QT_VG_BLEND_SUBTRACT_KHR      = 0x2017,
+QT_VG_BLEND_INVERT_KHR        = 0x2018,
+QT_VG_BLEND_EXCLUSION_KHR     = 0x2019,
+QT_VG_BLEND_LINEARDODGE_KHR   = 0x201a,
+QT_VG_BLEND_LINEARBURN_KHR    = 0x201b,
+QT_VG_BLEND_VIVIDLIGHT_KHR    = 0x201c,
+QT_VG_BLEND_LINEARLIGHT_KHR   = 0x201d,
+QT_VG_BLEND_PINLIGHT_KHR      = 0x201e,
+QT_VG_BLEND_HARDMIX_KHR       = 0x201f,
+QT_VG_BLEND_CLEAR_KHR         = 0x2020,
+QT_VG_BLEND_DST_KHR           = 0x2021,
+QT_VG_BLEND_SRC_OUT_KHR       = 0x2022,
+QT_VG_BLEND_DST_OUT_KHR       = 0x2023,
+QT_VG_BLEND_SRC_ATOP_KHR      = 0x2024,
+QT_VG_BLEND_DST_ATOP_KHR      = 0x2025,
+QT_VG_BLEND_XOR_KHR           = 0x2026
+};
 QVGPaintEnginePrivate();
 ~QVGPaintEnginePrivate();
 void init();
 void initObjects();
 QTransform transform;   // Currently active transform.
 bool simpleTransform;   // True if the transform is simple (non-projective).
 qreal penScale;         // Pen scaling factor from "transform".
 QTransform pathTransform;  // Calculated VG path transformation.
-QTransform glyphTransform; // Calculated VG glyph transformation.
 QTransform imageTransform; // Calculated VG image transformation.
 bool pathTransformSet;  // True if path transform set in the VG context.
 bool maskValid;         // True if vgMask() contains valid data.
 bool maskIsSet;         // True if mask would be fully set if it was valid.
 #if !defined(QVG_NO_DRAW_GLYPHS)
 QVGFontCache fontCache;
 QVGFontEngineCleaner *fontEngineCleaner;
 #endif
+bool hasAdvancedBlending;
 QScopedPointer<QPixmapFilter> convolutionFilter;
 QScopedPointer<QPixmapFilter> colorizeFilter;
 QScopedPointer<QPixmapFilter> dropShadowFilter;
 QScopedPointer<QPixmapFilter> blurFilter;
 clearOpacity = 1.0f;
 #if !defined(QVG_NO_DRAW_GLYPHS)
 fontEngineCleaner = 0;
 #endif
+hasAdvancedBlending = false;
 clearModes();
 }
 QVGPaintEnginePrivate::~QVGPaintEnginePrivate()
 2,    // segmentCapacityHint
 4,    // coordCapacityHint
 VG_PATH_CAPABILITY_ALL);
 vgAppendPathData(linePath, 2, segments, coords);
 #endif
+const char *extensions = reinterpret_cast<const char *>(vgGetString(VG_EXTENSIONS));
+if (extensions)
+hasAdvancedBlending = strstr(extensions, "VG_KHR_advanced_blending") != 0;
 }
 void QVGPaintEnginePrivate::destroy()
 {
 if (penPaint)
 // Construct the VG transform by combining the Qt transform with
 // the following viewport transformation:
 //        | 1  0  0   |
 //        | 0 -1 devh |
 //        | 0  0  1   |
-// The glyph transform uses a slightly different transformation:
-//        | 1  0  0       |   | 1 0  0.5 |   | 1  0     0.5      |
-//        | 0 -1 devh - 1 | * | 0 1 -0.5 | = | 0 -1 (devh - 0.5) |
-//        | 0  0  1       |   | 0 0   1  |   | 0  0      1       |
 // The full VG transform is effectively:
 //      1. Apply the user's transformation matrix.
-//      2. Translate glyphs by an extra (0.5, -0.5).
+//      2. Flip the co-ordinate system upside down.
-//      3. Flip the co-ordinate system upside down.
 QTransform viewport(1.0f, 0.0f, 0.0f,
 0.0f, -1.0f, 0.0f,
 0.0f, devh, 1.0f);
-QTransform gviewport(1.0f, 0.0f, 0.0f,
-0.0f, -1.0f, 0.0f,
-0.5f, devh - 0.5f, 1.0f);
 // Compute the path transform and determine if it is projective.
 pathTransform = transform * viewport;
-glyphTransform = transform * gviewport;
 bool projective = (pathTransform.m13() != 0.0f ||
 pathTransform.m23() != 0.0f ||
 pathTransform.m33() != 1.0f);
 if (projective) {
 // The engine cannot do projective path transforms for us,
 // so we will have to convert the co-ordinates ourselves.
 // Change the matrix to just the viewport transformation.
 pathTransform = viewport;
-glyphTransform = gviewport;
 simpleTransform = false;
 } else {
 simpleTransform = true;
 }
 pathTransformSet = false;
 QRgb bg = 0;
 int height = sourceImage.height();
 int width = sourceImage.width();
 for (int y=0; y<height; ++y) {
-uchar *source = sourceImage.scanLine(y);
+const uchar *source = sourceImage.constScanLine(y);
 QRgb *target = reinterpret_cast<QRgb *>(dest.scanLine(y));
 for (int x=0; x < width; ++x)
 target[x] = (source[x>>3] >> (x&7)) & 1 ? fg : bg;
 }
 return dest;
 }
-// defined in qpixmapdata_vg.cpp.
-const uchar *qt_vg_imageBits(const QImage& image);
 static VGImage toVGImage
 (const QImage & image, Qt::ImageConversionFlags flags = Qt::AutoColor)
 {
 QImage img(image);
 img = image.convertToFormat(QImage::Format_ARGB32_Premultiplied, flags);
 format = VG_sARGB_8888_PRE;
 break;
 }
-const uchar *pixels = qt_vg_imageBits(img);
+const uchar *pixels = img.constBits();
 VGImage vgImg = QVGImagePool::instance()->createPermanentImage
 (format, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
 vgImageSubData
 (vgImg, pixels, img.bytesPerLine(), format, 0, 0,
 img = image.convertToFormat(QImage::Format_ARGB32_Premultiplied, flags);
 format = VG_sARGB_8888_PRE;
 break;
 }
-const uchar *pixels = qt_vg_imageBits(img) + bpp * sr.x() +
+const uchar *pixels = img.constBits() + bpp * sr.x() +
 img.bytesPerLine() * sr.y();
 VGImage vgImg = QVGImagePool::instance()->createPermanentImage
 (format, sr.width(), sr.height(), VG_IMAGE_QUALITY_FASTER);
 vgImageSubData
 painter.begin(&img);
 painter.setOpacity(opacity);
 painter.drawImage(0, 0, image);
 painter.end();
-const uchar *pixels = qt_vg_imageBits(img);
+const uchar *pixels = img.constBits();
 VGImage vgImg = QVGImagePool::instance()->createPermanentImage
 (VG_sARGB_8888_PRE, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
 vgImageSubData
 (vgImg, pixels, img.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0,
 painter.begin(&img);
 painter.setOpacity(opacity);
 painter.drawImage(QPoint(0, 0), image, sr);
 painter.end();
-const uchar *pixels = qt_vg_imageBits(img);
+const uchar *pixels = img.constBits();
 VGImage vgImg = QVGImagePool::instance()->createPermanentImage
 (VG_sARGB_8888_PRE, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
 vgImageSubData
 (vgImg, pixels, img.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0,
 void QVGPaintEngine::compositionModeChanged()
 {
 Q_D(QVGPaintEngine);
 d->dirty |= QPaintEngine::DirtyCompositionMode;
-VGBlendMode vgMode = VG_BLEND_SRC_OVER;
+VGint vgMode = VG_BLEND_SRC_OVER;
 switch (state()->composition_mode) {
 case QPainter::CompositionMode_SourceOver:
 vgMode = VG_BLEND_SRC_OVER;
 break;
 break;
 case QPainter::CompositionMode_Lighten:
 vgMode = VG_BLEND_LIGHTEN;
 break;
 default:
-qWarning() << "QVGPaintEngine::compositionModeChanged unsupported mode" << state()->composition_mode;
+if (d->hasAdvancedBlending) {
-break;  // Fall back to VG_BLEND_SRC_OVER.
+switch (state()->composition_mode) {
-}
+case QPainter::CompositionMode_Overlay:
+vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_OVERLAY_KHR;
-d->setBlendMode(vgMode);
+break;
+case QPainter::CompositionMode_ColorDodge:
+vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_COLORDODGE_KHR;
+break;
+case QPainter::CompositionMode_ColorBurn:
+vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_COLORBURN_KHR;
+break;
+case QPainter::CompositionMode_HardLight:
+vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_HARDLIGHT_KHR;
+break;
+case QPainter::CompositionMode_SoftLight:
+vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_SOFTLIGHT_KHR;
+break;
+case QPainter::CompositionMode_Difference:
+vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_DIFFERENCE_KHR;
+break;
+case QPainter::CompositionMode_Exclusion:
+vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_EXCLUSION_KHR;
+break;
+case QPainter::CompositionMode_SourceOut:
+vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_SRC_OUT_KHR;
+break;
+case QPainter::CompositionMode_DestinationOut:
+vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_DST_OUT_KHR;
+break;
+case QPainter::CompositionMode_SourceAtop:
+vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_SRC_ATOP_KHR;
+break;
+case QPainter::CompositionMode_DestinationAtop:
+vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_DST_ATOP_KHR;
+break;
+case QPainter::CompositionMode_Xor:
+vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_XOR_KHR;
+break;
+default: break; // Fall back to VG_BLEND_SRC_OVER.
+}
+}
+if (vgMode == VG_BLEND_SRC_OVER)
+qWarning() << "QVGPaintEngine::compositionModeChanged unsupported mode" << state()->composition_mode;
+break;
+}
+d->setBlendMode(VGBlendMode(vgMode));
 }
 void QVGPaintEngine::renderHintsChanged()
 {
 Q_D(QVGPaintEngine);
 // Best performance will be achieved with QDrawPixmaps::OpaqueHint
 // (i.e. no opacity), no rotation or scaling, and drawing the full
 // pixmap rather than parts of the pixmap.  Even having just one of
 // these conditions will improve performance.
-void QVGPaintEngine::drawPixmaps
+void QVGPaintEngine::drawPixmapFragments(const QPainter::PixmapFragment *drawingData, int dataCount,
-(const QDrawPixmaps::Data *drawingData, int dataCount,
+const QPixmap &pixmap, QFlags<QPainter::PixmapFragmentHint> hints)
-const QPixmap &pixmap, QFlags<QDrawPixmaps::DrawingHint> hints)
 {
 #if !defined(QT_SHIVAVG)
 Q_D(QVGPaintEngine);
 // If the pixmap is not VG, or the transformation is projective,
 // then fall back to the default implementation.
 QPixmapData *pd = pixmap.pixmapData();
 if (!pd)
 return; // null QPixmap
 if (pd->classId() != QPixmapData::OpenVGClass || !d->simpleTransform) {
-QPaintEngineEx::drawPixmaps(drawingData, dataCount, pixmap, hints);
+QPaintEngineEx::drawPixmapFragments(drawingData, dataCount, pixmap, hints);
 return;
 }
 // Bail out if nothing to do.
 if (dataCount <= 0)
 // isn't needed at all, so use full source rects where possible.
 QVarLengthArray<VGImage> cachedImages;
 QVarLengthArray<QRect> cachedSources;
 // Select the opacity paint object.
-if ((hints & QDrawPixmaps::OpaqueHint) != 0 && d->opacity == 1.0f) {
+if ((hints & QPainter::OpaqueHint) != 0 && d->opacity == 1.0f) {
 d->setImageMode(VG_DRAW_IMAGE_NORMAL);
 }  else {
 hints = 0;
 if (d->fillPaint != d->opacityPaint) {
 vgSetPaint(d->opacityPaint, VG_FILL_PATH);
 }
 }
 for (int i = 0; i < dataCount; ++i) {
 QTransform transform(d->imageTransform);
-transform.translate(drawingData[i].point.x(), drawingData[i].point.y());
+transform.translate(drawingData[i].x, drawingData[i].y);
 transform.rotate(drawingData[i].rotation);
 VGImage child;
 QSize imageSize = vgpd->size();
-QRectF sr = drawingData[i].source;
+QRectF sr(drawingData[i].sourceLeft, drawingData[i].sourceTop,
+drawingData[i].width, drawingData[i].height);
 if (sr.topLeft().isNull() && sr.size() == imageSize) {
 child = vgImg;
 } else {
 // Look for a previous child with the same source rectangle
 // to avoid constantly calling vgChildImage()/vgDestroyImage().
 transform.translate(-0.5 * scaleX * sr.width(),
 -0.5 * scaleY * sr.height());
 transform.scale(scaleX, scaleY);
 d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);
-if ((hints & QDrawPixmaps::OpaqueHint) == 0) {
+if ((hints & QPainter::OpaqueHint) == 0) {
 qreal opacity = d->opacity * drawingData[i].opacity;
 if (opacity != 1.0f) {
 if (d->paintOpacity != opacity) {
 VGfloat values[4];
 values[0] = 1.0f;
 // Destroy the cached child sub-images.
 for (int i = 0; i < cachedImages.size(); ++i)
 vgDestroyImage(cachedImages[i]);
 #else
-QPaintEngineEx::drawPixmaps(drawingData, dataCount, pixmap, hints);
+QPaintEngineEx::drawPixmapFragments(drawingData, dataCount, pixmap, hints);
 #endif
 }
 QVGFontEngineCleaner::QVGFontEngineCleaner(QVGPaintEnginePrivate *d)
 : QObject(), d_ptr(d)
 {
 if (font != VG_INVALID_HANDLE)
 vgDestroyFont(font);
 }
-void QVGFontGlyphCache::setScaleFromText(const QTextItemInt &ti)
+void QVGFontGlyphCache::setScaleFromText(const QFont &font, QFontEngine *fontEngine)
 {
-QFontInfo fi(ti.font());
+QFontInfo fi(font);
 qreal pixelSize = fi.pixelSize();
-qreal emSquare = ti.fontEngine->properties().emSquare.toReal();
+qreal emSquare = fontEngine->properties().emSquare.toReal();
 scaleX = scaleY = static_cast<VGfloat>(pixelSize / emSquare);
 }
-void QVGFontGlyphCache::cacheGlyphs
+void QVGFontGlyphCache::cacheGlyphs(QVGPaintEnginePrivate *d,
-(QVGPaintEnginePrivate *d, const QTextItemInt &ti,
+QFontEngine *fontEngine,
-const QVarLengthArray<glyph_t> &glyphs)
+const glyph_t *g, int count)
 {
 VGfloat origin[2];
 VGfloat escapement[2];
-const glyph_t *g = glyphs.constData();
-int count = glyphs.size();
 glyph_metrics_t metrics;
 // Some Qt font engines don't set yoff in getUnscaledGlyph().
 // Zero the metric structure so that everything has a default value.
 memset(&metrics, 0, sizeof(metrics));
 while (count-- > 0) {
 } else {
 cachedGlyphs.insert(glyph);
 }
 #if !defined(QVG_NO_IMAGE_GLYPHS)
 Q_UNUSED(d);
-QImage scaledImage = ti.fontEngine->alphaMapForGlyph(glyph);
+QImage scaledImage = fontEngine->alphaMapForGlyph(glyph);
 VGImage vgImage = VG_INVALID_HANDLE;
-metrics = ti.fontEngine->boundingBox(glyph);
+metrics = fontEngine->boundingBox(glyph);
 if (!scaledImage.isNull()) {  // Not a space character
 if (scaledImage.format() == QImage::Format_Indexed8) {
 vgImage = vgCreateImage(VG_A_8, scaledImage.width(), scaledImage.height(), VG_IMAGE_QUALITY_FASTER);
-vgImageSubData(vgImage, qt_vg_imageBits(scaledImage), scaledImage.bytesPerLine(), VG_A_8, 0, 0, scaledImage.width(), scaledImage.height());
+vgImageSubData(vgImage, scaledImage.constBits(), scaledImage.bytesPerLine(), VG_A_8, 0, 0, scaledImage.width(), scaledImage.height());
 } else if (scaledImage.format() == QImage::Format_Mono) {
 QImage img = scaledImage.convertToFormat(QImage::Format_Indexed8);
 vgImage = vgCreateImage(VG_A_8, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
-vgImageSubData(vgImage, qt_vg_imageBits(img), img.bytesPerLine(), VG_A_8, 0, 0, img.width(), img.height());
+vgImageSubData(vgImage, img.constBits(), img.bytesPerLine(), VG_A_8, 0, 0, img.width(), img.height());
 } else {
 QImage img = scaledImage.convertToFormat(QImage::Format_ARGB32_Premultiplied);
 vgImage = vgCreateImage(VG_sARGB_8888_PRE, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
-vgImageSubData(vgImage, qt_vg_imageBits(img), img.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0, img.width(), img.height());
+vgImageSubData(vgImage, img.constBits(), img.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0, img.width(), img.height());
 }
 }
-origin[0] = -metrics.x.toReal() + 0.5f;
+origin[0] = -metrics.x.toReal();
-origin[1] = -metrics.y.toReal() + 0.5f;
+origin[1] = -metrics.y.toReal();
-escapement[0] = metrics.xoff.toReal();
+escapement[0] = 0;
-escapement[1] = metrics.yoff.toReal();
+escapement[1] = 0;
 vgSetGlyphToImage(font, glyph, vgImage, origin, escapement);
 vgDestroyImage(vgImage);    // Reduce reference count.
 #else
 // Calculate the path for the glyph and cache it.
 QPainterPath path;
-ti.fontEngine->getUnscaledGlyph(glyph, &path, &metrics);
+fontEngine->getUnscaledGlyph(glyph, &path, &metrics);
 VGPath vgPath;
 if (!path.isEmpty()) {
 vgPath = d->painterPathToVGPath(path);
 } else {
 // Probably a "space" character with no visible outline.
 vgPath = VG_INVALID_HANDLE;
 }
 origin[0] = 0;
 origin[1] = 0;
-escapement[0] = metrics.xoff.toReal();
+escapement[0] = 0;
-escapement[1] = metrics.yoff.toReal();
+escapement[1] = 0;
 vgSetGlyphToPath(font, glyph, vgPath, VG_FALSE, origin, escapement);
 vgDestroyPath(vgPath);      // Reduce reference count.
 #endif // !defined(QVG_NO_IMAGE_GLYPHS)
 }
 }
 // to the default Qt path stroking algorithm.
 if (!d->simpleTransform) {
 QPaintEngineEx::drawTextItem(p, textItem);
 return;
 }
 // Get the glyphs and positions associated with the text item.
 QVarLengthArray<QFixedPoint> positions;
 QVarLengthArray<glyph_t> glyphs;
-QTransform matrix = d->transform;
+QTransform matrix;
-matrix.translate(p.x(), p.y());
+ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
-ti.fontEngine->getGlyphPositions
-(ti.glyphs, matrix, ti.flags, glyphs, positions);
+if (!drawCachedGlyphs(glyphs.size(), glyphs.data(), ti.font(), ti.fontEngine, p, positions.data()))
+QPaintEngineEx::drawTextItem(p, textItem);
+#else
+// OpenGL 1.0 does not have support for VGFont and glyphs,
+// so fall back to the default Qt path stroking algorithm.
+QPaintEngineEx::drawTextItem(p, textItem);
+#endif
+}
+void QVGPaintEngine::drawStaticTextItem(QStaticTextItem *textItem)
+{
+drawCachedGlyphs(textItem->numGlyphs, textItem->glyphs, textItem->font, textItem->fontEngine,
+QPointF(0, 0), textItem->glyphPositions);
+}
+bool QVGPaintEngine::drawCachedGlyphs(int numGlyphs, const glyph_t *glyphs, const QFont &font,
+QFontEngine *fontEngine, const QPointF &p,
+const QFixedPoint *positions)
+{
+#if !defined(QVG_NO_DRAW_GLYPHS)
+Q_D(QVGPaintEngine);
 // Find the glyph cache for this font.
-QVGFontCache::ConstIterator it = d->fontCache.constFind(ti.fontEngine);
+QVGFontCache::ConstIterator it = d->fontCache.constFind(fontEngine);
 QVGFontGlyphCache *glyphCache;
 if (it != d->fontCache.constEnd()) {
 glyphCache = it.value();
 } else {
 glyphCache = new QVGFontGlyphCache();
 if (glyphCache->font == VG_INVALID_HANDLE) {
 qWarning("QVGPaintEngine::drawTextItem: OpenVG fonts are not supported by the OpenVG engine");
 delete glyphCache;
-QPaintEngineEx::drawTextItem(p, textItem);
+return false;
-return;
+}
-}
+glyphCache->setScaleFromText(font, fontEngine);
-glyphCache->setScaleFromText(ti);
+d->fontCache.insert(fontEngine, glyphCache);
-d->fontCache.insert(ti.fontEngine, glyphCache);
 if (!d->fontEngineCleaner)
 d->fontEngineCleaner = new QVGFontEngineCleaner(d);
-QObject::connect(ti.fontEngine, SIGNAL(destroyed()),
+QObject::connect(fontEngine, SIGNAL(destroyed()),
 d->fontEngineCleaner, SLOT(fontEngineDestroyed()));
 }
 // Set the transformation to use for drawing the current glyphs.
-QTransform glyphTransform(d->glyphTransform);
+QTransform glyphTransform(d->pathTransform);
 glyphTransform.translate(p.x(), p.y());
 #if defined(QVG_NO_IMAGE_GLYPHS)
 glyphTransform.scale(glyphCache->scaleX, glyphCache->scaleY);
 #endif
 d->setTransform(VG_MATRIX_GLYPH_USER_TO_SURFACE, glyphTransform);
 // Add the glyphs from the text item into the glyph cache.
-glyphCache->cacheGlyphs(d, ti, glyphs);
+glyphCache->cacheGlyphs(d, fontEngine, glyphs, numGlyphs);
+// Create the array of adjustments between glyphs
+QVarLengthArray<VGfloat> adjustments_x(numGlyphs);
+QVarLengthArray<VGfloat> adjustments_y(numGlyphs);
+for (int i = 1; i < numGlyphs; ++i) {
+adjustments_x[i-1] = (positions[i].x - positions[i-1].x).toReal();
+adjustments_y[i-1] = (positions[i].y - positions[i-1].y).toReal();
+}
 // Set the glyph drawing origin.
 VGfloat origin[2];
-origin[0] = 0;
+origin[0] = positions[0].x.toReal();
-origin[1] = 0;
+origin[1] = positions[0].y.toReal();
 vgSetfv(VG_GLYPH_ORIGIN, 2, origin);
 // Fast anti-aliasing for paths, better for images.
 #if !defined(QVG_NO_IMAGE_GLYPHS)
 d->setImageQuality(VG_IMAGE_QUALITY_BETTER);
 #endif
 // Draw the glyphs.  We need to fill with the brush associated with
 // the Qt pen, not the Qt brush.
 d->ensureBrush(state()->pen.brush());
-vgDrawGlyphs(glyphCache->font, glyphs.size(), (VGuint*)glyphs.data(),
+vgDrawGlyphs(glyphCache->font, numGlyphs, (VGuint*)glyphs,
-NULL, NULL, VG_FILL_PATH, VG_TRUE);
+adjustments_x.data(), adjustments_y.data(), VG_FILL_PATH, VG_TRUE);
+return true;
 #else
-// OpenGL 1.0 does not have support for VGFont and glyphs,
+Q_UNUSED(numGlyphs);
-// so fall back to the default Qt path stroking algorithm.
+Q_UNUSED(glyphs);
-QPaintEngineEx::drawTextItem(p, textItem);
+Q_UNUSED(font);
+Q_UNUSED(fontEngine);
+Q_UNUSED(p);
+Q_UNUSED(positions);
+return false;
 #endif
 }
 void QVGPaintEngine::setState(QPainterState *s)
 {
 (VG_sARGB_8888_PRE, img.width(), img.height(),
 VG_IMAGE_QUALITY_FASTER);
 if (vgImage == VG_INVALID_HANDLE)
 return;
 vgImageSubData
-(vgImage, qt_vg_imageBits(img) + img.bytesPerLine() * (img.height() - 1),
+(vgImage, img.constBits() + img.bytesPerLine() * (img.height() - 1),
 -(img.bytesPerLine()), VG_sARGB_8888_PRE, 0, 0,
 img.width(), img.height());
 vgDrawImage(vgImage);
 vgDestroyImage(vgImage);

branch	GCC_SURGE
changeset 31	5daf16870df6
parent 30	5dc02b23752f
child 33	3e2da88830cd