Merge remote-tracking branch 'qt-qa-review/master'
[qt:qt.git] / src / opengl / qwindowsurface_gl.cpp
1 /****************************************************************************
2 **
3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4 ** All rights reserved.
5 ** Contact: Nokia Corporation (qt-info@nokia.com)
6 **
7 ** This file is part of the QtOpenGL module of the Qt Toolkit.
8 **
9 ** $QT_BEGIN_LICENSE:LGPL$
10 ** GNU Lesser General Public License Usage
11 ** This file may be used under the terms of the GNU Lesser General Public
12 ** License version 2.1 as published by the Free Software Foundation and
13 ** appearing in the file LICENSE.LGPL included in the packaging of this
14 ** file. Please review the following information to ensure the GNU Lesser
15 ** General Public License version 2.1 requirements will be met:
16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
17 **
18 ** In addition, as a special exception, Nokia gives you certain additional
19 ** rights. These rights are described in the Nokia Qt LGPL Exception
20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
21 **
22 ** GNU General Public License Usage
23 ** Alternatively, this file may be used under the terms of the GNU General
24 ** Public License version 3.0 as published by the Free Software Foundation
25 ** and appearing in the file LICENSE.GPL included in the packaging of this
26 ** file. Please review the following information to ensure the GNU General
27 ** Public License version 3.0 requirements will be met:
28 ** http://www.gnu.org/copyleft/gpl.html.
29 **
30 ** Other Usage
31 ** Alternatively, this file may be used in accordance with the terms and
32 ** conditions contained in a signed written agreement between you and Nokia.
33 **
34 **
35 **
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42 #include <QtGui/QApplication>
43 #include <QtGui/QColormap>
44 #include <QtGui/QDesktopWidget>
45 #include <QtGui/QPaintDevice>
46 #include <QtGui/QWidget>
47
48 #include <qglframebufferobject.h>
49 #include <qglpixelbuffer.h>
50 #include <qcolormap.h>
51 #include <qdesktopwidget.h>
52 #include <private/qwidget_p.h>
53 #include "qdebug.h"
54
55 #ifdef Q_WS_X11
56 #include <private/qt_x11_p.h>
57 #include <qx11info_x11.h>
58
59 #ifndef QT_OPENGL_ES
60 #include <GL/glx.h>
61 #include <X11/Xlib.h>
62 #endif
63 #endif //Q_WS_X11
64
65 #include <private/qglextensions_p.h>
66 #include <private/qwindowsurface_gl_p.h>
67
68 #include <private/qgl_p.h>
69
70 #include <private/qglpixelbuffer_p.h>
71 #include <private/qgraphicssystem_gl_p.h>
72
73 #include <private/qpaintengineex_opengl2_p.h>
74 #include <private/qpixmapdata_gl_p.h>
75
76 #ifndef QT_OPENGL_ES_2
77 #include <private/qpaintengine_opengl_p.h>
78 #endif
79
80 #ifndef GLX_ARB_multisample
81 #define GLX_SAMPLE_BUFFERS_ARB  100000
82 #define GLX_SAMPLES_ARB         100001
83 #endif
84
85 #ifndef QT_NO_EGL
86 #include <private/qeglcontext_p.h>
87 #endif
88
89 QT_BEGIN_NAMESPACE
90
91 //
92 // QGLGraphicsSystem
93 //
94 #ifdef Q_WS_WIN
95 extern Q_GUI_EXPORT bool qt_win_owndc_required;
96 #endif
97 QGLGraphicsSystem::QGLGraphicsSystem(bool useX11GL)
98     : QGraphicsSystem(), m_useX11GL(useX11GL)
99 {
100 #if defined(Q_WS_X11) && !defined(QT_OPENGL_ES)
101     // only override the system defaults if the user hasn't already
102     // picked a visual
103     if (X11->visual == 0 && X11->visual_id == -1 && X11->visual_class == -1) {
104         // find a double buffered, RGBA visual that supports OpenGL
105         // and set that as the default visual for windows in Qt
106         int i = 0;
107         int spec[16];
108         spec[i++] = GLX_RGBA;
109         spec[i++] = GLX_DOUBLEBUFFER;
110
111         if (!qgetenv("QT_GL_SWAPBUFFER_PRESERVE").isNull()) {
112             spec[i++] = GLX_DEPTH_SIZE;
113             spec[i++] = 8;
114             spec[i++] = GLX_STENCIL_SIZE;
115             spec[i++] = 8;
116             spec[i++] = GLX_SAMPLE_BUFFERS_ARB;
117             spec[i++] = 1;
118             spec[i++] = GLX_SAMPLES_ARB;
119             spec[i++] = 4;
120         }
121
122         spec[i++] = XNone;
123
124         XVisualInfo *vi = glXChooseVisual(X11->display, X11->defaultScreen, spec);
125         if (vi) {
126             X11->visual_id = vi->visualid;
127             X11->visual_class = vi->c_class;
128
129             QGLFormat format;
130             int res;
131             glXGetConfig(X11->display, vi, GLX_LEVEL, &res);
132             format.setPlane(res);
133             glXGetConfig(X11->display, vi, GLX_DOUBLEBUFFER, &res);
134             format.setDoubleBuffer(res);
135             glXGetConfig(X11->display, vi, GLX_DEPTH_SIZE, &res);
136             format.setDepth(res);
137             if (format.depth())
138                 format.setDepthBufferSize(res);
139             glXGetConfig(X11->display, vi, GLX_RGBA, &res);
140             format.setRgba(res);
141             glXGetConfig(X11->display, vi, GLX_RED_SIZE, &res);
142             format.setRedBufferSize(res);
143             glXGetConfig(X11->display, vi, GLX_GREEN_SIZE, &res);
144             format.setGreenBufferSize(res);
145             glXGetConfig(X11->display, vi, GLX_BLUE_SIZE, &res);
146             format.setBlueBufferSize(res);
147             glXGetConfig(X11->display, vi, GLX_ALPHA_SIZE, &res);
148             format.setAlpha(res);
149             if (format.alpha())
150                 format.setAlphaBufferSize(res);
151             glXGetConfig(X11->display, vi, GLX_ACCUM_RED_SIZE, &res);
152             format.setAccum(res);
153             if (format.accum())
154                 format.setAccumBufferSize(res);
155             glXGetConfig(X11->display, vi, GLX_STENCIL_SIZE, &res);
156             format.setStencil(res);
157             if (format.stencil())
158                 format.setStencilBufferSize(res);
159             glXGetConfig(X11->display, vi, GLX_STEREO, &res);
160             format.setStereo(res);
161             glXGetConfig(X11->display, vi, GLX_SAMPLE_BUFFERS_ARB, &res);
162             format.setSampleBuffers(res);
163             if (format.sampleBuffers()) {
164                 glXGetConfig(X11->display, vi, GLX_SAMPLES_ARB, &res);
165                 format.setSamples(res);
166             }
167
168             QGLWindowSurface::surfaceFormat = format;
169             XFree(vi);
170
171             printf("using visual class %x, id %x\n", X11->visual_class, X11->visual_id);
172         }
173     }
174 #elif defined(Q_WS_WIN)
175     QGLWindowSurface::surfaceFormat.setDoubleBuffer(true);
176
177     qt_win_owndc_required = true;
178 #endif
179 }
180
181 //
182 // QGLWindowSurface
183 //
184 class QGLGlobalShareWidget
185 {
186 public:
187     QGLGlobalShareWidget() : widget(0), initializing(false) {
188         created = true;
189     }
190
191     QGLWidget *shareWidget() {
192         if (!initializing && !widget && !cleanedUp) {
193             initializing = true;
194             widget = new QGLWidget(QGLFormat(QGL::SingleBuffer | QGL::NoDepthBuffer | QGL::NoStencilBuffer));
195 #ifdef Q_OS_SYMBIAN
196             if (!widget->context()->isValid()) {
197                 delete widget;
198                 widget = 0;
199                 initializing = false;
200                 return 0;
201             }
202 #endif
203             widget->resize(1, 1);
204
205             // We don't need this internal widget to appear in QApplication::topLevelWidgets()
206             if (QWidgetPrivate::allWidgets)
207                 QWidgetPrivate::allWidgets->remove(widget);
208             initializing = false;
209         }
210         return widget;
211     }
212
213     // destroys the share widget and prevents recreation
214     void cleanup() {
215         QGLWidget *w = widget;
216         cleanedUp = true;
217         widget = 0;
218         delete w;
219     }
220
221     // destroys the share widget, but allows it to be recreated later on
222     void destroy() {
223         if (cleanedUp)
224             return;
225
226         QGLWidget *w = widget;
227
228         // prevent potential recursions
229         cleanedUp = true;
230         widget = 0;
231         delete w;
232         cleanedUp = false;
233     }
234
235     static bool cleanedUp;
236     static bool created;
237
238 private:
239     QGLWidget *widget;
240     bool initializing;
241 };
242
243 bool QGLGlobalShareWidget::cleanedUp = false;
244 bool QGLGlobalShareWidget::created = false;
245
246 static void qt_cleanup_gl_share_widget();
247 Q_GLOBAL_STATIC_WITH_INITIALIZER(QGLGlobalShareWidget, _qt_gl_share_widget,
248                                  {
249                                      qAddPostRoutine(qt_cleanup_gl_share_widget);
250                                  })
251
252 static void qt_cleanup_gl_share_widget()
253 {
254     if (QGLGlobalShareWidget::created)
255         _qt_gl_share_widget()->cleanup();
256 }
257
258 QGLWidget* qt_gl_share_widget()
259 {
260     if (QGLGlobalShareWidget::cleanedUp)
261         return 0;
262     return _qt_gl_share_widget()->shareWidget();
263 }
264
265 void qt_destroy_gl_share_widget()
266 {
267     if (QGLGlobalShareWidget::created)
268         _qt_gl_share_widget()->destroy();
269 }
270
271 const QGLContext *qt_gl_share_context()
272 {
273     QGLWidget *widget = qt_gl_share_widget();
274     if (widget)
275         return widget->context();
276     return 0;
277 }
278
279 struct QGLWindowSurfacePrivate
280 {
281     QGLFramebufferObject *fbo;
282     QGLPixelBuffer *pb;
283     GLuint tex_id;
284     GLuint pb_tex_id;
285
286     int tried_fbo : 1;
287     int tried_pb : 1;
288     int destructive_swap_buffers : 1;
289     int geometry_updated : 1;
290     int did_paint : 1;
291
292     QGLContext *ctx;
293
294     QList<QGLContext **> contexts;
295
296     QRegion paintedRegion;
297     QSize size;
298
299     QSize textureSize;
300
301     QList<QImage> buffers;
302     QGLWindowSurfaceGLPaintDevice glDevice;
303     QGLWindowSurface* q_ptr;
304
305     bool swap_region_support;
306 };
307
308 QGLFormat QGLWindowSurface::surfaceFormat;
309 QGLWindowSurface::SwapMode QGLWindowSurface::swapBehavior = QGLWindowSurface::AutomaticSwap;
310
311 void QGLWindowSurfaceGLPaintDevice::endPaint()
312 {
313     glFlush();
314     QGLPaintDevice::endPaint();
315 }
316
317 QSize QGLWindowSurfaceGLPaintDevice::size() const
318 {
319     return d->size;
320 }
321
322 QGLContext* QGLWindowSurfaceGLPaintDevice::context() const
323 {
324     return d->ctx;
325 }
326
327
328 int QGLWindowSurfaceGLPaintDevice::metric(PaintDeviceMetric m) const
329 {
330     return qt_paint_device_metric(d->q_ptr->window(), m);
331 }
332
333 QPaintEngine *QGLWindowSurfaceGLPaintDevice::paintEngine() const
334 {
335     return qt_qgl_paint_engine();
336 }
337
338 QGLWindowSurface::QGLWindowSurface(QWidget *window)
339     : QWindowSurface(window), d_ptr(new QGLWindowSurfacePrivate)
340 {
341 //    Q_ASSERT(window->isTopLevel());
342     d_ptr->pb = 0;
343     d_ptr->fbo = 0;
344     d_ptr->ctx = 0;
345     d_ptr->tex_id = 0;
346 #if defined (QT_OPENGL_ES_2)
347     d_ptr->tried_fbo = true;
348     d_ptr->tried_pb = true;
349 #else
350     d_ptr->tried_fbo = false;
351     d_ptr->tried_pb = false;
352 #endif
353     d_ptr->destructive_swap_buffers = qgetenv("QT_GL_SWAPBUFFER_PRESERVE").isNull();
354     d_ptr->glDevice.d = d_ptr;
355     d_ptr->q_ptr = this;
356     d_ptr->geometry_updated = false;
357     d_ptr->did_paint = false;
358     d_ptr->swap_region_support = false;
359 }
360
361 QGLWindowSurface::~QGLWindowSurface()
362 {
363     if (d_ptr->ctx)
364         glDeleteTextures(1, &d_ptr->tex_id);
365 #ifndef Q_WS_QPA // Don't delete the contexts. Destroying the window does that for us
366     foreach(QGLContext **ctx, d_ptr->contexts) {
367         delete *ctx;
368         *ctx = 0;
369     }
370 #endif
371     delete d_ptr->pb;
372     delete d_ptr->fbo;
373     delete d_ptr;
374
375     if (QGLGlobalShareWidget::cleanedUp)
376         return;
377
378 #ifdef Q_OS_SYMBIAN
379     // Destroy the context if necessary.
380     if (qt_gl_share_widget() && !qt_gl_share_context()->isSharing())
381         qt_destroy_gl_share_widget();
382 #endif
383 }
384
385 void QGLWindowSurface::deleted(QObject *object)
386 {
387     QWidget *widget = qobject_cast<QWidget *>(object);
388     if (widget) {
389         if (widget == window()) {
390             // Make sure that the fbo is destroyed before destroying its context.
391             delete d_ptr->fbo;
392             d_ptr->fbo = 0;
393         }
394
395 #ifndef Q_WS_QPA //no need to specifically delete the QGLContext as it will be deleted by QWidget
396         QWidgetPrivate *widgetPrivate = widget->d_func();
397         if (widgetPrivate->extraData()) {
398             union { QGLContext **ctxPtrPtr; void **voidPtrPtr; };
399             voidPtrPtr = &widgetPrivate->extraData()->glContext;
400             int index = d_ptr->contexts.indexOf(ctxPtrPtr);
401             if (index != -1) {
402                 delete *ctxPtrPtr;
403                 *ctxPtrPtr = 0;
404                 d_ptr->contexts.removeAt(index);
405             }
406         }
407 #endif
408     }
409 }
410
411 void QGLWindowSurface::hijackWindow(QWidget *widget)
412 {
413     QWidgetPrivate *widgetPrivate = widget->d_func();
414     widgetPrivate->createExtra();
415     if (widgetPrivate->extraData()->glContext)
416         return;
417
418     QGLContext *ctx = NULL;
419
420     // For translucent top-level widgets we need alpha in the format.
421     if (widget->testAttribute(Qt::WA_TranslucentBackground)) {
422         QGLFormat modFormat(surfaceFormat);
423         modFormat.setSampleBuffers(false);
424         modFormat.setSamples(0);
425         modFormat.setAlpha(true);
426         ctx = new QGLContext(modFormat, widget);
427     } else
428         ctx = new QGLContext(surfaceFormat, widget);
429
430     ctx->create(qt_gl_share_context());
431 #ifdef Q_OS_SYMBIAN
432     if (!ctx->isValid()) {
433         delete ctx;
434         return;
435     }
436 #endif
437 #ifndef QT_NO_EGL
438     static bool checkedForNOKSwapRegion = false;
439     static bool haveNOKSwapRegion = false;
440
441     if (!checkedForNOKSwapRegion) {
442         haveNOKSwapRegion = QEgl::hasExtension("EGL_NOK_swap_region2");
443         checkedForNOKSwapRegion = true;
444
445         if (haveNOKSwapRegion)
446             qDebug() << "Found EGL_NOK_swap_region2 extension. Using partial updates.";
447     }
448
449     d_ptr->destructive_swap_buffers = true;
450     if (ctx->d_func()->eglContext->configAttrib(EGL_SURFACE_TYPE)&EGL_SWAP_BEHAVIOR_PRESERVED_BIT) {
451         EGLint swapBehavior;
452         if (eglQuerySurface(ctx->d_func()->eglContext->display(), ctx->d_func()->eglSurface
453                             , EGL_SWAP_BEHAVIOR, &swapBehavior)) {
454             d_ptr->destructive_swap_buffers = (swapBehavior != EGL_BUFFER_PRESERVED);
455         }
456     }
457
458     d_ptr->swap_region_support = haveNOKSwapRegion;
459 #endif
460
461     widgetPrivate->extraData()->glContext = ctx;
462
463     union { QGLContext **ctxPtrPtr; void **voidPtrPtr; };
464
465     connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(deleted(QObject*)));
466
467     voidPtrPtr = &widgetPrivate->extraData()->glContext;
468     d_ptr->contexts << ctxPtrPtr;
469
470 #ifndef Q_OS_SYMBIAN
471     qDebug() << "hijackWindow() context created for" << widget << d_ptr->contexts.size();
472 #endif
473 }
474
475 QGLContext *QGLWindowSurface::context() const
476 {
477     return d_ptr->ctx;
478 }
479
480 QPaintDevice *QGLWindowSurface::paintDevice()
481 {
482     updateGeometry();
483
484 #ifdef Q_OS_SYMBIAN
485     // On symbian we always return glDevice, even if it's invalid
486     return &d_ptr->glDevice;
487 #else
488     if (d_ptr->pb)
489         return d_ptr->pb;
490
491     if (d_ptr->ctx)
492         return &d_ptr->glDevice;
493
494     QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext);
495     ctx->makeCurrent();
496
497     Q_ASSERT(d_ptr->fbo);
498     return d_ptr->fbo;
499 #endif
500 }
501
502 static void drawTexture(const QRectF &rect, GLuint tex_id, const QSize &texSize, const QRectF &src = QRectF());
503
504 void QGLWindowSurface::beginPaint(const QRegion &)
505 {
506     d_ptr->did_paint = true;
507     updateGeometry();
508
509     int clearFlags = 0;
510
511     QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext);
512
513     if (!ctx)
514         return;
515
516     if (ctx->d_func()->workaround_needsFullClearOnEveryFrame)
517         clearFlags = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
518     else if (ctx->format().alpha())
519         clearFlags = GL_COLOR_BUFFER_BIT;
520
521     if (clearFlags) {
522         if (d_ptr->fbo)
523             d_ptr->fbo->bind();
524
525         glClearColor(0.0, 0.0, 0.0, 0.0);
526         glClear(clearFlags);
527
528         if (d_ptr->fbo)
529             d_ptr->fbo->release();
530     }
531 }
532
533 void QGLWindowSurface::endPaint(const QRegion &rgn)
534 {
535     if (context())
536         d_ptr->paintedRegion |= rgn;
537
538     d_ptr->buffers.clear();
539 }
540
541 static void blitTexture(QGLContext *ctx, GLuint texture, const QSize &viewport, const QSize &texSize, const QRect &targetRect, const QRect &sourceRect)
542 {
543     glDisable(GL_DEPTH_TEST);
544     glDisable(GL_SCISSOR_TEST);
545     glDisable(GL_BLEND);
546
547     glViewport(0, 0, viewport.width(), viewport.height());
548
549     QGLShaderProgram *blitProgram =
550         QGLEngineSharedShaders::shadersForContext(ctx)->blitProgram();
551     blitProgram->bind();
552     blitProgram->setUniformValue("imageTexture", 0 /*QT_IMAGE_TEXTURE_UNIT*/);
553
554     // The shader manager's blit program does not multiply the
555     // vertices by the pmv matrix, so we need to do the effect
556     // of the orthographic projection here ourselves.
557     QRectF r;
558     qreal w = viewport.width();
559     qreal h = viewport.height();
560     r.setLeft((targetRect.left() / w) * 2.0f - 1.0f);
561     if (targetRect.right() == (viewport.width() - 1))
562         r.setRight(1.0f);
563     else
564         r.setRight((targetRect.right() / w) * 2.0f - 1.0f);
565     r.setBottom((targetRect.top() / h) * 2.0f - 1.0f);
566     if (targetRect.bottom() == (viewport.height() - 1))
567         r.setTop(1.0f);
568     else
569         r.setTop((targetRect.bottom() / w) * 2.0f - 1.0f);
570
571     drawTexture(r, texture, texSize, sourceRect);
572 }
573
574
575 void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
576 {
577     //### Find out why d_ptr->geometry_updated isn't always false.
578     // flush() should not be called when d_ptr->geometry_updated is true. It assumes that either
579     // d_ptr->fbo or d_ptr->pb is allocated and has the correct size.
580     if (d_ptr->geometry_updated)
581         return;
582
583     // did_paint is set to true in ::beginPaint. ::beginPaint means that we
584     // at least cleared the background (= painted something). In EGL API it's a
585     // mistake to call swapBuffers if nothing was painted unless
586     // EGL_BUFFER_PRESERVED is set. This check protects the flush func from
587     // being executed if it's for nothing.
588     if (!d_ptr->destructive_swap_buffers && !d_ptr->did_paint)
589         return;
590
591 #ifdef Q_OS_SYMBIAN
592     if (window() != widget) {
593         // For performance reasons we don't support
594         // flushing native child widgets on Symbian.
595         // It breaks overlapping native child widget
596         // rendering in some cases but we prefer performance.
597         return;
598     }
599 #endif
600
601
602     QWidget *parent = widget->internalWinId() ? widget : widget->nativeParentWidget();
603     Q_ASSERT(parent);
604
605 #if !defined(Q_WS_QPA)
606     if (!geometry().isValid())
607         return;
608 #else
609     if (!size().isValid())
610         return;
611 #endif
612
613     // Needed to support native child-widgets...
614     hijackWindow(parent);
615
616     QRect br = rgn.boundingRect().translated(offset);
617     br = br.intersected(window()->rect());
618     QPoint wOffset = qt_qwidget_data(parent)->wrect.topLeft();
619     QRect rect = br.translated(-offset - wOffset);
620
621     const GLenum target = GL_TEXTURE_2D;
622     Q_UNUSED(target);
623
624     if (QGLWindowSurface::swapBehavior == QGLWindowSurface::KillSwap)
625         return;
626
627     if (context()) {
628         context()->makeCurrent();
629
630         if (context()->format().doubleBuffer()) {
631 #if !defined(QT_OPENGL_ES_2)
632             if (d_ptr->destructive_swap_buffers) {
633                 glBindTexture(target, d_ptr->tex_id);
634
635                 QVector<QRect> rects = d_ptr->paintedRegion.rects();
636                 for (int i = 0; i < rects.size(); ++i) {
637                     QRect br = rects.at(i);
638                     if (br.isEmpty())
639                         continue;
640
641                     const uint bottom = window()->height() - (br.y() + br.height());
642                     glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());
643                 }
644
645                 glBindTexture(target, 0);
646
647                 QRegion dirtyRegion = QRegion(window()->rect()) - d_ptr->paintedRegion;
648
649                 if (!dirtyRegion.isEmpty()) {
650                     glMatrixMode(GL_MODELVIEW);
651                     glLoadIdentity();
652
653                     glMatrixMode(GL_PROJECTION);
654                     glLoadIdentity();
655 #ifndef QT_OPENGL_ES
656                     glOrtho(0, window()->width(), window()->height(), 0, -999999, 999999);
657 #else
658                     glOrthof(0, window()->width(), window()->height(), 0, -999999, 999999);
659 #endif
660                     glViewport(0, 0, window()->width(), window()->height());
661
662                     QVector<QRect> rects = dirtyRegion.rects();
663                     glColor4f(1, 1, 1, 1);
664                     for (int i = 0; i < rects.size(); ++i) {
665                         QRect rect = rects.at(i);
666                         if (rect.isEmpty())
667                             continue;
668
669                         drawTexture(rect, d_ptr->tex_id, window()->size(), rect);
670                     }
671                 }
672             }
673 #endif
674             bool doingPartialUpdate = false;
675             if (d_ptr->swap_region_support) {
676                 if (QGLWindowSurface::swapBehavior == QGLWindowSurface::AutomaticSwap)
677                     doingPartialUpdate = br.width() * br.height() < parent->geometry().width() * parent->geometry().height() * 0.2;
678                 else if (QGLWindowSurface::swapBehavior == QGLWindowSurface::AlwaysPartialSwap)
679                     doingPartialUpdate = true;
680             }
681
682             QGLContext *ctx = reinterpret_cast<QGLContext *>(parent->d_func()->extraData()->glContext);
683             if (widget != window()) {
684                 if (initializeOffscreenTexture(window()->size()))
685                     qWarning() << "QGLWindowSurface: Flushing to native child widget, may lead to significant performance loss";
686                 glBindTexture(target, d_ptr->tex_id);
687
688                 const uint bottom = window()->height() - (br.y() + br.height());
689                 glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());
690
691                 glBindTexture(target, 0);
692
693                 ctx->makeCurrent();
694                 if (doingPartialUpdate)
695                     blitTexture(ctx, d_ptr->tex_id, parent->size(), window()->size(), rect, br);
696                 else
697                     blitTexture(ctx, d_ptr->tex_id, parent->size(), window()->size(), parent->rect(), parent->rect().translated(offset + wOffset));
698             }
699
700             if (doingPartialUpdate)
701                 ctx->d_func()->swapRegion(br);
702             else
703                 ctx->swapBuffers();
704
705             d_ptr->paintedRegion = QRegion();
706         } else {
707             glFlush();
708         }
709         return;
710     }
711
712     QGLContext *previous_ctx = const_cast<QGLContext *>(QGLContext::currentContext());
713     QGLContext *ctx = reinterpret_cast<QGLContext *>(parent->d_func()->extraData()->glContext);
714 #ifdef Q_OS_SYMBIAN
715     if (!ctx)
716         return;
717 #endif
718
719     // QPainter::end() should have unbound the fbo, otherwise something is very wrong...
720     Q_ASSERT(!d_ptr->fbo || !d_ptr->fbo->isBound());
721
722     if (ctx != previous_ctx) {
723         ctx->makeCurrent();
724     }
725
726     QSize size = widget->rect().size();
727     if (d_ptr->destructive_swap_buffers && ctx->format().doubleBuffer()) {
728         rect = parent->rect();
729         br = rect.translated(wOffset + offset);
730         size = parent->size();
731     }
732
733     glDisable(GL_SCISSOR_TEST);
734
735     if (d_ptr->fbo && (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit)) {
736         const int h = d_ptr->fbo->height();
737
738         const int sx0 = br.left();
739         const int sx1 = br.left() + br.width();
740         const int sy0 = h - (br.top() + br.height());
741         const int sy1 = h - br.top();
742
743         const int tx0 = rect.left();
744         const int tx1 = rect.left() + rect.width();
745         const int ty0 = parent->height() - (rect.top() + rect.height());
746         const int ty1 = parent->height() - rect.top();
747
748         if (window() == parent || d_ptr->fbo->format().samples() <= 1) {
749             if (ctx->d_ptr->current_fbo != 0)
750                 glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, 0);
751
752             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, d_ptr->fbo->handle());
753
754             glBlitFramebufferEXT(sx0, sy0, sx1, sy1,
755                     tx0, ty0, tx1, ty1,
756                     GL_COLOR_BUFFER_BIT,
757                     GL_NEAREST);
758
759             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, 0);
760         } else {
761 #ifndef Q_OS_SYMBIAN // We don't have FBO pool on Symbian
762             // can't do sub-region blits with multisample FBOs
763             QGLFramebufferObject *temp = qgl_fbo_pool()->acquire(d_ptr->fbo->size(), QGLFramebufferObjectFormat());
764
765             glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, temp->handle());
766             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, d_ptr->fbo->handle());
767
768             glBlitFramebufferEXT(0, 0, d_ptr->fbo->width(), d_ptr->fbo->height(),
769                     0, 0, d_ptr->fbo->width(), d_ptr->fbo->height(),
770                     GL_COLOR_BUFFER_BIT,
771                     GL_NEAREST);
772
773             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, temp->handle());
774             glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, 0);
775
776             glBlitFramebufferEXT(sx0, sy0, sx1, sy1,
777                     tx0, ty0, tx1, ty1,
778                     GL_COLOR_BUFFER_BIT,
779                     GL_NEAREST);
780
781             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, 0);
782
783             qgl_fbo_pool()->release(temp);
784 #endif // Q_OS_SYMBIAN
785         }
786
787         ctx->d_ptr->current_fbo = 0;
788     }
789 #if !defined(QT_OPENGL_ES_2)
790     else {
791         GLuint texture;
792     if (d_ptr->fbo) {
793         texture = d_ptr->fbo->texture();
794     } else {
795         d_ptr->pb->makeCurrent();
796         glBindTexture(target, d_ptr->pb_tex_id);
797         const uint bottom = window()->height() - (br.y() + br.height());
798         glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());
799         texture = d_ptr->pb_tex_id;
800         glBindTexture(target, 0);
801     }
802
803         glDisable(GL_DEPTH_TEST);
804
805         if (d_ptr->fbo) {
806             d_ptr->fbo->release();
807         } else {
808             ctx->makeCurrent();
809         }
810
811         glMatrixMode(GL_MODELVIEW);
812         glLoadIdentity();
813
814         glMatrixMode(GL_PROJECTION);
815         glLoadIdentity();
816 #ifndef QT_OPENGL_ES
817         glOrtho(0, size.width(), size.height(), 0, -999999, 999999);
818 #else
819         glOrthof(0, size.width(), size.height(), 0, -999999, 999999);
820 #endif
821         glViewport(0, 0, size.width(), size.height());
822
823         glColor4f(1, 1, 1, 1);
824         drawTexture(rect, texture, window()->size(), br);
825
826         if (d_ptr->fbo)
827             d_ptr->fbo->bind();
828     }
829 #else
830     // OpenGL/ES 2.0 version of the fbo blit.
831     else if (d_ptr->fbo) {
832         Q_UNUSED(target);
833
834         if (d_ptr->fbo->isBound())
835             d_ptr->fbo->release();
836
837         blitTexture(ctx, d_ptr->fbo->texture(), size, window()->size(), rect, br);
838     }
839 #endif
840
841     if (ctx->format().doubleBuffer())
842         ctx->swapBuffers();
843     else
844         glFlush();
845
846     d_ptr->did_paint = false;
847 }
848
849
850 #if !defined(Q_WS_QPA)
851 void QGLWindowSurface::setGeometry(const QRect &rect)
852 {
853     QWindowSurface::setGeometry(rect);
854     d_ptr->geometry_updated = true;
855 }
856 #else
857 void QGLWindowSurface::resize(const QSize &size)
858 {
859     QWindowSurface::resize(size);
860     d_ptr->geometry_updated = true;
861 }
862 #endif
863
864 void QGLWindowSurface::updateGeometry() {
865     if (!d_ptr->geometry_updated)
866         return;
867     d_ptr->geometry_updated = false;
868
869     bool hijack(true);
870     QWidgetPrivate *wd = window()->d_func();
871     if (wd->extraData() && wd->extraData()->glContext) {
872 #ifdef Q_OS_SYMBIAN // Symbian needs to recreate the context when native window size changes
873         if (d_ptr->size != geometry().size()) {
874             QGLContext *ctx = reinterpret_cast<QGLContext *>(wd->extraData()->glContext);
875
876             if (ctx == QGLContext::currentContext())
877                  ctx->doneCurrent();
878
879             ctx->d_func()->destroyEglSurfaceForDevice();
880
881             // Delete other contexts (shouldn't happen too often, if at all)
882             while (d_ptr->contexts.size()) {
883                 QGLContext **ctxPtrPtr = d_ptr->contexts.takeFirst();
884                 if ((*ctxPtrPtr) != ctx)
885                     delete *ctxPtrPtr;
886             }
887             union { QGLContext **ctxPtrPtr; void **voidPtrPtr; };
888             voidPtrPtr = &wd->extraData()->glContext;
889             d_ptr->contexts << ctxPtrPtr;
890
891             ctx->d_func()->eglSurface = ctx->d_func()->eglContext->createSurface(window());
892
893             // Swap behaviour has been checked already in previous hijackWindow call.
894             // Reset swap behaviour based on that flag.
895             if (d_ptr->destructive_swap_buffers) {
896                 eglSurfaceAttrib(QEgl::display(), ctx->d_func()->eglSurfaceForDevice(),
897                                     EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED);
898
899                 if (eglGetError() != EGL_SUCCESS)
900                     qWarning("QGLWindowSurface::updateGeometry() - could not re-enable destroyed swap behaviour");
901             } else {
902                 eglSurfaceAttrib(QEgl::display(), ctx->d_func()->eglSurfaceForDevice(),
903                                     EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
904
905                 if (eglGetError() != EGL_SUCCESS)
906                     qWarning("QGLWindowSurface::updateGeometry() - could not re-enable preserved swap behaviour");                
907             }
908         }
909 #endif
910         hijack = false; // we already have gl context for widget
911     }
912
913     if (hijack)
914         hijackWindow(window());
915
916     QGLContext *ctx = reinterpret_cast<QGLContext *>(wd->extraData()->glContext);
917 #ifdef Q_OS_SYMBIAN
918     if (!ctx)
919         return;
920 #endif
921 #ifdef Q_WS_MAC
922     ctx->updatePaintDevice();
923 #endif
924
925     QSize surfSize = geometry().size();
926
927     if (surfSize.width() <= 0 || surfSize.height() <= 0)
928         return;
929
930     if (d_ptr->size == surfSize)
931         return;
932
933     d_ptr->size = surfSize;
934
935     if (d_ptr->ctx) {
936 #ifndef QT_OPENGL_ES_2
937         if (d_ptr->destructive_swap_buffers)
938             initializeOffscreenTexture(surfSize);
939 #endif
940         return;
941     }
942
943     const GLenum target = GL_TEXTURE_2D;
944     if (d_ptr->destructive_swap_buffers
945         && (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject)
946         && (d_ptr->fbo || !d_ptr->tried_fbo)
947         && qt_gl_preferGL2Engine())
948     {
949         d_ptr->tried_fbo = true;
950         ctx->d_ptr->internal_context = true;
951         ctx->makeCurrent();
952         delete d_ptr->fbo;
953
954         QGLFramebufferObjectFormat format;
955         format.setAttachment(QGLFramebufferObject::CombinedDepthStencil);
956         format.setInternalTextureFormat(GLenum(GL_RGBA));
957         format.setTextureTarget(target);
958
959         if (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit)
960             format.setSamples(8);
961
962         d_ptr->fbo = new QGLFramebufferObject(surfSize, format);
963
964         if (d_ptr->fbo->isValid()) {
965             qDebug() << "Created Window Surface FBO" << surfSize
966                      << "with samples" << d_ptr->fbo->format().samples();
967             return;
968         } else {
969             qDebug() << "QGLWindowSurface: Failed to create valid FBO, falling back";
970             delete d_ptr->fbo;
971             d_ptr->fbo = 0;
972         }
973     }
974
975 #if !defined(QT_OPENGL_ES_2) && !defined(Q_WS_QPA) //QPA doesn't support pixelbuffers
976     if (d_ptr->destructive_swap_buffers && (d_ptr->pb || !d_ptr->tried_pb)) {
977         d_ptr->tried_pb = true;
978
979         if (d_ptr->pb) {
980             d_ptr->pb->makeCurrent();
981             glDeleteTextures(1, &d_ptr->pb_tex_id);
982         }
983
984         delete d_ptr->pb;
985
986         d_ptr->pb = new QGLPixelBuffer(surfSize.width(), surfSize.height(),
987                                         QGLFormat(QGL::SampleBuffers | QGL::StencilBuffer | QGL::DepthBuffer),
988                                         qt_gl_share_widget());
989
990         if (d_ptr->pb->isValid()) {
991             qDebug() << "Created Window Surface Pixelbuffer, Sample buffers:" << d_ptr->pb->format().sampleBuffers();
992             d_ptr->pb->makeCurrent();
993
994             glGenTextures(1, &d_ptr->pb_tex_id);
995             glBindTexture(target, d_ptr->pb_tex_id);
996             glTexImage2D(target, 0, GL_RGBA, surfSize.width(), surfSize.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
997
998             glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
999             glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1000             glBindTexture(target, 0);
1001
1002             glMatrixMode(GL_PROJECTION);
1003             glLoadIdentity();
1004             glOrtho(0, d_ptr->pb->width(), d_ptr->pb->height(), 0, -999999, 999999);
1005
1006             d_ptr->pb->d_ptr->qctx->d_func()->internal_context = true;
1007             return;
1008         } else {
1009             qDebug() << "QGLWindowSurface: Failed to create valid pixelbuffer, falling back";
1010             delete d_ptr->pb;
1011             d_ptr->pb = 0;
1012         }
1013     }
1014 #endif // !defined(QT_OPENGL_ES_2) !defined(Q_WS_QPA)
1015
1016     ctx->makeCurrent();
1017
1018 #ifndef QT_OPENGL_ES_2
1019     if (d_ptr->destructive_swap_buffers)
1020         initializeOffscreenTexture(surfSize);
1021 #endif
1022 #ifndef Q_OS_SYMBIAN
1023     qDebug() << "QGLWindowSurface: Using plain widget as window surface" << this;
1024 #endif
1025     d_ptr->ctx = ctx;
1026     d_ptr->ctx->d_ptr->internal_context = true;
1027 }
1028
1029 bool QGLWindowSurface::initializeOffscreenTexture(const QSize &size)
1030 {
1031     if (size == d_ptr->textureSize)
1032         return false;
1033
1034     glGenTextures(1, &d_ptr->tex_id);
1035     glBindTexture(GL_TEXTURE_2D, d_ptr->tex_id);
1036     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.width(), size.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1037
1038     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1039     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1040     glBindTexture(GL_TEXTURE_2D, 0);
1041
1042     d_ptr->textureSize = size;
1043     return true;
1044 }
1045
1046 bool QGLWindowSurface::scroll(const QRegion &area, int dx, int dy)
1047 {
1048     // this code randomly fails currently for unknown reasons
1049     return false;
1050
1051     if (!d_ptr->pb)
1052         return false;
1053
1054     d_ptr->pb->makeCurrent();
1055
1056     QRect br = area.boundingRect();
1057
1058 #if 0
1059     // ## workaround driver issue (scrolling by these deltas is unbearably slow for some reason)
1060     // ## maybe we should use glCopyTexSubImage insteadk
1061     if (dx == 1 || dx == -1 || dy == 1 || dy == -1 || dy == 2)
1062         return false;
1063
1064     glRasterPos2i(br.x() + dx, br.y() + br.height() + dy);
1065     glCopyPixels(br.x(), d_ptr->pb->height() - (br.y() + br.height()), br.width(), br.height(), GL_COLOR);
1066     return true;
1067 #endif
1068
1069     const GLenum target = GL_TEXTURE_2D;
1070
1071     glBindTexture(target, d_ptr->tex_id);
1072     glCopyTexImage2D(target, 0, GL_RGBA, br.x(), d_ptr->pb->height() - (br.y() + br.height()), br.width(), br.height(), 0);
1073     glBindTexture(target, 0);
1074
1075     drawTexture(br.translated(dx, dy), d_ptr->tex_id, window()->size());
1076
1077     return true;
1078 }
1079
1080 static void drawTexture(const QRectF &rect, GLuint tex_id, const QSize &texSize, const QRectF &br)
1081 {
1082     const GLenum target = GL_TEXTURE_2D;
1083     QRectF src = br.isEmpty()
1084         ? QRectF(QPointF(), texSize)
1085         : QRectF(QPointF(br.x(), texSize.height() - br.bottom()), br.size());
1086
1087     if (target == GL_TEXTURE_2D) {
1088         qreal width = texSize.width();
1089         qreal height = texSize.height();
1090
1091         src.setLeft(src.left() / width);
1092         src.setRight(src.right() / width);
1093         src.setTop(src.top() / height);
1094         src.setBottom(src.bottom() / height);
1095     }
1096
1097     const GLfloat tx1 = src.left();
1098     const GLfloat tx2 = src.right();
1099     const GLfloat ty1 = src.top();
1100     const GLfloat ty2 = src.bottom();
1101
1102     GLfloat texCoordArray[4*2] = {
1103         tx1, ty2, tx2, ty2, tx2, ty1, tx1, ty1
1104     };
1105
1106     GLfloat vertexArray[4*2];
1107     extern void qt_add_rect_to_array(const QRectF &r, GLfloat *array); // qpaintengine_opengl.cpp
1108     qt_add_rect_to_array(rect, vertexArray);
1109
1110 #if !defined(QT_OPENGL_ES_2)
1111     glVertexPointer(2, GL_FLOAT, 0, vertexArray);
1112     glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
1113
1114     glBindTexture(target, tex_id);
1115     glEnable(target);
1116
1117     glEnableClientState(GL_VERTEX_ARRAY);
1118     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1119     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1120     glDisableClientState(GL_VERTEX_ARRAY);
1121     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1122
1123     glDisable(target);
1124     glBindTexture(target, 0);
1125 #else
1126     glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, vertexArray);
1127     glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, texCoordArray);
1128
1129     glBindTexture(target, tex_id);
1130
1131     glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
1132     glEnableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
1133     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1134     glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
1135     glDisableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
1136
1137     glBindTexture(target, 0);
1138 #endif
1139 }
1140
1141 QImage *QGLWindowSurface::buffer(const QWidget *widget)
1142 {
1143     QImage image;
1144
1145     if (d_ptr->pb)
1146         image = d_ptr->pb->toImage();
1147     else if (d_ptr->fbo)
1148         image = d_ptr->fbo->toImage();
1149
1150     if (image.isNull())
1151         return 0;
1152
1153     QRect rect = widget->rect();
1154     rect.translate(widget->mapTo(widget->window(), QPoint()));
1155
1156     QImage subImage = image.copy(rect);
1157     d_ptr->buffers << subImage;
1158     return &d_ptr->buffers.last();
1159 }
1160
1161 QWindowSurface::WindowSurfaceFeatures QGLWindowSurface::features() const
1162 {
1163     WindowSurfaceFeatures features = 0;
1164     if (!d_ptr->destructive_swap_buffers || d_ptr->swap_region_support)
1165         features |= PartialUpdates;
1166     if (!d_ptr->destructive_swap_buffers)
1167         features |= PreservedContents;
1168     return features;
1169 }
1170
1171 QT_END_NAMESPACE
1172