Changeset 561 for trunk/src/opengl/qgl_x11.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/opengl/qgl_x11.cpp (modified) (25 diffs)

trunk/src/opengl/qgl_x11.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information ([email protected])
+** All rights reserved.
+** Contact: Nokia Corporation ([email protected])
 **
 ** This file is part of the QtOpenGL module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you 
+** @nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -53 +53 @@
 #include <private/qfontengine_ft_p.h>
 #include <private/qt_x11_p.h>
+
+
 #ifdef Q_OS_HPUX
 // for GLXPBuffer
 #include <private/qglpixelbuffer_p.h>
 #endif
+
+
+
+
 
 #define INT8  dummy_INT8
@@ -63 +69 @@
 #undef  INT8
 #undef  INT32
+
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/Xos.h>
+
+
+
+
+
+
+
+
 #include <X11/Xatom.h>
 
@@ -80 +95 @@
 #define GLX_SAMPLE_BUFFERS_ARB  100000
 #define GLX_SAMPLES_ARB         100001
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 #endif
 
@@ -130 +164 @@
     GLCMapHash *qglcmap_hash;
 };
-Q_GLOBAL_STATIC(QGLCMapCleanupHandler, cmap_handler);
+Q_GLOBAL_STATIC(QGLCMapCleanupHandler, cmap_handler)
 
 static void cleanup_cmaps()
@@ -298 +332 @@
   QGLFormat UNIX/GLX-specific code
  *****************************************************************************/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 bool QGLFormat::hasOpenGL()
@@ -434 +524 @@
             return false;
     }
-    QString glxExt = QString(QLatin1String(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS)));
-    if (glxExt.contains(QLatin1String("GLX_SGI_video_sync"))) {
+    Q)));
+    if ()) {
         if (d->glFormat.swapInterval() == -1)
             d->glFormat.setSwapInterval(0);
@@ -444 +534 @@
 }
 
-
-/*!
-  \bold{X11 only:} This virtual function tries to find a
-  visual that matches the format, reducing the demands if the original
-  request cannot be met.
-
-  The algorithm for reducing the demands of the format is quite
-  simple-minded, so override this method in your subclass if your
-  application has spcific requirements on visual selection.
-
-  \sa chooseContext()
-*/
-
+/*
+  See qgl.cpp for qdoc comment.
+ */
 void *QGLContext::chooseVisual()
 {
@@ -520 +600 @@
 }
 
-
-/*!
-  \internal
-
-  \bold{X11 only:} This virtual function chooses a visual
-  that matches the OpenGL \link format() format\endlink. Reimplement this
-  function in a subclass if you need a custom visual.
-
-  \sa chooseContext()
-*/
-
+/*
+  See qgl.cpp for qdoc comment.
+ */
 void *QGLContext::tryVisual(const QGLFormat& f, int bufDepth)
 {
     Q_D(QGLContext);
-    int spec[40];
+    int spec[4];
     int i = 0;
     spec[i++] = GLX_LEVEL;
     spec[i++] = f.plane();
     const QX11Info *xinfo = qt_x11Info(d->paintDevice);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 #if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
@@ -544 +631 @@
     static bool useTranspExtChecked = false;
     if (f.plane() && !useTranspExtChecked && d->paintDevice) {
-        QByteArray estr(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
-        useTranspExt = estr.contains("GLX_EXT_visual_info");
+        Q(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
+        useTranspExt = e("GLX_EXT_visual_info");
         //# (A bit simplistic; that could theoretically be a substring)
         if (useTranspExt) {
@@ -566 +653 @@
         useTranspExtChecked = true;
     }
-    if (f.plane() && useTranspExt) {
+    if (f.plane() && useTranspExt) {
         // Required to avoid non-transparent overlay visual(!) on some systems
         spec[i++] = GLX_TRANSPARENT_TYPE_EXT;
@@ -573 +660 @@
 #endif
 
+
+
+
+
+
+
+
+
     if (f.doubleBuffer())
         spec[i++] = GLX_DOUBLEBUFFER;
+
+
     if (f.depth()) {
         spec[i++] = GLX_DEPTH_SIZE;
@@ -581 +678 @@
     if (f.stereo()) {
         spec[i++] = GLX_STEREO;
+
+
     }
     if (f.stencil()) {
@@ -587 +686 @@
     }
     if (f.rgba()) {
-        spec[i++] = GLX_RGBA;
+        if (!useFBConfig)
+            spec[i++] = GLX_RGBA;
         spec[i++] = GLX_RED_SIZE;
         spec[i++] = f.redBufferSize() == -1 ? 1 : f.redBufferSize();
@@ -622 +722 @@
     }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     spec[i] = XNone;
-    return glXChooseVisual(xinfo->display(), xinfo->screen(), spec);
+
+
+    XVisualInfo* chosenVisualInfo = 0;
+
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+    while (useFBConfig) {
+        GLXFBConfig *configs;
+        int configCount = 0;
+        configs = glXChooseFBConfig(xinfo->display(), xinfo->screen(), spec, &configCount);
+
+        if (!configs)
+            break; // fallback to trying glXChooseVisual
+
+        for (i = 0; i < configCount; ++i) {
+            XVisualInfo* vi;
+            vi = glXGetVisualFromFBConfig(xinfo->display(), configs[i]);
+            if (!vi)
+                continue;
+
+#if !defined(QT_NO_XRENDER)
+            QWidget* w = 0;
+            if (d->paintDevice->devType() == QInternal::Widget)
+                w = static_cast<QWidget*>(d->paintDevice);
+
+            if (w && w->testAttribute(Qt::WA_TranslucentBackground) && f.alpha()) {
+                // Attempt to find a config who's visual has a proper alpha channel
+                XRenderPictFormat *pictFormat;
+                pictFormat = XRenderFindVisualFormat(xinfo->display(), vi->visual);
+
+                if (pictFormat && (pictFormat->type == PictTypeDirect) && pictFormat->direct.alphaMask) {
+                    // The pict format for the visual matching the FBConfig indicates ARGB
+                    if (chosenVisualInfo)
+                        XFree(chosenVisualInfo);
+                    chosenVisualInfo = vi;
+                    break;
+                }
+            } else
+#endif //QT_NO_XRENDER
+            if (chosenVisualInfo) {
+                // If we've got a visual we can use and we're not trying to find one with a
+                // real alpha channel, we might as well just use the one we've got
+                break;
+            }
+
+            if (!chosenVisualInfo)
+                chosenVisualInfo = vi; // Have something to fall back to
+            else
+                XFree(vi);
+        }
+
+        XFree(configs);
+        break;
+    }
+#endif // defined(GLX_VERSION_1_3)
+
+    if (!chosenVisualInfo)
+        chosenVisualInfo = glXChooseVisual(xinfo->display(), xinfo->screen(), spec);
+
+    return chosenVisualInfo;
 }
 
@@ -671 +849 @@
         qWarning("QGLContext::makeCurrent(): Failed.");
 
-    if (ok) {
-        if (!qgl_context_storage.hasLocalData() && QThread::currentThread())
-            qgl_context_storage.setLocalData(new QGLThreadContext);
-        if (qgl_context_storage.hasLocalData())
-            qgl_context_storage.localData()->context = this;
-        currentCtx = this;
-    }
+    if (ok)
+        QGLContextPrivate::setCurrentContext(this);
 }
 
@@ -684 +857 @@
     Q_D(QGLContext);
     glXMakeCurrent(qt_x11Info(d->paintDevice)->display(), 0, 0);
-    if (qgl_context_storage.hasLocalData())
-        qgl_context_storage.localData()->context = 0;
-    currentCtx = 0;
+    QGLContextPrivate::setCurrentContext(0);
 }
 
@@ -704 +875 @@
             static bool resolved = false;
             if (!resolved) {
-                QString glxExt = QString(QLatin1String(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS)));
-                if (glxExt.contains(QLatin1String("GLX_SGI_video_sync"))) {
-#if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)
-                    void *handle = dlopen(NULL, RTLD_LAZY);
-                    if (handle) {
-                        glXGetVideoSyncSGI = (qt_glXGetVideoSyncSGI) dlsym(handle, "glXGetVideoSyncSGI");
-                        glXWaitVideoSyncSGI = (qt_glXWaitVideoSyncSGI) dlsym(handle, "glXWaitVideoSyncSGI");
-                        dlclose(handle);
-                    }
-                    if (!glXGetVideoSyncSGI)
-#endif
-                    {
-                        extern const QString qt_gl_library_name();
-                        QLibrary lib(qt_gl_library_name());
-                        glXGetVideoSyncSGI = (qt_glXGetVideoSyncSGI) lib.resolve("glXGetVideoSyncSGI");
-                        glXWaitVideoSyncSGI = (qt_glXWaitVideoSyncSGI) lib.resolve("glXWaitVideoSyncSGI");
-                    }
+                const QX11Info *xinfo = qt_x11Info(d->paintDevice);
+                QGLExtensionMatcher extensions(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
+                if (extensions.match("GLX_SGI_video_sync")) {
+                    glXGetVideoSyncSGI =  (qt_glXGetVideoSyncSGI)qglx_getProcAddress("glXGetVideoSyncSGI");
+                    glXWaitVideoSyncSGI = (qt_glXWaitVideoSyncSGI)qglx_getProcAddress("glXWaitVideoSyncSGI");
                 }
                 resolved = true;
@@ -949 +1108 @@
         return 0;
     if (!glXGetProcAddressARB) {
-        QString glxExt = QString(QLatin1String(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS)));
-        if (glxExt.contains(QLatin1String("GLX_ARB_get_proc_address"))) {
+        Q));
+        if ()) {
 #if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)
             void *handle = dlopen(NULL, RTLD_LAZY);
@@ -960 +1119 @@
 #endif
             {
+
                 extern const QString qt_gl_library_name();
                 QLibrary lib(qt_gl_library_name());
                 glXGetProcAddressARB = (qt_glXGetProcAddressARB) lib.resolve("glXGetProcAddressARB");
+
             }
         }
@@ -1184 +1345 @@
     d->glcx = context;
 
-
     if (parentWidget()) {
         // force creation of delay-created widgets
@@ -1191 +1351 @@
             d_func()->xinfo = parentWidget()->d_func()->xinfo;
     }
+
+
+
+
+
+
 
     bool createFailed = false;
@@ -1423 +1589 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 QT_END_NAMESPACE