qopenglwindow.cpp

Jenkins

qopenglwindow.cpp

Absolute File Name:

/home/qt/qt5_coco/qt5/qtbase/src/gui/kernel/qopenglwindow.cpp

Line

Source

Count

/****************************************************************************

** Contact: https://www.qt.io/licensing/

** This file is part of the QtGui module of the Qt Toolkit.

** $QT_BEGIN_LICENSE:LGPL$

** Commercial License Usage

** Licensees holding valid commercial Qt licenses may use this file in

** accordance with the commercial license agreement provided with the

** Software or, alternatively, in accordance with the terms contained in

** a written agreement between you and The Qt Company. For licensing terms

** and conditions see https://www.qt.io/terms-conditions. For further

** information use the contact form at https://www.qt.io/contact-us.

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 3 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL3 included in the

** packaging of this file. Please review the following information to

** ensure the GNU Lesser General Public License version 3 requirements

** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU

** General Public License version 2.0 or (at your option) the GNU General

** Public license version 3 or any later version approved by the KDE Free

** Qt Foundation. The licenses are as published by the Free Software

** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3

** included in the packaging of this file. Please review the following

** information to ensure the GNU General Public License requirements will

** be met: https://www.gnu.org/licenses/gpl-2.0.html and

** https://www.gnu.org/licenses/gpl-3.0.html.

** $QT_END_LICENSE$

****************************************************************************/

#include "qopenglwindow.h"

#include "qpaintdevicewindow_p.h"

#include <QtGui/QOpenGLFramebufferObject>

#include <QtGui/QOpenGLPaintDevice>

#include <QtGui/QOpenGLFunctions>

#include <QtGui/private/qopengltextureblitter_p.h>

#include <QtGui/private/qopenglextensions_p.h>

#include <QtGui/private/qopenglcontext_p.h>

#include <QtGui/QMatrix4x4>

#include <QtGui/QOffscreenSurface>

QT_BEGIN_NAMESPACE

/*!

\class QOpenGLWindow

\inmodule QtGui

\since 5.4

\brief The QOpenGLWindow class is a convenience subclass of QWindow to perform OpenGL painting.

QOpenGLWindow is an enhanced QWindow that allows easily creating windows that

perform OpenGL rendering using an API that is compatible with QOpenGLWidget

and is similar to the legacy QGLWidget. Unlike QOpenGLWidget, QOpenGLWindow

has no dependency on the widgets module and offers better performance.

A typical application will subclass QOpenGLWindow and reimplement the following

virtual functions:

\list

\li initializeGL() to perform OpenGL resource initialization

\li resizeGL() to set up the transformation matrices and other window size dependent resources

\li paintGL() to issue OpenGL commands or draw using QPainter

\endlist

To schedule a repaint, call the update() function. Note that this will not

immediately result in a call to paintGL(). Calling update() multiple times in

a row will not change the behavior in any way.

This is a slot so it can be connected to a \l QTimer::timeout() signal to

perform animation. Note however that in the modern OpenGL world it is a much

better choice to rely on synchronization to the vertical refresh rate of the

display. See \l{QSurfaceFormat::setSwapInterval()}{setSwapInterval()} on a

description of the swap interval. With a swap interval of \c 1, which is the

case on most systems by default, the

\l{QOpenGLContext::swapBuffers()}{swapBuffers()} call, that is executed

internally by QOpenGLWindow after each repaint, will block and wait for

vsync. This means that whenever the swap is done, an update can be scheduled

again by calling update(), without relying on timers.

To request a specific configuration for the context, use setFormat()

like for any other QWindow. This allows, among others, requesting a

given OpenGL version and profile, or enabling depth and stencil

buffers.

Unlike QWindow, QOpenGLWindow allows opening a painter on itself and perform

QPainter-based drawing.

100

QOpenGLWindow supports multiple update behaviors. The default,

101

\c NoPartialUpdate is equivalent to a regular, OpenGL-based QWindow or the

102

legacy QGLWidget. In contrast, \c PartialUpdateBlit and \c PartialUpdateBlend are

103

more in line with QOpenGLWidget's way of working, where there is always an

104

extra, dedicated framebuffer object present. These modes allow, by

105

sacrificing some performance, redrawing only a smaller area on each paint and

106

having the rest of the content preserved from of the previous frame. This is

107

useful for applications than render incrementally using QPainter, because

108

this way they do not have to redraw the entire window content on each

109

paintGL() call.

110

111

Similarly to QOpenGLWidget, QOpenGLWindow supports the Qt::AA_ShareOpenGLContexts

112

attribute. When enabled, the OpenGL contexts of all QOpenGLWindow instances will share

113

with each other. This allows accessing each other's shareable OpenGL resources.

114

115

For more information on graphics in Qt, see \l {Graphics}.

/*!

\enum QOpenGLWindow::UpdateBehavior

120

121

This enum describes the update strategy of the QOpenGLWindow.

122

123

\value NoPartialUpdate Indicates that the entire window surface will

124

redrawn on each update and so no additional framebuffers are needed.

125

This is the setting used in most cases and is equivalent to how drawing

126

directly via QWindow would function.

127

128

\value PartialUpdateBlit Indicates that the drawing performed in paintGL()

129

does not cover the entire window. In this case an extra framebuffer object

130

is created under the hood, and rendering performed in paintGL() will target

131

this framebuffer. This framebuffer is then blitted onto the window surface's

132

default framebuffer after each paint. This allows having QPainter-based drawing

133

code in paintGL() which only repaints a smaller area at a time, because, unlike

134

NoPartialUpdate, the previous content is preserved.

135

136

\value PartialUpdateBlend Similar to PartialUpdateBlit, but instead of using

137

framebuffer blits, the contents of the extra framebuffer is rendered by

138

drawing a textured quad with blending enabled. This, unlike PartialUpdateBlit,

139

allows alpha blended content and works even when the glBlitFramebuffer is

140

not available. Performance-wise this setting is likely to be somewhat slower

141

than PartialUpdateBlit.

/*!

\fn void QOpenGLWindow::frameSwapped()

146

147

This signal is emitted after the potentially blocking

148

\l{QOpenGLContext::swapBuffers()}{buffer swap} has been done. Applications

149

that wish to continuously repaint synchronized to the vertical refresh,

150

should issue an update() upon this signal. This allows for a much smoother

151

experience compared to the traditional usage of timers.

152

153

154

// GLES2 builds won't have these constants with the suffixless names

155

#ifndef GL_READ_FRAMEBUFFER

156

#define GL_READ_FRAMEBUFFER 0x8CA8

157

#endif

158

#ifndef GL_DRAW_FRAMEBUFFER

159

#define GL_DRAW_FRAMEBUFFER 0x8CA9

160

#endif

161

162

class QOpenGLWindowPaintDevice : public QOpenGLPaintDevice

163

{

164

public:

165

QOpenGLWindowPaintDevice(QOpenGLWindow *window) : m_window(window) { }

166

void ensureActiveTarget() Q_DECL_OVERRIDE;

167

168

QOpenGLWindow *m_window;

169

};

170

171

class QOpenGLWindowPrivate : public QPaintDeviceWindowPrivate

172

{

173

Q_DECLARE_PUBLIC(QOpenGLWindow)

174

public:

175

QOpenGLWindowPrivate(QOpenGLContext *shareContext, QOpenGLWindow::UpdateBehavior updateBehavior)

176

: updateBehavior(updateBehavior)

177

, hasFboBlit(false)

178

, shareContext(shareContext)

179

{

180

if (!shareContext)

181

this->shareContext = qt_gl_global_share_context();

182

}

183

184

~QOpenGLWindowPrivate();

185

186

static QOpenGLWindowPrivate *get(QOpenGLWindow *w) { return w->d_func(); }

void bindFBO();

void initialize();

void beginPaint(const QRegion &region) Q_DECL_OVERRIDE;

192

void endPaint() Q_DECL_OVERRIDE;

193

void flush(const QRegion &region) Q_DECL_OVERRIDE;

194

195

QOpenGLWindow::UpdateBehavior updateBehavior;

196

bool hasFboBlit;

197

QScopedPointer<QOpenGLContext> context;

198

QOpenGLContext *shareContext;

199

QScopedPointer<QOpenGLFramebufferObject> fbo;

200

QScopedPointer<QOpenGLWindowPaintDevice> paintDevice;

201

QOpenGLTextureBlitter blitter;

202

QColor backgroundColor;

203

QScopedPointer<QOffscreenSurface> offscreenSurface;

204

};

205

206

QOpenGLWindowPrivate::~QOpenGLWindowPrivate()

{

Q_Q(QOpenGLWindow);

if (q->isValid()) {

q->makeCurrent(); // this works even when the platformwindow is destroyed

211

paintDevice.reset(0);

fbo.reset(0);

blitter.destroy();

q->doneCurrent();

}

}

void QOpenGLWindowPrivate::initialize()

{

Q_Q(QOpenGLWindow);

if (context)

return;

context.reset(new QOpenGLContext);

226

context->setShareContext(shareContext);

227

context->setFormat(q->requestedFormat());

228

if (!context->create())

229

qWarning("QOpenGLWindow::beginPaint: Failed to create context");

230

if (!context->makeCurrent(q))

231

qWarning("QOpenGLWindow::beginPaint: Failed to make context current");

232

233

paintDevice.reset(new QOpenGLWindowPaintDevice(q));

234

if (updateBehavior == QOpenGLWindow::PartialUpdateBlit)

235

hasFboBlit = QOpenGLFramebufferObject::hasOpenGLFramebufferBlit();

q->initializeGL();

}

void QOpenGLWindowPrivate::beginPaint(const QRegion &region)

{

Q_UNUSED(region);

Q_Q(QOpenGLWindow);

initialize();

context->makeCurrent(q);

247

248

const int deviceWidth = q->width() * q->devicePixelRatio();

249

const int deviceHeight = q->height() * q->devicePixelRatio();

250

const QSize deviceSize(deviceWidth, deviceHeight);

251

if (updateBehavior > QOpenGLWindow::NoPartialUpdate) {

updateBehavior...oPartialUpdate	Description
TRUE	never evaluated
FALSE	never evaluated

252

if (!fbo || fbo->size() != deviceSize) {

!fbo	Description
TRUE	never evaluated
FALSE	never evaluated

fbo->size() != deviceSize	Description
TRUE	never evaluated
FALSE	never evaluated

253

QOpenGLFramebufferObjectFormat fboFormat;

254

fboFormat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);

255

if (const int samples = q->requestedFormat().samples()();

256

if (samples

samples > 0	Description
TRUE	never evaluated
FALSE	never evaluated

> 0) {

samples > 0	Description
TRUE	never evaluated
FALSE	never evaluated

257

if (updateBehavior != QOpenGLWindow::PartialUpdateBlend)

updateBehavior...ialUpdateBlend	Description
TRUE	never evaluated
FALSE	never evaluated

258

fboFormat.setSamples(q->requestedFormat().samples()););

never executed: fboFormat.setSamples(samples);

259

else

260

qWarning("QOpenGLWindow: PartialUpdateBlend does not support multisampling");

never executed:

QMessageLogger(__FILE__, 260, __PRETTY_FUNCTION__).warning("QOpenGLWindow: PartialUpdateBlend does not support multisampling");

261

}

262

fbo.reset(new QOpenGLFramebufferObject(deviceSize, fboFormat));

263

markWindowAsDirty();

264

}

never executed: end of block

265

} else {

never executed: end of block

266

markWindowAsDirty();

267

}

never executed: end of block

268

269

paintDevice->setSize(QSize(deviceWidth, deviceHeight));

270

paintDevice->setDevicePixelRatio(q->devicePixelRatio());

271

context->functions()->glViewport(0, 0, deviceWidth, deviceHeight);

272

273

context->functions()->glBindFramebuffer(GL_FRAMEBUFFER, context->defaultFramebufferObject());

q->paintUnderGL();

if (updateBehavior > QOpenGLWindow::NoPartialUpdate)

updateBehavior...oPartialUpdate	Description
TRUE	never evaluated
FALSE	never evaluated

278

fbo->bind();

never executed: fbo->bind();

279

}

never executed: end of block

280

281

void QOpenGLWindowPrivate::endPaint()

{

Q_Q(QOpenGLWindow);

if (updateBehavior > QOpenGLWindow::NoPartialUpdate)

286

fbo->release();

287

288

context->functions()->glBindFramebuffer(GL_FRAMEBUFFER, context->defaultFramebufferObject());

289

290

if (updateBehavior == QOpenGLWindow::PartialUpdateBlit && hasFboBlit) {

291

const int deviceWidth = q->width() * q->devicePixelRatio();

292

const int deviceHeight = q->height() * q->devicePixelRatio();

293

QOpenGLExtensions extensions(context.data());

294

extensions.glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo->handle());

295

extensions.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, context->defaultFramebufferObject());

296

extensions.glBlitFramebuffer(0, 0, deviceWidth, deviceHeight,

297

0, 0, deviceWidth, deviceHeight,

298

GL_COLOR_BUFFER_BIT, GL_NEAREST);

299

} else if (updateBehavior > QOpenGLWindow::NoPartialUpdate) {

300

if (updateBehavior == QOpenGLWindow::PartialUpdateBlend) {

301

context->functions()->glEnable(GL_BLEND);

302

context->functions()->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

303

}

304

if (!blitter.isCreated())

305

blitter.create();

306

307

QRect windowRect(QPoint(0, 0), fbo->size());

308

QMatrix4x4 target = QOpenGLTextureBlitter::targetTransform(windowRect, windowRect);

309

blitter.bind();

310

blitter.blit(fbo->texture(), target, QOpenGLTextureBlitter::OriginBottomLeft);

311

blitter.release();

312

313

if (updateBehavior == QOpenGLWindow::PartialUpdateBlend)

314

context->functions()->glDisable(GL_BLEND);

}

q->paintOverGL();

}

void QOpenGLWindowPrivate::bindFBO()

321

{

322

if (updateBehavior > QOpenGLWindow::NoPartialUpdate)

323

fbo->bind();

324

else

325

QOpenGLFramebufferObject::bindDefault();

326

}

327

328

void QOpenGLWindowPrivate::flush(const QRegion &region)

{

Q_UNUSED(region);

Q_Q(QOpenGLWindow);

context->swapBuffers(q);

333

emit q->frameSwapped();

334

}

335

336

void QOpenGLWindowPaintDevice::ensureActiveTarget()

337

{

338

QOpenGLWindowPrivate::get(m_window)->bindFBO();

}

/*!

Constructs a new QOpenGLWindow with the given \a parent and \a updateBehavior.

343

344

\sa QOpenGLWindow::UpdateBehavior

345

346

QOpenGLWindow::QOpenGLWindow(QOpenGLWindow::UpdateBehavior updateBehavior, QWindow *parent)

347

: QPaintDeviceWindow(*(new QOpenGLWindowPrivate(Q_NULLPTR, updateBehavior)), parent)

348

{

349

setSurfaceType(QSurface::OpenGLSurface);

}

/*!

Constructs a new QOpenGLWindow with the given \a parent and \a updateBehavior. The QOpenGLWindow's context will share with \a shareContext.

354

355

\sa QOpenGLWindow::UpdateBehavior shareContext

356

357

QOpenGLWindow::QOpenGLWindow(QOpenGLContext *shareContext, UpdateBehavior updateBehavior, QWindow *parent)

358

: QPaintDeviceWindow(*(new QOpenGLWindowPrivate(shareContext, updateBehavior)), parent)

359

{

360

setSurfaceType(QSurface::OpenGLSurface);

}

/*!

Destroys the QOpenGLWindow instance, freeing its resources.

365

366

The OpenGLWindow's context is made current in the destructor, allowing for

367

safe destruction of any child object that may need to release OpenGL

368

resources belonging to the context provided by this window.

369

370

\warning if you have objects wrapping OpenGL resources (such as

371

QOpenGLBuffer, QOpenGLShaderProgram, etc.) as members of a QOpenGLWindow

372

subclass, you may need to add a call to makeCurrent() in that subclass'

373

destructor as well. Due to the rules of C++ object destruction, those objects

374

will be destroyed \e{before} calling this function (but after that the

375

destructor of the subclass has run), therefore making the OpenGL context

376

current in this function happens too late for their safe disposal.

\sa makeCurrent

\since 5.5

QOpenGLWindow::~QOpenGLWindow()

{

makeCurrent();

}

/*!

\return the update behavior for this QOpenGLWindow.

389

390

QOpenGLWindow::UpdateBehavior QOpenGLWindow::updateBehavior() const

391

{

392

Q_D(const QOpenGLWindow);

393

return d->updateBehavior;

}

/*!

\return \c true if the window's OpenGL resources, like the context, have

398

been successfully initialized. Note that the return value is always \c false

399

until the window becomes exposed (shown).

400

401

bool QOpenGLWindow::isValid() const

402

{

403

Q_D(const QOpenGLWindow);

404

return d->context && d->context->isValid();

}

/*!

Prepares for rendering OpenGL content for this window by making the

409

corresponding context current and binding the framebuffer object, if there is

410

one, in that context context.

411

412

It is not necessary to call this function in most cases, because it is called

413

automatically before invoking paintGL(). It is provided nonetheless to support

414

advanced, multi-threaded scenarios where a thread different than the GUI or main

415

thread may want to update the surface or framebuffer contents. See QOpenGLContext

416

for more information on threading related issues.

417

418

This function is suitable for calling also when the underlying platform window

419

is already destroyed. This means that it is safe to call this function from

420

a QOpenGLWindow subclass' destructor. If there is no native window anymore,

421

an offscreen surface is used instead. This ensures that OpenGL resource

422

cleanup operations in the destructor will always work, as long as

423

this function is called first.

424

425

\sa QOpenGLContext, context(), paintGL(), doneCurrent()

426

427

void QOpenGLWindow::makeCurrent()

{

Q_D(QOpenGLWindow);

if (!isValid())

return;

// The platform window may be destroyed at this stage and therefore

435

// makeCurrent() may not safely be called with 'this'.

436

if (handle()) {

437

d->context->makeCurrent(this);

438

} else {

439

if (!d->offscreenSurface) {

440

d->offscreenSurface.reset(new QOffscreenSurface);

441

d->offscreenSurface->setFormat(d->context->format());

442

d->offscreenSurface->create();

443

}

444

d->context->makeCurrent(d->offscreenSurface.data());

}

d->bindFBO();

}

/*!

Releases the context.

452

453

It is not necessary to call this function in most cases, since the widget

454

will make sure the context is bound and released properly when invoking

paintGL().

\sa makeCurrent()

void QOpenGLWindow::doneCurrent()

{

Q_D(QOpenGLWindow);

if (!isValid())

return;

d->context->doneCurrent();

}

/*!

\return The QOpenGLContext used by this window or \c 0 if not yet initialized.

471

472

QOpenGLContext *QOpenGLWindow::context() const

473

{

474

Q_D(const QOpenGLWindow);

475

return d->context.data();

}

/*!

\return The QOpenGLContext requested to be shared with this window's QOpenGLContext.

480

481

QOpenGLContext *QOpenGLWindow::shareContext() const

482

{

483

Q_D(const QOpenGLWindow);

484

return d->shareContext;

}

/*!

The framebuffer object handle used by this window.

489

490

When the update behavior is set to \c NoPartialUpdate, there is no separate

491

framebuffer object. In this case the returned value is the ID of the

492

default framebuffer.

493

494

Otherwise the value of the ID of the framebuffer object or \c 0 if not

495

yet initialized.

496

497

GLuint QOpenGLWindow::defaultFramebufferObject() const

498

{

499

Q_D(const QOpenGLWindow);

500

if (d->updateBehavior > NoPartialUpdate && d->fbo)

501

return d->fbo->handle();

502

else if (QOpenGLContext *ctx = QOpenGLContext::currentContext())

503

return ctx->defaultFramebufferObject();

else

return 0;

}

extern Q_GUI_EXPORT QImage qt_gl_read_framebuffer(const QSize &size, bool alpha_format, bool include_alpha);

509

510

/*!

511

Returns a 32-bit RGB image of the framebuffer.

512

513

\note This is a potentially expensive operation because it relies on

514

glReadPixels() to read back the pixels. This may be slow and can stall the

515

GPU pipeline.

516

517

\note When used together with update behavior \c NoPartialUpdate, the returned

518

image may not contain the desired content when called after the front and back

519

buffers have been swapped (unless preserved swap is enabled in the underlying

520

windowing system interface). In this mode the function reads from the back

521

buffer and the contents of that may not match the content on the screen (the

522

front buffer). In this case the only place where this function can safely be

523

used is paintGL() or paintOverGL().

524

525

QImage QOpenGLWindow::grabFramebuffer()

{

if (!isValid())

return QImage();

makeCurrent();

return qt_gl_read_framebuffer(size() * devicePixelRatio(), false, false);

}

/*!

This virtual function is called once before the first call to paintGL() or

536

resizeGL(). Reimplement it in a subclass.

537

538

This function should set up any required OpenGL resources and state.

539

540

There is no need to call makeCurrent() because this has already been done

541

when this function is called. Note however that the framebuffer, in case

542

partial update mode is used, is not yet available at this stage, so avoid

543

issuing draw calls from here. Defer such calls to paintGL() instead.

544

545

\sa paintGL(), resizeGL()

546

547

void QOpenGLWindow::initializeGL()

{

}

/*!

This virtual function is called whenever the widget has been resized.

553

Reimplement it in a subclass. The new size is passed in \a w and \a h.

554

555

\note This is merely a convenience function in order to provide an API that is

556

compatible with QOpenGLWidget. Unlike with QOpenGLWidget, derived classes are

557

free to choose to override resizeEvent() instead of this function.

558

559

\note Avoid issuing OpenGL commands from this function as there may not be a

560

context current when it is invoked. If it cannot be avoided, call makeCurrent().

561

562

\note Scheduling updates from here is not necessary. The windowing systems

563

will send expose events that trigger an update automatically.

564

565

\sa initializeGL(), paintGL()

566

567

void QOpenGLWindow::resizeGL(int w, int h)

{

Q_UNUSED(w);

Q_UNUSED(h);

}

/*!

This virtual function is called whenever the window contents needs to be

575

painted. Reimplement it in a subclass.

576

577

There is no need to call makeCurrent() because this has already

578

been done when this function is called.

579

580

Before invoking this function, the context and the framebuffer, if there is

581

one, are bound, and the viewport is set up by a call to glViewport(). No

582

other state is set and no clearing or drawing is performed by the framework.

583

584

\note When using a partial update behavior, like \c PartialUpdateBlend, the

585

output of the previous paintGL() call is preserved and, after the additional

586

drawing perfomed in the current invocation of the function, the content is

587

blitted or blended over the content drawn directly to the window in

588

paintUnderGL().

589

590

\sa initializeGL(), resizeGL(), paintUnderGL(), paintOverGL(), UpdateBehavior

591

592

void QOpenGLWindow::paintGL()

{

}

/*!

The virtual function is called before each invocation of paintGL().

598

599

When the update mode is set to \c NoPartialUpdate, there is no difference

600

between this function and paintGL(), performing rendering in either of them

601

leads to the same result.

602

603

The difference becomes significant when using \c PartialUpdateBlend, where an

604

extra framebuffer object is used. There, paintGL() targets this additional

605

framebuffer object, which preserves its contents, while paintUnderGL() and

606

paintOverGL() target the default framebuffer, i.e. directly the window

607

surface, the contents of which is lost after each displayed frame.

608

609

\note Avoid relying on this function when the update behavior is

610

\c PartialUpdateBlit. This mode involves blitting the extra framebuffer used by

611

paintGL() onto the default framebuffer after each invocation of paintGL(),

612

thus overwriting all drawing generated in this function.

613

614

\sa paintGL(), paintOverGL(), UpdateBehavior

615

616

void QOpenGLWindow::paintUnderGL()

{

}

/*!

This virtual function is called after each invocation of paintGL().

622

623

When the update mode is set to NoPartialUpdate, there is no difference

624

between this function and paintGL(), performing rendering in either of them

625

leads to the same result.

626

627

Like paintUnderGL(), rendering in this function targets the default

628

framebuffer of the window, regardless of the update behavior. It gets called

629

after paintGL() has returned and the blit (PartialUpdateBlit) or quad drawing

630

(PartialUpdateBlend) has been done.

631

632

\sa paintGL(), paintUnderGL(), UpdateBehavior

633

634

void QOpenGLWindow::paintOverGL()

{

}

/*!

Paint \a event handler. Calls paintGL().

\sa paintGL()

void QOpenGLWindow::paintEvent(QPaintEvent *event)

{

Q_UNUSED(event);

paintGL();

}

/*!

Resize \a event handler. Calls resizeGL().

\sa resizeGL()

void QOpenGLWindow::resizeEvent(QResizeEvent *event)

{

Q_UNUSED(event);

Q_D(QOpenGLWindow);

d->initialize();

resizeGL(width(), height());

}

/*!

\internal

int QOpenGLWindow::metric(PaintDeviceMetric metric) const

666

{

667

Q_D(const QOpenGLWindow);

switch (metric) {

case PdmDepth:

if (d->paintDevice)

return d->paintDevice->depth();

break;

default:

break;

}

return QPaintDeviceWindow::metric(metric);

}

/*!

\internal

QPaintDevice *QOpenGLWindow::redirected(QPoint *) const

684

{

685

Q_D(const QOpenGLWindow);

686

if (QOpenGLContext::currentContext() == d->context.data())

687

return d->paintDevice.data();

return 0;

}

QT_END_NAMESPACE

Generated by Squish Coco Non-Commercial 4.3.0-BETA-master-30-08-2018-4cb69e9