Changeset 846 for trunk/src/openvg

Timestamp:

May 5, 2011, 5:36:53 AM (14 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/openvg/openvg.pro (modified) (2 diffs)
• src/openvg/qpaintengine_vg.cpp (modified) (46 diffs)
• src/openvg/qpaintengine_vg_p.h (modified) (4 diffs)
• src/openvg/qpixmapdata_vg.cpp (modified) (8 diffs)
• src/openvg/qpixmapdata_vg_p.h (modified) (5 diffs)
• src/openvg/qpixmapfilter_vg.cpp (modified) (1 diff)
• src/openvg/qpixmapfilter_vg_p.h (modified) (1 diff)
• src/openvg/qvg.h (modified) (1 diff)
• src/openvg/qvg_p.h (modified) (2 diffs)
• src/openvg/qvg_symbian.cpp (copied) (copied from branches/vendor/nokia/qt/4.7.2/src/openvg/qvg_symbian.cpp )
• src/openvg/qvgcompositionhelper_p.h (modified) (1 diff)
• src/openvg/qvgfontglyphcache_p.h (copied) (copied from branches/vendor/nokia/qt/4.7.2/src/openvg/qvgfontglyphcache_p.h )
• src/openvg/qvgimagepool.cpp (modified) (2 diffs)
• src/openvg/qvgimagepool_p.h (modified) (1 diff)
• src/openvg/qwindowsurface_vg.cpp (modified) (2 diffs)
• src/openvg/qwindowsurface_vg_p.h (modified) (1 diff)
• src/openvg/qwindowsurface_vgegl.cpp (modified) (13 diffs)
• src/openvg/qwindowsurface_vgegl_p.h (modified) (2 diffs)

trunk/src/openvg/openvg.pro

@@ -18 +18 @@
     qpixmapfilter_vg_p.h \
     qvgcompositionhelper_p.h \
-    qvgimagepool_p.h
+    qvgimagepool_p.h \
+    qvgfontglyphcache_p.h
 SOURCES += \
     qpaintengine_vg.cpp \
@@ -34 +35 @@
 }
 
-symbian: DEFINES += QVG_RECREATE_ON_SIZE_CHANGE QVG_BUFFER_SCROLLING
+symbian {
+    DEFINES += QVG_RECREATE_ON_SIZE_CHANGE QVG_BUFFER_SCROLLING QVG_SCISSOR_CLIP
+    SOURCES += \
+        qvg_symbian.cpp
+}
 
 include(../qbase.pri)

trunk/src/openvg/qpaintengine_vg.cpp

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
@@ -45 +45 @@
 #include "qvgcompositionhelper_p.h"
 #include "qvgimagepool_p.h"
+
 #if !defined(QT_NO_EGL)
-#include <QtGui/private/qegl_p.h>
+#include <QtGui/private/qegl_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 <QDebug>
 #include <QSet>
 
 QT_BEGIN_NAMESPACE
-
-// vgDrawGlyphs() only exists in OpenVG 1.1 and higher.
-#if !defined(OPENVG_VERSION_1_1) && !defined(QVG_NO_DRAW_GLYPHS)
-#define QVG_NO_DRAW_GLYPHS 1
-#endif
 
 // vgRenderToMask() only exists in OpenVG 1.1 and higher.
@@ -74 +73 @@
 #endif
 
+
+
+
 #if !defined(QVG_NO_DRAW_GLYPHS)
 
@@ -80 +82 @@
 
 class QVGPaintEnginePrivate;
-
-class QVGFontGlyphCache
-{
-public:
-    QVGFontGlyphCache();
-    ~QVGFontGlyphCache();
-
-    void cacheGlyphs(QVGPaintEnginePrivate *d,
-                     const QTextItemInt &ti,
-                     const QVarLengthArray<glyph_t> &glyphs);
-    void setScaleFromText(const QTextItemInt &ti);
-
-    VGFont font;
-    VGfloat scaleX;
-    VGfloat scaleY;
-    
-    uint cachedGlyphsMask[256 / 32];
-    QSet<glyph_t> cachedGlyphs;
-};
 
 typedef QHash<QFontEngine*, QVGFontGlyphCache*> QVGFontCache;
@@ -120 +103 @@
 class QVGPaintEnginePrivate : public QPaintEngineExPrivate
 {
+
 public:
     // Extra blending modes from VG_KHR_advanced_blending extension.
@@ -150 +134 @@
     };
 
-    QVGPaintEnginePrivate();
+    QVGPaintEnginePrivate();
     ~QVGPaintEnginePrivate();
 
@@ -171 +155 @@
     void setupColorRamp(const QGradient *grad, VGPaint paint);
     void setImageOptions();
+
 #if !defined(QVG_SCISSOR_CLIP)
     void ensureMask(QVGPaintEngine *engine, int width, int height);
@@ -259 +244 @@
     {
         if (!pathTransformSet) {
-            setTransform(VG_MATRIX_PATH_USER_TO_SURFACE, pathTransform);
+            QTransform aliasedTransform = pathTransform;
+            if (renderingQuality == VG_RENDERING_QUALITY_NONANTIALIASED && currentPen != Qt::NoPen)
+                aliasedTransform = aliasedTransform
+                    * QTransform::fromTranslate(aliasedCoordinateDelta, -aliasedCoordinateDelta);
+            setTransform(VG_MATRIX_PATH_USER_TO_SURFACE, aliasedTransform);
             pathTransformSet = true;
         }
@@ -299 +288 @@
     // Clear all lazily-set modes.
     void clearModes();
+
+
+
 };
 
@@ -314 +306 @@
         vgSeti(VG_RENDERING_QUALITY, mode);
         renderingQuality = mode;
+
     }
 }
@@ -350 +343 @@
 }
 
-QVGPaintEnginePrivate::QVGPaintEnginePrivate()
+QVGPaintEnginePrivate::QVGPaintEnginePrivate()
 {
     init();
@@ -968 +961 @@
         x1, y2 - yRadius,
         x1, y1 + yRadius,                   // LineTo
-        x1, y1 + KAPPA * yRadius,           // CurveTo
+        x1, y1 +      // CurveTo
         x1 + (1 - KAPPA) * xRadius, y1,
         x1 + xRadius, y1
@@ -1015 +1008 @@
     int width = sourceImage.width();
     for (int y=0; y<height; ++y) {
-        uchar *source = sourceImage.scanLine(y);
+        canLine(y);
         QRgb *target = reinterpret_cast<QRgb *>(dest.scanLine(y));
         for (int x=0; x < width; ++x)
@@ -1022 +1015 @@
     return dest;
 }
-
-// defined in qpixmapdata_vg.cpp.
-const uchar *qt_vg_imageBits(const QImage& image);
 
 static VGImage toVGImage
@@ -1059 +1049 @@
     }
 
-    const uchar *pixels = qt_vg_imageBits(img);
+    const uchar *pixels = );
 
     VGImage vgImg = QVGImagePool::instance()->createPermanentImage
@@ -1103 +1093 @@
     }
 
-    const uchar *pixels = qt_vg_imageBits(img) + bpp * sr.x() +
+    const uchar *pixels = ) + bpp * sr.x() +
                           img.bytesPerLine() * sr.y();
 
@@ -1125 +1115 @@
     painter.end();
 
-    const uchar *pixels = qt_vg_imageBits(img);
+    const uchar *pixels = );
 
     VGImage vgImg = QVGImagePool::instance()->createPermanentImage
@@ -1147 +1137 @@
     painter.end();
 
-    const uchar *pixels = qt_vg_imageBits(img);
+    const uchar *pixels = );
 
     VGImage vgImg = QVGImagePool::instance()->createPermanentImage
@@ -1452 +1442 @@
 
 QVGPaintEngine::QVGPaintEngine()
-    : QPaintEngineEx(*new QVGPaintEnginePrivate)
+    : QPaintEngineEx(*new QVGPaintEnginePrivate)
 {
 }
@@ -1513 +1503 @@
     ensureBrush(brush);
     setFillRule(rule);
+
+
     ensurePathTransform();
+
     vgDrawPath(path, VG_FILL_PATH);
 }
@@ -1627 +1620 @@
                     points[5] - points[1]);
         clip(rect.toRect(), op);
-    } else {
-        // The best we can do is clip to the bounding rectangle
-        // of all control points.
-        clip(path.controlPointRect().toRect(), op);
-    }
+        return;
+    }
+
+    // Try converting the path into a QRegion that tightly follows
+    // the outline of the path we want to clip with.
+    QRegion region;
+    if (!path.isEmpty())
+        region = QRegion(path.convertToPainterPath().toFillPolygon(QTransform()).toPolygon());
+
+    switch (op) {
+        case Qt::NoClip:
+        {
+            region = defaultClipRegion();
+        }
+        break;
+
+        case Qt::ReplaceClip:
+        {
+            region = d->transform.map(region);
+        }
+        break;
+
+        case Qt::IntersectClip:
+        {
+            region = s->clipRegion.intersect(d->transform.map(region));
+        }
+        break;
+
+        case Qt::UniteClip:
+        {
+            region = s->clipRegion.unite(d->transform.map(region));
+        }
+        break;
+    }
+    if (region.numRects() <= d->maxScissorRects) {
+        // We haven't reached the maximum scissor count yet, so we can
+        // still make use of this region.
+        s->clipRegion = region;
+        updateScissor();
+        return;
+    }
+
+    // The best we can do is clip to the bounding rectangle
+    // of all control points.
+    clip(path.controlPointRect().toRect(), op);
 }
 
@@ -2169 +2202 @@
     // Using the scissor to do clipping, so combine the systemClip
     // with the current painting clipRegion.
+
+
+
+
+
+
     QVGPainterState *s = state();
     if (s->clipEnabled) {
@@ -2218 +2257 @@
     QVector<QRect> rects = region.rects();
     int count = rects.count();
-    if (count > d->maxScissorRects)
-        count = d->maxScissorRects;
+    if (count > d->maxScissorRects) {
+#if !defined(QVG_SCISSOR_CLIP)
+         count = d->maxScissorRects;
+#else
+        // Use masking
+        int width = paintDevice()->width();
+        int height = paintDevice()->height();
+        vgMask(VG_INVALID_HANDLE, VG_CLEAR_MASK,
+                   0, 0, width, height);
+        for (int i = 0; i < rects.size(); ++i) {
+            vgMask(VG_INVALID_HANDLE, VG_FILL_MASK,
+                   rects[i].x(), height - rects[i].y() - rects[i].height(),
+                   rects[i].width(), rects[i].height());
+        }
+
+        vgSeti(VG_SCISSORING, VG_FALSE);
+        vgSeti(VG_MASKING, VG_TRUE);
+        d->maskValid = true;
+        d->maskIsSet = false;
+        d->scissorMask = false;
+        d->scissorActive = false;
+        d->scissorDirty = false;
+        d->scissorRegion = region;
+        return;
+#endif
+    }
+
     QVarLengthArray<VGint> params(count * 4);
     int height = paintDevice()->height();
@@ -2955 +3019 @@
 }
 
+
+
+
+
+
 static void drawVGImage(QVGPaintEnginePrivate *d,
                         const QRectF& r, VGImage vgImg,
@@ -3026 +3095 @@
     d->setImageMode(VG_DRAW_IMAGE_STENCIL);
     vgDrawImage(vgImg);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 }
 
@@ -3042 +3126 @@
         else
             drawVGImage(d, r, vgpd->toVGImage(d->opacity), vgpd->size(), sr);
-    } else {
-        drawImage(r, *(pd->buffer()), sr, Qt::AutoColor);
-    }
+
+        if(!vgpd->failedToAlloc)
+            return;
+
+        // try to reallocate next time if reasonable small pixmap
+        QSize screenSize = QApplication::desktop()->screenGeometry().size();
+        if (pm.size().width() <= screenSize.width()
+            && pm.size().height() <= screenSize.height())
+            vgpd->failedToAlloc = false;
+    }
+
+    drawImage(r, *(pd->buffer()), sr, Qt::AutoColor);
 }
 
@@ -3061 +3154 @@
         else
             drawVGImage(d, pos, vgpd->toVGImage(d->opacity));
-    } else {
-        drawImage(pos, *(pd->buffer()));
-    }
+
+        if (!vgpd->failedToAlloc)
+            return;
+
+        // try to reallocate next time if reasonable small pixmap
+        QSize screenSize = QApplication::desktop()->screenGeometry().size();
+        if (pm.size().width() <= screenSize.width()
+            && pm.size().height() <= screenSize.height())
+            vgpd->failedToAlloc = false;
+    }
+
+    drawImage(pos, *(pd->buffer()));
 }
 
@@ -3084 +3186 @@
         }
     } else {
-        // Monochrome images need to use the vgChildImage() path.
-        vgImg = toVGImage(image, flags);
-        drawVGImage(d, r, vgImg, image.size(), sr);
+        if (canVgWritePixels(image) && (r.size() == sr.size()) && !flags) {
+            // Optimization for straight blits, no blending
+            int x = sr.x();
+            int y = sr.y();
+            int bpp = image.depth() >> 3; // bytes
+            int offset = 0;
+            int bpl = image.bytesPerLine();
+            if (d->imageTransform.m22() < 0) {
+                // inverted
+                offset = ((y + sr.height()) * bpl) - ((image.width() - x) * bpp);
+                bpl = -bpl;
+            } else {
+                offset = (y * bpl) + (x * bpp);
+            }
+            const uchar *bits = image.constBits() + offset;
+
+            QPointF mapped = d->imageTransform.map(r.topLeft());
+            vgWritePixels(bits, bpl, qt_vg_image_to_vg_format(image.format()),
+                        mapped.x(), mapped.y() - sr.height(), r.width(), r.height());
+            return;
+        } else {
+            // Monochrome images need to use the vgChildImage() path.
+            vgImg = toVGImage(image, flags);
+            drawVGImage(d, r, vgImg, image.size(), sr);
+        }
     }
     vgDestroyImage(vgImg);
@@ -3095 +3219 @@
     Q_D(QVGPaintEngine);
     VGImage vgImg;
-    if (d->simpleTransform || d->opacity == 1.0f)
+    if (canVgWritePixels(image)) {
+        // Optimization for straight blits, no blending
+        bool inverted = (d->imageTransform.m22() < 0);
+        const uchar *bits = inverted ? image.constBits() + image.byteCount() : image.constBits();
+        int bpl = inverted ? -image.bytesPerLine() : image.bytesPerLine();
+
+        QPointF mapped = d->imageTransform.map(pos);
+        vgWritePixels(bits, bpl, qt_vg_image_to_vg_format(image.format()),
+                             mapped.x(), mapped.y() - image.height(), image.width(), image.height());
+        return;
+    } else if (d->simpleTransform || d->opacity == 1.0f) {
         vgImg = toVGImage(image);
-    else
+    
         vgImg = toVGImageWithOpacity(image, d->opacity);
+
     drawVGImage(d, pos, vgImg);
     vgDestroyImage(vgImg);
@@ -3107 +3242 @@
 {
     QBrush brush(state()->pen.color(), pixmap);
-    QTransform xform;
-    xform.translate(-s.x(), -s.y());
+    QTransform xform = QTransform::fromTranslate(r.x() - s.x(), r.y() - s.y());
     brush.setTransform(xform);
     fillRect(r, brush);
@@ -3117 +3251 @@
 // pixmap rather than parts of the pixmap.  Even having just one of
 // these conditions will improve performance.
-void QVGPaintEngine::drawPixmaps
-    (const QDrawPixmaps::Data *drawingData, int dataCount,
-     const QPixmap &pixmap, QFlags<QDrawPixmaps::DrawingHint> hints)
+void QVGPaintEngine::drawPixmapFragments(const QPainter::PixmapFragment *drawingData, int dataCount,
+                                         const QPixmap &pixmap, QFlags<QPainter::PixmapFragmentHint> hints)
 {
 #if !defined(QT_SHIVAVG)
@@ -3130 +3263 @@
         return; // null QPixmap
     if (pd->classId() != QPixmapData::OpenVGClass || !d->simpleTransform) {
-        QPaintEngineEx::drawPixmaps(drawingData, dataCount, pixmap, hints);
+        QPaintEngineEx::drawPixmaps(drawingData, dataCount, pixmap, hints);
         return;
     }
@@ -3154 +3287 @@
 
     // Select the opacity paint object.
-    if ((hints & QDrawPixmaps::OpaqueHint) != 0 && d->opacity == 1.0f) {
+    if ((hints & Q::OpaqueHint) != 0 && d->opacity == 1.0f) {
         d->setImageMode(VG_DRAW_IMAGE_NORMAL);
     }  else {
@@ -3166 +3299 @@
     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].);
         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;
@@ -3200 +3334 @@
         d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);
 
-        if ((hints & QDrawPixmaps::OpaqueHint) == 0) {
+        if ((hints & Q::OpaqueHint) == 0) {
             qreal opacity = d->opacity * drawingData[i].opacity;
             if (opacity != 1.0f) {
@@ -3226 +3360 @@
         vgDestroyImage(cachedImages[i]);
 #else
-    QPaintEngineEx::drawPixmaps(drawingData, dataCount, pixmap, hints);
+    QPaintEngineEx::drawPixmaps(drawingData, dataCount, pixmap, hints);
 #endif
 }
@@ -3257 +3391 @@
     font = vgCreateFont(0);
     scaleX = scaleY = 0.0;
+
     memset(cachedGlyphsMask, 0, sizeof(cachedGlyphsMask));
 }
@@ -3266 +3401 @@
 }
 
-void QVGFontGlyphCache::setScaleFromText(const QTextItemInt &ti)
-{
-    QFontInfo fi(ti.font());
+void QVGFontGlyphCache::setScaleFromText(const Q)
+{
+    QFontInfo fi();
     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
-        (QVGPaintEnginePrivate *d, const QTextItemInt &ti,
-         const QVarLengthArray<glyph_t> &glyphs)
+void QVGFontGlyphCache::cacheGlyphs
+        ,
+         )
 {
     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().
@@ -3300 +3433 @@
 #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.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.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.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0, img.width(), img.height());
             }
         }
@@ -3326 +3459 @@
         // 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()) {
@@ -3358 +3491 @@
         return;
     }
- 
+
     // Get the glyphs and positions associated with the text item.
     QVarLengthArray<QFixedPoint> positions;
@@ -3365 +3498 @@
     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);
+    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;
-        }
-        glyphCache->setScaleFromText(ti);
-        d->fontCache.insert(ti.fontEngine, glyphCache);
+            return false;
+        }
+        glyphCache->setScaleFromText(font, fontEngine);
+        d->fontCache.insert(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()));
     }
@@ -3388 +3546 @@
     // Set the transformation to use for drawing the current glyphs.
     QTransform glyphTransform(d->pathTransform);
-    glyphTransform.translate(p.x(), p.y());
+    if (d->transform.type() <= QTransform::TxTranslate) {
+        // Prevent blurriness of unscaled, unrotated text by forcing integer coordinates.
+        glyphTransform.translate(
+                floor(p.x() + glyphTransform.dx() + aliasedCoordinateDelta) - glyphTransform.dx(),
+                floor(p.y() - glyphTransform.dy() + aliasedCoordinateDelta) + glyphTransform.dy());
+    } else {
+        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, lyphs);
 
     // 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();
+    QVarLengthArray<VGfloat> adjustments_x();
+    QVarLengthArray<VGfloat> adjustments_y();
+    for (int i = 1; i < ; ++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] = positions[0].x.toReal();
-    origin[1] = positions[0].y.toReal();
+    origin[0] = positions[0].x.toReal();
+    origin[1] = positions[0].y.toReal();
     vgSetfv(VG_GLYPH_ORIGIN, 2, origin);
 
@@ -3422 +3592 @@
     // the Qt pen, not the Qt brush.
     d->ensureBrush(state()->pen.brush());
-    vgDrawGlyphs(glyphCache->font, glyphs.size(), (VGuint*)glyphs.data(),
+    vgDrawGlyphs(glyphCache->font, ,
                  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);
+    Q_UNUSED(numGlyphs);
+    Q_UNUSED(glyphs);
+    Q_UNUSED(font);
+    Q_UNUSED(fontEngine);
+    Q_UNUSED(p);
+    Q_UNUSED(positions);
+    return false;
 #endif
 }
@@ -3537 +3712 @@
         d->scissorMask = false;
         d->maskRect = QRect();
+
         clipEnabledChanged();
     }
@@ -3788 +3964 @@
             return;
         vgImageSubData
-            (vgImage, qt_vg_imageBits(img) + img.bytesPerLine() * (img.height() - 1),
+            (vgImage, ) + img.bytesPerLine() * (img.height() - 1),
              -(img.bytesPerLine()), VG_sARGB_8888_PRE, 0, 0,
              img.width(), img.height());

trunk/src/openvg/qpaintengine_vg_p.h

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
@@ -55 +55 @@
 
 #include <QtGui/private/qpaintengineex_p.h>
+
 
 QT_BEGIN_NAMESPACE
 
+
 class QVGPaintEnginePrivate;
 class QPixmapData;
@@ -137 +139 @@
     void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s);
 
-    void drawPixmaps(const QDrawPixmaps::Data *drawingData, int dataCount, const QPixmap &pixmap, QFlags<QDrawPixmaps::DrawingHint> hints);
+    void drawPixmapFragments(const QPainter::PixmapFragment *drawingData, int dataCount, const QPixmap &pixmap,
+                             QFlags<QPainter::PixmapFragmentHint> hints);
 
     void drawTextItem(const QPointF &p, const QTextItem &textItem);
+
+
+
+
 
     void setState(QPainterState *s);
@@ -164 +171 @@
     bool isDefaultClipRect(const QRect& rect);
     bool clearRect(const QRectF &rect, const QColor &color);
+
 };
-
 
 QT_END_NAMESPACE

trunk/src/openvg/qpixmapdata_vg.cpp

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
@@ -43 +43 @@
 #include "qpaintengine_vg_p.h"
 #include <QtGui/private/qdrawhelper_p.h>
+
+
+
 #include "qvg_p.h"
 #include "qvgimagepool_p.h"
-
-#if defined(Q_OS_SYMBIAN)
-#include <private/qt_s60_p.h>
-#include <fbs.h>
-#endif
-#ifdef QT_SYMBIAN_SUPPORTS_SGIMAGE
-#include <sgresource/sgimage.h>
-typedef EGLImageKHR (*pfnEglCreateImageKHR)(EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, EGLint*);
-typedef EGLBoolean (*pfnEglDestroyImageKHR)(EGLDisplay, EGLImageKHR);
-typedef VGImage (*pfnVgCreateEGLImageTargetKHR)(VGeglImageKHR);
-#endif // QT_SYMBIAN_SUPPORTS_SGIMAGE
+#include <QBuffer>
+#include <QImageReader>
+#include <QtGui/private/qimage_p.h>
 
 QT_BEGIN_NAMESPACE
@@ -71 +66 @@
     inImagePool = false;
     inLRU = false;
+
 #if !defined(QT_NO_EGL)
     context = 0;
@@ -161 +157 @@
         (const QImage &image, Qt::ImageConversionFlags flags)
 {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     if (image.size() == QSize(w, h))
         setSerialNumber(++qt_vg_pixmap_serial);
     else
         resize(image.width(), image.height());
-    source = image.convertToFormat(sourceFormat(), flags);
+
+    QImage::Format format = sourceFormat();
+    int d = image.depth();
+    if (d == 1 || d == 16 || d == 24 || (d == 32 && !image.hasAlphaChannel()))
+        format = QImage::Format_RGB32;
+    else if (!(flags & Qt::NoOpaqueDetection) && const_cast<QImage &>(image).data_ptr()->checkForAlphaPixels())
+        format = sourceFormat();
+    else
+        format = image.hasAlphaChannel() ? sourceFormat() : QImage::Format_RGB32;
+
+    if (inPlace && image.data_ptr()->convertInPlace(format, flags)) {
+        source = image;
+    } else {
+        source = image.convertToFormat(format);
+
+        // convertToFormat won't detach the image if format stays the same.
+        if (image.format() == format)
+            source.detach();
+    }
+
     recreate = true;
 }
@@ -234 +298 @@
 }
 
-// This function works around QImage::bits() making a deep copy if the
-// QImage is not const.  We force it to be const and then get the bits.
-// XXX: Should add a QImage::constBits() in the future to replace this.
-const uchar *qt_vg_imageBits(const QImage& image)
-{
-    return image.bits();
-}
-
 VGImage QVGPixmapData::toVGImage()
 {
-    if (!isValid())
+    if (!isValid())
         return VG_INVALID_HANDLE;
 
@@ -260 +316 @@
     if (vgImage == VG_INVALID_HANDLE) {
         vgImage = QVGImagePool::instance()->createImageForPixmap
-            (VG_sARGB_8888_PRE, w, h, VG_IMAGE_QUALITY_FASTER, this);
+            (, w, h, VG_IMAGE_QUALITY_FASTER, this);
 
         // Bail out if we run out of GPU memory - try again next time.
-        if (vgImage == VG_INVALID_HANDLE)
+        if (vgImage == VG_INVALID_HANDLE) {
+            failedToAlloc = true;
             return VG_INVALID_HANDLE;
+
 
         inImagePool = true;
@@ -274 +332 @@
         vgImageSubData
             (vgImage,
-             qt_vg_imageBits(source), source.bytesPerLine(),
-             VG_sARGB_8888_PRE, 0, 0, w, h);
+             ), source.bytesPerLine(),
+             , 0, 0, w, h);
     }
 
@@ -429 +487 @@
 }
 
-#if defined(Q_OS_SYMBIAN)
-
-static CFbsBitmap* createBlitCopy(CFbsBitmap* bitmap)
-{
-      CFbsBitmap *copy = q_check_ptr(new CFbsBitmap);
-      if(!copy)
-        return 0;
-
-      if (copy->Create(bitmap->SizeInPixels(), bitmap->DisplayMode()) != KErrNone) {
-          delete copy;
-          copy = 0;
-
-          return 0;
-      }
-
-      CFbsBitmapDevice* bitmapDevice = 0;
-      CFbsBitGc *bitmapGc = 0;
-      QT_TRAP_THROWING(bitmapDevice = CFbsBitmapDevice::NewL(copy));
-      QT_TRAP_THROWING(bitmapGc = CFbsBitGc::NewL());
-      bitmapGc->Activate(bitmapDevice);
-
-      bitmapGc->BitBlt(TPoint(), bitmap);
-
-      delete bitmapGc;
-      delete bitmapDevice;
-
-      return copy;
-}
-
-void QVGPixmapData::cleanup()
-{
-    is_null = w = h = 0;
-    recreate = false;
-    source = QImage();
-}
-
-void QVGPixmapData::fromNativeType(void* pixmap, NativeType type)
-{
-    if (type == QPixmapData::SgImage && pixmap) {
-#if defined(QT_SYMBIAN_SUPPORTS_SGIMAGE) && !defined(QT_NO_EGL)
-        RSgImage *sgImage = reinterpret_cast<RSgImage*>(pixmap);
-
-        destroyImages();
-        prevSize = QSize();
-
-        TInt err = 0;
-
-        RSgDriver driver;
-        err = driver.Open();
-        if (err != KErrNone) {
-            cleanup();
-            return;
-        }
-
-        if (sgImage->IsNull()) {
-            cleanup();
-            driver.Close();
-            return;
-        }
-
-        TSgImageInfo sgImageInfo;
-        err = sgImage->GetInfo(sgImageInfo);
-        if (err != KErrNone) {
-            cleanup();
-            driver.Close();
-            return;
-        }
-
-        pfnEglCreateImageKHR eglCreateImageKHR = (pfnEglCreateImageKHR) eglGetProcAddress("eglCreateImageKHR");
-        pfnEglDestroyImageKHR eglDestroyImageKHR = (pfnEglDestroyImageKHR) eglGetProcAddress("eglDestroyImageKHR");
-        pfnVgCreateEGLImageTargetKHR vgCreateEGLImageTargetKHR = (pfnVgCreateEGLImageTargetKHR) eglGetProcAddress("vgCreateEGLImageTargetKHR");
-
-        if (eglGetError() != EGL_SUCCESS || !eglCreateImageKHR || !eglDestroyImageKHR || !vgCreateEGLImageTargetKHR) {
-            cleanup();
-            driver.Close();
-            return;
-        }
-
-        const EGLint KEglImageAttribs[] = {EGL_IMAGE_PRESERVED_SYMBIAN, EGL_TRUE, EGL_NONE};
-        EGLImageKHR eglImage = eglCreateImageKHR(QEglContext::display(),
-                EGL_NO_CONTEXT,
-                EGL_NATIVE_PIXMAP_KHR,
-                (EGLClientBuffer)sgImage,
-                (EGLint*)KEglImageAttribs);
-
-        if (eglGetError() != EGL_SUCCESS) {
-            cleanup();
-            driver.Close();
-            return;
-        }
-
-        vgImage = vgCreateEGLImageTargetKHR(eglImage);
-        if (vgGetError() != VG_NO_ERROR) {
-            cleanup();
-            eglDestroyImageKHR(QEglContext::display(), eglImage);
-            driver.Close();
-            return;
-        }
-
-        w = sgImageInfo.iSizeInPixels.iWidth;
-        h = sgImageInfo.iSizeInPixels.iHeight;
-        d = 32; // We always use ARGB_Premultiplied for VG pixmaps.
-        is_null = (w <= 0 || h <= 0);
-        source = QImage();
-        recreate = false;
-        prevSize = QSize(w, h);
-        setSerialNumber(++qt_vg_pixmap_serial);
-        // release stuff
-        eglDestroyImageKHR(QEglContext::display(), eglImage);
-        driver.Close();
-#endif
-    } else if (type == QPixmapData::FbsBitmap) {
-        CFbsBitmap *bitmap = reinterpret_cast<CFbsBitmap*>(pixmap);
-
-        bool deleteSourceBitmap = false;
-
-#ifdef Q_SYMBIAN_HAS_EXTENDED_BITMAP_TYPE
-
-        // Rasterize extended bitmaps
-
-        TUid extendedBitmapType = bitmap->ExtendedBitmapType();
-        if (extendedBitmapType != KNullUid) {
-            bitmap = createBlitCopy(bitmap);
-            deleteSourceBitmap = true;
-        }
-#endif
-
-        if (bitmap->IsCompressedInRAM()) {
-            bitmap = createBlitCopy(bitmap);
-            deleteSourceBitmap = true;
-        }
-
-        TDisplayMode displayMode = bitmap->DisplayMode();
-        QImage::Format format = qt_TDisplayMode2Format(displayMode);
-
-        TSize size = bitmap->SizeInPixels();
-
-        bitmap->BeginDataAccess();
-        uchar *bytes = (uchar*)bitmap->DataAddress();
-        QImage img = QImage(bytes, size.iWidth, size.iHeight, format);
-        img = img.copy();
-        bitmap->EndDataAccess();
-
-        if(displayMode == EGray2) {
-            //Symbian thinks set pixels are white/transparent, Qt thinks they are foreground/solid
-            //So invert mono bitmaps so that masks work correctly.
-            img.invertPixels();
-        } else if(displayMode == EColor16M) {
-            img = img.rgbSwapped(); // EColor16M is BGR
-        }
-
-        fromImage(img, Qt::AutoColor);
-
-        if(deleteSourceBitmap)
-            delete bitmap;
-    }
-}
-
-void* QVGPixmapData::toNativeType(NativeType type)
-{
-    if (type == QPixmapData::SgImage) {
-#if defined(QT_SYMBIAN_SUPPORTS_SGIMAGE) && !defined(QT_NO_EGL)
-        toVGImage();
-
-        if (!isValid() || vgImage == VG_INVALID_HANDLE)
-            return 0;
-
-        TInt err = 0;
-
-        RSgDriver driver;
-        err = driver.Open();
-        if (err != KErrNone)
-            return 0;
-
-        TSgImageInfo sgInfo;
-        sgInfo.iPixelFormat = EUidPixelFormatARGB_8888_PRE;
-        sgInfo.iSizeInPixels.SetSize(w, h);
-        sgInfo.iUsage = ESgUsageBitOpenVgImage | ESgUsageBitOpenVgSurface;
-
-        RSgImage *sgImage = q_check_ptr(new RSgImage());
-        err = sgImage->Create(sgInfo, NULL, NULL);
-        if (err != KErrNone) {
-            driver.Close();
-            return 0;
-        }
-
-        pfnEglCreateImageKHR eglCreateImageKHR = (pfnEglCreateImageKHR) eglGetProcAddress("eglCreateImageKHR");
-        pfnEglDestroyImageKHR eglDestroyImageKHR = (pfnEglDestroyImageKHR) eglGetProcAddress("eglDestroyImageKHR");
-        pfnVgCreateEGLImageTargetKHR vgCreateEGLImageTargetKHR = (pfnVgCreateEGLImageTargetKHR) eglGetProcAddress("vgCreateEGLImageTargetKHR");
-
-        if (eglGetError() != EGL_SUCCESS || !eglCreateImageKHR || !eglDestroyImageKHR || !vgCreateEGLImageTargetKHR) {
-            driver.Close();
-            return 0;
-        }
-
-        const EGLint KEglImageAttribs[] = {EGL_IMAGE_PRESERVED_SYMBIAN, EGL_TRUE, EGL_NONE};
-        EGLImageKHR eglImage = eglCreateImageKHR(QEglContext::display(),
-                EGL_NO_CONTEXT,
-                EGL_NATIVE_PIXMAP_KHR,
-                (EGLClientBuffer)sgImage,
-                (EGLint*)KEglImageAttribs);
-        if (eglGetError() != EGL_SUCCESS) {
-            sgImage->Close();
-            driver.Close();
-            return 0;
-        }
-
-        VGImage dstVgImage = vgCreateEGLImageTargetKHR(eglImage);
-        if (vgGetError() != VG_NO_ERROR) {
-            eglDestroyImageKHR(QEglContext::display(), eglImage);
-            sgImage->Close();
-            driver.Close();
-            return 0;
-        }
-
-        vgCopyImage(dstVgImage, 0, 0,
-                vgImage, 0, 0,
-                w, h, VG_FALSE);
-
-        if (vgGetError() != VG_NO_ERROR) {
-            sgImage->Close();
-            sgImage = 0;
-        }
-        // release stuff
-        vgDestroyImage(dstVgImage);
-        eglDestroyImageKHR(QEglContext::display(), eglImage);
-        driver.Close();
-        return reinterpret_cast<void*>(sgImage);
-#endif
-    } else if (type == QPixmapData::FbsBitmap) {
-        CFbsBitmap *bitmap = q_check_ptr(new CFbsBitmap);
-
-        if (bitmap) {
-            if (bitmap->Create(TSize(source.width(), source.height()),
-                              EColor16MAP) == KErrNone) {
-                const uchar *sptr = qt_vg_imageBits(source);
-                bitmap->BeginDataAccess();
-
-                uchar *dptr = (uchar*)bitmap->DataAddress();
-                Mem::Copy(dptr, sptr, source.byteCount());
-
-                bitmap->EndDataAccess();
-            } else {
-                delete bitmap;
-                bitmap = 0;
-            }
-        }
-
-        return reinterpret_cast<void*>(bitmap);
-    }
-    return 0;
-}
-#endif //Q_OS_SYMBIAN
-
 QT_END_NAMESPACE

trunk/src/openvg/qpixmapdata_vg_p.h

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
@@ -65 +65 @@
 class QEglContext;
 class QVGImagePool;
+
 
 #if !defined(QT_NO_EGL)
@@ -88 +89 @@
     void resize(int width, int height);
     void fromImage(const QImage &image, Qt::ImageConversionFlags flags);
+
+
+
+
+
+