QGLPixmapData Class Reference

#include <qpixmapdata_gl_p.h>

Inheritance diagram for QGLPixmapData:

Public Functions
GLuint	bind (bool copyBack=true) const
void	copy (const QPixmapData *data, const QRect &rect)
QPixmapData *	createCompatiblePixmapData () const
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)
bool	scroll (int dx, int dy, const QRect &rect)
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 ()

Private Functions
void	copyBackFromRenderFbo (bool keepCurrentFboBound) const
void	createPixmapForImage (QImage &image, Qt::ImageConversionFlags flags, bool inPlace)
	out-of-place conversion (inPlace == false) will always detach() More...
void	ensureCreated () const
QColor	fillColor () const
QImage	fillImage (const QColor &color) const
bool	isUninitialized () const
bool	isValid () const
bool	needsFill () const
QGLPixmapData &	operator= (const QGLPixmapData &other)
	QGLPixmapData (const QGLPixmapData &other)
QSize	size () const
bool	useFramebufferObjects () const

Properties
QGLContext *	m_ctx
bool	m_dirty
QPaintEngine *	m_engine
QColor	m_fillColor
QGLPixmapGLPaintDevice	m_glDevice
bool	m_hasAlpha
bool	m_hasFillColor
QGLFramebufferObject *	m_renderFbo
QImage	m_source
QGLTexture	m_texture

Friends
class	QGLPixmapGLPaintDevice
class	QMeeGoLivePixmapData
class	QMeeGoPixmapData

Additional Inherited Members
Public Types inherited from QPixmapData
enum	ClassId {   RasterClass, X11Class, MacClass, DirectFBClass,   OpenGLClass, OpenVGClass, RuntimeClass, BlitterClass,   CustomClass = 1024 }
enum	PixelType { PixmapType, BitmapType }
Static Public Functions inherited from QPixmapData
static QPixmapData *	create (int w, int h, PixelType type)
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 109 of file qpixmapdata_gl_p.h.

Constructors and Destructors

QGLPixmapData() [1/2]

QGLPixmapData::QGLPixmapData

(

PixelType

type

)

Definition at line 254 of file qpixmapdata_gl.cpp.

Referenced by createCompatiblePixmapData().

    : QPixmapData(type, OpenGLClass)
    , m_renderFbo(0)
    , m_engine(0)
    , m_ctx(0)
    , m_dirty(false)
    , m_hasFillColor(false)
    , m_hasAlpha(false)
{
    setSerialNumber(++qt_gl_pixmap_serial);
    m_glDevice.setPixmapData(this);
}

~QGLPixmapData()

QGLPixmapData::~QGLPixmapData

(

)

Definition at line 267 of file qpixmapdata_gl.cpp.

{
    const QGLContext *shareContext = qt_gl_share_context();
    if (!shareContext)
        return;

    delete m_engine;

    if (m_texture.id) {
        QGLShareContextScope ctx(shareContext);
        glDeleteTextures(1, &m_texture.id);
    }
}

QGLPixmapData() [2/2]

QGLPixmapData::QGLPixmapData ( const QGLPixmapData &  other )

private

Functions

bind()

GLuint QGLPixmapData::bind

(

bool

copyBack = true

)

const

Definition at line 764 of file qpixmapdata_gl.cpp.

{
    if (m_renderFbo && copyBack) {
        copyBackFromRenderFbo(true);
    } else {
        ensureCreated();
    }

    GLuint id = m_texture.id;
    glBindTexture(GL_TEXTURE_2D, id);

    if (m_hasFillColor) {
        if (!useFramebufferObjects()) {
            m_source = QImage(w, h, QImage::Format_ARGB32_Premultiplied);
            m_source.fill(PREMUL(m_fillColor.rgba()));
        }

        m_hasFillColor = false;

        GLenum format = qt_gl_preferredTextureFormat();
        QImage tx(w, h, QImage::Format_ARGB32_Premultiplied);
        tx.fill(qt_gl_convertToGLFormat(m_fillColor.rgba(), format));
        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, format, GL_UNSIGNED_BYTE, tx.bits());
    }

    return id;
}

copy()

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

virtual

Reimplemented from QPixmapData.

Definition at line 522 of file qpixmapdata_gl.cpp.

{
    if (data->classId() != QPixmapData::OpenGLClass || !static_cast<const QGLPixmapData *>(data)->useFramebufferObjects()) {
        QPixmapData::copy(data, rect);
        return;
    }

    const QGLPixmapData *other = static_cast<const QGLPixmapData *>(data);
    if (other->m_renderFbo) {
        QGLShareContextScope ctx(qt_gl_share_context());

        resize(rect.width(), rect.height());
        m_hasAlpha = other->m_hasAlpha;
        ensureCreated();

        if (!ctx->d_ptr->fbo)
            glGenFramebuffers(1, &ctx->d_ptr->fbo);

        glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, ctx->d_ptr->fbo);
        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
                GL_TEXTURE_2D, m_texture.id, 0);

        if (!other->m_renderFbo->isBound())
            glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, other->m_renderFbo->handle());

        glDisable(GL_SCISSOR_TEST);
        if (ctx->d_ptr->active_engine && ctx->d_ptr->active_engine->type() == QPaintEngine::OpenGL2)
            static_cast<QGL2PaintEngineEx *>(ctx->d_ptr->active_engine)->invalidateState();

        glBlitFramebufferEXT(rect.x(), rect.y(), rect.x() + rect.width(), rect.y() + rect.height(),
                0, 0, w, h,
                GL_COLOR_BUFFER_BIT,
                GL_NEAREST);

        glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->current_fbo);
    } else {
        QPixmapData::copy(data, rect);
    }
}

copyBackFromRenderFbo()

void QGLPixmapData::copyBackFromRenderFbo ( bool  keepCurrentFboBound ) const

private

Definition at line 668 of file qpixmapdata_gl.cpp.

Referenced by bind(), and toImage().

{
    if (!isValid())
        return;

    m_hasFillColor = false;

    const QGLContext *share_ctx = qt_gl_share_context();
    QGLShareContextScope ctx(share_ctx);

    ensureCreated();

    if (!ctx->d_ptr->fbo)
        glGenFramebuffers(1, &ctx->d_ptr->fbo);

    glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, ctx->d_ptr->fbo);
    glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
        GL_TEXTURE_2D, m_texture.id, 0);

    const int x0 = 0;
    const int x1 = w;
    const int y0 = 0;
    const int y1 = h;

    if (!m_renderFbo->isBound())
        glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, m_renderFbo->handle());

    glDisable(GL_SCISSOR_TEST);

    glBlitFramebufferEXT(x0, y0, x1, y1,
            x0, y0, x1, y1,
            GL_COLOR_BUFFER_BIT,
            GL_NEAREST);

    if (keepCurrentFboBound) {
        glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->current_fbo);
    } else {
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, m_renderFbo->handle());
        ctx->d_ptr->current_fbo = m_renderFbo->handle();
    }
}

createCompatiblePixmapData()

QPixmapData * QGLPixmapData::createCompatiblePixmapData ( ) const

virtual

Reimplemented from QPixmapData.

Reimplemented in QMeeGoLivePixmapData, and QMeeGoPixmapData.

Definition at line 281 of file qpixmapdata_gl.cpp.

{
    return new QGLPixmapData(pixelType());
}

createPixmapForImage()

void QGLPixmapData::createPixmapForImage ( QImage &  image, Qt::ImageConversionFlags  flags, bool  inPlace  )

private

out-of-place conversion (inPlace == false) will always detach()

Definition at line 467 of file qpixmapdata_gl.cpp.

Referenced by fromData(), fromFile(), fromImage(), and fromImageReader().

{
    if (image.size() == QSize(w, h))
        setSerialNumber(++qt_gl_pixmap_serial);

    resize(image.width(), image.height());

    if (pixelType() == BitmapType) {
        m_source = image.convertToFormat(QImage::Format_MonoLSB);

    } else {
        QImage::Format format = QImage::Format_RGB32;
        if (qApp->desktop()->depth() == 16)
            format = QImage::Format_RGB16;

        if (image.hasAlphaChannel()
            && ((flags & Qt::NoOpaqueDetection)
                || const_cast<QImage &>(image).data_ptr()->checkForAlphaPixels()))
            format = QImage::Format_ARGB32_Premultiplied;;

        if (inPlace && image.data_ptr()->convertInPlace(format, flags)) {
            m_source = image;
        } else {
            m_source = image.convertToFormat(format);

            // convertToFormat won't detach the image if format stays the same.
            if (image.format() == format)
                m_source.detach();
        }
    }

    m_dirty = true;
    m_hasFillColor = false;

    m_hasAlpha = m_source.hasAlphaChannel();
    w = image.width();
    h = image.height();
    is_null = (w <= 0 || h <= 0);
    d = m_source.depth();

    if (m_texture.id) {
        QGLShareContextScope ctx(qt_gl_share_context());
        glDeleteTextures(1, &m_texture.id);
        m_texture.id = 0;
    }
}

ensureCreated()

void QGLPixmapData::ensureCreated ( ) const

private

Definition at line 326 of file qpixmapdata_gl.cpp.

Referenced by bind(), copy(), copyBackFromRenderFbo(), toImage(), and QMeeGoPixmapData::updateFromSoftImage().

{
    if (!m_dirty)
        return;

    m_dirty = false;

    QGLShareContextScope ctx(qt_gl_share_context());
    m_ctx = ctx;

    const GLenum internal_format = m_hasAlpha ? GL_RGBA : GL_RGB;
#ifdef QT_OPENGL_ES_2
    const GLenum external_format = internal_format;
#else
    const GLenum external_format = qt_gl_preferredTextureFormat();
#endif
    const GLenum target = GL_TEXTURE_2D;

    if (!m_texture.id) {
        glGenTextures(1, &m_texture.id);
        glBindTexture(target, m_texture.id);
        glTexImage2D(target, 0, internal_format, w, h, 0, external_format, GL_UNSIGNED_BYTE, 0);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    }

    if (!m_source.isNull()) {
        if (external_format == GL_RGB) {
            const QImage tx = m_source.convertToFormat(QImage::Format_RGB888).mirrored(false, true);

            glBindTexture(target, m_texture.id);
            glTexSubImage2D(target, 0, 0, 0, w, h, external_format,
                            GL_UNSIGNED_BYTE, tx.bits());
        } else {
            const QImage tx = ctx->d_func()->convertToGLFormat(m_source, true, external_format);

            glBindTexture(target, m_texture.id);
            glTexSubImage2D(target, 0, 0, 0, w, h, external_format,
                            GL_UNSIGNED_BYTE, tx.bits());
        }

        if (useFramebufferObjects())
            m_source = QImage();
    }

    m_texture.options &= ~QGLContext::MemoryManagedBindOption;
}

fill()

void QGLPixmapData::fill ( const QColor &  color )

virtual

Implements QPixmapData.

Definition at line 562 of file qpixmapdata_gl.cpp.

{
    if (!isValid())
        return;

    bool hasAlpha = color.alpha() != 255;
    if (hasAlpha && !m_hasAlpha) {
        if (m_texture.id) {
            glDeleteTextures(1, &m_texture.id);
            m_texture.id = 0;
            m_dirty = true;
        }
        m_hasAlpha = color.alpha() != 255;
    }

    if (useFramebufferObjects()) {
        m_source = QImage();
        m_hasFillColor = true;
        m_fillColor = color;
    } else {

        if (m_source.isNull()) {
            m_fillColor = color;
            m_hasFillColor = true;

        } else if (m_source.depth() == 32) {
            m_source.fill(PREMUL(color.rgba()));

        } else if (m_source.depth() == 1) {
            if (color == Qt::color1)
                m_source.fill(1);
            else
                m_source.fill(0);
        }
    }
}

fillColor()

QColor QGLPixmapData::fillColor ( ) const

inlineprivate

Definition at line 175 of file qpixmapdata_gl_p.h.

{ return m_fillColor; }

fillImage()

QImage QGLPixmapData::fillImage ( const QColor &  color ) const

private

Definition at line 604 of file qpixmapdata_gl.cpp.

Referenced by toImage().

{
    QImage img;
    if (pixelType() == BitmapType) {
        img = QImage(w, h, QImage::Format_MonoLSB);

        img.setColorCount(2);
        img.setColor(0, QColor(Qt::color0).rgba());
        img.setColor(1, QColor(Qt::color1).rgba());

        if (color == Qt::color1)
            img.fill(1);
        else
            img.fill(0);
    } else {
        img = QImage(w, h,
                m_hasAlpha
                ? QImage::Format_ARGB32_Premultiplied
                : QImage::Format_RGB32);
        img.fill(PREMUL(color.rgba()));
    }
    return img;
}

fromData()

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

virtual

Reimplemented from QPixmapData.

Definition at line 431 of file qpixmapdata_gl.cpp.

{
    bool alpha;
    const char *buf = reinterpret_cast<const char *>(buffer);
    if (m_texture.canBindCompressedTexture(buf, int(len), format, &alpha)) {
        resize(0, 0);
        QGLShareContextScope ctx(qt_gl_share_context());
        QSize size = m_texture.bindCompressedTexture(buf, int(len), format);
        if (!size.isEmpty()) {
            w = size.width();
            h = size.height();
            is_null = false;
            d = 32;
            m_hasAlpha = alpha;
            m_source = QImage();
            m_dirty = isValid();
            return true;
        }
    }

    QByteArray a = QByteArray::fromRawData(reinterpret_cast<const char *>(buffer), len);
    QBuffer b(&a);
    b.open(QIODevice::ReadOnly);
    QImage image = QImageReader(&b, format).read();
    if (image.isNull())
        return false;

    createPixmapForImage(image, flags, true);

    return !isNull();
}

fromFile()

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

virtual

Reimplemented from QPixmapData.

Definition at line 391 of file qpixmapdata_gl.cpp.

{
    if (pixelType() == QPixmapData::BitmapType)
        return QPixmapData::fromFile(filename, format, flags);
    QFile file(filename);
    if (file.open(QIODevice::ReadOnly)) {
        QByteArray data = file.peek(64);
        bool alpha;
        if (m_texture.canBindCompressedTexture
                (data.constData(), data.size(), format, &alpha)) {
            resize(0, 0);
            data = file.readAll();
            file.close();
            QGLShareContextScope ctx(qt_gl_share_context());
            QSize size = m_texture.bindCompressedTexture
                (data.constData(), data.size(), format);
            if (!size.isEmpty()) {
                w = size.width();
                h = size.height();
                is_null = false;
                d = 32;
                m_hasAlpha = alpha;
                m_source = QImage();
                m_dirty = isValid();
                return true;
            }
            return false;
        }
    }

    QImage image = QImageReader(filename, format).read();
    if (image.isNull())
        return false;

    createPixmapForImage(image, flags, true);

    return !isNull();
}

fromImage()

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

virtual

Implements QPixmapData.

Reimplemented in QMeeGoPixmapData.

Definition at line 374 of file qpixmapdata_gl.cpp.

Referenced by QMeeGoPixmapData::fromImage().

{
    QImage img = image;
    createPixmapForImage(img, flags, false);
}

fromImageReader()

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

virtual

Reimplemented from QPixmapData.

Definition at line 381 of file qpixmapdata_gl.cpp.

{
    QImage image = imageReader->read();
    if (image.isNull())
        return;

    createPixmapForImage(image, flags, true);
}

glDevice()

QGLPaintDevice * QGLPixmapData::glDevice

(

)

const

Definition at line 827 of file qpixmapdata_gl.cpp.

{
    return &m_glDevice;
}

hasAlphaChannel()

bool QGLPixmapData::hasAlphaChannel ( ) const

virtual

Implements QPixmapData.

Definition at line 599 of file qpixmapdata_gl.cpp.

{
    return m_hasAlpha;
}

isUninitialized()

bool QGLPixmapData::isUninitialized ( ) const

inlineprivate

Definition at line 172 of file qpixmapdata_gl_p.h.

{ return m_dirty && m_source.isNull(); }

isValid()

bool QGLPixmapData::isValid ( ) const

private

Definition at line 286 of file qpixmapdata_gl.cpp.

Referenced by copyBackFromRenderFbo(), fill(), fromData(), fromFile(), paintEngine(), resize(), and toImage().

{
    return w > 0 && h > 0;
}

isValidContext()

bool QGLPixmapData::isValidContext

(

const QGLContext *

ctx

)

const

Definition at line 291 of file qpixmapdata_gl.cpp.

{
    if (ctx == m_ctx)
        return true;

    const QGLContext *share_ctx = qt_gl_share_context();
    return ctx == share_ctx || QGLContext::areSharing(ctx, share_ctx);
}

metric()

int QGLPixmapData::metric ( QPaintDevice::PaintDeviceMetric  metric ) const

virtual

Implements QPixmapData.

Definition at line 797 of file qpixmapdata_gl.cpp.

{
    if (w == 0)
        return 0;

    switch (metric) {
    case QPaintDevice::PdmWidth:
        return w;
    case QPaintDevice::PdmHeight:
        return h;
    case QPaintDevice::PdmNumColors:
        return 0;
    case QPaintDevice::PdmDepth:
        return d;
    case QPaintDevice::PdmWidthMM:
        return qRound(w * 25.4 / qt_defaultDpiX());
    case QPaintDevice::PdmHeightMM:
        return qRound(h * 25.4 / qt_defaultDpiY());
    case QPaintDevice::PdmDpiX:
    case QPaintDevice::PdmPhysicalDpiX:
        return qt_defaultDpiX();
    case QPaintDevice::PdmDpiY:
    case QPaintDevice::PdmPhysicalDpiY:
        return qt_defaultDpiY();
    default:
        qWarning("QGLPixmapData::metric(): Invalid metric");
        return 0;
    }
}

needsFill()

bool QGLPixmapData::needsFill ( ) const

inlineprivate

Definition at line 174 of file qpixmapdata_gl_p.h.

{ return m_hasFillColor; }

operator=()

QGLPixmapData& QGLPixmapData::operator= ( const QGLPixmapData &  other )

private

paintEngine()

QPaintEngine * QGLPixmapData::paintEngine ( ) const

virtual

Implements QPixmapData.

Definition at line 718 of file qpixmapdata_gl.cpp.

{
    if (!isValid())
        return 0;

    if (m_renderFbo)
        return m_engine;

    if (useFramebufferObjects()) {
        extern QGLWidget* qt_gl_share_widget();

        if (!QGLContext::currentContext())
            const_cast<QGLContext *>(qt_gl_share_context())->makeCurrent();
        QGLShareContextScope ctx(qt_gl_share_context());

        QGLFramebufferObjectFormat format;
        format.setAttachment(QGLFramebufferObject::CombinedDepthStencil);
        format.setSamples(4);
        format.setInternalTextureFormat(GLenum(m_hasAlpha ? GL_RGBA : GL_RGB));

        m_renderFbo = qgl_fbo_pool()->acquire(size(), format);

        if (m_renderFbo) {
            if (!m_engine)
                m_engine = new QGL2PaintEngineEx;
            return m_engine;
        }

        qWarning() << "Failed to create pixmap texture buffer of size " << size() << ", falling back to raster paint engine";
    }

    m_dirty = true;
    if (m_source.size() != size())
        m_source = QImage(size(), QImage::Format_ARGB32_Premultiplied);
    if (m_hasFillColor) {
        m_source.fill(PREMUL(m_fillColor.rgba()));
        m_hasFillColor = false;
    }
    return m_source.paintEngine();
}

resize()

void QGLPixmapData::resize ( int  width, int  height  )

virtual

Implements QPixmapData.

Definition at line 300 of file qpixmapdata_gl.cpp.

Referenced by copy(), createPixmapForImage(), fromData(), fromFile(), QMeeGoPixmapData::fromTexture(), QMeeGoLivePixmapData::initializeThroughEGLImage(), and QMeeGoGraphicsSystem::pixmapDataWithGLTexture().

{
    if (width == w && height == h)
        return;

    if (width <= 0 || height <= 0) {
        width = 0;
        height = 0;
    }

    w = width;
    h = height;
    is_null = (w <= 0 || h <= 0);
    d = pixelType() == QPixmapData::PixmapType ? 32 : 1;

    if (m_texture.id) {
        QGLShareContextScope ctx(qt_gl_share_context());
        glDeleteTextures(1, &m_texture.id);
        m_texture.id = 0;
    }

    m_source = QImage();
    m_dirty = isValid();
    setSerialNumber(++qt_gl_pixmap_serial);
}

scroll()

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

virtual

Reimplemented from QPixmapData.

Reimplemented in QMeeGoLivePixmapData.

Definition at line 514 of file qpixmapdata_gl.cpp.

{
    Q_UNUSED(dx);
    Q_UNUSED(dy);
    Q_UNUSED(rect);
    return false;
}

size()

QSize QGLPixmapData::size ( ) const

inlineprivate

Definition at line 183 of file qpixmapdata_gl_p.h.

Referenced by fillImage(), fromData(), fromFile(), and paintEngine().

{ return QSize(w, h); }

texture()

QGLTexture * QGLPixmapData::texture

(

)

const

Definition at line 792 of file qpixmapdata_gl.cpp.

Referenced by QMeeGoPixmapData::fromEGLSharedImage(), QMeeGoPixmapData::fromTexture(), QMeeGoLivePixmapData::initializeThroughEGLImage(), and QMeeGoLivePixmapData::invalidateSurfaces().

{
    return &m_texture;
}

toImage()

QImage QGLPixmapData::toImage ( ) const

virtual

Implements QPixmapData.

Reimplemented in QMeeGoPixmapData.

Definition at line 630 of file qpixmapdata_gl.cpp.

{
    if (!isValid())
        return QImage();

    if (m_renderFbo) {
        copyBackFromRenderFbo(true);
    } else if (!m_source.isNull()) {
        QImageData *data = const_cast<QImage &>(m_source).data_ptr();
        if (data->paintEngine && data->paintEngine->isActive()
            && data->paintEngine->paintDevice() == &m_source)
        {
            return m_source.copy();
        }
        return m_source;
    } else if (m_dirty || m_hasFillColor) {
        return fillImage(m_fillColor);
    } else {
        ensureCreated();
    }

    QGLShareContextScope ctx(qt_gl_share_context());
    glBindTexture(GL_TEXTURE_2D, m_texture.id);
    return qt_gl_read_texture(QSize(w, h), true, true);
}

useFramebufferObjects()

bool QGLPixmapData::useFramebufferObjects ( ) const

private

Definition at line 710 of file qpixmapdata_gl.cpp.

Referenced by bind(), copy(), ensureCreated(), fill(), and paintEngine().

{
    return QGLFramebufferObject::hasOpenGLFramebufferObjects()
           && QGLFramebufferObject::hasOpenGLFramebufferBlit()
           && qt_gl_preferGL2Engine()
           && (w * h > 32*32); // avoid overhead of FBOs for small pixmaps
}

Friends and Related Functions

QGLPixmapGLPaintDevice

friend class QGLPixmapGLPaintDevice

friend

Definition at line 219 of file qpixmapdata_gl_p.h.

QMeeGoLivePixmapData

friend class QMeeGoLivePixmapData

friend

Definition at line 221 of file qpixmapdata_gl_p.h.

QMeeGoPixmapData

friend class QMeeGoPixmapData

friend

Definition at line 220 of file qpixmapdata_gl_p.h.

Properties

m_ctx

QGLContext* QGLPixmapData::m_ctx

mutableprivate

Definition at line 193 of file qpixmapdata_gl_p.h.

Referenced by ensureCreated(), and isValidContext().

m_dirty

bool QGLPixmapData::m_dirty

mutableprivate

Definition at line 208 of file qpixmapdata_gl_p.h.

Referenced by createPixmapForImage(), ensureCreated(), fill(), fromData(), fromFile(), paintEngine(), resize(), toImage(), and QMeeGoPixmapData::updateFromSoftImage().

m_engine

QPaintEngine* QGLPixmapData::m_engine

mutableprivate

Definition at line 192 of file qpixmapdata_gl_p.h.

Referenced by paintEngine(), and ~QGLPixmapData().

m_fillColor

QColor QGLPixmapData::m_fillColor

mutableprivate

Definition at line 212 of file qpixmapdata_gl_p.h.

Referenced by bind(), fill(), paintEngine(), and toImage().

m_glDevice

QGLPixmapGLPaintDevice QGLPixmapData::m_glDevice

mutableprivate

Definition at line 217 of file qpixmapdata_gl_p.h.

Referenced by glDevice(), and QGLPixmapData().

m_hasAlpha

bool QGLPixmapData::m_hasAlpha

mutableprivate

Definition at line 215 of file qpixmapdata_gl_p.h.

Referenced by copy(), createPixmapForImage(), ensureCreated(), fill(), fillImage(), fromData(), fromFile(), QMeeGoPixmapData::fromTexture(), hasAlphaChannel(), QMeeGoLivePixmapData::initializeThroughEGLImage(), and paintEngine().

m_hasFillColor

bool QGLPixmapData::m_hasFillColor

mutableprivate

Definition at line 213 of file qpixmapdata_gl_p.h.

Referenced by bind(), copyBackFromRenderFbo(), createPixmapForImage(), fill(), paintEngine(), and toImage().

m_renderFbo

QGLFramebufferObject* QGLPixmapData::m_renderFbo

mutableprivate

Definition at line 191 of file qpixmapdata_gl_p.h.

Referenced by bind(), copy(), copyBackFromRenderFbo(), paintEngine(), and toImage().

m_source

QImage QGLPixmapData::m_source

mutableprivate

Definition at line 203 of file qpixmapdata_gl_p.h.

Referenced by bind(), createPixmapForImage(), ensureCreated(), fill(), fromData(), fromFile(), paintEngine(), resize(), toImage(), and QMeeGoPixmapData::updateFromSoftImage().

m_texture

QGLTexture QGLPixmapData::m_texture

mutableprivate

Definition at line 205 of file qpixmapdata_gl_p.h.

Referenced by bind(), copy(), copyBackFromRenderFbo(), createPixmapForImage(), ensureCreated(), fill(), fromData(), fromFile(), resize(), texture(), toImage(), and ~QGLPixmapData().

---

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

• /src/opengl/qpixmapdata_gl_p.h
• /src/opengl/qpixmapdata_gl.cpp