#include <qmeegopixmapdata.h>

Inheritance diagram for QMeeGoPixmapData:

Public Functions
QPixmapData *	createCompatiblePixmapData () const

virtual void	fromEGLSharedImage (Qt::HANDLE handle, const QImage &softImage)

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

void	fromTexture (GLuint textureId, int w, int h, bool alpha)

	QMeeGoPixmapData ()

virtual QImage	toImage () const

virtual void	updateFromSoftImage ()

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	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)

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

QGLTexture *	texture () 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 bool	destroyEGLSharedImage (Qt::HANDLE h)

static Qt::HANDLE	imageToEGLSharedImage (const QImage &image)

static void	registerSharedImage (Qt::HANDLE handle, const QImage &si)

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

Public Variables
QImage	softImage

Static Public Variables
static QHash< void , QMeeGoImageInfo >	sharedImagesMap

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 53 of file qmeegopixmapdata.h.

Constructors and Destructors

◆ QMeeGoPixmapData()

QMeeGoPixmapData::QMeeGoPixmapData ( )

Definition at line 62 of file qmeegopixmapdata.cpp.

                                    : QGLPixmapData(QPixmapData::PixmapType)
 {
 }

Functions

◆ createCompatiblePixmapData()

QPixmapData * QMeeGoPixmapData::createCompatiblePixmapData ( ) const

virtual

Reimplemented from QGLPixmapData.

Definition at line 223 of file qmeegopixmapdata.cpp.

 {
     return new QMeeGoRasterPixmapData(pixelType());
 }

◆ destroyEGLSharedImage()

bool QMeeGoPixmapData::destroyEGLSharedImage ( Qt::HANDLE h )

static

Definition at line 191 of file qmeegopixmapdata.cpp.

Referenced by qt_meego_destroy_egl_shared_image().

 {
     QGLShareContextScope ctx(qt_gl_share_widget()->context());   
     QMeeGoExtensions::ensureInitialized();
 
     QMutableHashIterator <void*, QMeeGoImageInfo*> i(sharedImagesMap);
     while (i.hasNext()) {
         i.next();
         if (i.value()->handle == h)
             i.remove();
     }
 
     return QMeeGoExtensions::eglDestroySharedImageNOK(QEgl::display(), (EGLNativeSharedImageTypeNOK) h);
 }

◆ fromEGLSharedImage()

void QMeeGoPixmapData::fromEGLSharedImage	(	Qt::HANDLE	handle,
		const QImage &	softImage
	)

virtual

Definition at line 96 of file qmeegopixmapdata.cpp.

Referenced by fromImage(), and QMeeGoGraphicsSystem::pixmapDataFromEGLSharedImage().

 {
     if (si.isNull())
         qFatal("Trying to build pixmap with an empty/null softimage!");
         
     QGLShareContextScope ctx(qt_gl_share_widget()->context());
    
     QMeeGoExtensions::ensureInitialized();
  
     bool textureIsBound = false;
     GLuint newTextureId;
     GLint newWidth, newHeight;
 
     glGenTextures(1, &newTextureId);
     glBindTexture(GL_TEXTURE_2D, newTextureId);
     
     EGLImageKHR image = QEgl::eglCreateImageKHR(QEgl::display(), EGL_NO_CONTEXT, EGL_SHARED_IMAGE_NOK,
                                                 (EGLClientBuffer)handle, preserved_image_attribs);
 
     if (image != EGL_NO_IMAGE_KHR) {
         glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
         GLint err = glGetError();
         if (err == GL_NO_ERROR)
             textureIsBound = true;
         
         QMeeGoExtensions::eglQueryImageNOK(QEgl::display(), image, EGL_WIDTH, &newWidth);
         QMeeGoExtensions::eglQueryImageNOK(QEgl::display(), image, EGL_HEIGHT, &newHeight);
           
         QEgl::eglDestroyImageKHR(QEgl::display(), image);
     }
         
     if (textureIsBound) {
         fromTexture(newTextureId, newWidth, newHeight, 
                     (si.hasAlphaChannel() && const_cast<QImage &>(si).data_ptr()->checkForAlphaPixels()));
         texture()->options &= ~QGLContext::InvertedYBindOption;
         softImage = si;
         QMeeGoPixmapData::registerSharedImage(handle, softImage);
     } else {
         qWarning("Failed to create a texture from a shared image!");
         glDeleteTextures(1, &newTextureId);
     }
 }

◆ fromImage()

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

virtual

Reimplemented from QGLPixmapData.

Definition at line 79 of file qmeegopixmapdata.cpp.

 {
     void *rawResource = static_cast <void *> (((QImage &) image).data_ptr()->data);
 
     if (sharedImagesMap.contains(rawResource)) {
         QMeeGoImageInfo *info = sharedImagesMap.value(rawResource);
         fromEGLSharedImage(info->handle, image);
     } else {
         // This should *never* happen since the graphics system should never
         // create a QMeeGoPixmapData for an origin that doesn't contain a raster
         // image we know about. But...
         qWarning("QMeeGoPixmapData::fromImage called on non-know resource. Falling back...");
         QGLPixmapData::fromImage(image, flags);
     }
 }

◆ fromTexture()

void QMeeGoPixmapData::fromTexture	(	GLuint	textureId,
		int	w,
		int	h,
		bool	alpha
	)

Definition at line 66 of file qmeegopixmapdata.cpp.

Referenced by fromEGLSharedImage().

 {
     resize(w, h); 
     texture()->id = textureId;
     m_hasAlpha = alpha;
     softImage = QImage();
 }

◆ imageToEGLSharedImage()

Qt::HANDLE QMeeGoPixmapData::imageToEGLSharedImage ( const QImage & image )

static

Definition at line 139 of file qmeegopixmapdata.cpp.

Referenced by qt_meego_image_to_egl_shared_image().

 {
     QGLShareContextScope ctx(qt_gl_share_widget()->context());
 
     QMeeGoExtensions::ensureInitialized();
 
     GLuint textureId;
 
     glGenTextures(1, &textureId);
     glBindTexture(GL_TEXTURE_2D, textureId);
     if (image.hasAlphaChannel() && const_cast<QImage &>(image).data_ptr()->checkForAlphaPixels()) {
         void *converted = convertBGRA32_to_RGBA32(image.bits(), image.width(), image.height(), image.bytesPerLine());
         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width(), image.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, converted);
         free(converted);
     } else {
         void *converted = convertRGB32_to_RGB565(image.bits(), image.width(), image.height(), image.bytesPerLine());
         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image.width(), image.height(), 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, converted);
         free(converted);
     }
 
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
     EGLImageKHR eglimage = QEgl::eglCreateImageKHR(QEgl::display(), QEglContext::currentContext(QEgl::OpenGL)->context(),
                                                                                                 EGL_GL_TEXTURE_2D_KHR,
                                                                                                 (EGLClientBuffer) textureId,
                                                                                                 preserved_image_attribs);
     glDeleteTextures(1, &textureId);
     if (eglimage) {
         EGLNativeSharedImageTypeNOK handle = QMeeGoExtensions::eglCreateSharedImageNOK(QEgl::display(), eglimage, NULL);
         QEgl::eglDestroyImageKHR(QEgl::display(), eglimage);
         return (Qt::HANDLE) handle;
     } else {
         qWarning("Failed to create shared image from pixmap/texture!");
         return 0;
     }
 }

◆ registerSharedImage()

void QMeeGoPixmapData::registerSharedImage	(	Qt::HANDLE	handle,
		const QImage &	si
	)

static

Definition at line 206 of file qmeegopixmapdata.cpp.

Referenced by fromEGLSharedImage(), and QMeeGoGraphicsSystem::pixmapDataFromEGLSharedImage().

 {
     void *raw = static_cast <void *> (((QImage) si).data_ptr()->data);
     QMeeGoImageInfo *info;
     
     if (! sharedImagesMap.contains(raw)) {
         info = new QMeeGoImageInfo;
         info->handle = handle;
         info->rawFormat = si.format();
         sharedImagesMap.insert(raw, info);
     } else {
         info = sharedImagesMap.value(raw);
         if (info->handle != handle || info->rawFormat != si.format())
             qWarning("Inconsistency detected: overwriting entry in sharedImagesMap but handle/format different");
     }
 }

◆ toImage()

QImage QMeeGoPixmapData::toImage ( ) const

virtual

Reimplemented from QGLPixmapData.

Definition at line 74 of file qmeegopixmapdata.cpp.

 {
     return softImage;
 }

◆ updateFromSoftImage()

void QMeeGoPixmapData::updateFromSoftImage ( )

virtual

Definition at line 180 of file qmeegopixmapdata.cpp.

Referenced by QMeeGoGraphicsSystem::updateEGLSharedImagePixmap().

 {
     // FIXME That's broken with recent 16bit textures changes.
     m_dirty = true;
     m_source = softImage;
     ensureCreated();
     
     if (softImage.width() != w || softImage.height() != h)
         qWarning("Ooops, looks like softImage changed dimensions since last updated! Corruption ahead?!");
 }

Properties

◆ sharedImagesMap

QHash< void *, QMeeGoImageInfo * > QMeeGoPixmapData::sharedImagesMap

static

Definition at line 67 of file qmeegopixmapdata.h.

Referenced by QMeeGoGraphicsSystem::createPixmapData(), destroyEGLSharedImage(), fromImage(), and registerSharedImage().

◆ softImage

QImage QMeeGoPixmapData::softImage

Definition at line 65 of file qmeegopixmapdata.h.

Referenced by fromEGLSharedImage(), fromTexture(), toImage(), and updateFromSoftImage().

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

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

Public Functions

Static Public Functions

Public Variables

Static Public Variables

Additional Inherited Members

Detailed Description

Constructors and Destructors

◆ QMeeGoPixmapData()

Functions

◆ createCompatiblePixmapData()

◆ destroyEGLSharedImage()

◆ fromEGLSharedImage()

◆ fromImage()

◆ fromTexture()

◆ imageToEGLSharedImage()

◆ registerSharedImage()

◆ toImage()

◆ updateFromSoftImage()

Properties

◆ sharedImagesMap

◆ softImage