QGL2PaintEngineEx Class Reference

#include <qpaintengineex_opengl2_p.h>

Inheritance diagram for QGL2PaintEngineEx:

Public Functions
bool	begin (QPaintDevice *device)
	Reimplement this function to initialise your paint engine when painting is to start on the paint device pdev. More...
void	beginNativePainting ()
virtual void	brushChanged ()
virtual void	brushOriginChanged ()
virtual void	clip (const QVectorPath &path, Qt::ClipOperation op)
virtual void	clipEnabledChanged ()
virtual void	compositionModeChanged ()
virtual QPainterState *	createState (QPainterState *orig) const
virtual void	drawImage (const QRectF &r, const QImage &pm, const QRectF &sr, Qt::ImageConversionFlags flags=Qt::AutoColor)
	Reimplement this function to draw the part of the image specified by the sr rectangle in the given rectangle using the given conversion flags flags, to convert it to a pixmap. More...
virtual void	drawPixmap (const QRectF &r, const QPixmap &pm, const QRectF &sr)
	Reimplement this function to draw the part of the pm specified by the sr rectangle in the given r. More...
virtual void	drawPixmapFragments (const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap, QPainter::PixmapFragmentHints hints)
virtual void	drawPixmapFragments (const QRectF *targetRects, const QRectF *sourceRects, int fragmentCount, const QPixmap &pixmap, QPainter::PixmapFragmentHints hints)
virtual void	drawStaticTextItem (QStaticTextItem *textItem)
virtual void	drawTextItem (const QPointF &p, const QTextItem &textItem)
	This function draws the text item textItem at position p. More...
bool	drawTexture (const QRectF &r, GLuint textureId, const QSize &size, const QRectF &sr)
bool	end ()
	Reimplement this function to finish painting on the current paint device. More...
void	endNativePainting ()
void	ensureActive ()
virtual void	fill (const QVectorPath &path, const QBrush &brush)
void	invalidateState ()
bool	isNativePaintingActive () const
virtual void	opacityChanged ()
virtual void	penChanged ()
QPixmapFilter *	pixmapFilter (int type, const QPixmapFilter *prototype)
	QGL2PaintEngineEx ()
virtual void	renderHintsChanged ()
void	setRenderTextActive (bool)
virtual void	setState (QPainterState *s)
QOpenGL2PaintEngineState *	state ()
const QOpenGL2PaintEngineState *	state () const
virtual void	stroke (const QVectorPath &path, const QPen &pen)
bool	supportsTransformations (qreal, const QTransform &) const
virtual void	transformChanged ()
Type	type () const
	Reimplement this function to return the paint engine Type. More...
	~QGL2PaintEngineEx ()
Public Functions inherited from QPaintEngineEx
virtual void	clip (const QRect &rect, Qt::ClipOperation op)
virtual void	clip (const QRegion &region, Qt::ClipOperation op)
virtual void	clip (const QPainterPath &path, Qt::ClipOperation op)
virtual void	draw (const QVectorPath &path)
virtual void	drawEllipse (const QRectF &r)
	Reimplement this function to draw the largest ellipse that can be contained within rectangle rect. More...
virtual void	drawEllipse (const QRect &r)
	The default implementation of this function calls the floating point version of this function. More...
virtual void	drawImage (const QPointF &pos, const QImage &image)
virtual void	drawLines (const QLine *lines, int lineCount)
	The default implementation converts the first lineCount lines in lines to a QLineF and calls the floating point version of this function. More...
virtual void	drawLines (const QLineF *lines, int lineCount)
	The default implementation splits the list of lines in lines into lineCount separate calls to drawPath() or drawPolygon() depending on the feature set of the paint engine. More...
virtual void	drawPath (const QPainterPath &path)
	The default implementation ignores the path and does nothing. More...
virtual void	drawPixmap (const QPointF &pos, const QPixmap &pm)
virtual void	drawPoints (const QPointF *points, int pointCount)
	Draws the first pointCount points in the buffer points. More...
virtual void	drawPoints (const QPoint *points, int pointCount)
	Draws the first pointCount points in the buffer points. More...
virtual void	drawPolygon (const QPointF *points, int pointCount, PolygonDrawMode mode)
	Reimplement this virtual function to draw the polygon defined by the pointCount first points in points, using mode mode. More...
virtual void	drawPolygon (const QPoint *points, int pointCount, PolygonDrawMode mode)
	Reimplement this virtual function to draw the polygon defined by the pointCount first points in points, using mode mode. More...
virtual void	drawRects (const QRect *rects, int rectCount)
	The default implementation converts the first rectCount rectangles in the buffer rects to a QRectF and calls the floating point version of this function. More...
virtual void	drawRects (const QRectF *rects, int rectCount)
	Draws the first rectCount rectangles in the buffer rects. More...
virtual void	drawRoundedRect (const QRectF &rect, qreal xrad, qreal yrad, Qt::SizeMode mode)
virtual void	drawTiledPixmap (const QRectF &r, const QPixmap &pixmap, const QPointF &s)
	Reimplement this function to draw the pixmap in the given rect, starting at the given p. More...
virtual void	fillRect (const QRectF &rect, const QBrush &brush)
virtual void	fillRect (const QRectF &rect, const QColor &color)
virtual uint	flags () const
	QPaintEngineEx ()
QPainterState *	state ()
const QPainterState *	state () const
virtual void	sync ()
virtual void	updateState (const QPaintEngineState &state)
	Reimplement this function to update the state of a paint engine. More...
Public Functions inherited from QPaintEngine
void	clearDirty (DirtyFlags df)
virtual QPoint	coordinateOffset () const
	Returns the offset from the painters origo to the engines origo. More...
void	fix_neg_rect (int *x, int *y, int *w, int *h)
virtual HDC	getDC () const
	Empty default implementation. More...
bool	hasFeature (PaintEngineFeatures feature) const
	Returns true if the paint engine supports the specified feature; otherwise returns false. More...
bool	isActive () const
	Returns true if the paint engine is actively drawing; otherwise returns false. More...
bool	isExtended () const
	Returns true if the paint engine is a QPaintEngineEx derivative. More...
QPaintDevice *	paintDevice () const
	Returns the device that this engine is painting on, if painting is active; otherwise returns 0. More...
QPainter *	painter () const
	Returns the paint engine's painter. More...
	QPaintEngine (PaintEngineFeatures features=0)
	Creates a paint engine with the featureset specified by caps. More...
virtual void	releaseDC (HDC hdc) const
	Empty default implementation. More...
void	setActive (bool newState)
	Sets the active state of the paint engine to state. More...
void	setDirty (DirtyFlags df)
void	setPaintDevice (QPaintDevice *device)
void	setSystemClip (const QRegion &baseClip)
	Sets the system clip for this engine. More...
void	setSystemRect (const QRect &rect)
	Sets the target rect for drawing within the backing store. More...
void	syncState ()
	Updates all dirty states in this engine. More...
QRegion	systemClip () const
	Returns the system clip. More...
QRect	systemRect () const
	Retrieves the rect for drawing within the backing store. More...
bool	testDirty (DirtyFlags df)
virtual	~QPaintEngine ()
	Destroys the paint engine. More...

Additional Inherited Members
Public Types inherited from QPaintEngineEx
enum	Flags { DoNotEmulate = 0x01, IsEmulationEngine = 0x02 }
Public Types inherited from QPaintEngine
enum	DirtyFlag {   DirtyPen = 0x0001, DirtyBrush = 0x0002, DirtyBrushOrigin = 0x0004, DirtyFont = 0x0008,   DirtyBackground = 0x0010, DirtyBackgroundMode = 0x0020, DirtyTransform = 0x0040, DirtyClipRegion = 0x0080,   DirtyClipPath = 0x0100, DirtyHints = 0x0200, DirtyCompositionMode = 0x0400, DirtyClipEnabled = 0x0800,   DirtyOpacity = 0x1000, AllDirty = 0xffff }
	QPaintEngine::updateState(). More...
enum	PaintEngineFeature {   PrimitiveTransform = 0x00000001, PatternTransform = 0x00000002, PixmapTransform = 0x00000004, PatternBrush = 0x00000008,   LinearGradientFill = 0x00000010, RadialGradientFill = 0x00000020, ConicalGradientFill = 0x00000040, AlphaBlend = 0x00000080,   PorterDuff = 0x00000100, PainterPaths = 0x00000200, Antialiasing = 0x00000400, BrushStroke = 0x00000800,   ConstantOpacity = 0x00001000, MaskedBrush = 0x00002000, PerspectiveTransform = 0x00004000, BlendModes = 0x00008000,   ObjectBoundingModeGradients = 0x00010000, RasterOpModes = 0x00020000, PaintOutsidePaintEvent = 0x20000000, AllFeatures = 0xffffffff }
	This enum is used to describe the features or capabilities that the paint engine has. More...
enum	PolygonDrawMode { OddEvenMode, WindingMode, ConvexMode, PolylineMode }
enum	Type {   X11, Windows, QuickDraw, CoreGraphics,   MacPrinter, QWindowSystem, PostScript, OpenGL,   Picture, SVG, Raster, Direct3D,   Pdf, OpenVG, OpenGL2, PaintBuffer,   Blitter, User = 50, MaxUser = 100 }
Protected Functions inherited from QPaintEngineEx
	QPaintEngineEx (QPaintEngineExPrivate &data)
Protected Functions inherited from QPaintEngine
	QPaintEngine (QPaintEnginePrivate &data, PaintEngineFeatures devcaps=0)
Protected Variables inherited from QPaintEngine
uint	active: 1
QScopedPointer< QPaintEnginePrivate >	d_ptr
uint	extended: 1
PaintEngineFeatures	gccaps
uint	selfDestruct: 1
QPaintEngineState *	state

Detailed Description

Definition at line 107 of file qpaintengineex_opengl2_p.h.

Constructors and Destructors

QGL2PaintEngineEx()

QGL2PaintEngineEx::QGL2PaintEngineEx

(

)

Definition at line 1198 of file qpaintengineex_opengl2.cpp.

    : QPaintEngineEx(*(new QGL2PaintEngineExPrivate(this)))
{
}

~QGL2PaintEngineEx()

QGL2PaintEngineEx::~QGL2PaintEngineEx

(

)

Definition at line 1203 of file qpaintengineex_opengl2.cpp.

{
}

Functions

begin()

bool QGL2PaintEngineEx::begin ( QPaintDevice *  pdev )

virtual

Reimplement this function to initialise your paint engine when painting is to start on the paint device pdev.

Return true if the initialization was successful; otherwise return false.

See also

end() isActive()

Implements QPaintEngine.

Definition at line 2099 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);

//     qDebug("QGL2PaintEngineEx::begin()");
    if (pdev->devType() == QInternal::OpenGL)
        d->device = static_cast<QGLPaintDevice*>(pdev);
    else
        d->device = QGLPaintDevice::getDevice(pdev);

    if (!d->device)
        return false;

    d->ctx = d->device->context();
#ifdef Q_OS_SYMBIAN
    if (!d->ctx)
        return false;
#endif
    d->ctx->d_ptr->active_engine = this;

    const QSize sz = d->device->size();
    d->width = sz.width();
    d->height = sz.height();
    d->mode = BrushDrawingMode;
    d->imageDrawingMode = false;
    d->brushTextureDirty = true;
    d->brushUniformsDirty = true;
    d->matrixUniformDirty = true;
    d->matrixDirty = true;
    d->compositionModeDirty = true;
    d->opacityUniformDirty = true;
    d->needsSync = true;
    d->useSystemClip = !systemClip().isEmpty();
    d->currentBrush = QBrush();

    d->dirtyStencilRegion = QRect(0, 0, d->width, d->height);
    d->stencilClean = true;

    // Calling begin paint should make the correct context current. So, any
    // code which calls into GL or otherwise needs a current context *must*
    // go after beginPaint:
    d->device->beginPaint();

#if !defined(QT_OPENGL_ES_2)
    QGLExtensionMatcher extensions;
    d->hasCompatibilityExtension = extensions.match("GL_ARB_compatibility");

    bool success = qt_resolve_version_2_0_functions(d->ctx)
                   && qt_resolve_buffer_extensions(d->ctx)
                   && (!QGLFramebufferObject::hasOpenGLFramebufferObjects()
                       || qt_resolve_framebufferobject_extensions(d->ctx));
    Q_ASSERT(success);
    Q_UNUSED(success);
#endif

    d->shaderManager = new QGLEngineShaderManager(d->ctx);

    glDisable(GL_STENCIL_TEST);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_SCISSOR_TEST);

#if !defined(QT_OPENGL_ES_2)
    glDisable(GL_MULTISAMPLE);
#endif

    d->glyphCacheType = QFontEngineGlyphCache::Raster_A8;

#if !defined(QT_OPENGL_ES_2)
#if defined(Q_WS_WIN)
    if (qt_cleartype_enabled
        && (fontSmoothingApproximately(1.0) || fontSmoothingApproximately(2.1)))
#endif
#if defined(Q_WS_MAC)
    if (qt_applefontsmoothing_enabled)
#endif
        d->glyphCacheType = QFontEngineGlyphCache::Raster_RGBMask;
#endif

#if defined(QT_OPENGL_ES_2)
    // OpenGL ES can't switch MSAA off, so if the gl paint device is
    // multisampled, it's always multisampled.
    d->multisamplingAlwaysEnabled = d->device->format().sampleBuffers();
#else
    d->multisamplingAlwaysEnabled = false;
#endif

    return true;
}

beginNativePainting()

void QGL2PaintEngineEx::beginNativePainting ( )

virtual

Reimplemented from QPaintEngineEx.

Definition at line 553 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);
    ensureActive();
    d->transferMode(BrushDrawingMode);

    d->nativePaintingActive = true;

    QGLContext *ctx = d->ctx;
    glUseProgram(0);

    // Disable all the vertex attribute arrays:
    for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i)
        glDisableVertexAttribArray(i);

#ifndef QT_OPENGL_ES_2
    const QGLFormat &fmt = d->device->format();
    if (fmt.majorVersion() < 3 || (fmt.majorVersion() == 3 && fmt.minorVersion() < 1)
        || (fmt.majorVersion() == 3 && fmt.minorVersion() == 1 && d->hasCompatibilityExtension)
        || fmt.profile() == QGLFormat::CompatibilityProfile)
    {
        // be nice to people who mix OpenGL 1.x code with QPainter commands
        // by setting modelview and projection matrices to mirror the GL 1
        // paint engine
        const QTransform& mtx = state()->matrix;

        float mv_matrix[4][4] =
        {
            { float(mtx.m11()), float(mtx.m12()),     0, float(mtx.m13()) },
            { float(mtx.m21()), float(mtx.m22()),     0, float(mtx.m23()) },
            {                0,                0,     1,                0 },
            {  float(mtx.dx()),  float(mtx.dy()),     0, float(mtx.m33()) }
        };

        const QSize sz = d->device->size();

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho(0, sz.width(), sz.height(), 0, -999999, 999999);

        glMatrixMode(GL_MODELVIEW);
        glLoadMatrixf(&mv_matrix[0][0]);
    }
#else
    Q_UNUSED(ctx);
#endif

    d->lastTextureUsed = GLuint(-1);
    d->dirtyStencilRegion = QRect(0, 0, d->width, d->height);
    d->resetGLState();

    d->shaderManager->setDirty();

    d->needsSync = true;
}

brushChanged()

void QGL2PaintEngineEx::brushChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 1321 of file qpaintengineex_opengl2.cpp.

{ }

brushOriginChanged()

void QGL2PaintEngineEx::brushOriginChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 1322 of file qpaintengineex_opengl2.cpp.

{ }

clip()

void QGL2PaintEngineEx::clip ( const QVectorPath &  path, Qt::ClipOperation  op  )

virtual

Implements QPaintEngineEx.

Definition at line 2403 of file qpaintengineex_opengl2.cpp.

Referenced by QGL2PaintEngineExPrivate::stroke().

{
//     qDebug("QGL2PaintEngineEx::clip()");
    Q_D(QGL2PaintEngineEx);

    state()->clipChanged = true;

    ensureActive();

    if (op == Qt::ReplaceClip) {
        op = Qt::IntersectClip;
        if (d->hasClipOperations()) {
            d->systemStateChanged();
            state()->canRestoreClip = false;
        }
    }

#ifndef QT_GL_NO_SCISSOR_TEST
    if (!path.isEmpty() && op == Qt::IntersectClip && (path.shape() == QVectorPath::RectangleHint)) {
        const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
        QRectF rect(points[0], points[2]);

        if (state()->matrix.type() <= QTransform::TxScale
            || (state()->matrix.type() == QTransform::TxRotate
                && qFuzzyIsNull(state()->matrix.m11())
                && qFuzzyIsNull(state()->matrix.m22())))
        {
            state()->rectangleClip = state()->rectangleClip.intersected(state()->matrix.mapRect(rect).toRect());
            d->updateClipScissorTest();
            return;
        }
    }
#endif

    const QRect pathRect = state()->matrix.mapRect(path.controlPointRect()).toAlignedRect();

    switch (op) {
    case Qt::NoClip:
        if (d->useSystemClip) {
            state()->clipTestEnabled = true;
            state()->currentClip = 1;
        } else {
            state()->clipTestEnabled = false;
        }
        state()->rectangleClip = QRect(0, 0, d->width, d->height);
        state()->canRestoreClip = false;
        d->updateClipScissorTest();
        break;
    case Qt::IntersectClip:
        state()->rectangleClip = state()->rectangleClip.intersected(pathRect);
        d->updateClipScissorTest();
        d->resetClipIfNeeded();
        ++d->maxClip;
        d->writeClip(path, d->maxClip);
        state()->currentClip = d->maxClip;
        state()->clipTestEnabled = true;
        break;
    case Qt::UniteClip: {
        d->resetClipIfNeeded();
        ++d->maxClip;
        if (state()->rectangleClip.isValid()) {
            QPainterPath path;
            path.addRect(state()->rectangleClip);

            // flush the existing clip rectangle to the depth buffer
            d->writeClip(qtVectorPathForPath(state()->matrix.inverted().map(path)), d->maxClip);
        }

        state()->clipTestEnabled = false;
#ifndef QT_GL_NO_SCISSOR_TEST
        QRect oldRectangleClip = state()->rectangleClip;

        state()->rectangleClip = state()->rectangleClip.united(pathRect);
        d->updateClipScissorTest();

        QRegion extendRegion = QRegion(state()->rectangleClip) - oldRectangleClip;

        if (!extendRegion.isEmpty()) {
            QPainterPath extendPath;
            extendPath.addRegion(extendRegion);

            // first clear the depth buffer in the extended region
            d->writeClip(qtVectorPathForPath(state()->matrix.inverted().map(extendPath)), 0);
        }
#endif
        // now write the clip path
        d->writeClip(path, d->maxClip);
        state()->canRestoreClip = false;
        state()->currentClip = d->maxClip;
        state()->clipTestEnabled = true;
        break;
        }
    default:
        break;
    }
}

clipEnabledChanged()

void QGL2PaintEngineEx::clipEnabledChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 2305 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);

    state()->clipChanged = true;

    if (painter()->hasClipping())
        d->regenerateClip();
    else
        d->systemStateChanged();
}

compositionModeChanged()

void QGL2PaintEngineEx::compositionModeChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 1335 of file qpaintengineex_opengl2.cpp.

{
//     qDebug("QGL2PaintEngineEx::compositionModeChanged()");
    Q_D(QGL2PaintEngineEx);
    state()->compositionModeChanged = true;
    d->compositionModeDirty = true;
}

createState()

QPainterState * QGL2PaintEngineEx::createState ( QPainterState *  orig ) const

virtual

Reimplemented from QPaintEngineEx.

Definition at line 2597 of file qpaintengineex_opengl2.cpp.

{
    if (orig)
        const_cast<QGL2PaintEngineEx *>(this)->ensureActive();

    QOpenGL2PaintEngineState *s;
    if (!orig)
        s = new QOpenGL2PaintEngineState();
    else
        s = new QOpenGL2PaintEngineState(*static_cast<QOpenGL2PaintEngineState *>(orig));

    s->matrixChanged = false;
    s->compositionModeChanged = false;
    s->opacityChanged = false;
    s->renderHintsChanged = false;
    s->clipChanged = false;

    return s;
}

drawImage()

void QGL2PaintEngineEx::drawImage ( const QRectF &  r, const QImage &  pm, const QRectF &  sr, Qt::ImageConversionFlags  flags = Qt::AutoColor  )

virtual

Reimplement this function to draw the part of the image specified by the sr rectangle in the given rectangle using the given conversion flags flags, to convert it to a pixmap.

Implements QPaintEngineEx.

Definition at line 1411 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);
    QGLContext *ctx = d->ctx;

    int max_texture_size = ctx->d_func()->maxTextureSize();
    if (image.width() > max_texture_size || image.height() > max_texture_size) {
        QImage scaled = image.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);

        const qreal sx = scaled.width() / qreal(image.width());
        const qreal sy = scaled.height() / qreal(image.height());

        drawImage(dest, scaled, scaleRect(src, sx, sy));
        return;
    }

    ensureActive();
    d->transferMode(ImageDrawingMode);

    glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);

    QGLTexture *texture = ctx->d_func()->bindTexture(image, GL_TEXTURE_2D, GL_RGBA, QGLContext::InternalBindOption);
    GLuint id = texture->id;

    d->updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
                           state()->renderHints & QPainter::SmoothPixmapTransform, id);
    d->drawTexture(dest, src, image.size(), !image.hasAlphaChannel());
}

drawPixmap()

void QGL2PaintEngineEx::drawPixmap ( const QRectF &  r, const QPixmap &  pm, const QRectF &  sr  )

virtual

Reimplement this function to draw the part of the pm specified by the sr rectangle in the given r.

Implements QPaintEngineEx.

Definition at line 1374 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);
    QGLContext *ctx = d->ctx;

    int max_texture_size = ctx->d_func()->maxTextureSize();
    if (pixmap.width() > max_texture_size || pixmap.height() > max_texture_size) {
        QPixmap scaled = pixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);

        const qreal sx = scaled.width() / qreal(pixmap.width());
        const qreal sy = scaled.height() / qreal(pixmap.height());

        drawPixmap(dest, scaled, scaleRect(src, sx, sy));
        return;
    }

    ensureActive();
    d->transferMode(ImageDrawingMode);

    glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
    QGLTexture *texture =
        ctx->d_func()->bindTexture(pixmap, GL_TEXTURE_2D, GL_RGBA,
                                    QGLContext::InternalBindOption
                                    | QGLContext::CanFlipNativePixmapBindOption);

    GLfloat top = texture->options & QGLContext::InvertedYBindOption ? (pixmap.height() - src.top()) : src.top();
    GLfloat bottom = texture->options & QGLContext::InvertedYBindOption ? (pixmap.height() - src.bottom()) : src.bottom();
    QGLRect srcRect(src.left(), top, src.right(), bottom);

    bool isBitmap = pixmap.isQBitmap();
    bool isOpaque = !isBitmap && !pixmap.hasAlpha();

    d->updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
                           state()->renderHints & QPainter::SmoothPixmapTransform, texture->id);
    d->drawTexture(dest, srcRect, pixmap.size(), isOpaque, isBitmap);
}

drawPixmapFragments() [1/2]

void QGL2PaintEngineEx::drawPixmapFragments ( const QPainter::PixmapFragment *  fragments, int  fragmentCount, const QPixmap &  pixmap, QPainter::PixmapFragmentHints  hints  )

virtual

Reimplemented from QPaintEngineEx.

Definition at line 1895 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);
    // Use fallback for extended composition modes.
    if (state()->composition_mode > QPainter::CompositionMode_Plus) {
        QPaintEngineEx::drawPixmapFragments(fragments, fragmentCount, pixmap, hints);
        return;
    }

    QSize size = pixmap.size();

    ensureActive();
    int max_texture_size = d->ctx->d_func()->maxTextureSize();
    if (size.width() > max_texture_size || size.height() > max_texture_size) {
        QPixmap scaled = pixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
        d->drawPixmapFragments(fragments, fragmentCount, scaled, size, hints);
    } else {
        d->drawPixmapFragments(fragments, fragmentCount, pixmap, size, hints);
    }
}

drawPixmapFragments() [2/2]

void QGL2PaintEngineEx::drawPixmapFragments ( const QRectF *  targetRects, const QRectF *  sourceRects, int  fragmentCount, const QPixmap &  pixmap, QPainter::PixmapFragmentHints  hints  )

virtual

Reimplemented from QPaintEngineEx.

Definition at line 1917 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);
    // Use fallback for extended composition modes.
    if (state()->composition_mode > QPainter::CompositionMode_Plus) {
        QPaintEngineEx::drawPixmapFragments(targetRects, sourceRects, fragmentCount, pixmap, hints);
        return;
    }

    QSize size = pixmap.size();

    ensureActive();
    int max_texture_size = d->ctx->d_func()->maxTextureSize();
    if (size.width() > max_texture_size || size.height() > max_texture_size) {
        QPixmap scaled = pixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
        d->drawPixmapFragments(targetRects, sourceRects, fragmentCount, scaled, size, hints);
    } else {
        d->drawPixmapFragments(targetRects, sourceRects, fragmentCount, pixmap, size, hints);
    }
}

drawStaticTextItem()

void QGL2PaintEngineEx::drawStaticTextItem ( QStaticTextItem *  textItem )

virtual

Reimplemented from QPaintEngineEx.

Definition at line 1441 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);

    ensureActive();

    QPainterState *s = state();
    float det = s->matrix.determinant();

    // don't try to cache huge fonts or vastly transformed fonts
    QFontEngine *fontEngine = textItem->fontEngine();
    const qreal pixelSize = fontEngine->fontDef.pixelSize;
    if (pixelSize * pixelSize * qAbs(det) < QT_MAX_CACHED_GLYPH_SIZE * QT_MAX_CACHED_GLYPH_SIZE && det >= 0.25f && det <= 4.f) {
        QFontEngineGlyphCache::Type glyphType = fontEngine->glyphFormat >= 0
                                                ? QFontEngineGlyphCache::Type(textItem->fontEngine()->glyphFormat)
                                                : d->glyphCacheType;
        if (glyphType == QFontEngineGlyphCache::Raster_RGBMask) {
            if (!QGLFramebufferObject::hasOpenGLFramebufferObjects()
                || d->device->alphaRequested() || s->matrix.type() > QTransform::TxTranslate
                || (s->composition_mode != QPainter::CompositionMode_Source
                && s->composition_mode != QPainter::CompositionMode_SourceOver))
            {
                glyphType = QFontEngineGlyphCache::Raster_A8;
            }
        }

        d->drawCachedGlyphs(glyphType, textItem);
    } else {
        QPaintEngineEx::drawStaticTextItem(textItem);
    }
}

drawTextItem()

void QGL2PaintEngineEx::drawTextItem ( const QPointF &  p, const QTextItem &  textItem  )

virtual

This function draws the text item textItem at position p.

The default implementation of this function converts the text to a QPainterPath and paints the resulting path.

Reimplemented from QPaintEngine.

Definition at line 1496 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);

    ensureActive();
    QOpenGL2PaintEngineState *s = state();

    const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);

    QTransform::TransformationType txtype = s->matrix.type();

    float det = s->matrix.determinant();
    bool drawCached = txtype < QTransform::TxProject;

    // don't try to cache huge fonts or vastly transformed fonts
    const qreal pixelSize = ti.fontEngine->fontDef.pixelSize;
    if (pixelSize * pixelSize * qAbs(det) >= QT_MAX_CACHED_GLYPH_SIZE * QT_MAX_CACHED_GLYPH_SIZE ||
        det < 0.25f || det > 4.f)
        drawCached = false;

    QFontEngineGlyphCache::Type glyphType = ti.fontEngine->glyphFormat >= 0
                                            ? QFontEngineGlyphCache::Type(ti.fontEngine->glyphFormat)
                                            : d->glyphCacheType;


    if (glyphType == QFontEngineGlyphCache::Raster_RGBMask) {
        if (!QGLFramebufferObject::hasOpenGLFramebufferObjects()
            || d->device->alphaRequested() || txtype > QTransform::TxTranslate
            || (state()->composition_mode != QPainter::CompositionMode_Source
            && state()->composition_mode != QPainter::CompositionMode_SourceOver))
        {
            glyphType = QFontEngineGlyphCache::Raster_A8;
        }
    }

    if (drawCached) {
        QVarLengthArray<QFixedPoint> positions;
        QVarLengthArray<glyph_t> glyphs;
        QTransform matrix = QTransform::fromTranslate(p.x(), p.y());
        ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);

        {
            QStaticTextItem staticTextItem;
            staticTextItem.chars = const_cast<QChar *>(ti.chars);
            staticTextItem.setFontEngine(ti.fontEngine);
            staticTextItem.glyphs = glyphs.data();
            staticTextItem.numChars = ti.num_chars;
            staticTextItem.numGlyphs = glyphs.size();
            staticTextItem.glyphPositions = positions.data();

            d->drawCachedGlyphs(glyphType, &staticTextItem);
        }
        return;
    }

    QPaintEngineEx::drawTextItem(p, ti);
}

drawTexture()

bool QGL2PaintEngineEx::drawTexture	(	const QRectF &	r,
		GLuint	textureId,
		const QSize &	size,
		const QRectF &	sr
	)

Definition at line 1473 of file qpaintengineex_opengl2.cpp.

Referenced by QGLPixmapDropShadowFilter::processGL().

{
    Q_D(QGL2PaintEngineEx);
    if (!d->shaderManager)
        return false;

    ensureActive();
    d->transferMode(ImageDrawingMode);

#ifndef QT_OPENGL_ES_2
    QGLContext *ctx = d->ctx;
#endif
    glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
    glBindTexture(GL_TEXTURE_2D, textureId);

    QGLRect srcRect(src.left(), src.bottom(), src.right(), src.top());

    d->updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
                           state()->renderHints & QPainter::SmoothPixmapTransform, textureId);
    d->drawTexture(dest, srcRect, size, false);
    return true;
}

end()

bool QGL2PaintEngineEx::end ( )

virtual

Reimplement this function to finish painting on the current paint device.

Return true if painting was finished successfully; otherwise return false.

See also

begin() isActive()

Implements QPaintEngine.

Definition at line 2188 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);
    QGLContext *ctx = d->ctx;

    glUseProgram(0);
    d->transferMode(BrushDrawingMode);
    d->device->endPaint();

#if defined(Q_WS_X11)
    // On some (probably all) drivers, deleting an X pixmap which has been bound to a texture
    // before calling glFinish/swapBuffers renders garbage. Presumably this is because X deletes
    // the pixmap behind the driver's back before it's had a chance to use it. To fix this, we
    // reference all QPixmaps which have been bound to stop them being deleted and only deref
    // them here, after swapBuffers, where they can be safely deleted.
    ctx->d_func()->boundPixmaps.clear();
#endif
    d->ctx->d_ptr->active_engine = 0;

    d->resetGLState();

    delete d->shaderManager;
    d->shaderManager = 0;
    d->currentBrush = QBrush();

#ifdef QT_OPENGL_CACHE_AS_VBOS
    if (!d->unusedVBOSToClean.isEmpty()) {
        glDeleteBuffers(d->unusedVBOSToClean.size(), d->unusedVBOSToClean.constData());
        d->unusedVBOSToClean.clear();
    }
    if (!d->unusedIBOSToClean.isEmpty()) {
        glDeleteBuffers(d->unusedIBOSToClean.size(), d->unusedIBOSToClean.constData());
        d->unusedIBOSToClean.clear();
    }
#endif

    return false;
}

endNativePainting()

void QGL2PaintEngineEx::endNativePainting ( )

virtual

Reimplemented from QPaintEngineEx.

Definition at line 632 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);
    d->needsSync = true;
    d->nativePaintingActive = false;
}

ensureActive()

void QGL2PaintEngineEx::ensureActive

(

)

Definition at line 2227 of file qpaintengineex_opengl2.cpp.

Referenced by clip(), createState(), drawImage(), drawPixmap(), drawPixmapFragments(), drawStaticTextItem(), drawTextItem(), drawTexture(), fill(), and stroke().

{
    Q_D(QGL2PaintEngineEx);
    QGLContext *ctx = d->ctx;

    if (isActive() && ctx->d_ptr->active_engine != this) {
        ctx->d_ptr->active_engine = this;
        d->needsSync = true;
    }

    d->device->ensureActiveTarget();

    if (d->needsSync) {
        d->transferMode(BrushDrawingMode);
        glViewport(0, 0, d->width, d->height);
        d->needsSync = false;
        d->lastMaskTextureUsed = 0;
        d->shaderManager->setDirty();
        d->ctx->d_func()->syncGlState();
        for (int i = 0; i < 3; ++i)
            d->vertexAttribPointers[i] = (GLfloat*)-1; // Assume the pointers are clobbered
        setState(state());
    }
}

fill()

void QGL2PaintEngineEx::fill ( const QVectorPath &  path, const QBrush &  brush  )

virtual

Implements QPaintEngineEx.

Definition at line 1207 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);

    if (qbrush_style(brush) == Qt::NoBrush)
        return;
    ensureActive();
    d->setBrush(brush);
    d->fill(path);
}

invalidateState()

void QGL2PaintEngineEx::invalidateState

(

)

Definition at line 639 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);
    d->needsSync = true;
}

isNativePaintingActive()

bool QGL2PaintEngineEx::isNativePaintingActive

(

)

const

Definition at line 645 of file qpaintengineex_opengl2.cpp.

                                                     {
    Q_D(const QGL2PaintEngineEx);
    return d->nativePaintingActive;
}

opacityChanged()

void QGL2PaintEngineEx::opacityChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 1324 of file qpaintengineex_opengl2.cpp.

{
//    qDebug("QGL2PaintEngineEx::opacityChanged()");
    Q_D(QGL2PaintEngineEx);
    state()->opacityChanged = true;

    Q_ASSERT(d->shaderManager);
    d->brushUniformsDirty = true;
    d->opacityUniformDirty = true;
}

penChanged()

void QGL2PaintEngineEx::penChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 1320 of file qpaintengineex_opengl2.cpp.

{ }

pixmapFilter()

QPixmapFilter * QGL2PaintEngineEx::pixmapFilter ( int  type, const QPixmapFilter *  prototype  )

virtual

Reimplemented from QPaintEngineEx.

Definition at line 130 of file qglpixmapfilter.cpp.

{
    Q_D(QGL2PaintEngineEx);
    switch (type) {
    case QPixmapFilter::ColorizeFilter:
        if (!d->colorizeFilter)
            d->colorizeFilter.reset(new QGLPixmapColorizeFilter);
        return d->colorizeFilter.data();

    case QPixmapFilter::BlurFilter: {
        if (!d->blurFilter)
            d->blurFilter.reset(new QGLPixmapBlurFilter());
        return d->blurFilter.data();
        }

    case QPixmapFilter::DropShadowFilter: {
        if (!d->dropShadowFilter)
            d->dropShadowFilter.reset(new QGLPixmapDropShadowFilter());
        return d->dropShadowFilter.data();
        }

    case QPixmapFilter::ConvolutionFilter:
        if (!d->convolutionFilter)
            d->convolutionFilter.reset(new QGLPixmapConvolutionFilter);
        return d->convolutionFilter.data();

    default: break;
    }
    return QPaintEngineEx::pixmapFilter(type, prototype);
}

renderHintsChanged()

void QGL2PaintEngineEx::renderHintsChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 1343 of file qpaintengineex_opengl2.cpp.

Referenced by setState().

{
    state()->renderHintsChanged = true;

#if !defined(QT_OPENGL_ES_2)
    if ((state()->renderHints & QPainter::Antialiasing)
        || (state()->renderHints & QPainter::HighQualityAntialiasing))
        glEnable(GL_MULTISAMPLE);
    else
        glDisable(GL_MULTISAMPLE);
#endif

    Q_D(QGL2PaintEngineEx);
    d->lastTextureUsed = GLuint(-1);
    d->brushTextureDirty = true;
//    qDebug("QGL2PaintEngineEx::renderHintsChanged() not implemented!");
}

setRenderTextActive()

void QGL2PaintEngineEx::setRenderTextActive

(

bool

)

setState()

void QGL2PaintEngineEx::setState ( QPainterState *  s )

virtual

Reimplemented from QPaintEngineEx.

Definition at line 2554 of file qpaintengineex_opengl2.cpp.

Referenced by ensureActive().

{
    //     qDebug("QGL2PaintEngineEx::setState()");

    Q_D(QGL2PaintEngineEx);

    QOpenGL2PaintEngineState *s = static_cast<QOpenGL2PaintEngineState *>(new_state);
    QOpenGL2PaintEngineState *old_state = state();

    QPaintEngineEx::setState(s);

    if (s->isNew) {
        // Newly created state object.  The call to setState()
        // will either be followed by a call to begin(), or we are
        // setting the state as part of a save().
        s->isNew = false;
        return;
    }

    // Setting the state as part of a restore().

    if (old_state == s || old_state->renderHintsChanged)
        renderHintsChanged();

    if (old_state == s || old_state->matrixChanged)
        d->matrixDirty = true;

    if (old_state == s || old_state->compositionModeChanged)
        d->compositionModeDirty = true;

    if (old_state == s || old_state->opacityChanged)
        d->opacityUniformDirty = true;

    if (old_state == s || old_state->clipChanged) {
        if (old_state && old_state != s && old_state->canRestoreClip) {
            d->updateClipScissorTest();
            glDepthFunc(GL_LEQUAL);
        } else {
            d->regenerateClip();
        }
    }
}

state() [1/2]

QOpenGL2PaintEngineState* QGL2PaintEngineEx::state ( )

inline

Definition at line 147 of file qpaintengineex_opengl2_p.h.

Referenced by clip(), clipEnabledChanged(), compositionModeChanged(), drawImage(), drawPixmap(), drawPixmapFragments(), drawStaticTextItem(), drawTextItem(), drawTexture(), QGL2PaintEngineExPrivate::drawTexture(), ensureActive(), QGL2PaintEngineExPrivate::fill(), QGL2PaintEngineExPrivate::fillStencilWithVertexArray(), opacityChanged(), QGL2PaintEngineExPrivate::prepareForDraw(), renderHintsChanged(), QGL2PaintEngineExPrivate::resetClipIfNeeded(), setState(), stroke(), transformChanged(), QGL2PaintEngineExPrivate::updateBrushTexture(), QGL2PaintEngineExPrivate::updateBrushUniforms(), QGL2PaintEngineExPrivate::updateCompositionMode(), and QGL2PaintEngineExPrivate::updateMatrix().

                                             {
        return static_cast<QOpenGL2PaintEngineState *>(QPaintEngineEx::state());
    }

state() [2/2]

const QOpenGL2PaintEngineState* QGL2PaintEngineEx::state ( ) const

inline

Definition at line 150 of file qpaintengineex_opengl2_p.h.

                                                         {
        return static_cast<const QOpenGL2PaintEngineState *>(QPaintEngineEx::state());
    }

stroke()

void QGL2PaintEngineEx::stroke ( const QVectorPath &  path, const QPen &  pen  )

virtual

Reimplemented from QPaintEngineEx.

Definition at line 1221 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);

    const QBrush &penBrush = qpen_brush(pen);
    if (qpen_style(pen) == Qt::NoPen || qbrush_style(penBrush) == Qt::NoBrush)
        return;

    QOpenGL2PaintEngineState *s = state();
    if (pen.isCosmetic() && !qt_scaleForTransform(s->transform(), 0)) {
        // QTriangulatingStroker class is not meant to support cosmetically sheared strokes.
        QPaintEngineEx::stroke(path, pen);
        return;
    }

    ensureActive();
    d->setBrush(penBrush);
    d->stroke(path, pen);
}

supportsTransformations()

bool QGL2PaintEngineEx::supportsTransformations ( qreal  , const QTransform &    ) const

inlinevirtual

Reimplemented from QPaintEngineEx.

Definition at line 164 of file qpaintengineex_opengl2_p.h.

{ return true; }

transformChanged()

void QGL2PaintEngineEx::transformChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 1361 of file qpaintengineex_opengl2.cpp.

{
    Q_D(QGL2PaintEngineEx);
    d->matrixDirty = true;
    state()->matrixChanged = true;
}

type()

Type QGL2PaintEngineEx::type ( ) const

inlinevirtual

Reimplement this function to return the paint engine Type.

Implements QPaintEngine.

Definition at line 143 of file qpaintengineex_opengl2_p.h.

{ return OpenGL2; }

---

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

• /src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
• /src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
• /src/opengl/qglpixmapfilter.cpp