QMeeGoGraphicsSystem Class Reference

#include <qmeegographicssystem.h>

Inheritance diagram for QMeeGoGraphicsSystem:

Public Types
enum	SwitchPolicy { AutomaticSwitch, ManualSwitch, NoSwitch }

Public Functions
virtual QPixmapData *	createPixmapData (QPixmapData::PixelType) const
virtual QPixmapData *	createPixmapData (QPixmapData *origin)
virtual QWindowSurface *	createWindowSurface (QWidget *widget) const
	QMeeGoGraphicsSystem ()
	~QMeeGoGraphicsSystem ()
Public Functions inherited from QGraphicsSystem
virtual QGraphicsSystemEx *	platformExtension ()
virtual	~QGraphicsSystem ()

Static Public Functions
static void *	createFenceSync ()
static void	destroyFenceSync (void *fenceSync)
static Qt::HANDLE	getLiveTextureHandle (QPixmap *pixmap)
static QImage *	lockLiveTexture (QPixmap *pixmap, void *fenceSync)
static QPixmapData *	pixmapDataFromEGLImage (Qt::HANDLE handle)
static QPixmapData *	pixmapDataFromEGLSharedImage (Qt::HANDLE handle, const QImage &softImage)
static QPixmapData *	pixmapDataFromLiveTextureHandle (Qt::HANDLE handle)
static QPixmapData *	pixmapDataWithGLTexture (int w, int h)
static QPixmapData *	pixmapDataWithNewLiveTexture (int w, int h, QImage::Format format)
static void	registerSwitchCallback (QMeeGoSwitchCallback callback)
static bool	releaseLiveTexture (QPixmap *pixmap, QImage *image)
static QString	runningGraphicsSystemName ()
static void	setSurfaceFixedSize (int width, int height)
static void	setSurfaceScaling (int x, int y, int width, int height)
static void	setTranslucent (bool translucent)
static void	switchToMeeGo ()
static void	switchToRaster ()
static void	updateEGLSharedImagePixmap (QPixmap *pixmap)
static QPixmapData *	wrapPixmapData (QPixmapData *pmd)
Static Public Functions inherited from QGraphicsSystem
static QPixmapData *	createDefaultPixmapData (QPixmapData::PixelType type)

Static Public Variables
static SwitchPolicy	switchPolicy = QMeeGoGraphicsSystem::AutomaticSwitch

Static Private Functions
static void	destroySurfaceForLiveTexturePixmap (QPixmapData *pmd)
static EGLSurface	getSurfaceForLiveTexturePixmap (QPixmap *pixmap)
static bool	meeGoRunning ()
static void	triggerSwitchCallbacks (int type, const char *name)

Static Private Attributes
static QHash< Qt::HANDLE, QPixmap * >	liveTexturePixmaps
static bool	surfaceWasCreated = false
static QList< QMeeGoSwitchCallback >	switchCallbacks

Detailed Description

Definition at line 52 of file qmeegographicssystem.h.

Enumerations

SwitchPolicy

enum QMeeGoGraphicsSystem::SwitchPolicy

Enumerator
AutomaticSwitch
ManualSwitch
NoSwitch

Definition at line 55 of file qmeegographicssystem.h.

{ AutomaticSwitch, ManualSwitch, NoSwitch };

Constructors and Destructors

QMeeGoGraphicsSystem()

QMeeGoGraphicsSystem::QMeeGoGraphicsSystem

(

)

Definition at line 72 of file qmeegographicssystem.cpp.

{
    qDebug("Using the meego graphics system");
}

~QMeeGoGraphicsSystem()

QMeeGoGraphicsSystem::~QMeeGoGraphicsSystem

(

)

Definition at line 77 of file qmeegographicssystem.cpp.

{
    qDebug("Meego graphics system destroyed");
    qt_destroy_gl_share_widget();
}

Functions

createFenceSync()

void * QMeeGoGraphicsSystem::createFenceSync ( )

static

Definition at line 363 of file qmeegographicssystem.cpp.

Referenced by qt_meego_create_fence_sync().

{
    QGLShareContextScope ctx(qt_gl_share_widget()->context());
    QMeeGoExtensions::ensureInitialized();
    return QMeeGoExtensions::eglCreateSyncKHR(QEgl::display(), EGL_SYNC_FENCE_KHR, NULL);
}

createPixmapData() [1/2]

QPixmapData * QMeeGoGraphicsSystem::createPixmapData ( QPixmapData::PixelType  type ) const

virtual

Implements QGraphicsSystem.

Definition at line 217 of file qmeegographicssystem.cpp.

{
    return new QRasterPixmapData(type);
}

createPixmapData() [2/2]

QPixmapData * QMeeGoGraphicsSystem::createPixmapData ( QPixmapData *  origin )

virtual

Reimplemented from QGraphicsSystem.

Definition at line 222 of file qmeegographicssystem.cpp.

{
    // If the pixmap is a raster type...
    // and if the pixmap pointer matches our mapping...
    // create a shared image instead with the given handle.

    if (!origin->isNull() && origin->classId() == QPixmapData::RasterClass) {
        QRasterPixmapData *rasterClass = static_cast <QRasterPixmapData *> (origin);
        void *rawResource = static_cast <void *> (rasterClass->buffer()->data_ptr()->data);

        if (QMeeGoPixmapData::sharedImagesMap.contains(rawResource))
            return new QMeeGoPixmapData();
    }

    return new QRasterPixmapData(origin->pixelType());
}

createWindowSurface()

QWindowSurface * QMeeGoGraphicsSystem::createWindowSurface ( QWidget *  widget ) const

virtual

Implements QGraphicsSystem.

Definition at line 200 of file qmeegographicssystem.cpp.

{
    QGLWidget *shareWidget = qt_gl_share_widget();

    if (!shareWidget)
        return new QRasterWindowSurface(widget);

    QGLShareContextScope ctx(shareWidget->context());

    if (QApplicationPrivate::instance()->graphics_system_name == QLatin1String("runtime"))
        switch_handler()->addWidget(widget);

    QMeeGoGraphicsSystem::surfaceWasCreated = true;
    QWindowSurface *surface = new QGLWindowSurface(widget);
    return surface;
}

destroyFenceSync()

void QMeeGoGraphicsSystem::destroyFenceSync ( void *  fenceSync )

static

Definition at line 370 of file qmeegographicssystem.cpp.

Referenced by qt_meego_destroy_fence_sync().

{
    QGLShareContextScope ctx(qt_gl_share_widget()->context());
    QMeeGoExtensions::ensureInitialized();
    QMeeGoExtensions::eglDestroySyncKHR(QEgl::display(), fenceSync);
}

destroySurfaceForLiveTexturePixmap()

static void QMeeGoGraphicsSystem::destroySurfaceForLiveTexturePixmap ( QPixmapData *  pmd )

staticprivate

getLiveTextureHandle()

Qt::HANDLE QMeeGoGraphicsSystem::getLiveTextureHandle ( QPixmap *  pixmap )

static

Definition at line 357 of file qmeegographicssystem.cpp.

Referenced by qt_meego_live_texture_get_handle().

{
    QMeeGoLivePixmapData *pixmapData = static_cast<QMeeGoLivePixmapData*>(pixmap->data_ptr().data());
    return pixmapData->handle();
}

getSurfaceForLiveTexturePixmap()

static EGLSurface QMeeGoGraphicsSystem::getSurfaceForLiveTexturePixmap ( QPixmap *  pixmap )

staticprivate

lockLiveTexture()

QImage * QMeeGoGraphicsSystem::lockLiveTexture ( QPixmap *  pixmap, void *  fenceSync  )

static

Definition at line 345 of file qmeegographicssystem.cpp.

Referenced by qt_meego_live_texture_lock().

{
    QMeeGoLivePixmapData *pixmapData = static_cast<QMeeGoLivePixmapData*>(pixmap->data_ptr().data());
    return pixmapData->lock(fenceSync);
}

meeGoRunning()

bool QMeeGoGraphicsSystem::meeGoRunning ( )

staticprivate

Definition at line 330 of file qmeegographicssystem.cpp.

Referenced by pixmapDataFromEGLSharedImage(), and switchToMeeGo().

{
    return runningGraphicsSystemName() == "meego";
}

pixmapDataFromEGLImage()

static QPixmapData* QMeeGoGraphicsSystem::pixmapDataFromEGLImage ( Qt::HANDLE  handle )

static

pixmapDataFromEGLSharedImage()

QPixmapData * QMeeGoGraphicsSystem::pixmapDataFromEGLSharedImage ( Qt::HANDLE  handle, const QImage &  softImage  )

static

Definition at line 286 of file qmeegographicssystem.cpp.

Referenced by qt_meego_pixmapdata_from_egl_shared_image().

{
    if (softImage.format() != QImage::Format_ARGB32_Premultiplied &&
        softImage.format() != QImage::Format_RGB32) {
        qFatal("For egl shared images, the soft image has to be ARGB32_Premultiplied or RGB32");
        return NULL;
    }

    if (QMeeGoGraphicsSystem::meeGoRunning()) {
        QMeeGoPixmapData *pmd = new QMeeGoPixmapData;
        pmd->fromEGLSharedImage(handle, softImage);
        return QMeeGoGraphicsSystem::wrapPixmapData(pmd);
    } else {
        QRasterPixmapData *pmd = new QRasterPixmapData(QPixmapData::PixmapType);
        pmd->fromImage(softImage, Qt::NoFormatConversion);

        // Make sure that the image was not converted in any way
        if (pmd->buffer()->data_ptr()->data !=
            const_cast<QImage &>(softImage).data_ptr()->data)
            qFatal("Iternal misalignment of raster data detected. Prolly a QImage copy fail.");

        QMeeGoPixmapData::registerSharedImage(handle, softImage);
        return QMeeGoGraphicsSystem::wrapPixmapData(pmd);
    }
}

pixmapDataFromLiveTextureHandle()

QPixmapData * QMeeGoGraphicsSystem::pixmapDataFromLiveTextureHandle ( Qt::HANDLE  handle )

static

Definition at line 340 of file qmeegographicssystem.cpp.

Referenced by qt_meego_pixmapdata_from_live_texture_handle().

{
    return new QMeeGoLivePixmapData(handle);
}

pixmapDataWithGLTexture()

QPixmapData * QMeeGoGraphicsSystem::pixmapDataWithGLTexture ( int  w, int  h  )

static

Definition at line 323 of file qmeegographicssystem.cpp.

Referenced by qt_meego_pixmapdata_with_gl_texture().

{
    QGLPixmapData *pmd = new QGLPixmapData(QPixmapData::PixmapType);
    pmd->resize(w, h);
    return QMeeGoGraphicsSystem::wrapPixmapData(pmd);
}

pixmapDataWithNewLiveTexture()

QPixmapData * QMeeGoGraphicsSystem::pixmapDataWithNewLiveTexture ( int  w, int  h, QImage::Format  format  )

static

Definition at line 335 of file qmeegographicssystem.cpp.

Referenced by qt_meego_pixmapdata_with_new_live_texture().

{
    return new QMeeGoLivePixmapData(w, h, format);
}

registerSwitchCallback()

void QMeeGoGraphicsSystem::registerSwitchCallback ( QMeeGoSwitchCallback  callback )

static

Definition at line 429 of file qmeegographicssystem.cpp.

Referenced by qt_meego_register_switch_callback().

{
    switchCallbacks << callback;
}

releaseLiveTexture()

bool QMeeGoGraphicsSystem::releaseLiveTexture ( QPixmap *  pixmap, QImage *  image  )

static

Definition at line 351 of file qmeegographicssystem.cpp.

Referenced by qt_meego_live_texture_release().

{
    QMeeGoLivePixmapData *pixmapData = static_cast<QMeeGoLivePixmapData*>(pixmap->data_ptr().data());
    return pixmapData->release(image);
}

runningGraphicsSystemName()

QString QMeeGoGraphicsSystem::runningGraphicsSystemName ( )

static

Definition at line 377 of file qmeegographicssystem.cpp.

Referenced by meeGoRunning(), and switchToRaster().

{
    if (!QApplicationPrivate::instance()) {
        qWarning("Querying graphics system but application not running yet!");
        return QString();
    }

    QString name = QApplicationPrivate::instance()->graphics_system_name;
    if (name == QLatin1String("runtime")) {
        QRuntimeGraphicsSystem *rsystem = (QRuntimeGraphicsSystem *) QApplicationPrivate::instance()->graphics_system;
        name = rsystem->graphicsSystemName();
    }

    return name;
}

setSurfaceFixedSize()

void QMeeGoGraphicsSystem::setSurfaceFixedSize ( int  width, int  height  )

static

Definition at line 253 of file qmeegographicssystem.cpp.

Referenced by qt_meego_set_surface_fixed_size().

{
    if (QMeeGoGraphicsSystem::surfaceWasCreated) {
        qWarning("Trying to set surface fixed size but surface already created!");
        return;
    }

#ifdef QT_WAS_PATCHED
    QEglProperties *properties = new QEglProperties();
    properties->setValue(EGL_FIXED_WIDTH_NOK, width);
    properties->setValue(EGL_FIXED_HEIGHT_NOK, height);
    QGLContextPrivate::setExtraWindowSurfaceCreationProps(properties);
#endif
}

setSurfaceScaling()

void QMeeGoGraphicsSystem::setSurfaceScaling ( int  x, int  y, int  width, int  height  )

static

Definition at line 268 of file qmeegographicssystem.cpp.

Referenced by qt_meego_set_surface_scaling().

{
    QMeeGoExtensions::ensureInitialized();
    QMeeGoExtensions::eglSetSurfaceScalingNOK(QEgl::display(), QEglContext::currentContext(QEgl::OpenGL)->currentSurface, x, y, width, height);
}

setTranslucent()

void QMeeGoGraphicsSystem::setTranslucent ( bool  translucent )

static

Definition at line 274 of file qmeegographicssystem.cpp.

Referenced by qt_meego_set_translucent().

{
    if (QMeeGoGraphicsSystem::surfaceWasCreated) {
        qWarning("Trying to set translucency but surface already created!");
        return;
    }

    QGLWindowSurface::surfaceFormat.setSampleBuffers(false);
    QGLWindowSurface::surfaceFormat.setSamples(0);
    QGLWindowSurface::surfaceFormat.setAlpha(translucent);
}

switchToMeeGo()

void QMeeGoGraphicsSystem::switchToMeeGo ( )

static

Definition at line 393 of file qmeegographicssystem.cpp.

Referenced by QMeeGoGraphicsSystemSwitchHandler::eventFilter(), QMeeGoGraphicsSystemSwitchHandler::handleMapNotify(), qt_meego_switch_to_meego(), and QMeeGoGraphicsSystemSwitchHandler::switchToMeeGo().

{
    if (switchPolicy == NoSwitch || meeGoRunning())
        return;

    if (QApplicationPrivate::instance()->graphics_system_name != QLatin1String("runtime"))
        qWarning("Can't switch to meego - switching only supported with 'runtime' graphics system.");
    else {
        triggerSwitchCallbacks(0, "meego");

        QApplication *app = static_cast<QApplication *>(QCoreApplication::instance());
        app->setGraphicsSystem(QLatin1String("meego"));

        triggerSwitchCallbacks(1, "meego");
    }
}

switchToRaster()

void QMeeGoGraphicsSystem::switchToRaster ( )

static

Definition at line 410 of file qmeegographicssystem.cpp.

Referenced by QMeeGoGraphicsSystemSwitchHandler::eventFilter(), qt_meego_switch_to_raster(), QMeeGoGraphicsSystemSwitchHandler::removeWidget(), and QMeeGoGraphicsSystemSwitchHandler::switchToRaster().

{
    if (switchPolicy == NoSwitch || runningGraphicsSystemName() == QLatin1String("raster"))
        return;

    if (QApplicationPrivate::instance()->graphics_system_name != QLatin1String("runtime"))
        qWarning("Can't switch to raster - switching only supported with 'runtime' graphics system.");
    else {
        triggerSwitchCallbacks(0, "raster");

        QApplication *app = static_cast<QApplication *>(QCoreApplication::instance());
        app->setGraphicsSystem(QLatin1String("raster"));

        QMeeGoLivePixmapData::invalidateSurfaces();

        triggerSwitchCallbacks(1, "raster");
    }
}

triggerSwitchCallbacks()

void QMeeGoGraphicsSystem::triggerSwitchCallbacks ( int  type, const char *  name  )

staticprivate

Definition at line 434 of file qmeegographicssystem.cpp.

Referenced by switchToMeeGo(), and switchToRaster().

{
    for (int i = 0; i < switchCallbacks.size(); ++i)
        switchCallbacks.at(i)(type, name);
}

updateEGLSharedImagePixmap()

void QMeeGoGraphicsSystem::updateEGLSharedImagePixmap ( QPixmap *  pixmap )

static

Definition at line 312 of file qmeegographicssystem.cpp.

Referenced by qt_meego_update_egl_shared_image_pixmap().

{
    QMeeGoPixmapData *pmd = (QMeeGoPixmapData *) pixmap->pixmapData();

    // Basic sanity check to make sure this is really a QMeeGoPixmapData...
    if (pmd->classId() != QPixmapData::OpenGLClass)
        qFatal("Trying to updated EGLSharedImage pixmap but it's not really a shared image pixmap!");

    pmd->updateFromSoftImage();
}

wrapPixmapData()

QPixmapData * QMeeGoGraphicsSystem::wrapPixmapData ( QPixmapData *  pmd )

static

Definition at line 239 of file qmeegographicssystem.cpp.

Referenced by pixmapDataFromEGLSharedImage(), and pixmapDataWithGLTexture().

{
    QString name = QApplicationPrivate::instance()->graphics_system_name;
    if (name == "runtime") {
        QRuntimeGraphicsSystem *rsystem = (QRuntimeGraphicsSystem *) QApplicationPrivate::instance()->graphics_system;
        QRuntimePixmapData *rt = new QRuntimePixmapData(rsystem, pmd->pixelType());;
        rt->m_data = pmd;
        rt->readBackInfo();
        rsystem->m_pixmapDatas << rt;
        return rt;
    } else
        return pmd;
}

Properties

liveTexturePixmaps

QHash< Qt::HANDLE, QPixmap * > QMeeGoGraphicsSystem::liveTexturePixmaps

staticprivate

Definition at line 98 of file qmeegographicssystem.h.

surfaceWasCreated

bool QMeeGoGraphicsSystem::surfaceWasCreated = false

staticprivate

Definition at line 97 of file qmeegographicssystem.h.

Referenced by createWindowSurface(), setSurfaceFixedSize(), and setTranslucent().

switchCallbacks

QList< QMeeGoSwitchCallback > QMeeGoGraphicsSystem::switchCallbacks

staticprivate

Definition at line 99 of file qmeegographicssystem.h.

Referenced by registerSwitchCallback(), and triggerSwitchCallbacks().

switchPolicy

QMeeGoGraphicsSystem::SwitchPolicy QMeeGoGraphicsSystem::switchPolicy = QMeeGoGraphicsSystem::AutomaticSwitch

static

Definition at line 89 of file qmeegographicssystem.h.

Referenced by QMeeGoGraphicsSystemSwitchHandler::eventFilter(), QMeeGoGraphicsSystemSwitchHandler::handleMapNotify(), qt_meego_set_switch_policy(), QMeeGoGraphicsSystemSwitchHandler::removeWidget(), switchToMeeGo(), and switchToRaster().

---

The documentation for this class was generated from the following files:

• /src/plugins/graphicssystems/meego/qmeegographicssystem.h
• /src/plugins/graphicssystems/meego/qmeegographicssystem.cpp