#include <qpaintengine_opengl_p.h>

Inheritance diagram for QOpenGLPaintEngine:

Public Functions
bool	begin (QPaintDevice *pdev)
	Reimplement this function to initialise your paint engine when painting is to start on the paint device pdev. More...

void	brushChanged ()

void	brushOriginChanged ()

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

void	clipEnabledChanged ()

void	compositionModeChanged ()

QPainterState *	createState (QPainterState *orig) const

void	drawEllipse (const QRectF &rect)
	Reimplement this function to draw the largest ellipse that can be contained within rectangle rect. More...

void	drawImage (const QRectF &r, const QImage &image, const QRectF &sr, Qt::ImageConversionFlags conversionFlags)
	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...

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

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

void	drawPath (const QPainterPath &path)
	The default implementation ignores the path and does nothing. More...

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

void	drawPoints (const QPointF *p, int pointCount)
	Draws the first pointCount points in the buffer points. More...

void	drawPoints (const QPoint *p, int pointCount)
	Draws the first pointCount points in the buffer points. More...

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

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

void	drawRects (const QRectF *r, int rectCount)
	Draws the first rectCount rectangles in the buffer rects. More...

void	drawRects (const QRect *r, 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...

void	drawStaticTextItem (QStaticTextItem *staticTextItem)

void	drawTextItem (const QPointF &p, const QTextItem &ti)
	This function draws the text item textItem at position p. More...

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

bool	end ()
	Reimplement this function to finish painting on the current paint device. More...

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

HDC	handle () const

void	opacityChanged ()

void	penChanged ()

	QOpenGLPaintEngine ()

void	renderHintsChanged ()

void	setState (QPainterState *s)

QOpenGLPaintEngineState *	state ()

const QOpenGLPaintEngineState *	state () const

bool	supportsTransformations (qreal, const QTransform &) const

void	transformChanged ()

Type	type () const
	Reimplement this function to return the paint engine Type. More...

void	updateBrush (const QBrush &brush, const QPointF &pt)

void	updateClipRegion (const QRegion &region, Qt::ClipOperation op)

void	updateCompositionMode (QPainter::CompositionMode composition_mode)

void	updateFont (const QFont &font)

void	updateMatrix (const QTransform &matrix)

void	updatePen (const QPen &pen)

void	updateRenderHints (QPainter::RenderHints hints)

void	updateState (const QPaintEngineState &state)
	Reimplement this function to update the state of a paint engine. More...

	~QOpenGLPaintEngine ()

Public Functions inherited from QPaintEngineEx
virtual void	beginNativePainting ()

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 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	drawPixmap (const QPointF &pos, const QPixmap &pm)

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	drawRoundedRect (const QRectF &rect, qreal xrad, qreal yrad, Qt::SizeMode mode)

virtual void	endNativePainting ()

virtual void	fillRect (const QRectF &rect, const QBrush &brush)

virtual void	fillRect (const QRectF &rect, const QColor &color)

virtual uint	flags () const

virtual QPixmapFilter *	pixmapFilter (int, const QPixmapFilter *)

	QPaintEngineEx ()

QPainterState *	state ()

const QPainterState *	state () const

virtual void	stroke (const QVectorPath &path, const QPen &pen)

virtual void	sync ()

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

Private Functions
void	drawPolyInternal (const QPolygonF &pa, bool close=true)

void	drawTextureRect (int tx_width, int tx_height, const QRectF &r, const QRectF &sr, GLenum target, QGLTexture *tex)

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 76 of file qpaintengine_opengl_p.h.

Constructors and Destructors

◆ QOpenGLPaintEngine()

QOpenGLPaintEngine::QOpenGLPaintEngine ( )

Definition at line 1235 of file qpaintengine_opengl.cpp.

     : QPaintEngineEx(*(new QOpenGLPaintEnginePrivate))
 {
 }

◆ ~QOpenGLPaintEngine()

QOpenGLPaintEngine::~QOpenGLPaintEngine ( )

Definition at line 1240 of file qpaintengine_opengl.cpp.

1241 {

1242 }

Functions

◆ begin()

bool QOpenGLPaintEngine::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 1244 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
 
     if (pdev->devType() == QInternal::OpenGL)
         d->device = static_cast<QGLPaintDevice*>(pdev);
     else
         d->device = QGLPaintDevice::getDevice(pdev);
 
     if (!d->device)
         return false;
 
     d->offscreen.setDevice(pdev);
     d->has_fast_pen = false;
     d->inverseScale = 1;
     d->opacity = 1;
     d->device->beginPaint();
     d->matrix = QTransform();
     d->has_antialiasing = false;
     d->high_quality_antialiasing = false;
 
     QSize sz(d->device->size());
     d->dirty_stencil = QRect(0, 0, sz.width(), sz.height());
 
     d->use_emulation = false;
 
     for (int i = 0; i < 4; ++i)
         for (int j = 0; j < 4; ++j)
             d->mv_matrix[i][j] = (i == j ? qreal(1) : qreal(0));
 
     bool has_frag_program = (QGLExtensions::glExtensions() & QGLExtensions::FragmentProgram)
                             && (pdev->devType() != QInternal::Pixmap);
 
     QGLContext *ctx = const_cast<QGLContext *>(d->device->context());
     if (!ctx) {
         qWarning() << "QOpenGLPaintEngine: paint device doesn't have a valid GL context.";
         return false;
     }
 
     if (has_frag_program)
         has_frag_program = qt_resolve_frag_program_extensions(ctx) && qt_resolve_version_1_3_functions(ctx);
 
     d->use_stencil_method = d->device->format().stencil()
                             && (QGLExtensions::glExtensions() & QGLExtensions::StencilWrap);
     if (d->device->format().directRendering()
         && (d->use_stencil_method && QGLExtensions::glExtensions() & QGLExtensions::StencilTwoSide))
         d->has_stencil_face_ext = qt_resolve_stencil_face_extension(ctx);
 
 #ifdef Q_WS_X11
     static bool nvidia_workaround_needs_init = true;
     if (nvidia_workaround_needs_init) {
         // nvidia 9x.xx unix drivers contain a bug which requires us to
         // call glFinish before releasing an fbo to avoid painting
         // artifacts
         const QByteArray versionString(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
         const int pos = versionString.indexOf("NVIDIA");
         if (pos >= 0) {
             const float nvidiaDriverVersion = versionString.mid(pos + strlen("NVIDIA")).toFloat();
             qt_nvidiaFboNeedsFinish = nvidiaDriverVersion >= 90.0 && nvidiaDriverVersion < 100.0;
         }
         nvidia_workaround_needs_init = false;
     }
 #endif
 
 #ifndef QT_OPENGL_ES
     if (!ctx->d_ptr->internal_context) {
         glGetDoublev(GL_PROJECTION_MATRIX, &d->projection_matrix[0][0]);
         glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
         glPushAttrib(GL_ALL_ATTRIB_BITS);
 
         glDisableClientState(GL_EDGE_FLAG_ARRAY);
         glDisableClientState(GL_INDEX_ARRAY);
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
         glDisable(GL_TEXTURE_1D);
         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
         glPixelTransferi(GL_MAP_COLOR, false);
         glPixelTransferi(GL_MAP_STENCIL, false);
         glDisable(GL_TEXTURE_GEN_S);
 
         glPixelStorei(GL_PACK_SWAP_BYTES, false);
         glPixelStorei(GL_PACK_LSB_FIRST, false);
         glPixelStorei(GL_PACK_ROW_LENGTH, 0);
         glPixelStorei(GL_PACK_SKIP_ROWS, 0);
         glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
         glPixelStorei(GL_PACK_ALIGNMENT, 4);
 
         glPixelStorei(GL_UNPACK_SWAP_BYTES, false);
         glPixelStorei(GL_UNPACK_LSB_FIRST, false);
         glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
         glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
         glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
         glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
 
         if (QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2) {
             glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0);
             glPixelStorei(GL_PACK_SKIP_IMAGES, 0);
             glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
             glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0);
         }
     }
 #endif
 
     if (!ctx->d_ptr->internal_context) {
         glMatrixMode(GL_MODELVIEW);
         glPushMatrix();
         glMatrixMode(GL_TEXTURE);
         glPushMatrix();
         glLoadIdentity();
         glDisableClientState(GL_COLOR_ARRAY);
         glDisableClientState(GL_NORMAL_ARRAY);
         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
         glDisableClientState(GL_VERTEX_ARRAY);
 
         if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
             glDisable(GL_MULTISAMPLE);
         glDisable(GL_TEXTURE_2D);
         if (QGLExtensions::glExtensions() & QGLExtensions::TextureRectangle)
             glDisable(GL_TEXTURE_RECTANGLE_NV);
         glDisable(GL_STENCIL_TEST);
         glDisable(GL_CULL_FACE);
         glDisable(GL_LIGHTING);
         glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     }
 
     d->offscreen.begin();
 
     glViewport(0, 0, sz.width(), sz.height()); // XXX (Embedded): We need a solution for GLWidgets that draw in a part or a bigger surface...
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
 #ifdef QT_OPENGL_ES
     glOrthof(0, sz.width(), sz.height(), 0, -999999, 999999);
 #else
     glOrtho(0, sz.width(), sz.height(), 0, -999999, 999999);
 #endif
     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
     glEnable(GL_BLEND);
     d->composition_mode = QPainter::CompositionMode_SourceOver;
 
 #ifdef QT_OPENGL_ES
     d->max_texture_size = ctx->d_func()->maxTextureSize();
 #else
     bool shared_ctx = QGLContext::areSharing(d->device->context(), d->shader_ctx);
 
     if (shared_ctx) {
         d->max_texture_size = d->shader_ctx->d_func()->maxTextureSize();
     } else {
         d->max_texture_size = ctx->d_func()->maxTextureSize();
 
         if (d->shader_ctx) {
             d->shader_ctx->makeCurrent();
             glBindTexture(GL_TEXTURE_1D, 0);
             glDeleteTextures(1, &d->grad_palette);
 
             if (has_frag_program && d->use_fragment_programs)
                 glDeleteTextures(1, &d->drawable_texture);
             ctx->makeCurrent();
         }
         d->shader_ctx = d->device->context();
         glGenTextures(1, &d->grad_palette);
 
         qt_mask_texture_cache()->clearCache();
         d->use_fragment_programs = has_frag_program;
     }
 
     if (d->use_fragment_programs && (!shared_ctx || sz.width() > d->drawable_texture_size.width()
                                      || sz.height() > d->drawable_texture_size.height()))
     {
         // delete old texture if size has increased, otherwise it was deleted earlier
         if (shared_ctx)
             glDeleteTextures(1, &d->drawable_texture);
 
         d->dirty_drawable_texture = true;
         d->drawable_texture_size = QSize(qt_next_power_of_two(sz.width()),
                                          qt_next_power_of_two(sz.height()));
     }
 #endif
 
     updateClipRegion(QRegion(), Qt::NoClip);
     penChanged();
     brushChanged();
     opacityChanged();
     compositionModeChanged();
     renderHintsChanged();
     transformChanged();
     return true;
 }

◆ brushChanged()

void QOpenGLPaintEngine::brushChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 5419 of file qpaintengine_opengl.cpp.

Referenced by begin().

 {
     updateBrush(state()->brush, state()->brushOrigin);
 }

◆ brushOriginChanged()

void QOpenGLPaintEngine::brushOriginChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 5424 of file qpaintengine_opengl.cpp.

 {
     updateBrush(state()->brush, state()->brushOrigin);
 }

◆ clip()

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

virtual

Implements QPaintEngineEx.

Definition at line 5501 of file qpaintengine_opengl.cpp.

 {
     const qreal *points = path.points();
     const QPainterPath::ElementType *types = path.elements();
     if (!types && path.shape() == QVectorPath::RectangleHint) {
         QRectF r(points[0], points[1], points[4]-points[0], points[5]-points[1]);
         updateClipRegion(QRegion(r.toRect()), op);
         return;
     }
 
     QPainterPath p;
     if (types) {
         int id = 0;
         for (int i=0; i<path.elementCount(); ++i) {
             switch(types[i]) {
             case QPainterPath::MoveToElement:
                 p.moveTo(QPointF(points[id], points[id+1]));
                 id+=2;
                 break;
             case QPainterPath::LineToElement:
                 p.lineTo(QPointF(points[id], points[id+1]));
                 id+=2;
                 break;
             case QPainterPath::CurveToElement: {
                 QPointF p1(points[id], points[id+1]);
                 QPointF p2(points[id+2], points[id+3]);
                 QPointF p3(points[id+4], points[id+5]);
                 p.cubicTo(p1, p2, p3);
                 id+=6;
                 break;
             }
             case QPainterPath::CurveToDataElement:
                 ;
                 break;
             }
         }
     } else if (!path.isEmpty()) {
         p.moveTo(QPointF(points[0], points[1]));
         int id = 2;
         for (int i=1; i<path.elementCount(); ++i) {
             p.lineTo(QPointF(points[id], points[id+1]));
             id+=2;
         }
     }
     if (path.hints() & QVectorPath::WindingFill)
         p.setFillRule(Qt::WindingFill);
 
     updateClipRegion(QRegion(p.toFillPolygon().toPolygon(), p.fillRule()), op);
     return;
 }

◆ clipEnabledChanged()

void QOpenGLPaintEngine::clipEnabledChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 5407 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
 
     d->updateDepthClip();
 }

◆ compositionModeChanged()

void QOpenGLPaintEngine::compositionModeChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 5438 of file qpaintengine_opengl.cpp.

Referenced by begin().

 {
     updateCompositionMode(state()->composition_mode);
 }

◆ createState()

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

virtual

Reimplemented from QPaintEngineEx.

Definition at line 5578 of file qpaintengine_opengl.cpp.

 {
     const Q_D(QOpenGLPaintEngine);
 
     QOpenGLPaintEngineState *s;
     if (!orig)
         s = new QOpenGLPaintEngineState();
     else
         s = new QOpenGLPaintEngineState(*static_cast<QOpenGLPaintEngineState *>(orig));
 
     d->last_created_state = s;
     return s;
 }

◆ drawEllipse()

void QOpenGLPaintEngine::drawEllipse ( const QRectF & rect )

virtual

Reimplement this function to draw the largest ellipse that can be contained within rectangle rect.

The default implementation calls drawPolygon().

Reimplemented from QPaintEngineEx.

Definition at line 5025 of file qpaintengine_opengl.cpp.

 {
 #ifndef Q_WS_QWS
     Q_D(QOpenGLPaintEngine);
 
     if (d->use_emulation) {
         QPaintEngineEx::drawEllipse(rect);
         return;
     }
 
     if (d->high_quality_antialiasing) {
         if (d->has_brush) {
             d->disableClipping();
 
             glMatrixMode(GL_MODELVIEW);
             glPushMatrix();
             glLoadIdentity();
 
             GLuint program = qt_gl_program_cache()->getProgram(d->device->context(),
                                                                FRAGMENT_PROGRAM_MASK_ELLIPSE_AA, 0, true);
             QGLEllipseMaskGenerator maskGenerator(rect,
                                                   d->matrix,
                                                   d->offscreen,
                                                   program,
                                                   mask_variable_locations[FRAGMENT_PROGRAM_MASK_ELLIPSE_AA]);
 
             d->addItem(qt_mask_texture_cache()->getMask(maskGenerator, d));
 
             d->enableClipping();
 
             glMatrixMode(GL_MODELVIEW);
             glPopMatrix();
         }
 
         if (d->has_pen) {
             QPainterPath path;
             path.addEllipse(rect);
 
             d->strokePath(path, false);
         }
     } else {
         DEBUG_ONCE_STR("QOpenGLPaintEngine::drawEllipse(): falling back to drawPath()");
 
         QPainterPath path;
         path.addEllipse(rect);
         drawPath(path);
     }
 #else
     QPaintEngineEx::drawEllipse(rect);
 #endif
 }

◆ drawImage()

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

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 4427 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
 
     const int sz = d->max_texture_size;
     if (image.width() > sz || image.height() > sz) {
         QRectF subsr;
         const QImage sub = qSubImage(image, sr, &subsr);
 
         if (sub.width() <= sz && sub.height() <= sz) {
             drawImage(r, sub, subsr, 0);
         } else {
             const QImage scaled = sub.scaled(sz, sz, Qt::KeepAspectRatio);
             const qreal sx = scaled.width() / qreal(sub.width());
             const qreal sy = scaled.height() / qreal(sub.height());
 
             drawImage(r, scaled, scaleRect(subsr, sx, sy), 0);
         }
         return;
     }
 
     if (d->composition_mode > QPainter::CompositionMode_Plus || (d->high_quality_antialiasing && !d->isFastRect(r)))
         d->drawImageAsPath(r, image, sr);
     else {
         GLenum target = qt_gl_preferredTextureTarget();
         d->flushDrawQueue();
         QGLTexture *tex =
             d->device->context()->d_func()->bindTexture(image, target, GL_RGBA,
                                                         QGLContext::InternalBindOption);
         drawTextureRect(image.width(), image.height(), r, sr, target, tex);
     }
 }

◆ drawLines() [1/2]

void QOpenGLPaintEngine::drawLines	(	const QLineF *	lines,
		int	lineCount
	)

virtual

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.

Reimplemented from QPaintEngineEx.

Definition at line 3697 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
 
     if (d->use_emulation) {
         QPaintEngineEx::drawLines(lines, lineCount);
         return;
     }
 
     if (d->has_pen) {
         QOpenGLCoordinateOffset offset(d);
         if (d->has_fast_pen && !d->high_quality_antialiasing) {
             //### gradient resolving on lines isn't correct
             d->setGradientOps(d->cpen.brush(), QRectF());
 
             bool useRects = false;
             // scale or 90 degree rotation?
             if (d->matrix.type() <= QTransform::TxTranslate
                 || (!d->cpen.isCosmetic()
                     && (d->matrix.type() <= QTransform::TxScale
                         || (d->matrix.type() == QTransform::TxRotate
                             && d->matrix.m11() == 0 && d->matrix.m22() == 0)))) {
                 useRects = true;
                 for (int i = 0; i < lineCount; ++i) {
                     if (lines[i].p1().x() != lines[i].p2().x()
                         && lines[i].p1().y() != lines[i].p2().y()) {
                         useRects = false;
                         break;
                     }
                 }
             }
 
             GLfloat endCap = d->cpen.capStyle() == Qt::FlatCap ? 0.0f : 0.5f;
             if (useRects) {
                 QVarLengthArray<GLfloat> vertexArray(12 * lineCount);
 
                 GLfloat quad[8];
                 for (int i = 0; i < lineCount; ++i) {
                     GLfloat x1 = lines[i].x1();
                     GLfloat x2 = lines[i].x2();
                     GLfloat y1 = lines[i].y1();
                     GLfloat y2 = lines[i].y2();
 
                     if (x1 == x2) {
                         if (y1 > y2)
                             qSwap(y1, y2);
 
                         quad[0] = x1 - 0.5f;
                         quad[1] = y1 - endCap;
 
                         quad[2] = x1 + 0.5f;
                         quad[3] = y1 - endCap;
 
                         quad[4] = x1 + 0.5f;
                         quad[5] = y2 + endCap;
 
                         quad[6] = x1 - 0.5f;
                         quad[7] = y2 + endCap;
                     } else {
                         if (x1 > x2)
                             qSwap(x1, x2);
 
                         quad[0] = x1 - endCap;
                         quad[1] = y1 + 0.5f;
 
                         quad[2] = x1 - endCap;
                         quad[3] = y1 - 0.5f;
 
                         quad[4] = x2 + endCap;
                         quad[5] = y1 - 0.5f;
 
                         quad[6] = x2 + endCap;
                         quad[7] = y1 + 0.5f;
                     }
 
                     addQuadAsTriangle(quad, &vertexArray[12*i]);
                 }
 
                 glEnableClientState(GL_VERTEX_ARRAY);
 
                 glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
                 glDrawArrays(GL_TRIANGLES, 0, lineCount*6);
 
                 glDisableClientState(GL_VERTEX_ARRAY);
             } else {
                 QVarLengthArray<GLfloat> vertexArray(4 * lineCount);
                 for (int i = 0; i < lineCount; ++i) {
                     vertexArray[4*i]   = lines[i].x1();
                     vertexArray[4*i+1] = lines[i].y1();
                     vertexArray[4*i+2] = lines[i].x2();
                     vertexArray[4*i+3] = lines[i].y2();
                 }
 
                 glEnableClientState(GL_VERTEX_ARRAY);
 
                 glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
                 glDrawArrays(GL_LINES, 0, lineCount*2);
 
                 glVertexPointer(2, GL_FLOAT, 4*sizeof(GLfloat), vertexArray.constData() + 2);
                 glDrawArrays(GL_POINTS, 0, lineCount);
 
                 glDisableClientState(GL_VERTEX_ARRAY);
             }
         } else {
             QPainterPath path;
             path.setFillRule(Qt::WindingFill);
             for (int i=0; i<lineCount; ++i) {
                 const QLineF &l = lines[i];
 
                 if (l.p1() == l.p2()) {
                     if (d->cpen.capStyle() != Qt::FlatCap) {
                         QPointF p = l.p1();
                         drawPoints(&p, 1);
                     }
                     continue;
                 }
 
                 path.moveTo(l.x1(), l.y1());
                 path.lineTo(l.x2(), l.y2());
             }
 
             if (d->has_fast_pen && d->high_quality_antialiasing)
                 d->strokeLines(path);
             else
                 d->strokePath(path, false);
         }
     }
 }

◆ drawLines() [2/2]

void QOpenGLPaintEngine::drawLines	(	const QLine *	lines,
		int	lineCount
	)

virtual

The default implementation converts the first lineCount lines in lines to a QLineF and calls the floating point version of this function.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Reimplemented from QPaintEngineEx.

Definition at line 3669 of file qpaintengine_opengl.cpp.

 {
     struct PointF {
         qreal x;
         qreal y;
     };
     struct LineF {
         PointF p1;
         PointF p2;
     };
     Q_ASSERT(sizeof(PointF) == sizeof(QPointF));
     Q_ASSERT(sizeof(LineF) == sizeof(QLineF));
     LineF fl[256];
     while (lineCount) {
         int i = 0;
         while (i < lineCount && i < 256) {
             fl[i].p1.x = lines[i].x1();
             fl[i].p1.y = lines[i].y1();
             fl[i].p2.x = lines[i].x2();
             fl[i].p2.y = lines[i].y2();
             ++i;
         }
         drawLines((QLineF *)(void *)fl, i);
         lines += i;
         lineCount -= i;
     }
 }

◆ drawPath()

void QOpenGLPaintEngine::drawPath ( const QPainterPath & path )

virtual

The default implementation ignores the path and does nothing.

Reimplemented from QPaintEngineEx.

Definition at line 4166 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
 
     if (path.isEmpty())
         return;
 
     if (d->use_emulation) {
         QPaintEngineEx::drawPath(path);
         return;
     }
 
     QOpenGLCoordinateOffset offset(d);
 
     if (d->has_brush) {
         bool path_closed = pathClosed(path);
 
         bool has_thick_pen =
             path_closed
             && d->has_pen
             && d->cpen.style() == Qt::SolidLine
             && d->cpen.isSolid()
             && d->cpen.color().alpha() == 255
             && d->txop < QTransform::TxProject
             && d->cpen.widthF() >= 2 / qSqrt(qMin(d->matrix.m11() * d->matrix.m11()
                                                   + d->matrix.m21() * d->matrix.m21(),
                                                   d->matrix.m12() * d->matrix.m12()
                                                   + d->matrix.m22() * d->matrix.m22()));
 
         if (has_thick_pen) {
             DEBUG_ONCE qDebug() << "QOpenGLPaintEngine::drawPath(): Using thick pen optimization, style:" << d->cbrush.style();
 
             d->flushDrawQueue();
 
             bool temp = d->high_quality_antialiasing;
             d->high_quality_antialiasing = false;
 
             updateCompositionMode(d->composition_mode);
 
             d->fillPath(path);
 
             d->high_quality_antialiasing = temp;
             updateCompositionMode(d->composition_mode);
         } else {
             d->fillPath(path);
         }
     }
 
     if (d->has_pen) {
         if (d->has_fast_pen && !d->high_quality_antialiasing)
             d->strokePathFastPen(path, state()->penNeedsResolving());
         else
             d->strokePath(path, true);
     }
 }

◆ drawPixmap()

void QOpenGLPaintEngine::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 4289 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
     if (pm.depth() == 1) {
         QPixmap tpx(pm.size());
         tpx.fill(Qt::transparent);
         QPainter p(&tpx);
         p.setPen(d->cpen);
         p.drawPixmap(0, 0, pm);
         p.end();
         drawPixmap(r, tpx, sr);
         return;
     }
 
     const int sz = d->max_texture_size;
     if (pm.width() > sz || pm.height() > sz) {
         QRectF subsr;
         const QPixmap sub = qSubImage(pm, sr, &subsr);
 
         if (sub.width() <= sz && sub.height() <= sz) {
             drawPixmap(r, sub, subsr);
         } else {
             const QPixmap scaled = sub.scaled(sz, sz, Qt::KeepAspectRatio);
             const qreal sx = scaled.width() / qreal(sub.width());
             const qreal sy = scaled.height() / qreal(sub.height());
 
             drawPixmap(r, scaled, scaleRect(subsr, sx, sy));
         }
         return;
     }
 
 
     if (d->composition_mode > QPainter::CompositionMode_Plus || (d->high_quality_antialiasing && !d->isFastRect(r)))
         d->drawImageAsPath(r, pm.toImage(), sr);
     else {
         GLenum target = qt_gl_preferredTextureTarget();
         d->flushDrawQueue();
         QGLTexture *tex =
             d->device->context()->d_func()->bindTexture(pm, target, GL_RGBA,
                                                         QGLContext::InternalBindOption);
         drawTextureRect(pm.width(), pm.height(), r, sr, target, tex);
     }
 }

◆ drawPoints() [1/2]

void QOpenGLPaintEngine::drawPoints	(	const QPointF *	points,
		int	pointCount
	)

virtual

Draws the first pointCount points in the buffer points.

Reimplemented from QPaintEngineEx.

Definition at line 3596 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
 
     if (d->use_emulation) {
         QPaintEngineEx::drawPoints(points, pointCount);
         return;
     }
 
     d->setGradientOps(d->cpen.brush(), QRectF());
 
     if (!d->cpen.isCosmetic() || d->high_quality_antialiasing) {
         Qt::PenCapStyle capStyle = d->cpen.capStyle();
         if (capStyle == Qt::FlatCap)
             d->cpen.setCapStyle(Qt::SquareCap);
         QPaintEngine::drawPoints(points, pointCount);
         d->cpen.setCapStyle(capStyle);
         return;
     }
 
     d->flushDrawQueue();
 
     if (d->has_fast_pen) {
         QVarLengthArray<GLfloat> vertexArray(6 * pointCount);
 
         glMatrixMode(GL_MODELVIEW);
         glPushMatrix();
         glLoadIdentity();
 
         int j = 0;
         for (int i = 0; i < pointCount; ++i) {
             QPointF mapped = d->matrix.map(points[i]);
 
             GLfloat x = GLfloat(qRound(mapped.x()));
             GLfloat y = GLfloat(qRound(mapped.y()));
 
             vertexArray[j++] = x;
             vertexArray[j++] = y - 0.5f;
 
             vertexArray[j++] = x + 1.5f;
             vertexArray[j++] = y + 1.0f;
 
             vertexArray[j++] = x;
             vertexArray[j++] = y + 1.0f;
         }
 
         glEnableClientState(GL_VERTEX_ARRAY);
 
         glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
         glDrawArrays(GL_TRIANGLES, 0, pointCount*3);
 
         glDisableClientState(GL_VERTEX_ARRAY);
 
         glPopMatrix();
         return;
     }
 
     const qreal *vertexArray = reinterpret_cast<const qreal*>(&points[0]);
 
     if (sizeof(qreal) == sizeof(double)) {
         Q_ASSERT(sizeof(QPointF) == 16);
         glVertexPointer(2, GL_DOUBLE, 0, vertexArray);
     }
     else {
         Q_ASSERT(sizeof(QPointF) == 8);
         glVertexPointer(2, GL_FLOAT, 0, vertexArray);
     }
 
     glEnableClientState(GL_VERTEX_ARRAY);
     glDrawArrays(GL_POINTS, 0, pointCount);
     glDisableClientState(GL_VERTEX_ARRAY);
 }

◆ drawPoints() [2/2]

void QOpenGLPaintEngine::drawPoints	(	const QPoint *	points,
		int	pointCount
	)

virtual

Draws the first pointCount points in the buffer points.

The default implementation converts the first pointCount QPoints in points to QPointFs and calls the floating point version of drawPoints.

Reimplemented from QPaintEngineEx.

Definition at line 3579 of file qpaintengine_opengl.cpp.

 {
     Q_ASSERT(sizeof(QT_PointF) == sizeof(QPointF));
     QT_PointF fp[256];
     while (pointCount) {
         int i = 0;
         while (i < pointCount && i < 256) {
             fp[i].x = points[i].x();
             fp[i].y = points[i].y();
             ++i;
         }
         drawPoints((QPointF *)(void *)fp, i);
         points += i;
         pointCount -= i;
     }
 }

◆ drawPolygon() [1/2]

void QOpenGLPaintEngine::drawPolygon	(	const QPointF *	points,
		int	pointCount,
		PolygonDrawMode	mode
	)

virtual

Reimplement this virtual function to draw the polygon defined by the pointCount first points in points, using mode mode.

Note: At least one of the drawPolygon() functions must be reimplemented.

Reimplemented from QPaintEngineEx.

Definition at line 3837 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
     if(pointCount < 2)
         return;
 
     if (d->use_emulation) {
         QPaintEngineEx::drawPolygon(points, pointCount, mode);
         return;
     }
 
     QRectF bounds;
     if ((mode == ConvexMode && !d->high_quality_antialiasing && state()->brushNeedsResolving()) ||
         ((d->has_fast_pen && !d->high_quality_antialiasing) && state()->penNeedsResolving())) {
         qreal minx = points[0].x(), miny = points[0].y(),
               maxx = points[0].x(), maxy = points[0].y();
         for (int i = 1; i < pointCount; ++i) {
             const QPointF &pt = points[i];
             if (minx > pt.x())
                 minx = pt.x();
             if (miny > pt.y())
                 miny = pt.y();
             if (maxx < pt.x())
                 maxx = pt.x();
             if (maxy < pt.y())
                 maxy = pt.y();
         }
         bounds = QRectF(minx, maxx, maxx-minx, maxy-miny);
     }
 
     QOpenGLCoordinateOffset offset(d);
 
     if (d->has_brush && mode != PolylineMode) {
         if (mode == ConvexMode && !d->high_quality_antialiasing) {
             //### resolving on polygon from points isn't correct
             d->setGradientOps(d->cbrush, bounds);
 
             const qreal *vertexArray = reinterpret_cast<const qreal*>(&points[0]);
 
             if (sizeof(qreal) == sizeof(double)) {
                 Q_ASSERT(sizeof(QPointF) == 16);
                 glVertexPointer(2, GL_DOUBLE, 0, vertexArray);
             }
             else {
                 Q_ASSERT(sizeof(QPointF) == 8);
                 glVertexPointer(2, GL_FLOAT, 0, vertexArray);
             }
 
             glEnableClientState(GL_VERTEX_ARRAY);
             glDrawArrays(GL_TRIANGLE_FAN, 0, pointCount);
             glDisableClientState(GL_VERTEX_ARRAY);
         } else {
             QPainterPath path;
             path.setFillRule(mode == WindingMode ? Qt::WindingFill : Qt::OddEvenFill);
             path.moveTo(points[0]);
             for (int i=1; i<pointCount; ++i)
                 path.lineTo(points[i]);
             d->fillPath(path);
         }
     }
 
     if (d->has_pen) {
         if (d->has_fast_pen && !d->high_quality_antialiasing) {
             d->setGradientOps(d->cpen.brush(), bounds);
             QVarLengthArray<GLfloat> vertexArray(pointCount*2 + 2);
             glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
             int i;
             for (i=0; i<pointCount; ++i) {
                 vertexArray[i*2] = points[i].x();
                 vertexArray[i*2+1] = points[i].y();
             }
 
             glEnableClientState(GL_VERTEX_ARRAY);
             if (mode != PolylineMode) {
                 vertexArray[i*2] = vertexArray[0];
                 vertexArray[i*2+1] = vertexArray[1];
                 glDrawArrays(GL_LINE_STRIP, 0, pointCount+1);
             } else {
                 glDrawArrays(GL_LINE_STRIP, 0, pointCount);
                 glDrawArrays(GL_POINTS, pointCount-1, 1);
             }
             glDisableClientState(GL_VERTEX_ARRAY);
         } else {
             QPainterPath path(points[0]);
             for (int i = 1; i < pointCount; ++i)
                 path.lineTo(points[i]);
             if (mode != PolylineMode)
                 path.lineTo(points[0]);
 
             if (d->has_fast_pen)
                 d->strokeLines(path);
             else
                 d->strokePath(path, true);
         }
     }
 }

◆ drawPolygon() [2/2]

void QOpenGLPaintEngine::drawPolygon	(	const QPoint *	points,
		int	pointCount,
		PolygonDrawMode	mode
	)

virtual

Reimplement this virtual function to draw the polygon defined by the pointCount first points in points, using mode mode.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Note: At least one of the drawPolygon() functions must be reimplemented.

Reimplemented from QPaintEngineEx.

Definition at line 3826 of file qpaintengine_opengl.cpp.

 {
     Q_ASSERT(sizeof(QT_PointF) == sizeof(QPointF));
     QVarLengthArray<QT_PointF> p(pointCount);
     for (int i=0; i<pointCount; ++i) {
         p[i].x = points[i].x();
         p[i].y = points[i].y();
     }
     drawPolygon((QPointF *)p.data(), pointCount, mode);
 }

◆ drawPolyInternal()

void QOpenGLPaintEngine::drawPolyInternal	(	const QPolygonF &	pa,
		bool	close = `true`
	)

private

◆ drawRects() [1/2]

void QOpenGLPaintEngine::drawRects	(	const QRectF *	rects,
		int	rectCount
	)

virtual

Draws the first rectCount rectangles in the buffer rects.

The default implementation of this function calls drawPath() or drawPolygon() depending on the feature set of the paint engine.

Reimplemented from QPaintEngineEx.

Definition at line 3513 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
 
     if (d->use_emulation) {
         QPaintEngineEx::drawRects(rects, rectCount);
         return;
     }
 
     for (int i=0; i<rectCount; ++i) {
         const QRectF &r = rects[i];
 
         // optimization for rects which can be drawn aliased
         if (!d->high_quality_antialiasing || d->isFastRect(r)) {
             d->drawFastRect(r);
         } else {
             QPainterPath path;
             path.addRect(r);
 
             if (d->has_brush) {
                 d->disableClipping();
                 GLuint program = qt_gl_program_cache()->getProgram(d->device->context(),
                                                                    FRAGMENT_PROGRAM_MASK_TRAPEZOID_AA, 0, true);
 
                 if (d->matrix.type() >= QTransform::TxProject) {
                     QGLPathMaskGenerator maskGenerator(path, d->matrix, d->offscreen, program);
                     d->addItem(qt_mask_texture_cache()->getMask(maskGenerator, d));
                 } else {
                     QGLRectMaskGenerator maskGenerator(path, d->matrix, d->offscreen, program);
                     d->addItem(qt_mask_texture_cache()->getMask(maskGenerator, d));
                 }
 
                 d->enableClipping();
             }
 
             if (d->has_pen) {
                 if (d->has_fast_pen)
                     d->strokeLines(path);
                 else
                     d->strokePath(path, false);
             }
         }
     }
 }

◆ drawRects() [2/2]

void QOpenGLPaintEngine::drawRects	(	const QRect *	rects,
		int	rectCount
	)

virtual

The default implementation converts the first rectCount rectangles in the buffer rects to a QRectF and calls the floating point version of this function.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Reimplemented from QPaintEngineEx.

Definition at line 3488 of file qpaintengine_opengl.cpp.

 {
     struct RectF {
         qreal x;
         qreal y;
         qreal w;
         qreal h;
     };
     Q_ASSERT(sizeof(RectF) == sizeof(QRectF));
     RectF fr[256];
     while (rectCount) {
         int i = 0;
         while (i < rectCount && i < 256) {
             fr[i].x = rects[i].x();
             fr[i].y = rects[i].y();
             fr[i].w = rects[i].width();
             fr[i].h = rects[i].height();
             ++i;
         }
         drawRects((QRectF *)(void *)fr, i);
         rects += i;
         rectCount -= i;
     }
 }

◆ drawStaticTextItem()

void QOpenGLPaintEngine::drawStaticTextItem ( QStaticTextItem * staticTextItem )

virtual

Reimplemented from QPaintEngineEx.

Definition at line 4922 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
 
     d->flushDrawQueue();
 
     // make sure the glyphs we want to draw are in the cache
     qt_glyph_cache()->cacheGlyphs(d->device->context(), textItem->fontEngine(), textItem->glyphs,
                                   textItem->numGlyphs);
 
     d->setGradientOps(Qt::SolidPattern, QRectF()); // turns off gradient ops
     qt_glColor4ubv(d->pen_color);
     glEnable(GL_TEXTURE_2D);
 
 #ifdef Q_WS_QWS
     // XXX: it is necessary to disable alpha writes on GLES/embedded because we don't want
     // text rendering to update the alpha in the window surface.
     // XXX: This may not be needed as this behavior does seem to be caused by driver bug
     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
 #endif
 
     // do the actual drawing
     GLfloat vertexArray[4*2];
     GLfloat texCoordArray[4*2];
 
     glVertexPointer(2, GL_FLOAT, 0, vertexArray);
     glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
 
     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
     bool antialias = !(textItem->fontEngine()->fontDef.styleStrategy & QFont::NoAntialias)
                                    && (d->matrix.type() > QTransform::TxTranslate);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
 
     for (int i=0; i< textItem->numGlyphs; ++i) {
         QGLGlyphCoord *g = qt_glyph_cache()->lookup(textItem->fontEngine(), textItem->glyphs[i]);
 
         // we don't cache glyphs with no width/height
         if (!g)
             continue;
 
         qreal x1, x2, y1, y2;
         x1 = g->x;
         y1 = g->y;
         x2 = x1 + g->width;
         y2 = y1 + g->height;
 
         QPointF logical_pos((textItem->glyphPositions[i].x - g->x_offset).toReal(),
                             (textItem->glyphPositions[i].y + g->y_offset).toReal());
 
         qt_add_rect_to_array(QRectF(logical_pos, QSizeF(g->log_width, g->log_height)), vertexArray);
         qt_add_texcoords_to_array(x1, y1, x2, y2, texCoordArray);
 
         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
     }
 
     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
     glDisableClientState(GL_VERTEX_ARRAY);
 
     glDisable(GL_TEXTURE_2D);
 
 #ifdef Q_WS_QWS
     // XXX: This may not be needed as this behavior does seem to be caused by driver bug
     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 #endif
 
 }

◆ drawTextItem()

void QOpenGLPaintEngine::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 4991 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
 
     const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
 
     // fall back to drawing a polygon if the scale factor is large, or
     // we use a gradient pen
     if ((d->matrix.det() > 1) || (d->pen_brush_style >= Qt::LinearGradientPattern
                                   && d->pen_brush_style <= Qt::ConicalGradientPattern)) {
         QPaintEngine::drawTextItem(p, textItem);
         return;
     }
 
     // add the glyphs used to the glyph texture cache
     QVarLengthArray<QFixedPoint> positions;
     QVarLengthArray<glyph_t> glyphs;
     QTransform matrix = QTransform::fromTranslate(qRound(p.x()), qRound(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();
         drawStaticTextItem(&staticTextItem);
     }
 
 }

◆ drawTextureRect()

void QOpenGLPaintEngine::drawTextureRect	(	int	tx_width,
		int	tx_height,
		const QRectF &	r,
		const QRectF &	sr,
		GLenum	target,
		QGLTexture *	tex
	)

private

Definition at line 4461 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
 #ifndef QT_OPENGL_ES
     glPushAttrib(GL_CURRENT_BIT);
     glDisable(GL_TEXTURE_GEN_S);
 #endif
     glColor4f(d->opacity, d->opacity, d->opacity, d->opacity);
     glEnable(target);
     updateTextureFilter(target, GL_CLAMP_TO_EDGE, d->use_smooth_pixmap_transform);
 
     qreal x1, x2, y1, y2;
     if (target == GL_TEXTURE_2D) {
         x1 = sr.x() / tx_width;
         x2 = x1 + sr.width() / tx_width;
         if (tex->options & QGLContext::InvertedYBindOption) {
             y1 = 1 - (sr.bottom() / tx_height);
             y2 = 1 - (sr.y() / tx_height);
         } else {
             y1 = sr.bottom() / tx_height;
             y2 = sr.y() / tx_height;
         }
     } else {
         x1 = sr.x();
         x2 = sr.right();
         y1 = sr.bottom();
         y2 = sr.y();
     }
 
     GLfloat vertexArray[4*2];
     GLfloat texCoordArray[4*2];
 
     qt_add_rect_to_array(r, vertexArray);
     qt_add_texcoords_to_array(x1, y2, x2, y1, texCoordArray);
 
     glVertexPointer(2, GL_FLOAT, 0, vertexArray);
     glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
 
     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
     glDisableClientState(GL_VERTEX_ARRAY);
 
     glDisable(target);
 #ifndef QT_OPENGL_ES
     glPopAttrib();
 #endif
 }

◆ drawTiledPixmap()

void QOpenGLPaintEngine::drawTiledPixmap	(	const QRectF &	rect,
		const QPixmap &	pixmap,
		const QPointF &	p
	)

virtual

Reimplement this function to draw the pixmap in the given rect, starting at the given p.

The pixmap will be drawn repeatedly until the rect is filled.

Reimplemented from QPaintEngineEx.

Definition at line 4333 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
     if (pm.depth() == 1) {
         QPixmap tpx(pm.size());
         tpx.fill(Qt::transparent);
         QPainter p(&tpx);
         p.setPen(d->cpen);
         p.drawPixmap(0, 0, pm);
         p.end();
         drawTiledPixmap(r, tpx, offset);
         return;
     }
 
     QImage scaled;
     const int sz = d->max_texture_size;
     if (pm.width() > sz || pm.height() > sz) {
         int rw = qCeil(r.width());
         int rh = qCeil(r.height());
         if (rw < pm.width() && rh < pm.height()) {
             drawTiledPixmap(r, pm.copy(0, 0, rw, rh), offset);
             return;
         }
 
         scaled = pm.toImage().scaled(sz, sz, Qt::KeepAspectRatio);
     }
 
     if (d->composition_mode > QPainter::CompositionMode_Plus || (d->high_quality_antialiasing && !d->isFastRect(r))) {
         if (scaled.isNull())
             d->drawTiledImageAsPath(r, pm.toImage(), 1, 1, offset);
         else {
             const qreal sx = pm.width() / qreal(scaled.width());
             const qreal sy = pm.height() / qreal(scaled.height());
             d->drawTiledImageAsPath(r, scaled, sx, sy, offset);
         }
     } else {
         d->flushDrawQueue();
 
         QGLTexture *tex;
         if (scaled.isNull())
             tex = d->device->context()->d_func()->bindTexture(pm, GL_TEXTURE_2D, GL_RGBA,
                                                               QGLContext::InternalBindOption);
         else
             tex = d->device->context()->d_func()->bindTexture(scaled, GL_TEXTURE_2D, GL_RGBA,
                                                               QGLContext::InternalBindOption);
         updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, d->use_smooth_pixmap_transform);
 
 #ifndef QT_OPENGL_ES
         glPushAttrib(GL_CURRENT_BIT);
         glDisable(GL_TEXTURE_GEN_S);
 #endif
         glColor4f(d->opacity, d->opacity, d->opacity, d->opacity);
         glEnable(GL_TEXTURE_2D);
 
         GLdouble tc_w = r.width()/pm.width();
         GLdouble tc_h = r.height()/pm.height();
 
         // Rotate the texture so that it is aligned correctly and the
         // wrapping is done correctly
         if (tex->options & QGLContext::InvertedYBindOption) {
             glMatrixMode(GL_TEXTURE);
             glPushMatrix();
             glRotatef(180.0, 0.0, 1.0, 0.0);
             glRotatef(180.0, 0.0, 0.0, 1.0);
         }
 
         GLfloat vertexArray[4*2];
         GLfloat texCoordArray[4*2];
 
         double offset_x = offset.x() / pm.width();
         double offset_y = offset.y() / pm.height();
 
         qt_add_rect_to_array(r, vertexArray);
         qt_add_texcoords_to_array(offset_x, offset_y,
                                   tc_w + offset_x, tc_h + offset_y, texCoordArray);
 
         glVertexPointer(2, GL_FLOAT, 0, vertexArray);
         glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
 
         glEnableClientState(GL_VERTEX_ARRAY);
         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
         glDisableClientState(GL_VERTEX_ARRAY);
         if (tex->options & QGLContext::InvertedYBindOption)
             glPopMatrix();
 
         glDisable(GL_TEXTURE_2D);
 #ifndef QT_OPENGL_ES
         glPopAttrib();
 #endif
     }
 }

◆ end()

bool QOpenGLPaintEngine::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 1432 of file qpaintengine_opengl.cpp.

Referenced by QGLMaskTextureCache::maintainCache().

 {
     Q_D(QOpenGLPaintEngine);
     d->flushDrawQueue();
     d->offscreen.end();
     QGLContext *ctx = const_cast<QGLContext *>(d->device->context());
     if (!ctx->d_ptr->internal_context) {
         glMatrixMode(GL_TEXTURE);
         glPopMatrix();
         glMatrixMode(GL_MODELVIEW);
         glPopMatrix();
     }
 #ifndef QT_OPENGL_ES
     if (ctx->d_ptr->internal_context) {
         glDisable(GL_SCISSOR_TEST);
     } else {
         glMatrixMode(GL_PROJECTION);
         glLoadMatrixd(&d->projection_matrix[0][0]);
         glPopAttrib();
         glPopClientAttrib();
     }
 #endif
     d->device->endPaint();
     qt_mask_texture_cache()->maintainCache();
 
 #if defined(Q_WS_X11)
     // clear out the references we hold for textures bound with the
     // texture_from_pixmap extension
     ctx->d_func()->boundPixmaps.clear();
 #endif
     return true;
 }

◆ fill()

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

virtual

Implements QPaintEngineEx.

Definition at line 5455 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
 
     if (brush.style() == Qt::NoBrush)
         return;
 
     if ((!d->use_fragment_programs && needsEmulation(brush.style())) || qt_isExtendedRadialGradient(brush)) {
         QPainter *p = painter();
         QBrush oldBrush = p->brush();
         p->setBrush(brush);
         qt_draw_helper(p->d_ptr.data(), qt_painterPathFromVectorPath(path), QPainterPrivate::FillDraw);
         p->setBrush(oldBrush);
         return;
     }
 
     QBrush old_brush = state()->brush;
     updateBrush(brush, state()->brushOrigin);
 
     const qreal *points = path.points();
     const QPainterPath::ElementType *types = path.elements();
     if (!types && path.shape() == QVectorPath::RectangleHint) {
         QRectF r(points[0], points[1], points[4]-points[0], points[5]-points[1]);
         QPen old_pen = state()->pen;
         updatePen(Qt::NoPen);
         drawRects(&r, 1);
         updatePen(old_pen);
     } else {
         d->fillPath(qt_painterPathFromVectorPath(path));
     }
 
     updateBrush(old_brush, state()->brushOrigin);
 }

◆ handle()

HDC QOpenGLPaintEngine::handle ( ) const

Definition at line 4517 of file qpaintengine_opengl.cpp.

 {
     return 0;
 }

◆ opacityChanged()

void QOpenGLPaintEngine::opacityChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 5429 of file qpaintengine_opengl.cpp.

Referenced by begin().

 {
     Q_D(QOpenGLPaintEngine);
     QPainterState *s = state();
     d->opacity = s->opacity;
     updateBrush(s->brush, s->brushOrigin);
     updatePen(s->pen);
 }

◆ penChanged()

void QOpenGLPaintEngine::penChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 5414 of file qpaintengine_opengl.cpp.

Referenced by begin().

 {
     updatePen(state()->pen);
 }

◆ renderHintsChanged()

void QOpenGLPaintEngine::renderHintsChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 5443 of file qpaintengine_opengl.cpp.

Referenced by begin().

 {
     updateRenderHints(state()->renderHints);
 }

◆ setState()

void QOpenGLPaintEngine::setState ( QPainterState * s )

virtual

Reimplemented from QPaintEngineEx.

Definition at line 5552 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
     QOpenGLPaintEngineState *new_state = static_cast<QOpenGLPaintEngineState *>(s);
     QOpenGLPaintEngineState *old_state = state();
 
     QPaintEngineEx::setState(s);
 
     // are we in a save() ?
     if (s == d->last_created_state) {
         d->last_created_state = 0;
         return;
     }
 
     if (isActive()) {
         if (old_state->depthClipId != new_state->depthClipId)
             d->updateDepthClip();
         penChanged();
         brushChanged();
         opacityChanged();
         compositionModeChanged();
         renderHintsChanged();
         transformChanged();
     }
 }

◆ state() [1/2]

QOpenGLPaintEngineState* QOpenGLPaintEngine::state ( )

inline

Definition at line 101 of file qpaintengine_opengl_p.h.

Referenced by updateClipRegion().

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

◆ state() [2/2]

const QOpenGLPaintEngineState* QOpenGLPaintEngine::state ( ) const

inline

Definition at line 104 of file qpaintengine_opengl_p.h.

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

◆ supportsTransformations()

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

inlinevirtual

Reimplemented from QPaintEngineEx.

Definition at line 146 of file qpaintengine_opengl_p.h.

146 { return true; }

◆ transformChanged()

void QOpenGLPaintEngine::transformChanged ( )

virtual

Implements QPaintEngineEx.

Definition at line 5448 of file qpaintengine_opengl.cpp.

Referenced by begin().

 {
     updateMatrix(state()->matrix);
 }

◆ type()

Type QOpenGLPaintEngine::type ( ) const

inlinevirtual

Reimplement this function to return the paint engine Type.

Implements QPaintEngine.

Definition at line 145 of file qpaintengine_opengl_p.h.

145 { return QPaintEngine::OpenGL; }

QPaintEngine::OpenGL

Definition: qpaintengine.h:207

◆ updateBrush()

void QOpenGLPaintEngine::updateBrush	(	const QBrush &	brush,
		const QPointF &	pt
	)

Definition at line 2166 of file qpaintengine_opengl.cpp.

Referenced by updateState().

 {
     Q_D(QOpenGLPaintEngine);
     d->cbrush = brush;
     d->brush_style = brush.style();
     d->brush_origin = origin;
     d->has_brush = (d->brush_style != Qt::NoBrush);
     d->updateUseEmulation();
 }

◆ updateClipRegion()

void QOpenGLPaintEngine::updateClipRegion	(	const QRegion &	region,
		Qt::ClipOperation	op
	)

Definition at line 2347 of file qpaintengine_opengl.cpp.

Referenced by begin(), and updateState().

 {
     Q_D(QOpenGLPaintEngine);
 
     // clipping is only supported when a stencil or depth buffer is
     // available
     if (!d->device->format().depth())
         return;
 
     d->use_system_clip = false;
     QRegion sysClip = systemClip();
     if (!sysClip.isEmpty()) {
         if (d->pdev->devType() != QInternal::Widget) {
             d->use_system_clip = true;
         } else {
 #ifndef Q_WS_QWS
             // Only use the system clip if we're currently rendering a widget with a GL painter.
             if (d->currentClipWidget) {
                 QWidgetPrivate *widgetPrivate = qt_widget_private(d->currentClipWidget->window());
                 d->use_system_clip = widgetPrivate->extra && widgetPrivate->extra->inRenderWithPainter;
             }
 #endif
         }
     }
 
     d->flushDrawQueue();
 
     if (op == Qt::NoClip && !d->use_system_clip) {
         state()->hasClipping = false;
         state()->clipRegion = QRegion();
         d->updateDepthClip();
         return;
     }
 
     bool isScreenClip = false;
     if (!d->use_system_clip) {
         QVector<QRect> untransformedRects = clipRegion.rects();
 
         if (untransformedRects.size() == 1) {
             QPainterPath path;
             path.addRect(untransformedRects[0]);
             path = d->matrix.map(path);
 
             if (path.contains(QRectF(QPointF(), d->device->size())))
                 isScreenClip = true;
         }
     }
 
     QRegion region = isScreenClip ? QRegion() : clipRegion * d->matrix;
     switch (op) {
     case Qt::NoClip:
         if (!d->use_system_clip)
             break;
         state()->clipRegion = sysClip;
         break;
     case Qt::IntersectClip:
         if (isScreenClip)
             return;
         if (state()->hasClipping) {
             state()->clipRegion &= region;
             break;
         }
         // fall through
     case Qt::ReplaceClip:
         if (d->use_system_clip)
             state()->clipRegion = region & sysClip;
         else
             state()->clipRegion = region;
         break;
     case Qt::UniteClip:
         state()->clipRegion |= region;
         if (d->use_system_clip)
             state()->clipRegion &= sysClip;
         break;
     default:
         break;
     }
 
     if (isScreenClip) {
         state()->hasClipping = false;
         state()->clipRegion = QRegion();
     } else {
         state()->hasClipping = op != Qt::NoClip || d->use_system_clip;
     }
 
     if (state()->hasClipping && state()->clipRegion.rects().size() == 1)
         state()->fastClip = state()->clipRegion.rects().at(0);
     else
         state()->fastClip = QRect();
 
     d->updateDepthClip();
 }

◆ updateCompositionMode()

void QOpenGLPaintEngine::updateCompositionMode ( QPainter::CompositionMode composition_mode )

Definition at line 2489 of file qpaintengine_opengl.cpp.

Referenced by updateState().

 {
     Q_D(QOpenGLPaintEngine);
 
     if (!d->use_fragment_programs && composition_mode > QPainter::CompositionMode_Plus)
         composition_mode = QPainter::CompositionMode_SourceOver;
 
     d->composition_mode = composition_mode;
 
     d->has_fast_composition_mode = (!d->high_quality_antialiasing && composition_mode <= QPainter::CompositionMode_Plus)
                                    || composition_mode == QPainter::CompositionMode_SourceOver
                                    || composition_mode == QPainter::CompositionMode_Destination
                                    || composition_mode == QPainter::CompositionMode_DestinationOver
                                    || composition_mode == QPainter::CompositionMode_DestinationOut
                                    || composition_mode == QPainter::CompositionMode_SourceAtop
                                    || composition_mode == QPainter::CompositionMode_Xor
                                    || composition_mode == QPainter::CompositionMode_Plus;
 
     if (d->has_fast_composition_mode)
         d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODE_BLEND_MODE_MASK : COMPOSITION_MODE_BLEND_MODE_NOMASK;
     else if (composition_mode <= QPainter::CompositionMode_Plus)
         d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_SIMPLE_PORTER_DUFF : COMPOSITION_MODES_SIMPLE_PORTER_DUFF_NOMASK;
     else
         switch (composition_mode) {
         case QPainter::CompositionMode_Multiply:
             d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_MULTIPLY : COMPOSITION_MODES_MULTIPLY_NOMASK;
             break;
         case QPainter::CompositionMode_Screen:
             d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_SCREEN : COMPOSITION_MODES_SCREEN_NOMASK;
             break;
         case QPainter::CompositionMode_Overlay:
             d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_OVERLAY : COMPOSITION_MODES_OVERLAY_NOMASK;
             break;
         case QPainter::CompositionMode_Darken:
             d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_DARKEN : COMPOSITION_MODES_DARKEN_NOMASK;
             break;
         case QPainter::CompositionMode_Lighten:
             d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_LIGHTEN : COMPOSITION_MODES_LIGHTEN_NOMASK;
             break;
         case QPainter::CompositionMode_ColorDodge:
             d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_COLORDODGE : COMPOSITION_MODES_COLORDODGE_NOMASK;
             break;
         case QPainter::CompositionMode_ColorBurn:
             d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_COLORBURN : COMPOSITION_MODES_COLORBURN_NOMASK;
             break;
         case QPainter::CompositionMode_HardLight:
             d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_HARDLIGHT : COMPOSITION_MODES_HARDLIGHT_NOMASK;
             break;
         case QPainter::CompositionMode_SoftLight:
             d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_SOFTLIGHT : COMPOSITION_MODES_SOFTLIGHT_NOMASK;
             break;
         case QPainter::CompositionMode_Difference:
             d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_DIFFERENCE : COMPOSITION_MODES_DIFFERENCE_NOMASK;
             break;
         case QPainter::CompositionMode_Exclusion:
             d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_EXCLUSION : COMPOSITION_MODES_EXCLUSION_NOMASK;
             break;
         default:
             Q_ASSERT(false);
         }
 
     switch(composition_mode) {
     case QPainter::CompositionMode_DestinationOver:
         glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE);
         d->setPorterDuffData(0, 1, 1, 1, 1);
         break;
     case QPainter::CompositionMode_Clear:
         glBlendFunc(GL_ZERO, GL_ZERO);
         d->setPorterDuffData(0, 0, 0, 0, 0);
         break;
     case QPainter::CompositionMode_Source:
         glBlendFunc(GL_ONE, GL_ZERO);
         d->setPorterDuffData(1, 0, 1, 1, 0);
         break;
     case QPainter::CompositionMode_Destination:
         glBlendFunc(GL_ZERO, GL_ONE);
         d->setPorterDuffData(0, 1, 1, 0, 1);
         break;
     case QPainter::CompositionMode_SourceIn:
         glBlendFunc(GL_DST_ALPHA, GL_ZERO);
         d->setPorterDuffData(1, 0, 1, 0, 0);
         break;
     case QPainter::CompositionMode_DestinationIn:
         glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
         d->setPorterDuffData(0, 1, 1, 0, 0);
         break;
     case QPainter::CompositionMode_SourceOut:
         glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ZERO);
         d->setPorterDuffData(0, 0, 0, 1, 0);
         break;
     case QPainter::CompositionMode_DestinationOut:
         glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
         d->setPorterDuffData(0, 0, 0, 0, 1);
         break;
     case QPainter::CompositionMode_SourceAtop:
         glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         d->setPorterDuffData(1, 0, 1, 0, 1);
         break;
     case QPainter::CompositionMode_DestinationAtop:
         glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA);
         d->setPorterDuffData(0, 1, 1, 1, 0);
         break;
     case QPainter::CompositionMode_Xor:
         glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         d->setPorterDuffData(0, 0, 0, 1, 1);
         break;
     case QPainter::CompositionMode_SourceOver:
         glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
         d->setPorterDuffData(1, 0, 1, 1, 1);
         break;
     case QPainter::CompositionMode_Plus:
         glBlendFunc(GL_ONE, GL_ONE);
         d->setPorterDuffData(1, 1, 1, 1, 1);
         break;
     default:
         break;
     }
 }

◆ updateFont()

void QOpenGLPaintEngine::updateFont ( const QFont & font )

Definition at line 2176 of file qpaintengine_opengl.cpp.

Referenced by updateState().

2177 {

2178 }

◆ updateMatrix()

void QOpenGLPaintEngine::updateMatrix ( const QTransform & matrix )

Definition at line 2180 of file qpaintengine_opengl.cpp.

Referenced by updateState().

 {
     Q_D(QOpenGLPaintEngine);
 
     d->matrix = mtx;
 
     d->mv_matrix[0][0] = mtx.m11();
     d->mv_matrix[0][1] = mtx.m12();
     d->mv_matrix[0][2] = 0;
     d->mv_matrix[0][3] = mtx.m13();
 
     d->mv_matrix[1][0] = mtx.m21();
     d->mv_matrix[1][1] = mtx.m22();
     d->mv_matrix[1][2] = 0;
     d->mv_matrix[1][3] = mtx.m23();
 
     d->mv_matrix[2][0] = 0;
     d->mv_matrix[2][1] = 0;
     d->mv_matrix[2][2] = 1;
     d->mv_matrix[2][3] = 0;
 
     d->mv_matrix[3][0] = mtx.dx();
     d->mv_matrix[3][1] = mtx.dy();
     d->mv_matrix[3][2] = 0;
     d->mv_matrix[3][3] = mtx.m33();
 
     d->txop = mtx.type();
 
     // 1/10000 == 0.0001, so we have good enough res to cover curves
     // that span the entire widget...
     d->inverseScale = qMax(1 / qMax( qMax(qAbs(mtx.m11()), qAbs(mtx.m22())),
                                      qMax(qAbs(mtx.m12()), qAbs(mtx.m21())) ),
                            qreal(0.0001));
 
     d->updateGLMatrix();
     d->updateFastPen();
 }

◆ updatePen()

void QOpenGLPaintEngine::updatePen ( const QPen & pen )

Definition at line 2140 of file qpaintengine_opengl.cpp.

Referenced by updateState().

 {
     Q_D(QOpenGLPaintEngine);
     Qt::PenStyle pen_style = pen.style();
     d->pen_brush_style = pen.brush().style();
     d->cpen = pen;
     d->has_pen = (pen_style != Qt::NoPen) && (d->pen_brush_style != Qt::NoBrush);
     d->updateUseEmulation();
 
     if (pen.isCosmetic()) {
         GLfloat width = pen.widthF() == 0.0f ? 1.0f : pen.widthF();
         glLineWidth(width);
         glPointSize(width);
     }
 
     if (d->pen_brush_style >= Qt::LinearGradientPattern
         && d->pen_brush_style <= Qt::ConicalGradientPattern)
     {
         d->setGLPen(Qt::white);
     } else {
         d->setGLPen(pen.color());
     }
 
     d->updateFastPen();
 }

◆ updateRenderHints()

void QOpenGLPaintEngine::updateRenderHints ( QPainter::RenderHints hints )

Definition at line 2440 of file qpaintengine_opengl.cpp.

Referenced by updateState().

 {
     Q_D(QOpenGLPaintEngine);
 
     d->flushDrawQueue();
     d->use_smooth_pixmap_transform = bool(hints & QPainter::SmoothPixmapTransform);
     if ((hints & QPainter::Antialiasing) || (hints & QPainter::HighQualityAntialiasing)) {
         if (d->use_fragment_programs && QGLOffscreen::isSupported()
             && (hints & QPainter::HighQualityAntialiasing)) {
             d->high_quality_antialiasing = true;
         } else {
             d->high_quality_antialiasing = false;
             if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
                 glEnable(GL_MULTISAMPLE);
         }
     } else {
         d->high_quality_antialiasing = false;
         if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
             glDisable(GL_MULTISAMPLE);
     }
 
     if (d->high_quality_antialiasing) {
         d->offscreen.initialize();
 
         if (!d->offscreen.isValid()) {
             DEBUG_ONCE_STR("Unable to initialize offscreen, disabling high quality antialiasing");
             d->high_quality_antialiasing = false;
             if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
                 glEnable(GL_MULTISAMPLE);
         }
     }
 
     d->has_antialiasing = d->high_quality_antialiasing
                           || ((hints & QPainter::Antialiasing)
                               && (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers));
 }

◆ updateState()

void QOpenGLPaintEngine::updateState ( const QPaintEngineState & state )

virtual

Reimplement this function to update the state of a paint engine.

When implemented, this function is responsible for checking the paint engine's current state and update the properties that are changed. Use the QPaintEngineState::state() function to find out which properties that must be updated, then use the corresponding GetFunction{get function} to retrieve the current values for the given properties.

See also: QPaintEngineState

Reimplemented from QPaintEngineEx.

Definition at line 1465 of file qpaintengine_opengl.cpp.

 {
     Q_D(QOpenGLPaintEngine);
     QPaintEngine::DirtyFlags flags = state.state();
 
     bool update_fast_pen = false;
 
     if (flags & DirtyOpacity) {
         update_fast_pen = true;
         d->opacity = state.opacity();
         if (d->opacity > 1.0f)
             d->opacity = 1.0f;
         if (d->opacity < 0.f)
             d->opacity = 0.f;
         // force update
         flags |= DirtyPen;
         flags |= DirtyBrush;
     }
 
     if (flags & DirtyTransform) {
         update_fast_pen = true;
         updateMatrix(state.transform());
         // brush setup depends on transform state
         if (state.brush().style() != Qt::NoBrush)
             flags |= DirtyBrush;
     }
 
     if (flags & DirtyPen) {
         update_fast_pen = true;
         updatePen(state.pen());
     }
 
     if (flags & (DirtyBrush | DirtyBrushOrigin)) {
         updateBrush(state.brush(), state.brushOrigin());
     }
 
     if (flags & DirtyFont) {
         updateFont(state.font());
     }
 
     if (state.state() & DirtyClipEnabled) {
         if (state.isClipEnabled())
             updateClipRegion(painter()->clipRegion(), Qt::ReplaceClip);
         else
             updateClipRegion(QRegion(), Qt::NoClip);
     }
 
     if (flags & DirtyClipPath) {
         updateClipRegion(QRegion(state.clipPath().toFillPolygon().toPolygon(),
                                  state.clipPath().fillRule()),
                          state.clipOperation());
     }
 
     if (flags & DirtyClipRegion) {
         updateClipRegion(state.clipRegion(), state.clipOperation());
     }
 
     if (flags & DirtyHints) {
         updateRenderHints(state.renderHints());
     }
 
     if (flags & DirtyCompositionMode) {
         updateCompositionMode(state.compositionMode());
     }
 
     if (update_fast_pen) {
         Q_D(QOpenGLPaintEngine);
         qreal pen_width = d->cpen.widthF();
         d->has_fast_pen =
             ((pen_width == 0 || (pen_width <= 1 && d->txop <= QTransform::TxTranslate))
              || d->cpen.isCosmetic())
             && d->cpen.style() == Qt::SolidLine
             && d->cpen.isSolid();
     }
 }

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

/src/opengl/qpaintengine_opengl_p.h
/src/opengl/qpaintengine_opengl.cpp

Public Functions

Private Functions

Additional Inherited Members

Detailed Description

Constructors and Destructors

◆ QOpenGLPaintEngine()

◆ ~QOpenGLPaintEngine()

Functions

◆ begin()

◆ brushChanged()

◆ brushOriginChanged()

◆ clip()

◆ clipEnabledChanged()

◆ compositionModeChanged()

◆ createState()

◆ drawEllipse()

◆ drawImage()

◆ drawLines() [1/2]

◆ drawLines() [2/2]

◆ drawPath()

◆ drawPixmap()

◆ drawPoints() [1/2]

◆ drawPoints() [2/2]

◆ drawPolygon() [1/2]

◆ drawPolygon() [2/2]

◆ drawPolyInternal()

◆ drawRects() [1/2]

◆ drawRects() [2/2]

◆ drawStaticTextItem()

◆ drawTextItem()

◆ drawTextureRect()

◆ drawTiledPixmap()

◆ end()

◆ fill()

◆ handle()

◆ opacityChanged()

◆ penChanged()

◆ renderHintsChanged()

◆ setState()

◆ state() [1/2]

◆ state() [2/2]

◆ supportsTransformations()

◆ transformChanged()

◆ type()

◆ updateBrush()

◆ updateClipRegion()

◆ updateCompositionMode()

◆ updateFont()

◆ updateMatrix()

◆ updatePen()

◆ updateRenderHints()

◆ updateState()