#include <qmeegolivepixmapdata.h>

Inheritance diagram for QMeeGoLivePixmapData:

Public Functions
QPixmapData *	createCompatiblePixmapData () const

void	destroySurfaceForPixmapData (QPixmapData *pmd)

EGLSurface	getSurfaceForBackingPixmap ()

Qt::HANDLE	handle ()

void	initializeThroughEGLImage ()

QImage *	lock (EGLSyncKHR fenceSync)

	QMeeGoLivePixmapData (int w, int h, QImage::Format format)

	QMeeGoLivePixmapData (Qt::HANDLE h)

bool	release (QImage *img)

bool	scroll (int dx, int dy, const QRect &rect)

	~QMeeGoLivePixmapData ()

Public Functions inherited from QGLPixmapData
GLuint	bind (bool copyBack=true) const

void	copy (const QPixmapData *data, const QRect &rect)

void	fill (const QColor &color)

bool	fromData (const uchar buffer, uint len, const char format, Qt::ImageConversionFlags flags)

bool	fromFile (const QString &filename, const char *format, Qt::ImageConversionFlags flags)

void	fromImage (const QImage &image, Qt::ImageConversionFlags flags)

void	fromImageReader (QImageReader *imageReader, Qt::ImageConversionFlags flags)

QGLPaintDevice *	glDevice () const

bool	hasAlphaChannel () const

bool	isValidContext (const QGLContext *ctx) const

int	metric (QPaintDevice::PaintDeviceMetric metric) const

QPaintEngine *	paintEngine () const

	QGLPixmapData (PixelType type)

void	resize (int width, int height)

QGLTexture *	texture () const

QImage	toImage () const

	~QGLPixmapData ()

Public Functions inherited from QPixmapData
virtual QPixmap	alphaChannel () const

virtual QImage *	buffer ()

qint64	cacheKey () const

ClassId	classId () const

int	colorCount () const

int	depth () const

int	height () const

bool	isNull () const

virtual QBitmap	mask () const

QT_DEPRECATED int	numColors () const

PixelType	pixelType () const

	QPixmapData (PixelType pixelType, int classId)

virtual QPixmapData *	runtimeData () const

int	serialNumber () const

virtual void	setAlphaChannel (const QPixmap &alphaChannel)

virtual void	setMask (const QBitmap &mask)

virtual QImage	toImage (const QRect &rect) const

virtual QPixmap	transformed (const QTransform &matrix, Qt::TransformationMode mode) const

int	width () const

virtual	~QPixmapData ()

Static Public Functions
static void	invalidateSurfaces ()

Static Public Functions inherited from QPixmapData
static QPixmapData *	create (int w, int h, PixelType type)

Public Variables
QPixmap *	backingX11Pixmap

QImage	lockedImage

QMeeGoLivePixmapDataList::Iterator	pos

Additional Inherited Members
Public Types inherited from QPixmapData
enum	ClassId { RasterClass, X11Class, MacClass, DirectFBClass, OpenGLClass, OpenVGClass, RuntimeClass, BlitterClass, CustomClass = 1024 }

enum	PixelType { PixmapType, BitmapType }

Protected Functions inherited from QPixmapData
void	setSerialNumber (int serNo)

Protected Variables inherited from QPixmapData
int	d

int	h

bool	is_null

int	w

Detailed Description

Definition at line 52 of file qmeegolivepixmapdata.h.

Constructors and Destructors

◆ QMeeGoLivePixmapData() [1/2]

QMeeGoLivePixmapData::QMeeGoLivePixmapData	(	int	w,
		int	h,
		QImage::Format	format
	)

Definition at line 115 of file qmeegolivepixmapdata.cpp.

                                                                             : QGLPixmapData(QPixmapData::PixmapType)
 {
     QImage image(w, h, format);
     QX11PixmapData *pmd = new QX11PixmapData(QPixmapData::PixmapType);
     pmd->fromImage(image, Qt::NoOpaqueDetection);
     backingX11Pixmap = new QPixmap(pmd);
 
     initializeThroughEGLImage();
 
     pos = all_live_pixmaps.insert(all_live_pixmaps.begin(), this);
 }

◆ QMeeGoLivePixmapData() [2/2]

QMeeGoLivePixmapData::QMeeGoLivePixmapData ( Qt::HANDLE h )

Definition at line 127 of file qmeegolivepixmapdata.cpp.

                                                      : QGLPixmapData(QPixmapData::PixmapType)
 {
     backingX11Pixmap = new QPixmap(QPixmap::fromX11Pixmap(h));
     initializeThroughEGLImage();
 
     pos = all_live_pixmaps.insert(all_live_pixmaps.begin(), this);
 }

◆ ~QMeeGoLivePixmapData()

QMeeGoLivePixmapData::~QMeeGoLivePixmapData ( )

Definition at line 135 of file qmeegolivepixmapdata.cpp.

 {
     delete backingX11Pixmap;
     all_live_pixmaps.erase(pos);
 }

Functions

◆ createCompatiblePixmapData()

QPixmapData * QMeeGoLivePixmapData::createCompatiblePixmapData ( ) const

virtual

Reimplemented from QGLPixmapData.

Definition at line 177 of file qmeegolivepixmapdata.cpp.

 {
     qWarning("Create compatible called on live pixmap! Expect fail soon...");
     return new QMeeGoRasterPixmapData(pixelType());
 }

◆ destroySurfaceForPixmapData()

void QMeeGoLivePixmapData::destroySurfaceForPixmapData ( QPixmapData * pmd )

Definition at line 306 of file qmeegolivepixmapdata.cpp.

Referenced by getSurfaceForBackingPixmap().

 {
     Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
     QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
     if (pixmapData->gl_surface) {
         eglDestroySurface(QEgl::display(), (EGLSurface)pixmapData->gl_surface);
         pixmapData->gl_surface = 0;
     }
 }

◆ getSurfaceForBackingPixmap()

EGLSurface QMeeGoLivePixmapData::getSurfaceForBackingPixmap ( )

Definition at line 266 of file qmeegolivepixmapdata.cpp.

Referenced by lock(), and release().

 {
     initializeThroughEGLImage();
 
     // This code is a crative remix of the stuff that can be found in the
     // Qt's TFP implementation in /src/opengl/qgl_x11egl.cpp ::bindiTextureFromNativePixmap
     QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(backingX11Pixmap->data_ptr().data());
     Q_ASSERT(pixmapData->classId() == QPixmapData::X11Class);
     bool hasAlpha = pixmapData->hasAlphaChannel();
 
     if (pixmapData->gl_surface &&
         hasAlpha == (pixmapData->flags & QX11PixmapData::GlSurfaceCreatedWithAlpha))
         return pixmapData->gl_surface;
 
     // Check to see if the surface is still valid
     if (pixmapData->gl_surface &&
         hasAlpha != ((pixmapData->flags & QX11PixmapData::GlSurfaceCreatedWithAlpha) > 0)) {
         // Surface is invalid!
         destroySurfaceForPixmapData(pixmapData);
     }
 
     if (pixmapData->gl_surface == 0) {
         EGLConfig config = QEgl::defaultConfig(QInternal::Pixmap,
                                                QEgl::OpenGL,
                                                hasAlpha ? QEgl::Translucent : QEgl::NoOptions);
 
         pixmapData->gl_surface = (void*)QEgl::createSurface(backingX11Pixmap, config);
 
         if (hasAlpha)
             pixmapData->flags |= QX11PixmapData::GlSurfaceCreatedWithAlpha;
         else
             pixmapData->flags &= ~QX11PixmapData::GlSurfaceCreatedWithAlpha;
 
         if (pixmapData->gl_surface == (void*)EGL_NO_SURFACE)
             return NULL;
     }
 
     return pixmapData->gl_surface;
 }

◆ handle()

Qt::HANDLE QMeeGoLivePixmapData::handle ( )

Definition at line 250 of file qmeegolivepixmapdata.cpp.

Referenced by QMeeGoGraphicsSystem::getLiveTextureHandle().

 {
     return backingX11Pixmap->handle();
 }

◆ initializeThroughEGLImage()

void QMeeGoLivePixmapData::initializeThroughEGLImage ( )

Definition at line 141 of file qmeegolivepixmapdata.cpp.

Referenced by getSurfaceForBackingPixmap(), and QMeeGoLivePixmapData().

 {
     if (texture()->id != 0)
         return;
 
     QGLShareContextScope ctx(qt_gl_share_widget()->context());
     QMeeGoExtensions::ensureInitialized();
 
     EGLImageKHR eglImage = EGL_NO_IMAGE_KHR;
     GLuint newTextureId = 0;
 
     eglImage = QEgl::eglCreateImageKHR(QEgl::display(), EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR,
                                        (EGLClientBuffer) backingX11Pixmap->handle(), preserved_attribs);
 
     if (eglImage == EGL_NO_IMAGE_KHR) {
         qWarning("eglCreateImageKHR failed (live texture)!");
         return;
     }
 
     glGenTextures(1, &newTextureId);
     glBindTexture(GL_TEXTURE_2D, newTextureId);
 
     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (EGLImageKHR) eglImage);
     if (glGetError() == GL_NO_ERROR) {
         resize(backingX11Pixmap->width(), backingX11Pixmap->height());
         texture()->id = newTextureId;
         texture()->options &= ~QGLContext::InvertedYBindOption;
         m_hasAlpha = backingX11Pixmap->hasAlphaChannel();
     } else {
         qWarning("Failed to create a texture from an egl image (live texture)!");
         glDeleteTextures(1, &newTextureId);
     }
 
     QEgl::eglDestroyImageKHR(QEgl::display(), eglImage);
 }

◆ invalidateSurfaces()

void QMeeGoLivePixmapData::invalidateSurfaces ( )

static

Definition at line 316 of file qmeegolivepixmapdata.cpp.

Referenced by qt_meego_invalidate_live_surfaces(), and QMeeGoGraphicsSystem::switchToRaster().

 {
     foreach (QMeeGoLivePixmapData *data, all_live_pixmaps) {
         QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(data->backingX11Pixmap->data_ptr().data());
         *data->texture() = QGLTexture();
         pixmapData->gl_surface = 0;
     }
 }

◆ lock()

QImage * QMeeGoLivePixmapData::lock ( EGLSyncKHR fenceSync )

Definition at line 183 of file qmeegolivepixmapdata.cpp.

Referenced by QMeeGoGraphicsSystem::lockLiveTexture(), and scroll().

 {
     QGLShareContextScope ctx(qt_gl_share_widget()->context());
     QMeeGoExtensions::ensureInitialized();
 
     if (fenceSync) {
         QMeeGoExtensions::eglClientWaitSyncKHR(QEgl::display(),
                                                fenceSync,
                                                EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
                                                EGL_FOREVER_KHR);
     }
 
     void *data = 0;
     int pitch = 0;
     int surfaceWidth = 0;
     int surfaceHeight = 0;
     EGLSurface surface = 0;
     QImage::Format format;
     lockedImage = QImage();
 
     surface = getSurfaceForBackingPixmap();
     if (! QMeeGoExtensions::eglLockSurfaceKHR(QEgl::display(), surface, lock_attribs)) {
         qWarning("Failed to lock surface (live texture)!");
         return &lockedImage;
     }
 
     eglQuerySurface(QEgl::display(), surface, EGL_BITMAP_POINTER_KHR, (EGLint*) &data);
     eglQuerySurface(QEgl::display(), surface, EGL_BITMAP_PITCH_KHR, (EGLint*) &pitch);
     eglQuerySurface(QEgl::display(), surface, EGL_WIDTH, (EGLint*) &surfaceWidth);
     eglQuerySurface(QEgl::display(), surface, EGL_HEIGHT, (EGLint*) &surfaceHeight);
 
     // Ok, here we know we just support those two formats. Real solution would be:
     // query also the format.
     if (backingX11Pixmap->depth() > 16)
         format = QImage::Format_ARGB32_Premultiplied;
     else
         format = QImage::Format_RGB16;
 
     if (data == NULL || pitch == 0) {
         qWarning("Failed to query the live texture!");
         return &lockedImage;
     }
 
     if (width() != surfaceWidth || height() != surfaceHeight) {
         qWarning("Live texture dimensions don't match!");
         QMeeGoExtensions::eglUnlockSurfaceKHR(QEgl::display(), surface);
         return &lockedImage;
     }
 
     lockedImage = QImage((uchar *) data, width(), height(), pitch, format);
     return &lockedImage;
 }

◆ release()

bool QMeeGoLivePixmapData::release ( QImage * img )

Definition at line 236 of file qmeegolivepixmapdata.cpp.

Referenced by QMeeGoGraphicsSystem::releaseLiveTexture(), and scroll().

 {
     QGLShareContextScope ctx(qt_gl_share_widget()->context());
     QMeeGoExtensions::ensureInitialized();
 
     if (QMeeGoExtensions::eglUnlockSurfaceKHR(QEgl::display(), getSurfaceForBackingPixmap())) {
         lockedImage = QImage();
         return true;
     } else {
         lockedImage = QImage();
         return false;
     }
 }

◆ scroll()

bool QMeeGoLivePixmapData::scroll	(	int	dx,
		int	dy,
		const QRect &	rect
	)

virtual

Reimplemented from QGLPixmapData.

Definition at line 255 of file qmeegolivepixmapdata.cpp.

 {
     lock(NULL);
 
     if (!lockedImage.isNull())
         qt_scrollRectInImage(lockedImage, rect, QPoint(dx, dy));
 
     release(&lockedImage);
     return true;
 }

Properties

◆ backingX11Pixmap

QPixmap* QMeeGoLivePixmapData::backingX11Pixmap

Definition at line 71 of file qmeegolivepixmapdata.h.

Referenced by getSurfaceForBackingPixmap(), handle(), initializeThroughEGLImage(), invalidateSurfaces(), lock(), QMeeGoLivePixmapData(), and ~QMeeGoLivePixmapData().

◆ lockedImage

QImage QMeeGoLivePixmapData::lockedImage

Definition at line 72 of file qmeegolivepixmapdata.h.

Referenced by lock(), release(), and scroll().

◆ pos

QMeeGoLivePixmapDataList::Iterator QMeeGoLivePixmapData::pos

Definition at line 73 of file qmeegolivepixmapdata.h.

Referenced by QMeeGoLivePixmapData(), and ~QMeeGoLivePixmapData().

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

/src/plugins/graphicssystems/meego/qmeegolivepixmapdata.h
/src/plugins/graphicssystems/meego/qmeegolivepixmapdata.cpp

Public Functions

Static Public Functions

Public Variables

Additional Inherited Members