Changeset 769 for trunk/src/openvg


Ignore:
Timestamp:
Aug 2, 2010, 9:27:30 PM (15 years ago)
Author:
Dmitry A. Kuminov
Message:

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

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk

  • trunk/src/openvg/openvg.pro

    r561 r769  
    3434}
    3535
     36symbian: DEFINES += QVG_RECREATE_ON_SIZE_CHANGE QVG_BUFFER_SCROLLING
     37
    3638include(../qbase.pri)
    3739

  • trunk/src/openvg/qpaintengine_vg.cpp

    r651 r769  
    7676#if !defined(QVG_NO_DRAW_GLYPHS)
    7777
    78 extern int qt_defaultDpiX();
    79 extern int qt_defaultDpiY();
     78Q_DECL_IMPORT extern int qt_defaultDpiX();
     79Q_DECL_IMPORT extern int qt_defaultDpiY();
    8080
    8181class QVGPaintEnginePrivate;
    … …  
    121121{
    122122public:
     123    // Extra blending modes from VG_KHR_advanced_blending extension.
     124    // Use the QT_VG prefix to avoid conflicts with any definitions
     125    // that may come in via <VG/vgext.h>.
     126    enum AdvancedBlending {
     127        QT_VG_BLEND_OVERLAY_KHR       = 0x2010,
     128        QT_VG_BLEND_HARDLIGHT_KHR     = 0x2011,
     129        QT_VG_BLEND_SOFTLIGHT_SVG_KHR = 0x2012,
     130        QT_VG_BLEND_SOFTLIGHT_KHR     = 0x2013,
     131        QT_VG_BLEND_COLORDODGE_KHR    = 0x2014,
     132        QT_VG_BLEND_COLORBURN_KHR     = 0x2015,
     133        QT_VG_BLEND_DIFFERENCE_KHR    = 0x2016,
     134        QT_VG_BLEND_SUBTRACT_KHR      = 0x2017,
     135        QT_VG_BLEND_INVERT_KHR        = 0x2018,
     136        QT_VG_BLEND_EXCLUSION_KHR     = 0x2019,
     137        QT_VG_BLEND_LINEARDODGE_KHR   = 0x201a,
     138        QT_VG_BLEND_LINEARBURN_KHR    = 0x201b,
     139        QT_VG_BLEND_VIVIDLIGHT_KHR    = 0x201c,
     140        QT_VG_BLEND_LINEARLIGHT_KHR   = 0x201d,
     141        QT_VG_BLEND_PINLIGHT_KHR      = 0x201e,
     142        QT_VG_BLEND_HARDMIX_KHR       = 0x201f,
     143        QT_VG_BLEND_CLEAR_KHR         = 0x2020,
     144        QT_VG_BLEND_DST_KHR           = 0x2021,
     145        QT_VG_BLEND_SRC_OUT_KHR       = 0x2022,
     146        QT_VG_BLEND_DST_OUT_KHR       = 0x2023,
     147        QT_VG_BLEND_SRC_ATOP_KHR      = 0x2024,
     148        QT_VG_BLEND_DST_ATOP_KHR      = 0x2025,
     149        QT_VG_BLEND_XOR_KHR           = 0x2026
     150    };
     151
    123152    QVGPaintEnginePrivate();
    124153    ~QVGPaintEnginePrivate();
    … …  
    218247#endif
    219248
     249    bool hasAdvancedBlending;
     250
    220251    QScopedPointer<QPixmapFilter> convolutionFilter;
    221252    QScopedPointer<QPixmapFilter> colorizeFilter;
    … …  
    370401    fontEngineCleaner = 0;
    371402#endif
     403
     404    hasAdvancedBlending = false;
    372405
    373406    clearModes();
    … …  
    447480    vgAppendPathData(linePath, 2, segments, coords);
    448481#endif
     482
     483    const char *extensions = reinterpret_cast<const char *>(vgGetString(VG_EXTENSIONS));
     484    if (extensions)
     485        hasAdvancedBlending = strstr(extensions, "VG_KHR_advanced_blending") != 0;
    449486}
    450487
    … …  
    497534}
    498535
    499 extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale);
     536Q_DECL_IMPORT extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale);
    500537
    501538void QVGPaintEnginePrivate::updateTransform(QPaintDevice *pdev)
    502539{
    503     VGfloat devh = pdev->height() - 1;
     540    VGfloat devh = pdev->height();
    504541
    505542    // Construct the VG transform by combining the Qt transform with
    506543    // the following viewport transformation:
    507     //        | 1  0  0   |   | 1 0  0.5 |   | 1  0     0.5      |
    508     //        | 0 -1 devh | * | 0 1 -0.5 | = | 0 -1 (0.5 + devh) |
    509     //        | 0  0  1   |   | 0 0   1  |   | 0  0      1       |
     544    //        | 1  0  0   |
     545    //        | 0 -1 devh |
     546    //        | 0  0  1   |
    510547    // The full VG transform is effectively:
    511548    //      1. Apply the user's transformation matrix.
    512     //      2. Translate by (0.5, -0.5) to correct for Qt and VG putting
    513     //         the centre of the pixel at different positions.
    514     //      3. Flip the co-ordinate system upside down.
     549    //      2. Flip the co-ordinate system upside down.
    515550    QTransform viewport(1.0f, 0.0f, 0.0f,
    516551                        0.0f, -1.0f, 0.0f,
    517                         0.5f, devh + 0.5f, 1.0f);
    518 
    519     // The image transform is always the full transformation,
    520     // because it can be projective.
    521     imageTransform = transform * viewport;
    522 
    523     // Determine if the transformation is projective.
    524     bool projective = (imageTransform.m13() != 0.0f ||
    525                        imageTransform.m23() != 0.0f ||
    526                        imageTransform.m33() != 1.0f);
     552                        0.0f, devh, 1.0f);
     553
     554    // Compute the path transform and determine if it is projective.
     555    pathTransform = transform * viewport;
     556    bool projective = (pathTransform.m13() != 0.0f ||
     557                       pathTransform.m23() != 0.0f ||
     558                       pathTransform.m33() != 1.0f);
    527559    if (projective) {
    528560        // The engine cannot do projective path transforms for us,
    … …  
    532564        simpleTransform = false;
    533565    } else {
    534         pathTransform = imageTransform;
    535566        simpleTransform = true;
    536567    }
    537568    pathTransformSet = false;
     569
     570    // The image transform is always the full transformation,
     571    imageTransform = transform * viewport;
    538572
    539573    // Calculate the scaling factor to use for turning cosmetic pens
    … …  
    9681002}
    9691003
    970 extern QImage qt_imageForBrush(int style, bool invert);
     1004Q_DECL_IMPORT extern QImage qt_imageForBrush(int style, bool invert);
    9711005
    9721006static QImage colorizeBitmap(const QImage &image, const QColor &color)
    … …  
    20632097        (QVGPaintEngine *engine, int width, int height)
    20642098{
     2099    scissorMask = false;
    20652100    if (maskIsSet) {
    20662101        vgMask(VG_INVALID_HANDLE, VG_FILL_MASK, 0, 0, width, height);
    … …  
    22952330    d->dirty |= QPaintEngine::DirtyCompositionMode;
    22962331
    2297     VGBlendMode vgMode = VG_BLEND_SRC_OVER;
     2332    VGint vgMode = VG_BLEND_SRC_OVER;
    22982333
    22992334    switch (state()->composition_mode) {
    … …  
    23292364        break;
    23302365    default:
    2331         qWarning() << "QVGPaintEngine::compositionModeChanged unsupported mode" << state()->composition_mode;
    2332         break;  // Fall back to VG_BLEND_SRC_OVER.
    2333     }
    2334 
    2335     d->setBlendMode(vgMode);
     2366        if (d->hasAdvancedBlending) {
     2367            switch (state()->composition_mode) {
     2368            case QPainter::CompositionMode_Overlay:
     2369                vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_OVERLAY_KHR;
     2370                break;
     2371            case QPainter::CompositionMode_ColorDodge:
     2372                vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_COLORDODGE_KHR;
     2373                break;
     2374            case QPainter::CompositionMode_ColorBurn:
     2375                vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_COLORBURN_KHR;
     2376                break;
     2377            case QPainter::CompositionMode_HardLight:
     2378                vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_HARDLIGHT_KHR;
     2379                break;
     2380            case QPainter::CompositionMode_SoftLight:
     2381                vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_SOFTLIGHT_KHR;
     2382                break;
     2383            case QPainter::CompositionMode_Difference:
     2384                vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_DIFFERENCE_KHR;
     2385                break;
     2386            case QPainter::CompositionMode_Exclusion:
     2387                vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_EXCLUSION_KHR;
     2388                break;
     2389            case QPainter::CompositionMode_SourceOut:
     2390                vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_SRC_OUT_KHR;
     2391                break;
     2392            case QPainter::CompositionMode_DestinationOut:
     2393                vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_DST_OUT_KHR;
     2394                break;
     2395            case QPainter::CompositionMode_SourceAtop:
     2396                vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_SRC_ATOP_KHR;
     2397                break;
     2398            case QPainter::CompositionMode_DestinationAtop:
     2399                vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_DST_ATOP_KHR;
     2400                break;
     2401            case QPainter::CompositionMode_Xor:
     2402                vgMode = QVGPaintEnginePrivate::QT_VG_BLEND_XOR_KHR;
     2403                break;
     2404            default: break; // Fall back to VG_BLEND_SRC_OVER.
     2405            }
     2406        }
     2407        if (vgMode == VG_BLEND_SRC_OVER)
     2408            qWarning() << "QVGPaintEngine::compositionModeChanged unsupported mode" << state()->composition_mode;
     2409        break;
     2410    }
     2411
     2412    d->setBlendMode(VGBlendMode(vgMode));
    23362413}
    23372414
    … …  
    24002477
    24012478    // Check to see if we can use vgClear() for faster filling.
    2402     if (brush.style() == Qt::SolidPattern &&
     2479    if (brush.style() == Qt::SolidPattern && brush.isOpaque() &&
    24032480            clipTransformIsSimple(d->transform) && d->opacity == 1.0f &&
    24042481            clearRect(rect, brush.color())) {
    … …  
    24432520
    24442521    // Check to see if we can use vgClear() for faster filling.
    2445     if (clipTransformIsSimple(d->transform) && d->opacity == 1.0f &&
     2522    if (clipTransformIsSimple(d->transform) && d->opacity == 1.0f && color.alpha() == 255 &&
    24462523            clearRect(rect, color)) {
    24472524        return;
    … …  
    32403317            }
    32413318        }
    3242         origin[0] = -metrics.x.toReal() + 0.5f;
    3243         origin[1] = -metrics.y.toReal() + 0.5f;
    3244         escapement[0] = metrics.xoff.toReal();
    3245         escapement[1] = metrics.yoff.toReal();
     3319        origin[0] = -metrics.x.toReal();
     3320        origin[1] = -metrics.y.toReal();
     3321        escapement[0] = 0;
     3322        escapement[1] = 0;
    32463323        vgSetGlyphToImage(font, glyph, vgImage, origin, escapement);
    32473324        vgDestroyImage(vgImage);    // Reduce reference count.
    … …  
    32593336        origin[0] = 0;
    32603337        origin[1] = 0;
    3261         escapement[0] = metrics.xoff.toReal();
    3262         escapement[1] = metrics.yoff.toReal();
     3338        escapement[0] = 0;
     3339        escapement[1] = 0;
    32633340        vgSetGlyphToPath(font, glyph, vgPath, VG_FALSE, origin, escapement);
    32643341        vgDestroyPath(vgPath);      // Reduce reference count.
    … …  
    32853362    QVarLengthArray<QFixedPoint> positions;
    32863363    QVarLengthArray<glyph_t> glyphs;
    3287     QTransform matrix = d->transform;
    3288     matrix.translate(p.x(), p.y());
    3289     ti.fontEngine->getGlyphPositions
    3290         (ti.glyphs, matrix, ti.flags, glyphs, positions);
     3364    QTransform matrix;
     3365    ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
    32913366
    32923367    // Find the glyph cache for this font.
    … …  
    33223397    glyphCache->cacheGlyphs(d, ti, glyphs);
    33233398
     3399    // Create the array of adjustments between glyphs
     3400    QVarLengthArray<VGfloat> adjustments_x(glyphs.size());
     3401    QVarLengthArray<VGfloat> adjustments_y(glyphs.size());
     3402    for (int i = 1; i < glyphs.size(); ++i) {
     3403        adjustments_x[i-1] = (positions[i].x - positions[i-1].x).toReal();
     3404        adjustments_y[i-1] = (positions[i].y - positions[i-1].y).toReal();
     3405    }
     3406
    33243407    // Set the glyph drawing origin.
    33253408    VGfloat origin[2];
    3326     origin[0] = 0;
    3327     origin[1] = 0;
     3409    origin[0] = positions[0].x.toReal();
     3410    origin[1] = positions[0].y.toReal();
    33283411    vgSetfv(VG_GLYPH_ORIGIN, 2, origin);
    33293412
    … …  
    33403423    d->ensureBrush(state()->pen.brush());
    33413424    vgDrawGlyphs(glyphCache->font, glyphs.size(), (VGuint*)glyphs.data(),
    3342                  NULL, NULL, VG_FILL_PATH, VG_TRUE);
     3425                 adjustments_x.data(), adjustments_y.data(), VG_FILL_PATH, VG_TRUE);
    33433426#else
    33443427    // OpenGL 1.0 does not have support for VGFont and glyphs,
    … …  
    36453728    } else {
    36463729        // Set the path transform to the default viewport transformation.
    3647         VGfloat devh = screenSize.height() - 1;
     3730        VGfloat devh = screenSize.height();
    36483731        QTransform viewport(1.0f, 0.0f, 0.0f,
    36493732                            0.0f, -1.0f, 0.0f,
    3650                             -0.5f, devh + 0.5f, 1.0f);
     3733                            0.0f, devh, 1.0f);
    36513734        d->setTransform(VG_MATRIX_PATH_USER_TO_SURFACE, viewport);
    36523735
    … …  
    36843767
    36853768    // Set the image transformation and modes.
    3686     VGfloat devh = screenSize.height() - 1;
     3769    VGfloat devh = screenSize.height();
    36873770    QTransform transform(1.0f, 0.0f, 0.0f,
    36883771                         0.0f, -1.0f, 0.0f,
    3689                          -0.5f, devh + 0.5f, 1.0f);
     3772                         0.0f, devh, 1.0f);
    36903773    transform.translate(offset.x(), offset.y());
    36913774    d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);

  • trunk/src/openvg/qpixmapdata_vg.cpp

    r651 r769  
    4646#include "qvgimagepool_p.h"
    4747
    48 #ifdef QT_SYMBIAN_SUPPORTS_SGIMAGE
     48#if defined(Q_OS_SYMBIAN)
    4949#include <private/qt_s60_p.h>
    5050#include <fbs.h>
    51 #include <graphics/sgimage.h>
     51#endif
     52#ifdef QT_SYMBIAN_SUPPORTS_SGIMAGE
     53#include <sgresource/sgimage.h>
    5254typedef EGLImageKHR (*pfnEglCreateImageKHR)(EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, EGLint*);
    5355typedef EGLBoolean (*pfnEglDestroyImageKHR)(EGLDisplay, EGLImageKHR);
    … …  
    353355}
    354356
    355 extern int qt_defaultDpiX();
    356 extern int qt_defaultDpiY();
     357Q_DECL_IMPORT extern int qt_defaultDpiX();
     358Q_DECL_IMPORT extern int qt_defaultDpiY();
    357359
    358360int QVGPixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
    … …  
    465467void QVGPixmapData::fromNativeType(void* pixmap, NativeType type)
    466468{
     469    if (type == QPixmapData::SgImage && pixmap) {
    467470#if defined(QT_SYMBIAN_SUPPORTS_SGIMAGE) && !defined(QT_NO_EGL)
    468     if (type == QPixmapData::SgImage && pixmap) {
    469471        RSgImage *sgImage = reinterpret_cast<RSgImage*>(pixmap);
    470         // when "0" used as argument then
    471         // default display, context are used
    472         if (!context)
    473             context = qt_vg_create_context(0, QInternal::Pixmap);
    474472
    475473        destroyImages();
    … …  
    478476        TInt err = 0;
    479477
    480         err = SgDriver::Open();
    481         if(err != KErrNone) {
     478        RSgDriver driver;
     479        err = driver.Open();
     480        if (err != KErrNone) {
    482481            cleanup();
    483482            return;
    484483        }
    485484
    486         if(sgImage->IsNull()) {
     485        if (sgImage->IsNull()) {
    487486            cleanup();
    488             SgDriver::Close();
     487            driver.Close();
    489488            return;
    490489        }
    … …  
    492491        TSgImageInfo sgImageInfo;
    493492        err = sgImage->GetInfo(sgImageInfo);
    494         if(err != KErrNone) {
     493        if (err != KErrNone) {
    495494            cleanup();
    496             SgDriver::Close();
     495            driver.Close();
    497496            return;
    498497        }
    … …  
    502501        pfnVgCreateEGLImageTargetKHR vgCreateEGLImageTargetKHR = (pfnVgCreateEGLImageTargetKHR) eglGetProcAddress("vgCreateEGLImageTargetKHR");
    503502
    504         if(eglGetError() != EGL_SUCCESS || !eglCreateImageKHR || !eglDestroyImageKHR || !vgCreateEGLImageTargetKHR) {
     503        if (eglGetError() != EGL_SUCCESS || !eglCreateImageKHR || !eglDestroyImageKHR || !vgCreateEGLImageTargetKHR) {
    505504            cleanup();
    506             SgDriver::Close();
     505            driver.Close();
    507506            return;
    508507        }
    509508
    510509        const EGLint KEglImageAttribs[] = {EGL_IMAGE_PRESERVED_SYMBIAN, EGL_TRUE, EGL_NONE};
    511         EGLImageKHR eglImage = eglCreateImageKHR(context->display(),
     510        EGLImageKHR eglImage = eglCreateImageKHR(QEglContext::display(),
    512511                EGL_NO_CONTEXT,
    513512                EGL_NATIVE_PIXMAP_KHR,
    … …  
    515514                (EGLint*)KEglImageAttribs);
    516515
    517         if(eglGetError() != EGL_SUCCESS) {
     516        if (eglGetError() != EGL_SUCCESS) {
    518517            cleanup();
    519             SgDriver::Close();
     518            driver.Close();
    520519            return;
    521520        }
    522521
    523522        vgImage = vgCreateEGLImageTargetKHR(eglImage);
    524         if(vgGetError() != VG_NO_ERROR) {
     523        if (vgGetError() != VG_NO_ERROR) {
    525524            cleanup();
    526             eglDestroyImageKHR(context->display(), eglImage);
    527             SgDriver::Close();
     525            eglDestroyImageKHR(QEglContext::display(), eglImage);
     526            driver.Close();
    528527            return;
    529528        }
    … …  
    538537        setSerialNumber(++qt_vg_pixmap_serial);
    539538        // release stuff
    540         eglDestroyImageKHR(context->display(), eglImage);
    541         SgDriver::Close();
     539        eglDestroyImageKHR(QEglContext::display(), eglImage);
     540        driver.Close();
     541#endif
    542542    } else if (type == QPixmapData::FbsBitmap) {
    543543        CFbsBitmap *bitmap = reinterpret_cast<CFbsBitmap*>(pixmap);
    … …  
    585585            delete bitmap;
    586586    }
    587 #else
    588     Q_UNUSED(pixmap);
    589     Q_UNUSED(type);
    590 #endif
    591587}
    592588
    593589void* QVGPixmapData::toNativeType(NativeType type)
    594590{
     591    if (type == QPixmapData::SgImage) {
    595592#if defined(QT_SYMBIAN_SUPPORTS_SGIMAGE) && !defined(QT_NO_EGL)
    596     if (type == QPixmapData::SgImage) {
    597593        toVGImage();
    598594
    599         if(!isValid() || vgImage == VG_INVALID_HANDLE)
     595        if (!isValid() || vgImage == VG_INVALID_HANDLE)
    600596            return 0;
    601597
    602598        TInt err = 0;
    603599
    604         err = SgDriver::Open();
    605         if(err != KErrNone)
     600        RSgDriver driver;
     601        err = driver.Open();
     602        if (err != KErrNone)
    606603            return 0;
    607604
    … …  
    609606        sgInfo.iPixelFormat = EUidPixelFormatARGB_8888_PRE;
    610607        sgInfo.iSizeInPixels.SetSize(w, h);
    611         sgInfo.iUsage = ESgUsageOpenVgImage | ESgUsageOpenVgTarget;
    612         sgInfo.iShareable = ETrue;
    613         sgInfo.iCpuAccess = ESgCpuAccessNone;
    614         sgInfo.iScreenId = KSgScreenIdMain; //KSgScreenIdAny;
    615         sgInfo.iUserAttributes = NULL;
    616         sgInfo.iUserAttributeCount = 0;
     608        sgInfo.iUsage = ESgUsageBitOpenVgImage | ESgUsageBitOpenVgSurface;
    617609
    618610        RSgImage *sgImage = q_check_ptr(new RSgImage());
    619611        err = sgImage->Create(sgInfo, NULL, NULL);
    620         if(err != KErrNone) {
    621             SgDriver::Close();
     612        if (err != KErrNone) {
     613            driver.Close();
    622614            return 0;
    623615        }
    … …  
    627619        pfnVgCreateEGLImageTargetKHR vgCreateEGLImageTargetKHR = (pfnVgCreateEGLImageTargetKHR) eglGetProcAddress("vgCreateEGLImageTargetKHR");
    628620
    629         if(eglGetError() != EGL_SUCCESS || !eglCreateImageKHR || !eglDestroyImageKHR || !vgCreateEGLImageTargetKHR) {
    630             SgDriver::Close();
     621        if (eglGetError() != EGL_SUCCESS || !eglCreateImageKHR || !eglDestroyImageKHR || !vgCreateEGLImageTargetKHR) {
     622            driver.Close();
    631623            return 0;
    632624        }
    633625
    634626        const EGLint KEglImageAttribs[] = {EGL_IMAGE_PRESERVED_SYMBIAN, EGL_TRUE, EGL_NONE};
    635         EGLImageKHR eglImage = eglCreateImageKHR(context->display(),
     627        EGLImageKHR eglImage = eglCreateImageKHR(QEglContext::display(),
    636628                EGL_NO_CONTEXT,
    637629                EGL_NATIVE_PIXMAP_KHR,
    638630                (EGLClientBuffer)sgImage,
    639631                (EGLint*)KEglImageAttribs);
    640         if(eglGetError() != EGL_SUCCESS) {
     632        if (eglGetError() != EGL_SUCCESS) {
    641633            sgImage->Close();
    642             SgDriver::Close();
     634            driver.Close();
    643635            return 0;
    644636        }
    645637
    646638        VGImage dstVgImage = vgCreateEGLImageTargetKHR(eglImage);
    647         if(vgGetError() != VG_NO_ERROR) {
    648             eglDestroyImageKHR(context->display(), eglImage);
     639        if (vgGetError() != VG_NO_ERROR) {
     640            eglDestroyImageKHR(QEglContext::display(), eglImage);
    649641            sgImage->Close();
    650             SgDriver::Close();
     642            driver.Close();
    651643            return 0;
    652644        }
    … …  
    656648                w, h, VG_FALSE);
    657649
    658         if(vgGetError() != VG_NO_ERROR) {
     650        if (vgGetError() != VG_NO_ERROR) {
    659651            sgImage->Close();
    660652            sgImage = 0;
    … …  
    662654        // release stuff
    663655        vgDestroyImage(dstVgImage);
    664         eglDestroyImageKHR(context->display(), eglImage);
    665         SgDriver::Close();
     656        eglDestroyImageKHR(QEglContext::display(), eglImage);
     657        driver.Close();
    666658        return reinterpret_cast<void*>(sgImage);
     659#endif
    667660    } else if (type == QPixmapData::FbsBitmap) {
    668661        CFbsBitmap *bitmap = q_check_ptr(new CFbsBitmap);
    … …  
    686679        return reinterpret_cast<void*>(bitmap);
    687680    }
    688 #else
    689     Q_UNUSED(type);
    690681    return 0;
    691 #endif
    692682}
    693683#endif //Q_OS_SYMBIAN

  • trunk/src/openvg/qwindowsurface_vg.cpp

    r651 r769  
    5858    // Create the default type of EGL window surface for windows.
    5959    d_ptr = new QVGEGLWindowSurfaceDirect(this);
     60    setStaticContentsSupport(d_ptr->supportsStaticContents());
    6061}
    6162
    … …  
    9091bool QVGWindowSurface::scroll(const QRegion &area, int dx, int dy)
    9192{
    92     return QWindowSurface::scroll(area, dx, dy);
     93    if (!d_ptr->scroll(window(), area, dx, dy))
     94        return QWindowSurface::scroll(area, dx, dy);
     95    return true;
    9396}
    9497

  • trunk/src/openvg/qwindowsurface_vgegl.cpp

    r651 r769  
    178178    } else {
    179179        QVGSharedContext *shared = sharedContext();
    180         shared->firstPixmap = pd->next;
     180        if (shared)
     181           shared->firstPixmap = pd->next;
    181182    }
    182183}
    … …  
    226227    context = new QEglContext();
    227228    context->setApi(QEgl::OpenVG);
    228     if (!context->openDisplay(device)) {
    229         delete context;
    230         return 0;
    231     }
    232229
    233230    // Set the swap interval for the display.
    234231    QByteArray interval = qgetenv("QT_VG_SWAP_INTERVAL");
    235232    if (!interval.isEmpty())
    236         eglSwapInterval(context->display(), interval.toInt());
     233        eglSwapInterval(QEglContext::display(), interval.toInt());
    237234    else
    238         eglSwapInterval(context->display(), 1);
     235        eglSwapInterval(QEglContext::display(), 1);
    239236
    240237#ifdef EGL_RENDERABLE_TYPE
    … …  
    250247        EGLConfig cfg;
    251248        if (eglChooseConfig
    252                     (context->display(), properties, &cfg, 1, &matching) &&
     249                    (QEglContext::display(), properties, &cfg, 1, &matching) &&
    253250                matching > 0) {
    254251            // Check that the selected configuration actually supports OpenVG
    … …  
    257254            EGLint type = 0;
    258255            eglGetConfigAttrib
    259                 (context->display(), cfg, EGL_CONFIG_ID, &id);
     256                (QEglContext::display(), cfg, EGL_CONFIG_ID, &id);
    260257            eglGetConfigAttrib
    261                 (context->display(), cfg, EGL_RENDERABLE_TYPE, &type);
     258                (QEglContext::display(), cfg, EGL_RENDERABLE_TYPE, &type);
    262259            if (cfgId == id && (type & EGL_OPENVG_BIT) != 0) {
    263260                context->setConfig(cfg);
    … …  
    338335    shared->context->doneCurrent();
    339336    if (shared->surface != EGL_NO_SURFACE) {
    340         eglDestroySurface(shared->context->display(), shared->surface);
     337        eglDestroySurface(QEglContext::display(), shared->surface);
    341338        shared->surface = EGL_NO_SURFACE;
    342339    }
    … …  
    416413        }
    417414        shared->surface = eglCreatePbufferSurface
    418             (shared->context->display(), shared->context->config(), attribs);
     415            (QEglContext::display(), shared->context->config(), attribs);
    419416    }
    420417    return shared->surface;
    … …  
    559556            recreateBackBuffer = false;
    560557            if (backBufferSurface != EGL_NO_SURFACE) {
    561                 eglDestroySurface(context->display(), backBufferSurface);
     558                eglDestroySurface(QEglContext::display(), backBufferSurface);
    562559                backBufferSurface = EGL_NO_SURFACE;
    563560            }
    … …  
    572569                // Create an EGL surface for rendering into the VGImage.
    573570                backBufferSurface = eglCreatePbufferFromClientBuffer
    574                     (context->display(), EGL_OPENVG_IMAGE,
     571                    (QEglContext::display(), EGL_OPENVG_IMAGE,
    575572                     (EGLClientBuffer)(backBuffer),
    576573                     context->config(), NULL);
    … …  
    663660        windowSurface = context->createSurface(widget, &surfaceProps);
    664661        isPaintingActive = false;
     662        needToSwap = true;
    665663    }
    666664#else
    … …  
    708706        // Did we get a direct to window rendering surface?
    709707        EGLint buffer = 0;
    710         if (eglQueryContext(context->display(), context->context(),
     708        if (eglQueryContext(QEglContext::display(), context->context(),
    711709                            EGL_RENDER_BUFFER, &buffer) &&
    712710                buffer == EGL_SINGLE_BUFFER) {
    … …  
    714712        }
    715713#endif
    716 #if !defined(QVG_NO_PRESERVED_SWAP)
    717         // Try to force the surface back buffer to preserve its contents.
    718         if (needToSwap) {
    719             eglGetError();  // Clear error state first.
    720             eglSurfaceAttrib(context->display(), surface,
    721                              EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
    722             if (eglGetError() != EGL_SUCCESS) {
    723                 qWarning("QVG: could not enable preserved swap");
    724             }
    725         }
    726 #endif
    727714        windowSurface = surface;
    728715        isPaintingActive = false;
    729716    }
     717
     718#if !defined(QVG_NO_PRESERVED_SWAP)
     719    // Try to force the surface back buffer to preserve its contents.
     720    if (needToSwap) {
     721        eglGetError();  // Clear error state first.
     722        eglSurfaceAttrib(QEglContext::display(), windowSurface,
     723                EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
     724        if (eglGetError() != EGL_SUCCESS) {
     725            qWarning("QVG: could not enable preserved swap");
     726        }
     727    }
     728#endif
    730729    return context;
    731730}
    … …  
    760759}
    761760
     761bool QVGEGLWindowSurfaceDirect::supportsStaticContents() const
     762{
     763#if defined(QVG_BUFFER_SCROLLING) && !defined(QVG_NO_PRESERVED_SWAP)
     764    return true;
     765#else
     766    return QVGEGLWindowSurfacePrivate::supportsStaticContents();
     767#endif
     768}
     769
     770bool QVGEGLWindowSurfaceDirect::scroll(QWidget *widget, const QRegion& area, int dx, int dy)
     771{
     772#ifdef QVG_BUFFER_SCROLLING
     773    QEglContext *context = ensureContext(widget);
     774    if (context) {
     775        context->makeCurrent(windowSurface);
     776        QRect scrollRect = area.boundingRect();
     777        int sx = scrollRect.x();
     778        int sy = size.height() - scrollRect.y() - scrollRect.height();
     779        vgSeti(VG_SCISSORING, VG_FALSE);
     780        vgCopyPixels(sx + dx, sy - dy, sx, sy, scrollRect.width(), scrollRect.height());
     781        context->lazyDoneCurrent();
     782        return true;
     783    }
     784#endif
     785    return false;
     786}
     787
    762788QT_END_NAMESPACE
    763789

  • trunk/src/openvg/qwindowsurface_vgegl_p.h

    r651 r769  
    7878    virtual VGImage surfaceImage() const;
    7979    virtual QSize surfaceSize() const = 0;
     80    virtual bool supportsStaticContents() const { return false; }
     81    virtual bool scroll(QWidget *, const QRegion&, int, int) { return false; }
    8082
    8183private:
    … …  
    129131    void endPaint(QWidget *widget, const QRegion& region, QImage *image);
    130132    QSize surfaceSize() const { return size; }
     133    bool supportsStaticContents() const;
     134    bool scroll(QWidget *widget, const QRegion& area, int dx, int dy);
    131135
    132136protected:
Note: See TracChangeset for help on using the changeset viewer.