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

equal deleted inserted replaced

-:cc75c76972ee
+:c0432d11811c
 #define QVG_NO_RENDER_TO_MASK 1
 #endif
 #if !defined(QVG_NO_DRAW_GLYPHS)
-extern int qt_defaultDpiX();
+Q_DECL_IMPORT extern int qt_defaultDpiX();
-extern int qt_defaultDpiY();
+Q_DECL_IMPORT extern int qt_defaultDpiY();
 class QVGPaintEnginePrivate;
 class QVGFontGlyphCache
 {
 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.
 mat[7] = transform.m32();
 mat[8] = transform.m33();
 vgLoadMatrix(mat);
 }
-extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale);
+Q_DECL_IMPORT extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale);
 void QVGPaintEnginePrivate::updateTransform(QPaintDevice *pdev)
 {
 VGfloat devh = pdev->height();
 // 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;
 #endif
 return vgpath;
 }
-extern QImage qt_imageForBrush(int style, bool invert);
+Q_DECL_IMPORT extern QImage qt_imageForBrush(int style, bool invert);
 static QImage colorizeBitmap(const QImage &image, const QColor &color)
 {
 QImage sourceImage = image.convertToFormat(QImage::Format_MonoLSB);
 QImage dest = QImage(sourceImage.size(), QImage::Format_ARGB32_Premultiplied);
 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());
 }
 }
-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;
 // 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)
 }
 }
 }
 // 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);
 // Find the glyph cache for this font.
 QVGFontCache::ConstIterator it = d->fontCache.constFind(ti.fontEngine);
 QVGFontGlyphCache *glyphCache;
 if (it != d->fontCache.constEnd()) {
 QObject::connect(ti.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);
+// Create the array of adjustments between glyphs
+QVarLengthArray<VGfloat> adjustments_x(glyphs.size());
+QVarLengthArray<VGfloat> adjustments_y(glyphs.size());
+for (int i = 1; i < glyphs.size(); ++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);
 // 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(),
-NULL, NULL, VG_FILL_PATH, VG_TRUE);
+adjustments_x.data(), adjustments_y.data(), VG_FILL_PATH, VG_TRUE);
 #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

branch	RCL_3
changeset 13	c0432d11811c
parent 7	3f74d0d4af4c