This enum describes the update semantics of QOpenGLWidget.

See also

updateBehavior(), setUpdateBehavior()

Constructs a widget which is a child of parent with widget flags set to flags.

Destroys the QOpenGLWidget instance, freeing its resources.

The QOpenGLWidget's context is made current in the destructor, allowing for safe destruction of any child object that may need to release OpenGL resources belonging to the context provided by this widget.

If you have objects wrapping OpenGL resources (such as QOpenGLBuffer, QOpenGLShaderProgram, etc.) as members of a OpenGLWidget subclass, you may need to add a call to makeCurrent() in that subclass destructor as well. Due to the rules of C++ object destruction, those objects will be destroyed before calling this function (but after that the destructor of the subclass has run), therefore making the OpenGL context current in this function happens too late for their safe disposal.

See also

makeCurrent()

This signal is emitted when the widget's top-level window is about to begin composing the textures of its QOpenGLWidget children and the other widgets.

This signal is emitted when the widget's size is changed and therefore the framebuffer object is going to be recreated.

Returns the QOpenGLContext used by this widget or a nullptr if not initialized. The context and the framebuffer object used by the widget changes when reparenting the widget via setParent().

See also

QOpenGLContext::setShareContext(), defaultFramebufferObject()

Returns The framebuffer object handle or 0 if not yet initialized.

The framebuffer object belongs to the context returned by context() and may not be accessible from other contexts. The context and the framebuffer object used by the widget changes when reparenting the widget via setParent(). In addition, the framebuffer object changes on each resize.

See also

context()

Releases the context. It is not necessary to call this method in most cases since the widget will make sure the context is bound and released properly when invoking paintGL().

Reimplemented from QWidget::event()

Returns the context and surface format used by this widget and its toplevel window. After the widget and its toplevel have both been created, resized and shown, this function will return the actual format of the context. This may differ from the requested format if the request could not be fulfilled by the platform. It is also possible to get larger color buffer sizes than requested.

When the widget's window and the related OpenGL resources are not yet initialized, the return value is the format that has been set via setFormat().

See also

setFormat(), context()

This signal is emitted after the widget's top-level window has finished composition and returned from its potentially blocking QOpenGLContext::swapBuffers() call.

Renders and returns a 32-bit RGB image of the framebuffer. This is a potentially expensive operation because it relies on glReadPixels() to read back the pixels. This may be slow and can stall the GPU pipeline.

Called once before the first call to paintGL() or resizeGL(). Reimplement it in a subclass. This fmethod should set up any required OpenGL resources and state.

There is no need to call makeCurrent() because this has already been done when this function is called. Note however that the framebuffer is not yet available at this stage, so avoid issuing draw calls from here. Defer such calls to paintGL() instead.

See also

paintGL(), resizeGL()

Returns true if the widget and OpenGL resources, like the context, have been successfully initialized. The return value is always false until the widget is shown.

Prepares for rendering OpenGL content for this widget by making the corresponding context current and binding the framebuffer object in that context. It is not necessary to call this function in most cases, because it is called automatically before invoking paintGL().

See also

context(), paintGL(), doneCurrent()

Returns the metric information for the given paint device metric.

See also

PaintDeviceMetric

Reimplemented from QPaintDevice::metric()

Returns a pointer to the paint engine used for drawing on the device.

Implements QPaintDevice::paintEngine()

This event handler can be reimplemented in a subclass to receive paint events passed in event. A paint event is a request to repaint all or part of a widget. It can happen for one of the following reasons.

• repaint() or update() was invoked
• widget was obscured and has now been uncovered
• some other reason

Many widgets can simply repaint their entire surface when asked to, but some slow widgets need to optimize by painting only the requested region: QPaintEvent::region(). This speed optimization does not change the result, as painting is clipped to that region during event processing. QListView and QTableView do this, for example.

CopperSpice also tries to speed up painting by merging multiple paint events into one. When update() is called several times or the window system sends several paint events, CopperSpice merges these events into one event with a larger region (see QRegion::united()). The repaint() method does not permit this optimization, so we suggest using update() whenever possible.

When the paint event occurs, the update region has normally been erased, so you are painting on the widget's background. The background can be set using setBackgroundRole() and setPalette().

QWidget automatically double-buffers its painting, so there is no need to write double-buffering code in paintEvent() to avoid flicker.

For the X11 platform it is possible to toggle global double buffering by calling qt_x11_set_global_double_buffer().

Generally you should refrain from calling update() or repaint() inside a paintEvent(). For example, calling update() or repaint() on children inside a paintevent() results in undefined behavior; the child may or may not get a paint event.

Warning

If you are using a custom paint engine without the CopperSpice backingstore, Qt::WA_PaintOnScreen must be set. Otherwise, QWidget::paintEngine() will never be called; the backingstore will be used instead.

See also

event(), repaint(), update(), QPainter, QPixmap, QPaintEvent

Reimplemented from QWidget::paintEvent()

Called whenever the widget needs to be painted. Reimplement it in a subclass. There is no need to call makeCurrent() because this has already been done when this method is called.

Before invoking this function, the context and the framebuffer are bound, and the viewport is set up by a call to glViewport(). No other state is set and no clearing or drawing is performed by the framework.

See also

initializeGL(), resizeGL()

This signal is emitted right after the framebuffer object has been recreated due to resizing the widget.

This event handler can be reimplemented in a subclass to receive widget resize events which are passed in the event parameter. When resizeEvent() is called, the widget already has its new geometry. The old size is accessible through QResizeEvent::oldSize().

The widget will be erased and receive a paint event immediately after processing the resize event. No drawing need be (or should be) done inside this handler.

See also

moveEvent(), event(), resize(), QResizeEvent, paintEvent()

Reimplemented from QWidget::resizeEvent()

Called any time the widget has been resized. The new size is specified by w and h. There is no need to call makeCurrent() because this has already been done when this function is called. Additionally, the framebuffer is also bound.

See also

initializeGL(), paintGL()

Sets the requested surface format.

When the format is not explicitly set via this function, the format returned by QSurfaceFormat::defaultFormat() will be used. This means that when having multiple OpenGL widgets, individual calls to this function can be replaced by one single call to QSurfaceFormat::setDefaultFormat() before creating the first widget.

Requesting an alpha buffer via this function will not lead to the desired results when the intention is to make other widgets beneath visible. Instead, use Qt::WA_AlwaysStackOnTop to enable semi-transparent QOpenGLWidget instances with other widgets visible underneath. Keep in mind however that this breaks the stacking order, so it will no longer be possible to have other widgets on top of the QOpenGLWidget.

See also

format(), Qt::WidgetAttribute, QSurfaceFormat::setDefaultFormat()

Sets this widget's update behavior to updateBehavior.

See also

updateBehavior()

Returns the update behavior of the widget.

See also

setUpdateBehavior()