--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/opengl/qgl_x11.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,1755 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgl.h"
+#include "qgl_p.h"
+
+#include "qmap.h"
+#include "qapplication.h"
+#include "qcolormap.h"
+#include "qdesktopwidget.h"
+#include "qpixmap.h"
+#include "qhash.h"
+#include "qlibrary.h"
+#include "qdebug.h"
+#include <private/qfontengine_ft_p.h>
+#include <private/qt_x11_p.h>
+#include <private/qpixmap_x11_p.h>
+#ifdef Q_OS_HPUX
+// for GLXPBuffer
+#include <private/qglpixelbuffer_p.h>
+#endif
+
+// We always define GLX_EXT_texture_from_pixmap ourselves because
+// we can't trust system headers to do it properly
+#define GLX_EXT_texture_from_pixmap 1
+
+#define INT8 dummy_INT8
+#define INT32 dummy_INT32
+#include <GL/glx.h>
+#undef INT8
+#undef INT32
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xos.h>
+#ifdef Q_OS_VXWORS
+# ifdef open
+# undef open
+# endif
+# ifdef getpid
+# undef getpid
+# endif
+#endif // Q_OS_VXWORKS
+#include <X11/Xatom.h>
+
+#if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)
+#include <dlfcn.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+extern Drawable qt_x11Handle(const QPaintDevice *pd);
+extern const QX11Info *qt_x11Info(const QPaintDevice *pd);
+
+#ifndef GLX_ARB_multisample
+#define GLX_SAMPLE_BUFFERS_ARB 100000
+#define GLX_SAMPLES_ARB 100001
+#endif
+
+#ifndef GLX_TEXTURE_2D_BIT_EXT
+#define GLX_TEXTURE_2D_BIT_EXT 0x00000002
+#define GLX_TEXTURE_RECTANGLE_BIT_EXT 0x00000004
+#define GLX_BIND_TO_TEXTURE_RGB_EXT 0x20D0
+#define GLX_BIND_TO_TEXTURE_RGBA_EXT 0x20D1
+#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT 0x20D2
+#define GLX_BIND_TO_TEXTURE_TARGETS_EXT 0x20D3
+#define GLX_Y_INVERTED_EXT 0x20D4
+#define GLX_TEXTURE_FORMAT_EXT 0x20D5
+#define GLX_TEXTURE_TARGET_EXT 0x20D6
+#define GLX_MIPMAP_TEXTURE_EXT 0x20D7
+#define GLX_TEXTURE_FORMAT_NONE_EXT 0x20D8
+#define GLX_TEXTURE_FORMAT_RGB_EXT 0x20D9
+#define GLX_TEXTURE_FORMAT_RGBA_EXT 0x20DA
+#define GLX_TEXTURE_2D_EXT 0x20DC
+#define GLX_TEXTURE_RECTANGLE_EXT 0x20DD
+#define GLX_FRONT_LEFT_EXT 0x20DE
+#endif
+
+/*
+ The qt_gl_choose_cmap function is internal and used by QGLWidget::setContext()
+ and GLX (not Windows). If the application can't find any sharable
+ colormaps, it must at least create as few colormaps as possible. The
+ dictionary solution below ensures only one colormap is created per visual.
+ Colormaps are also deleted when the application terminates.
+*/
+
+struct QCMapEntry {
+ QCMapEntry();
+ ~QCMapEntry();
+
+ Colormap cmap;
+ bool alloc;
+ XStandardColormap scmap;
+};
+
+QCMapEntry::QCMapEntry()
+{
+ cmap = 0;
+ alloc = false;
+ scmap.colormap = 0;
+}
+
+QCMapEntry::~QCMapEntry()
+{
+ if (alloc)
+ XFreeColormap(X11->display, cmap);
+}
+typedef QHash<int, QCMapEntry *> CMapEntryHash;
+typedef QHash<int, QMap<int, QRgb> > GLCMapHash;
+static bool mesa_gl = false;
+static bool first_time = true;
+
+static void cleanup_cmaps();
+
+struct QGLCMapCleanupHandler {
+ QGLCMapCleanupHandler() {
+ cmap_hash = new CMapEntryHash;
+ qglcmap_hash = new GLCMapHash;
+ }
+ ~QGLCMapCleanupHandler() {
+ delete cmap_hash;
+ delete qglcmap_hash;
+ }
+ CMapEntryHash *cmap_hash;
+ GLCMapHash *qglcmap_hash;
+};
+Q_GLOBAL_STATIC(QGLCMapCleanupHandler, cmap_handler)
+
+static void cleanup_cmaps()
+{
+ CMapEntryHash *hash = cmap_handler()->cmap_hash;
+ QHash<int, QCMapEntry *>::ConstIterator it = hash->constBegin();
+ while (it != hash->constEnd()) {
+ delete it.value();
+ ++it;
+ }
+
+ hash->clear();
+ cmap_handler()->qglcmap_hash->clear();
+}
+
+Colormap qt_gl_choose_cmap(Display *dpy, XVisualInfo *vi)
+{
+ if (first_time) {
+ const char *v = glXQueryServerString(dpy, vi->screen, GLX_VERSION);
+ if (v)
+ mesa_gl = (strstr(v, "Mesa") != 0);
+ first_time = false;
+ }
+
+ CMapEntryHash *hash = cmap_handler()->cmap_hash;
+ CMapEntryHash::ConstIterator it = hash->constFind((long) vi->visualid + (vi->screen * 256));
+ if (it != hash->constEnd())
+ return it.value()->cmap; // found colormap for visual
+
+ if (vi->visualid ==
+ XVisualIDFromVisual((Visual *) QX11Info::appVisual(vi->screen))) {
+ // qDebug("Using x11AppColormap");
+ return QX11Info::appColormap(vi->screen);
+ }
+
+ QCMapEntry *x = new QCMapEntry();
+
+ XStandardColormap *c;
+ int n, i;
+
+ // qDebug("Choosing cmap for vID %0x", vi->visualid);
+
+ if (mesa_gl) { // we're using MesaGL
+ Atom hp_cmaps = XInternAtom(dpy, "_HP_RGB_SMOOTH_MAP_LIST", true);
+ if (hp_cmaps && vi->visual->c_class == TrueColor && vi->depth == 8) {
+ if (XGetRGBColormaps(dpy,RootWindow(dpy,vi->screen),&c,&n,
+ hp_cmaps)) {
+ i = 0;
+ while (i < n && x->cmap == 0) {
+ if (c[i].visualid == vi->visual->visualid) {
+ x->cmap = c[i].colormap;
+ x->scmap = c[i];
+ //qDebug("Using HP_RGB scmap");
+
+ }
+ i++;
+ }
+ XFree((char *)c);
+ }
+ }
+ }
+ if (!x->cmap) {
+ if (XGetRGBColormaps(dpy,RootWindow(dpy,vi->screen),&c,&n,
+ XA_RGB_DEFAULT_MAP)) {
+ for (int i = 0; i < n && x->cmap == 0; ++i) {
+ if (!c[i].red_max ||
+ !c[i].green_max ||
+ !c[i].blue_max ||
+ !c[i].red_mult ||
+ !c[i].green_mult ||
+ !c[i].blue_mult)
+ continue; // invalid stdcmap
+ if (c[i].visualid == vi->visualid) {
+ x->cmap = c[i].colormap;
+ x->scmap = c[i];
+ //qDebug("Using RGB_DEFAULT scmap");
+ }
+ }
+ XFree((char *)c);
+ }
+ }
+ if (!x->cmap) { // no shared cmap found
+ x->cmap = XCreateColormap(dpy, RootWindow(dpy,vi->screen), vi->visual,
+ AllocNone);
+ x->alloc = true;
+ // qDebug("Allocating cmap");
+ }
+
+ // colormap hash should be cleanup only when the QApplication dtor is called
+ if (hash->isEmpty())
+ qAddPostRoutine(cleanup_cmaps);
+
+ // associate cmap with visualid
+ hash->insert((long) vi->visualid + (vi->screen * 256), x);
+ return x->cmap;
+}
+
+struct QTransColor
+{
+ VisualID vis;
+ int screen;
+ long color;
+};
+
+static QVector<QTransColor> trans_colors;
+static int trans_colors_init = false;
+
+static void find_trans_colors()
+{
+ struct OverlayProp {
+ long visual;
+ long type;
+ long value;
+ long layer;
+ };
+
+ trans_colors_init = true;
+
+ Display* appDisplay = X11->display;
+
+ int scr;
+ int lastsize = 0;
+ for (scr = 0; scr < ScreenCount(appDisplay); scr++) {
+ QWidget* rootWin = QApplication::desktop()->screen(scr);
+ if (!rootWin)
+ return; // Should not happen
+ Atom overlayVisualsAtom = XInternAtom(appDisplay,
+ "SERVER_OVERLAY_VISUALS", True);
+ if (overlayVisualsAtom == XNone)
+ return; // Server has no overlays
+
+ Atom actualType;
+ int actualFormat;
+ ulong nItems;
+ ulong bytesAfter;
+ unsigned char *retval = 0;
+ int res = XGetWindowProperty(appDisplay, rootWin->winId(),
+ overlayVisualsAtom, 0, 10000, False,
+ overlayVisualsAtom, &actualType,
+ &actualFormat, &nItems, &bytesAfter,
+ &retval);
+
+ if (res != Success || actualType != overlayVisualsAtom
+ || actualFormat != 32 || nItems < 4 || !retval)
+ return; // Error reading property
+
+ OverlayProp *overlayProps = (OverlayProp *)retval;
+
+ int numProps = nItems / 4;
+ trans_colors.resize(lastsize + numProps);
+ int j = lastsize;
+ for (int i = 0; i < numProps; i++) {
+ if (overlayProps[i].type == 1) {
+ trans_colors[j].vis = (VisualID)overlayProps[i].visual;
+ trans_colors[j].screen = scr;
+ trans_colors[j].color = (int)overlayProps[i].value;
+ j++;
+ }
+ }
+ XFree(overlayProps);
+ lastsize = j;
+ trans_colors.resize(lastsize);
+ }
+}
+
+/*****************************************************************************
+ QGLFormat UNIX/GLX-specific code
+ *****************************************************************************/
+
+void* qglx_getProcAddress(const char* procName)
+{
+ // On systems where the GL driver is pluggable (like Mesa), we have to use
+ // the glXGetProcAddressARB extension to resolve other function pointers as
+ // the symbols wont be in the GL library, but rather in a plugin loaded by
+ // the GL library.
+ typedef void* (*qt_glXGetProcAddressARB)(const char *);
+ static qt_glXGetProcAddressARB glXGetProcAddressARB = 0;
+ static bool triedResolvingGlxGetProcAddress = false;
+ if (!triedResolvingGlxGetProcAddress) {
+ triedResolvingGlxGetProcAddress = true;
+ QString glxExt = QLatin1String(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS));
+ if (glxExt.contains(QLatin1String("GLX_ARB_get_proc_address"))) {
+#if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)
+ void *handle = dlopen(NULL, RTLD_LAZY);
+ if (handle) {
+ glXGetProcAddressARB = (qt_glXGetProcAddressARB) dlsym(handle, "glXGetProcAddressARB");
+ dlclose(handle);
+ }
+ if (!glXGetProcAddressARB)
+#endif
+ {
+#if !defined(QT_NO_LIBRARY)
+ extern const QString qt_gl_library_name();
+ QLibrary lib(qt_gl_library_name());
+ glXGetProcAddressARB = (qt_glXGetProcAddressARB) lib.resolve("glXGetProcAddressARB");
+#endif
+ }
+ }
+ }
+
+ void *procAddress = 0;
+ if (glXGetProcAddressARB)
+ procAddress = glXGetProcAddressARB(procName);
+
+ // If glXGetProcAddress didn't work, try looking the symbol up in the GL library
+#if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)
+ if (!procAddress) {
+ void *handle = dlopen(NULL, RTLD_LAZY);
+ if (handle) {
+ procAddress = dlsym(handle, procName);
+ dlclose(handle);
+ }
+ }
+#endif
+#if !defined(QT_NO_LIBRARY)
+ if (!procAddress) {
+ extern const QString qt_gl_library_name();
+ QLibrary lib(qt_gl_library_name());
+ procAddress = lib.resolve(procName);
+ }
+#endif
+
+ return procAddress;
+}
+
+bool QGLFormat::hasOpenGL()
+{
+ return glXQueryExtension(X11->display, 0, 0) != 0;
+}
+
+
+bool QGLFormat::hasOpenGLOverlays()
+{
+ if (!trans_colors_init)
+ find_trans_colors();
+ return trans_colors.size() > 0;
+}
+
+/*****************************************************************************
+ QGLContext UNIX/GLX-specific code
+ *****************************************************************************/
+
+bool QGLContext::chooseContext(const QGLContext* shareContext)
+{
+ Q_D(QGLContext);
+ const QX11Info *xinfo = qt_x11Info(d->paintDevice);
+
+ Display* disp = xinfo->display();
+ d->vi = chooseVisual();
+ if (!d->vi)
+ return false;
+
+ if (deviceIsPixmap() &&
+ (((XVisualInfo*)d->vi)->depth != xinfo->depth() ||
+ ((XVisualInfo*)d->vi)->screen != xinfo->screen()))
+ {
+ XFree(d->vi);
+ XVisualInfo appVisInfo;
+ memset(&appVisInfo, 0, sizeof(XVisualInfo));
+ appVisInfo.visualid = XVisualIDFromVisual((Visual *) xinfo->visual());
+ appVisInfo.screen = xinfo->screen();
+ int nvis;
+ d->vi = XGetVisualInfo(disp, VisualIDMask | VisualScreenMask, &appVisInfo, &nvis);
+ if (!d->vi)
+ return false;
+
+ int useGL;
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_USE_GL, &useGL);
+ if (!useGL)
+ return false; //# Chickening out already...
+ }
+ int res;
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_LEVEL, &res);
+ d->glFormat.setPlane(res);
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_DOUBLEBUFFER, &res);
+ d->glFormat.setDoubleBuffer(res);
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_DEPTH_SIZE, &res);
+ d->glFormat.setDepth(res);
+ if (d->glFormat.depth())
+ d->glFormat.setDepthBufferSize(res);
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_RGBA, &res);
+ d->glFormat.setRgba(res);
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_RED_SIZE, &res);
+ d->glFormat.setRedBufferSize(res);
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_GREEN_SIZE, &res);
+ d->glFormat.setGreenBufferSize(res);
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_BLUE_SIZE, &res);
+ d->glFormat.setBlueBufferSize(res);
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_ALPHA_SIZE, &res);
+ d->glFormat.setAlpha(res);
+ if (d->glFormat.alpha())
+ d->glFormat.setAlphaBufferSize(res);
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_ACCUM_RED_SIZE, &res);
+ d->glFormat.setAccum(res);
+ if (d->glFormat.accum())
+ d->glFormat.setAccumBufferSize(res);
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_STENCIL_SIZE, &res);
+ d->glFormat.setStencil(res);
+ if (d->glFormat.stencil())
+ d->glFormat.setStencilBufferSize(res);
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_STEREO, &res);
+ d->glFormat.setStereo(res);
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_SAMPLE_BUFFERS_ARB, &res);
+ d->glFormat.setSampleBuffers(res);
+ if (d->glFormat.sampleBuffers()) {
+ glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_SAMPLES_ARB, &res);
+ d->glFormat.setSamples(res);
+ }
+
+ Bool direct = format().directRendering() ? True : False;
+
+ if (shareContext &&
+ (!shareContext->isValid() || !shareContext->d_func()->cx)) {
+ qWarning("QGLContext::chooseContext(): Cannot share with invalid context");
+ shareContext = 0;
+ }
+
+ // 1. Sharing between rgba and color-index will give wrong colors.
+ // 2. Contexts cannot be shared btw. direct/non-direct renderers.
+ // 3. Pixmaps cannot share contexts that are set up for direct rendering.
+ // 4. If the contexts are not created on the same screen, they can't be shared
+
+ if (shareContext
+ && (format().rgba() != shareContext->format().rgba()
+ || (deviceIsPixmap() && glXIsDirect(disp, (GLXContext)shareContext->d_func()->cx))
+ || (shareContext->d_func()->screen != xinfo->screen())))
+ {
+ shareContext = 0;
+ }
+
+ d->cx = 0;
+ if (shareContext) {
+ d->cx = glXCreateContext(disp, (XVisualInfo *)d->vi,
+ (GLXContext)shareContext->d_func()->cx, direct);
+ d->screen = ((XVisualInfo*)d->vi)->screen;
+ if (d->cx) {
+ QGLContext *share = const_cast<QGLContext *>(shareContext);
+ d->sharing = true;
+ share->d_func()->sharing = true;
+ }
+ }
+ if (!d->cx) {
+ d->cx = glXCreateContext(disp, (XVisualInfo *)d->vi, NULL, direct);
+ d->screen = ((XVisualInfo*)d->vi)->screen;
+ }
+ if (!d->cx)
+ return false;
+ d->glFormat.setDirectRendering(glXIsDirect(disp, (GLXContext)d->cx));
+ if (deviceIsPixmap()) {
+#if defined(GLX_MESA_pixmap_colormap) && defined(QGL_USE_MESA_EXT)
+ d->gpm = glXCreateGLXPixmapMESA(disp, (XVisualInfo *)d->vi,
+ qt_x11Handle(d->paintDevice),
+ qt_gl_choose_cmap(disp, (XVisualInfo *)d->vi));
+#else
+ d->gpm = (quint32)glXCreateGLXPixmap(disp, (XVisualInfo *)d->vi,
+ qt_x11Handle(d->paintDevice));
+#endif
+ if (!d->gpm)
+ return false;
+ }
+ QString glxExt = QLatin1String(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS));
+ if (glxExt.contains(QLatin1String("GLX_SGI_video_sync"))) {
+ if (d->glFormat.swapInterval() == -1)
+ d->glFormat.setSwapInterval(0);
+ } else {
+ d->glFormat.setSwapInterval(-1);
+ }
+ return true;
+}
+
+/*
+ See qgl.cpp for qdoc comment.
+ */
+void *QGLContext::chooseVisual()
+{
+ Q_D(QGLContext);
+ static const int bufDepths[] = { 8, 4, 2, 1 }; // Try 16, 12 also?
+ //todo: if pixmap, also make sure that vi->depth == pixmap->depth
+ void* vis = 0;
+ int i = 0;
+ bool fail = false;
+ QGLFormat fmt = format();
+ bool tryDouble = !fmt.doubleBuffer(); // Some GL impl's only have double
+ bool triedDouble = false;
+ bool triedSample = false;
+ if (fmt.sampleBuffers())
+ fmt.setSampleBuffers(QGLExtensions::glExtensions & QGLExtensions::SampleBuffers);
+ while(!fail && !(vis = tryVisual(fmt, bufDepths[i]))) {
+ if (!fmt.rgba() && bufDepths[i] > 1) {
+ i++;
+ continue;
+ }
+ if (tryDouble) {
+ fmt.setDoubleBuffer(true);
+ tryDouble = false;
+ triedDouble = true;
+ continue;
+ } else if (triedDouble) {
+ fmt.setDoubleBuffer(false);
+ triedDouble = false;
+ }
+ if (!triedSample && fmt.sampleBuffers()) {
+ fmt.setSampleBuffers(false);
+ triedSample = true;
+ continue;
+ }
+ if (fmt.stereo()) {
+ fmt.setStereo(false);
+ continue;
+ }
+ if (fmt.accum()) {
+ fmt.setAccum(false);
+ continue;
+ }
+ if (fmt.stencil()) {
+ fmt.setStencil(false);
+ continue;
+ }
+ if (fmt.alpha()) {
+ fmt.setAlpha(false);
+ continue;
+ }
+ if (fmt.depth()) {
+ fmt.setDepth(false);
+ continue;
+ }
+ if (fmt.doubleBuffer()) {
+ fmt.setDoubleBuffer(false);
+ continue;
+ }
+ fail = true;
+ }
+ d->glFormat = fmt;
+ return vis;
+}
+
+/*
+ See qgl.cpp for qdoc comment.
+ */
+void *QGLContext::tryVisual(const QGLFormat& f, int bufDepth)
+{
+ Q_D(QGLContext);
+ int spec[45];
+ int i = 0;
+ spec[i++] = GLX_LEVEL;
+ spec[i++] = f.plane();
+ const QX11Info *xinfo = qt_x11Info(d->paintDevice);
+ bool useFBConfig = false;
+
+#if defined(GLX_VERSION_1_3) && !defined(QT_NO_XRENDER) && !defined(Q_OS_HPUX)
+ /*
+ HPUX defines GLX_VERSION_1_3 but does not implement the corresponding functions.
+ Specifically glXChooseFBConfig and glXGetVisualFromFBConfig are not implemented.
+ */
+ QWidget* widget = 0;
+ if (d->paintDevice->devType() == QInternal::Widget)
+ widget = static_cast<QWidget*>(d->paintDevice);
+
+ // Only use glXChooseFBConfig for widgets if we're trying to get an ARGB visual
+ if (widget && widget->testAttribute(Qt::WA_TranslucentBackground) && X11->use_xrender)
+ useFBConfig = true;
+#endif
+
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
+ static bool useTranspExt = false;
+ static bool useTranspExtChecked = false;
+ if (f.plane() && !useTranspExtChecked && d->paintDevice) {
+ QByteArray estr(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
+ useTranspExt = estr.contains("GLX_EXT_visual_info");
+ //# (A bit simplistic; that could theoretically be a substring)
+ if (useTranspExt) {
+ QByteArray cstr(glXGetClientString(xinfo->display(), GLX_VENDOR));
+ useTranspExt = !cstr.contains("Xi Graphics"); // bug workaround
+ if (useTranspExt) {
+ // bug workaround - some systems (eg. FireGL) refuses to return an overlay
+ // visual if the GLX_TRANSPARENT_TYPE_EXT attribute is specified, even if
+ // the implementation supports transparent overlays
+ int tmpSpec[] = { GLX_LEVEL, f.plane(), GLX_TRANSPARENT_TYPE_EXT,
+ f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT,
+ XNone };
+ XVisualInfo * vinf = glXChooseVisual(xinfo->display(), xinfo->screen(), tmpSpec);
+ if (!vinf) {
+ useTranspExt = false;
+ }
+ }
+ }
+
+ useTranspExtChecked = true;
+ }
+ if (f.plane() && useTranspExt && !useFBConfig) {
+ // Required to avoid non-transparent overlay visual(!) on some systems
+ spec[i++] = GLX_TRANSPARENT_TYPE_EXT;
+ spec[i++] = f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT;
+ }
+#endif
+
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+ // GLX_RENDER_TYPE is only in glx >=1.3
+ if (useFBConfig) {
+ spec[i++] = GLX_RENDER_TYPE;
+ spec[i++] = f.rgba() ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
+ }
+#endif
+
+ if (f.doubleBuffer())
+ spec[i++] = GLX_DOUBLEBUFFER;
+ if (useFBConfig)
+ spec[i++] = True;
+ if (f.depth()) {
+ spec[i++] = GLX_DEPTH_SIZE;
+ spec[i++] = f.depthBufferSize() == -1 ? 1 : f.depthBufferSize();
+ }
+ if (f.stereo()) {
+ spec[i++] = GLX_STEREO;
+ if (useFBConfig)
+ spec[i++] = True;
+ }
+ if (f.stencil()) {
+ spec[i++] = GLX_STENCIL_SIZE;
+ spec[i++] = f.stencilBufferSize() == -1 ? 1 : f.stencilBufferSize();
+ }
+ if (f.rgba()) {
+ if (!useFBConfig)
+ spec[i++] = GLX_RGBA;
+ spec[i++] = GLX_RED_SIZE;
+ spec[i++] = f.redBufferSize() == -1 ? 1 : f.redBufferSize();
+ spec[i++] = GLX_GREEN_SIZE;
+ spec[i++] = f.greenBufferSize() == -1 ? 1 : f.greenBufferSize();
+ spec[i++] = GLX_BLUE_SIZE;
+ spec[i++] = f.blueBufferSize() == -1 ? 1 : f.blueBufferSize();
+ if (f.alpha()) {
+ spec[i++] = GLX_ALPHA_SIZE;
+ spec[i++] = f.alphaBufferSize() == -1 ? 1 : f.alphaBufferSize();
+ }
+ if (f.accum()) {
+ spec[i++] = GLX_ACCUM_RED_SIZE;
+ spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+ spec[i++] = GLX_ACCUM_GREEN_SIZE;
+ spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+ spec[i++] = GLX_ACCUM_BLUE_SIZE;
+ spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+ if (f.alpha()) {
+ spec[i++] = GLX_ACCUM_ALPHA_SIZE;
+ spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+ }
+ }
+ } else {
+ spec[i++] = GLX_BUFFER_SIZE;
+ spec[i++] = bufDepth;
+ }
+
+ if (f.sampleBuffers()) {
+ spec[i++] = GLX_SAMPLE_BUFFERS_ARB;
+ spec[i++] = 1;
+ spec[i++] = GLX_SAMPLES_ARB;
+ spec[i++] = f.samples() == -1 ? 4 : f.samples();
+ }
+
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+ if (useFBConfig) {
+ spec[i++] = GLX_DRAWABLE_TYPE;
+ switch(d->paintDevice->devType()) {
+ case QInternal::Pixmap:
+ spec[i++] = GLX_PIXMAP_BIT;
+ break;
+ case QInternal::Pbuffer:
+ spec[i++] = GLX_PBUFFER_BIT;
+ break;
+ default:
+ qWarning("QGLContext: Unknown paint device type %d", d->paintDevice->devType());
+ // Fall-through & assume it's a window
+ case QInternal::Widget:
+ spec[i++] = GLX_WINDOW_BIT;
+ break;
+ };
+ }
+#endif
+
+ spec[i] = XNone;
+
+
+ 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;
+}
+
+
+void QGLContext::reset()
+{
+ Q_D(QGLContext);
+ if (!d->valid)
+ return;
+ d->cleanup();
+ const QX11Info *xinfo = qt_x11Info(d->paintDevice);
+ doneCurrent();
+ if (d->gpm)
+ glXDestroyGLXPixmap(xinfo->display(), (GLXPixmap)d->gpm);
+ d->gpm = 0;
+ glXDestroyContext(xinfo->display(), (GLXContext)d->cx);
+ if (d->vi)
+ XFree(d->vi);
+ d->vi = 0;
+ d->cx = 0;
+ d->crWin = false;
+ d->sharing = false;
+ d->valid = false;
+ d->transpColor = QColor();
+ d->initDone = false;
+ qgl_share_reg()->removeShare(this);
+}
+
+
+void QGLContext::makeCurrent()
+{
+ Q_D(QGLContext);
+ if (!d->valid) {
+ qWarning("QGLContext::makeCurrent(): Cannot make invalid context current.");
+ return;
+ }
+ const QX11Info *xinfo = qt_x11Info(d->paintDevice);
+ bool ok = true;
+ if (d->paintDevice->devType() == QInternal::Pixmap) {
+ ok = glXMakeCurrent(xinfo->display(), (GLXPixmap)d->gpm, (GLXContext)d->cx);
+ } else if (d->paintDevice->devType() == QInternal::Pbuffer) {
+ ok = glXMakeCurrent(xinfo->display(), (GLXPbuffer)d->pbuf, (GLXContext)d->cx);
+ } else if (d->paintDevice->devType() == QInternal::Widget) {
+ ok = glXMakeCurrent(xinfo->display(), ((QWidget *)d->paintDevice)->winId(), (GLXContext)d->cx);
+ }
+ if (!ok)
+ qWarning("QGLContext::makeCurrent(): Failed.");
+
+ if (ok)
+ QGLContextPrivate::setCurrentContext(this);
+}
+
+void QGLContext::doneCurrent()
+{
+ Q_D(QGLContext);
+ glXMakeCurrent(qt_x11Info(d->paintDevice)->display(), 0, 0);
+ QGLContextPrivate::setCurrentContext(0);
+}
+
+
+void QGLContext::swapBuffers() const
+{
+ Q_D(const QGLContext);
+ if (!d->valid)
+ return;
+ if (!deviceIsPixmap()) {
+ int interval = d->glFormat.swapInterval();
+ if (interval > 0) {
+ typedef int (*qt_glXGetVideoSyncSGI)(uint *);
+ typedef int (*qt_glXWaitVideoSyncSGI)(int, int, uint *);
+ static qt_glXGetVideoSyncSGI glXGetVideoSyncSGI = 0;
+ static qt_glXWaitVideoSyncSGI glXWaitVideoSyncSGI = 0;
+ static bool resolved = false;
+ if (!resolved) {
+ QString glxExt = QLatin1String(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS));
+ if (glxExt.contains(QLatin1String("GLX_SGI_video_sync"))) {
+ glXGetVideoSyncSGI = (qt_glXGetVideoSyncSGI)qglx_getProcAddress("glXGetVideoSyncSGI");
+ glXWaitVideoSyncSGI = (qt_glXWaitVideoSyncSGI)qglx_getProcAddress("glXWaitVideoSyncSGI");
+ }
+ resolved = true;
+ }
+ if (glXGetVideoSyncSGI && glXWaitVideoSyncSGI) {
+ uint counter;
+ if (!glXGetVideoSyncSGI(&counter))
+ glXWaitVideoSyncSGI(interval + 1, (counter + interval) % (interval + 1), &counter);
+ }
+ }
+ glXSwapBuffers(qt_x11Info(d->paintDevice)->display(),
+ static_cast<QWidget *>(d->paintDevice)->winId());
+ }
+}
+
+QColor QGLContext::overlayTransparentColor() const
+{
+ if (isValid())
+ return Qt::transparent;
+ return QColor(); // Invalid color
+}
+
+static uint qt_transparent_pixel(VisualID id, int screen)
+{
+ for (int i = 0; i < trans_colors.size(); i++) {
+ if (trans_colors[i].vis == id && trans_colors[i].screen == screen)
+ return trans_colors[i].color;
+ }
+ return 0;
+}
+
+uint QGLContext::colorIndex(const QColor& c) const
+{
+ Q_D(const QGLContext);
+ int screen = ((XVisualInfo *)d->vi)->screen;
+ QColormap colmap = QColormap::instance(screen);
+ if (isValid()) {
+ if (format().plane() && c == Qt::transparent) {
+ return qt_transparent_pixel(((XVisualInfo *)d->vi)->visualid,
+ ((XVisualInfo *)d->vi)->screen);
+ }
+ if (((XVisualInfo*)d->vi)->visualid ==
+ XVisualIDFromVisual((Visual *) QX11Info::appVisual(screen)))
+ return colmap.pixel(c); // We're using QColor's cmap
+
+ XVisualInfo *info = (XVisualInfo *) d->vi;
+ CMapEntryHash *hash = cmap_handler()->cmap_hash;
+ CMapEntryHash::ConstIterator it = hash->constFind(long(info->visualid)
+ + (info->screen * 256));
+ QCMapEntry *x = 0;
+ if (it != hash->constEnd())
+ x = it.value();
+ if (x && !x->alloc) { // It's a standard colormap
+ int rf = (int)(((float)c.red() * (x->scmap.red_max+1))/256.0);
+ int gf = (int)(((float)c.green() * (x->scmap.green_max+1))/256.0);
+ int bf = (int)(((float)c.blue() * (x->scmap.blue_max+1))/256.0);
+ uint p = x->scmap.base_pixel
+ + (rf * x->scmap.red_mult)
+ + (gf * x->scmap.green_mult)
+ + (bf * x->scmap.blue_mult);
+ return p;
+ } else {
+ QMap<int, QRgb> &cmap = (*cmap_handler()->qglcmap_hash)[(long)info->visualid];
+
+ // already in the map?
+ QRgb target = c.rgb();
+ QMap<int, QRgb>::Iterator it = cmap.begin();
+ for (; it != cmap.end(); ++it) {
+ if ((*it) == target)
+ return it.key();
+ }
+
+ // need to alloc color
+ unsigned long plane_mask[2];
+ unsigned long color_map_entry;
+ if (!XAllocColorCells (QX11Info::display(), x->cmap, true, plane_mask, 0,
+ &color_map_entry, 1))
+ return colmap.pixel(c);
+
+ XColor col;
+ col.flags = DoRed | DoGreen | DoBlue;
+ col.pixel = color_map_entry;
+ col.red = (ushort)((qRed(c.rgb()) / 255.0) * 65535.0 + 0.5);
+ col.green = (ushort)((qGreen(c.rgb()) / 255.0) * 65535.0 + 0.5);
+ col.blue = (ushort)((qBlue(c.rgb()) / 255.0) * 65535.0 + 0.5);
+ XStoreColor(QX11Info::display(), x->cmap, &col);
+
+ cmap.insert(color_map_entry, target);
+ return color_map_entry;
+ }
+ }
+ return 0;
+}
+
+#ifndef QT_NO_FONTCONFIG
+/*! \internal
+ This is basically a substitute for glxUseXFont() which can only
+ handle XLFD fonts. This version relies on freetype to render the
+ glyphs, but it works with all fonts that fontconfig provides - both
+ antialiased and aliased bitmap and outline fonts.
+*/
+static void qgl_use_font(QFontEngineFT *engine, int first, int count, int listBase)
+{
+ GLfloat color[4];
+ glGetFloatv(GL_CURRENT_COLOR, color);
+
+ // save the pixel unpack state
+ GLint gl_swapbytes, gl_lsbfirst, gl_rowlength, gl_skiprows, gl_skippixels, gl_alignment;
+ glGetIntegerv (GL_UNPACK_SWAP_BYTES, &gl_swapbytes);
+ glGetIntegerv (GL_UNPACK_LSB_FIRST, &gl_lsbfirst);
+ glGetIntegerv (GL_UNPACK_ROW_LENGTH, &gl_rowlength);
+ glGetIntegerv (GL_UNPACK_SKIP_ROWS, &gl_skiprows);
+ glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &gl_skippixels);
+ glGetIntegerv (GL_UNPACK_ALIGNMENT, &gl_alignment);
+
+ glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
+ glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+ glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+ glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+ const bool antialiased = engine->drawAntialiased();
+ FT_Face face = engine->lockFace();
+
+ // start generating font glyphs
+ for (int i = first; i < count; ++i) {
+ int list = listBase + i;
+ GLfloat x0, y0, dx, dy;
+
+ FT_Error err;
+
+ err = FT_Load_Glyph(face, FT_Get_Char_Index(face, i), FT_LOAD_DEFAULT);
+ if (err) {
+ qDebug("failed loading glyph %d from font", i);
+ Q_ASSERT(!err);
+ }
+ err = FT_Render_Glyph(face->glyph, (antialiased ? FT_RENDER_MODE_NORMAL
+ : FT_RENDER_MODE_MONO));
+ if (err) {
+ qDebug("failed rendering glyph %d from font", i);
+ Q_ASSERT(!err);
+ }
+
+ FT_Bitmap bm = face->glyph->bitmap;
+ x0 = face->glyph->metrics.horiBearingX >> 6;
+ y0 = (face->glyph->metrics.height - face->glyph->metrics.horiBearingY) >> 6;
+ dx = face->glyph->metrics.horiAdvance >> 6;
+ dy = 0;
+ int sz = bm.pitch * bm.rows;
+ uint *aa_glyph = 0;
+ uchar *ua_glyph = 0;
+
+ if (antialiased)
+ aa_glyph = new uint[sz];
+ else
+ ua_glyph = new uchar[sz];
+
+ // convert to GL format
+ for (int y = 0; y < bm.rows; ++y) {
+ for (int x = 0; x < bm.pitch; ++x) {
+ int c1 = y*bm.pitch + x;
+ int c2 = (bm.rows - y - 1) > 0 ? (bm.rows-y-1)*bm.pitch + x : x;
+ if (antialiased) {
+ aa_glyph[c1] = (int(color[0]*255) << 24)
+ | (int(color[1]*255) << 16)
+ | (int(color[2]*255) << 8) | bm.buffer[c2];
+ } else {
+ ua_glyph[c1] = bm.buffer[c2];
+ }
+ }
+ }
+
+ glNewList(list, GL_COMPILE);
+ if (antialiased) {
+ // calling glBitmap() is just a trick to move the current
+ // raster pos, since glGet*() won't work in display lists
+ glBitmap(0, 0, 0, 0, x0, -y0, 0);
+ glDrawPixels(bm.pitch, bm.rows, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, aa_glyph);
+ glBitmap(0, 0, 0, 0, dx-x0, y0, 0);
+ } else {
+ glBitmap(bm.pitch*8, bm.rows, -x0, y0, dx, dy, ua_glyph);
+ }
+ glEndList();
+ antialiased ? delete[] aa_glyph : delete[] ua_glyph;
+ }
+
+ engine->unlockFace();
+
+ // restore pixel unpack settings
+ glPixelStorei(GL_UNPACK_SWAP_BYTES, gl_swapbytes);
+ glPixelStorei(GL_UNPACK_LSB_FIRST, gl_lsbfirst);
+ glPixelStorei(GL_UNPACK_ROW_LENGTH, gl_rowlength);
+ glPixelStorei(GL_UNPACK_SKIP_ROWS, gl_skiprows);
+ glPixelStorei(GL_UNPACK_SKIP_PIXELS, gl_skippixels);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, gl_alignment);
+}
+#endif
+
+#undef d
+void QGLContext::generateFontDisplayLists(const QFont & fnt, int listBase)
+{
+ QFont f(fnt);
+ QFontEngine *engine = f.d->engineForScript(QUnicodeTables::Common);
+
+ if (engine->type() == QFontEngine::Multi)
+ engine = static_cast<QFontEngineMulti *>(engine)->engine(0);
+#ifndef QT_NO_FONTCONFIG
+ if(engine->type() == QFontEngine::Freetype) {
+ qgl_use_font(static_cast<QFontEngineFT *>(engine), 0, 256, listBase);
+ return;
+ }
+#endif
+ // glXUseXFont() only works with XLFD font structures and a few GL
+ // drivers crash if 0 is passed as the font handle
+ f.setStyleStrategy(QFont::OpenGLCompatible);
+ if (f.handle() && engine->type() == QFontEngine::XLFD)
+ glXUseXFont(static_cast<Font>(f.handle()), 0, 256, listBase);
+}
+
+void *QGLContext::getProcAddress(const QString &proc) const
+{
+ typedef void *(*qt_glXGetProcAddressARB)(const GLubyte *);
+ static qt_glXGetProcAddressARB glXGetProcAddressARB = 0;
+ static bool resolved = false;
+
+ if (resolved && !glXGetProcAddressARB)
+ return 0;
+ if (!glXGetProcAddressARB) {
+ QString glxExt = QLatin1String(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS));
+ if (glxExt.contains(QLatin1String("GLX_ARB_get_proc_address"))) {
+#if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)
+ void *handle = dlopen(NULL, RTLD_LAZY);
+ if (handle) {
+ glXGetProcAddressARB = (qt_glXGetProcAddressARB) dlsym(handle, "glXGetProcAddressARB");
+ dlclose(handle);
+ }
+ if (!glXGetProcAddressARB)
+#endif
+ {
+#if !defined(QT_NO_LIBRARY)
+ extern const QString qt_gl_library_name();
+ QLibrary lib(qt_gl_library_name());
+ glXGetProcAddressARB = (qt_glXGetProcAddressARB) lib.resolve("glXGetProcAddressARB");
+#endif
+ }
+ }
+ resolved = true;
+ }
+ if (!glXGetProcAddressARB)
+ return 0;
+ return glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(proc.toLatin1().data()));
+}
+
+/*****************************************************************************
+ QGLOverlayWidget (Internal overlay class for X11)
+ *****************************************************************************/
+
+class QGLOverlayWidget : public QGLWidget
+{
+ Q_OBJECT
+public:
+ QGLOverlayWidget(const QGLFormat& format, QGLWidget* parent, const QGLWidget* shareWidget=0);
+
+protected:
+ void initializeGL();
+ void paintGL();
+ void resizeGL(int w, int h);
+ bool x11Event(XEvent *e) { return realWidget->x11Event(e); }
+
+private:
+ QGLWidget* realWidget;
+
+private:
+ Q_DISABLE_COPY(QGLOverlayWidget)
+};
+
+
+QGLOverlayWidget::QGLOverlayWidget(const QGLFormat& format, QGLWidget* parent,
+ const QGLWidget* shareWidget)
+ : QGLWidget(format, parent, shareWidget ? shareWidget->d_func()->olw : 0)
+{
+ setAttribute(Qt::WA_X11OpenGLOverlay);
+ realWidget = parent;
+}
+
+
+
+void QGLOverlayWidget::initializeGL()
+{
+ QColor transparentColor = context()->overlayTransparentColor();
+ if (transparentColor.isValid())
+ qglClearColor(transparentColor);
+ else
+ qWarning("QGLOverlayWidget::initializeGL(): Could not get transparent color");
+ realWidget->initializeOverlayGL();
+}
+
+
+void QGLOverlayWidget::resizeGL(int w, int h)
+{
+ glViewport(0, 0, w, h);
+ realWidget->resizeOverlayGL(w, h);
+}
+
+
+void QGLOverlayWidget::paintGL()
+{
+ realWidget->paintOverlayGL();
+}
+
+#undef Bool
+QT_BEGIN_INCLUDE_NAMESPACE
+#include "qgl_x11.moc"
+QT_END_INCLUDE_NAMESPACE
+
+/*****************************************************************************
+ QGLWidget UNIX/GLX-specific code
+ *****************************************************************************/
+void QGLWidgetPrivate::init(QGLContext *context, const QGLWidget *shareWidget)
+{
+ Q_Q(QGLWidget);
+ initContext(context, shareWidget);
+ olw = 0;
+
+ if (q->isValid() && context->format().hasOverlay()) {
+ QString olwName = q->objectName();
+ olwName += QLatin1String("-QGL_internal_overlay_widget");
+ olw = new QGLOverlayWidget(QGLFormat::defaultOverlayFormat(), q, shareWidget);
+ olw->setObjectName(olwName);
+ if (olw->isValid()) {
+ olw->setAutoBufferSwap(false);
+ olw->setFocusProxy(q);
+ }
+ else {
+ delete olw;
+ olw = 0;
+ glcx->d_func()->glFormat.setOverlay(false);
+ }
+ }
+}
+
+bool QGLWidgetPrivate::renderCxPm(QPixmap* pm)
+{
+ Q_Q(QGLWidget);
+ if (((XVisualInfo*)glcx->d_func()->vi)->depth != pm->depth())
+ return false;
+
+ GLXPixmap glPm;
+#if defined(GLX_MESA_pixmap_colormap) && defined(QGL_USE_MESA_EXT)
+ glPm = glXCreateGLXPixmapMESA(X11->display,
+ (XVisualInfo*)glcx->vi,
+ (Pixmap)pm->handle(),
+ qt_gl_choose_cmap(pm->X11->display,
+ (XVisualInfo*)glcx->vi));
+#else
+ glPm = (quint32)glXCreateGLXPixmap(X11->display,
+ (XVisualInfo*)glcx->d_func()->vi,
+ (Pixmap)pm->handle());
+#endif
+
+ if (!glXMakeCurrent(X11->display, glPm, (GLXContext)glcx->d_func()->cx)) {
+ glXDestroyGLXPixmap(X11->display, glPm);
+ return false;
+ }
+
+ glDrawBuffer(GL_FRONT);
+ if (!glcx->initialized())
+ q->glInit();
+ q->resizeGL(pm->width(), pm->height());
+ q->paintGL();
+ glFlush();
+ q->makeCurrent();
+ glXDestroyGLXPixmap(X11->display, glPm);
+ q->resizeGL(q->width(), q->height());
+ return true;
+}
+
+/*! \internal
+ Free up any allocated colormaps. This fn is only called for
+ top-level widgets.
+*/
+void QGLWidgetPrivate::cleanupColormaps()
+{
+ if (!cmap.handle()) {
+ return;
+ } else {
+ XFreeColormap(X11->display, (Colormap) cmap.handle());
+ cmap.setHandle(0);
+ }
+}
+
+void QGLWidget::setMouseTracking(bool enable)
+{
+ Q_D(QGLWidget);
+ if (d->olw)
+ d->olw->setMouseTracking(enable);
+ QWidget::setMouseTracking(enable);
+}
+
+
+void QGLWidget::resizeEvent(QResizeEvent *)
+{
+ Q_D(QGLWidget);
+ if (!isValid())
+ return;
+ makeCurrent();
+ if (!d->glcx->initialized())
+ glInit();
+ glXWaitX();
+ resizeGL(width(), height());
+ if (d->olw)
+ d->olw->setGeometry(rect());
+}
+
+const QGLContext* QGLWidget::overlayContext() const
+{
+ Q_D(const QGLWidget);
+ if (d->olw)
+ return d->olw->context();
+ else
+ return 0;
+}
+
+
+void QGLWidget::makeOverlayCurrent()
+{
+ Q_D(QGLWidget);
+ if (d->olw)
+ d->olw->makeCurrent();
+}
+
+
+void QGLWidget::updateOverlayGL()
+{
+ Q_D(QGLWidget);
+ if (d->olw)
+ d->olw->updateGL();
+}
+
+/*!
+ \internal
+
+ Sets a new QGLContext, \a context, for this QGLWidget, using the
+ shared context, \a shareContext. If \a deleteOldContext is true,
+ the original context is deleted; otherwise it is overridden.
+*/
+void QGLWidget::setContext(QGLContext *context,
+ const QGLContext* shareContext,
+ bool deleteOldContext)
+{
+ Q_D(QGLWidget);
+ if (context == 0) {
+ qWarning("QGLWidget::setContext: Cannot set null context");
+ return;
+ }
+ if (!context->deviceIsPixmap() && context->device() != this) {
+ qWarning("QGLWidget::setContext: Context must refer to this widget");
+ return;
+ }
+
+ if (d->glcx)
+ d->glcx->doneCurrent();
+ QGLContext* oldcx = d->glcx;
+ d->glcx = context;
+
+ if (parentWidget()) {
+ // force creation of delay-created widgets
+ parentWidget()->winId();
+ if (parentWidget()->x11Info().screen() != x11Info().screen())
+ d_func()->xinfo = parentWidget()->d_func()->xinfo;
+ }
+
+ // If the application has set WA_TranslucentBackground and not explicitly set
+ // the alpha buffer size to zero, modify the format so it have an alpha channel
+ QGLFormat& fmt = d->glcx->d_func()->glFormat;
+ if (testAttribute(Qt::WA_TranslucentBackground) && fmt.alphaBufferSize() == -1)
+ fmt.setAlphaBufferSize(1);
+
+ bool createFailed = false;
+ if (!d->glcx->isValid()) {
+ if (!d->glcx->create(shareContext ? shareContext : oldcx))
+ createFailed = true;
+ }
+ if (createFailed) {
+ if (deleteOldContext)
+ delete oldcx;
+ return;
+ }
+
+ if (d->glcx->windowCreated() || d->glcx->deviceIsPixmap()) {
+ if (deleteOldContext)
+ delete oldcx;
+ return;
+ }
+
+ bool visible = isVisible();
+ if (visible)
+ hide();
+
+ XVisualInfo *vi = (XVisualInfo*)d->glcx->d_func()->vi;
+ XSetWindowAttributes a;
+
+ QColormap colmap = QColormap::instance(vi->screen);
+ a.colormap = qt_gl_choose_cmap(QX11Info::display(), vi); // find best colormap
+ a.background_pixel = colmap.pixel(palette().color(backgroundRole()));
+ a.border_pixel = colmap.pixel(Qt::black);
+ Window p = RootWindow(X11->display, vi->screen);
+ if (parentWidget())
+ p = parentWidget()->winId();
+
+ Window w = XCreateWindow(X11->display, p, x(), y(), width(), height(),
+ 0, vi->depth, InputOutput, vi->visual,
+ CWBackPixel|CWBorderPixel|CWColormap, &a);
+ Window *cmw;
+ Window *cmwret;
+ int count;
+ if (XGetWMColormapWindows(X11->display, window()->winId(),
+ &cmwret, &count)) {
+ cmw = new Window[count+1];
+ memcpy((char *)cmw, (char *)cmwret, sizeof(Window)*count);
+ XFree((char *)cmwret);
+ int i;
+ for (i=0; i<count; i++) {
+ if (cmw[i] == winId()) { // replace old window
+ cmw[i] = w;
+ break;
+ }
+ }
+ if (i >= count) // append new window
+ cmw[count++] = w;
+ } else {
+ count = 1;
+ cmw = new Window[count];
+ cmw[0] = w;
+ }
+
+#if defined(GLX_MESA_release_buffers) && defined(QGL_USE_MESA_EXT)
+ if (oldcx && oldcx->windowCreated())
+ glXReleaseBuffersMESA(X11->display, winId());
+#endif
+ if (deleteOldContext)
+ delete oldcx;
+ oldcx = 0;
+
+ if (testAttribute(Qt::WA_WState_Created))
+ create(w);
+ else
+ d->createWinId(w);
+ XSetWMColormapWindows(X11->display, window()->winId(), cmw, count);
+ delete [] cmw;
+
+ // calling QWidget::create() will always result in a new paint
+ // engine being created - get rid of it and replace it with our
+ // own
+
+ if (visible)
+ show();
+ XFlush(X11->display);
+ d->glcx->setWindowCreated(true);
+}
+
+const QGLColormap & QGLWidget::colormap() const
+{
+ Q_D(const QGLWidget);
+ return d->cmap;
+}
+
+/*\internal
+ Store color values in the given colormap.
+*/
+static void qStoreColors(QWidget * tlw, Colormap cmap,
+ const QGLColormap & cols)
+{
+ Q_UNUSED(tlw);
+ XColor c;
+ QRgb color;
+
+ for (int i = 0; i < cols.size(); i++) {
+ color = cols.entryRgb(i);
+ c.pixel = i;
+ c.red = (ushort)((qRed(color) / 255.0) * 65535.0 + 0.5);
+ c.green = (ushort)((qGreen(color) / 255.0) * 65535.0 + 0.5);
+ c.blue = (ushort)((qBlue(color) / 255.0) * 65535.0 + 0.5);
+ c.flags = DoRed | DoGreen | DoBlue;
+ XStoreColor(X11->display, cmap, &c);
+ }
+}
+
+/*\internal
+ Check whether the given visual supports dynamic colormaps or not.
+*/
+static bool qCanAllocColors(QWidget * w)
+{
+ bool validVisual = false;
+ int numVisuals;
+ long mask;
+ XVisualInfo templ;
+ XVisualInfo * visuals;
+ VisualID id = XVisualIDFromVisual((Visual *) w->window()->x11Info().visual());
+
+ mask = VisualScreenMask;
+ templ.screen = w->x11Info().screen();
+ visuals = XGetVisualInfo(X11->display, mask, &templ, &numVisuals);
+
+ for (int i = 0; i < numVisuals; i++) {
+ if (visuals[i].visualid == id) {
+ switch (visuals[i].c_class) {
+ case TrueColor:
+ case StaticColor:
+ case StaticGray:
+ case XGrayScale:
+ validVisual = false;
+ break;
+ case DirectColor:
+ case PseudoColor:
+ validVisual = true;
+ break;
+ }
+ break;
+ }
+ }
+ XFree(visuals);
+
+ if (!validVisual)
+ return false;
+ return true;
+}
+
+
+void QGLWidget::setColormap(const QGLColormap & c)
+{
+ Q_D(QGLWidget);
+ QWidget * tlw = window(); // must return a valid widget
+
+ d->cmap = c;
+ if (!d->cmap.handle())
+ return;
+
+ if (!qCanAllocColors(this)) {
+ qWarning("QGLWidget::setColormap: Cannot create a read/write "
+ "colormap for this visual");
+ return;
+ }
+
+ // If the child GL widget is not of the same visual class as the
+ // toplevel widget we will get in trouble..
+ Window wid = tlw->winId();
+ Visual * vis = (Visual *) tlw->x11Info().visual();;
+ VisualID cvId = XVisualIDFromVisual((Visual *) x11Info().visual());
+ VisualID tvId = XVisualIDFromVisual((Visual *) tlw->x11Info().visual());
+ if (cvId != tvId) {
+ wid = winId();
+ vis = (Visual *) x11Info().visual();
+ }
+
+ if (!d->cmap.handle()) // allocate a cmap if necessary
+ d->cmap.setHandle(XCreateColormap(X11->display, wid, vis, AllocAll));
+
+ qStoreColors(this, (Colormap) d->cmap.handle(), c);
+ XSetWindowColormap(X11->display, wid, (Colormap) d->cmap.handle());
+
+ // tell the wm that this window has a special colormap
+ Window * cmw;
+ Window * cmwret;
+ int count;
+ if (XGetWMColormapWindows(X11->display, tlw->winId(), &cmwret, &count))
+ {
+ cmw = new Window[count+1];
+ memcpy((char *) cmw, (char *) cmwret, sizeof(Window) * count);
+ XFree((char *) cmwret);
+ int i;
+ for (i = 0; i < count; i++) {
+ if (cmw[i] == winId()) {
+ break;
+ }
+ }
+ if (i >= count) // append new window only if not in the list
+ cmw[count++] = winId();
+ } else {
+ count = 1;
+ cmw = new Window[count];
+ cmw[0] = winId();
+ }
+ XSetWMColormapWindows(X11->display, tlw->winId(), cmw, count);
+ delete [] cmw;
+}
+
+void QGLExtensions::init()
+{
+ static bool init_done = false;
+
+ if (init_done)
+ return;
+ init_done = true;
+
+ QGLWidget dmy;
+ dmy.makeCurrent();
+ init_extensions();
+
+ // 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();
+ nvidiaFboNeedsFinish = nvidiaDriverVersion >= 90.0 && nvidiaDriverVersion < 100.0;
+ }
+}
+
+// Solaris defines glXBindTexImageEXT as part of the GL library
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+typedef void (*qt_glXBindTexImageEXT)(Display*, GLXDrawable, int, const int*);
+typedef void (*qt_glXReleaseTexImageEXT)(Display*, GLXDrawable, int);
+static qt_glXBindTexImageEXT glXBindTexImageEXT = 0;
+static qt_glXReleaseTexImageEXT glXReleaseTexImageEXT = 0;
+
+bool qt_resolveTextureFromPixmap()
+{
+ static bool resolvedTextureFromPixmap = false;
+
+ if (!resolvedTextureFromPixmap) {
+ resolvedTextureFromPixmap = true;
+
+ // Check to see if we have NPOT texture support
+ if ( !(QGLExtensions::glExtensions & QGLExtensions::NPOTTextures) &&
+ !(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0))
+ {
+ return false; // Can't use TFP without NPOT
+ }
+
+ QString glxExt = QLatin1String(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS));
+ if (glxExt.contains(QLatin1String("GLX_EXT_texture_from_pixmap"))) {
+ glXBindTexImageEXT = (qt_glXBindTexImageEXT) qglx_getProcAddress("glXBindTexImageEXT");
+ glXReleaseTexImageEXT = (qt_glXReleaseTexImageEXT) qglx_getProcAddress("glXReleaseTexImageEXT");
+ }
+ }
+
+ return glXBindTexImageEXT && glXReleaseTexImageEXT;
+}
+#endif //defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+
+
+QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmapData *pmd, const qint64 key,
+ QGLContext::BindOptions options)
+{
+#if !defined(GLX_VERSION_1_3) || defined(Q_OS_HPUX)
+ return 0;
+#else
+ Q_Q(QGLContext);
+
+ Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
+
+ if (!qt_resolveTextureFromPixmap())
+ return 0;
+
+ QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
+ const QX11Info &x11Info = pixmapData->xinfo;
+
+ // Store the configs (Can be static because configs aren't dependent on current context)
+ static GLXFBConfig glxRGBPixmapConfig = 0;
+ static bool RGBConfigInverted = false;
+ static GLXFBConfig glxRGBAPixmapConfig = 0;
+ static bool RGBAConfigInverted = false;
+
+ bool hasAlpha = pixmapData->hasAlphaChannel();
+
+ // Check to see if we need a config
+ if ( (hasAlpha && !glxRGBAPixmapConfig) || (!hasAlpha && !glxRGBPixmapConfig) ) {
+ GLXFBConfig *configList = 0;
+ int configCount = 0;
+
+ int configAttribs[] = {
+ hasAlpha ? GLX_BIND_TO_TEXTURE_RGBA_EXT : GLX_BIND_TO_TEXTURE_RGB_EXT, True,
+ GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
+ GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
+ // QGLContext::bindTexture() can't return an inverted texture, but QPainter::drawPixmap() can:
+ GLX_Y_INVERTED_EXT, options & QGLContext::CanFlipNativePixmapBindOption ? GLX_DONT_CARE : False,
+ XNone
+ };
+ configList = glXChooseFBConfig(x11Info.display(), x11Info.screen(), configAttribs, &configCount);
+ if (!configList)
+ return 0;
+
+ int yInv;
+ glXGetFBConfigAttrib(x11Info.display(), configList[0], GLX_Y_INVERTED_EXT, &yInv);
+
+ if (hasAlpha) {
+ glxRGBAPixmapConfig = configList[0];
+ RGBAConfigInverted = yInv;
+ }
+ else {
+ glxRGBPixmapConfig = configList[0];
+ RGBConfigInverted = yInv;
+ }
+
+ XFree(configList);
+ }
+
+ // Check to see if the surface is still valid
+ if (pixmapData->gl_surface &&
+ hasAlpha != (pixmapData->flags & QX11PixmapData::GlSurfaceCreatedWithAlpha))
+ {
+ // Surface is invalid!
+ destroyGlSurfaceForPixmap(pixmapData);
+ }
+
+ // Check to see if we need a surface
+ if (!pixmapData->gl_surface) {
+ GLXPixmap glxPixmap;
+ int pixmapAttribs[] = {
+ GLX_TEXTURE_FORMAT_EXT, hasAlpha ? GLX_TEXTURE_FORMAT_RGBA_EXT : GLX_TEXTURE_FORMAT_RGB_EXT,
+ GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
+ GLX_MIPMAP_TEXTURE_EXT, False, // Maybe needs to be don't care
+ XNone
+ };
+
+ // Wrap the X Pixmap into a GLXPixmap:
+ glxPixmap = glXCreatePixmap(x11Info.display(),
+ hasAlpha ? glxRGBAPixmapConfig : glxRGBPixmapConfig,
+ pixmapData->handle(), pixmapAttribs);
+
+ if (!glxPixmap)
+ return 0;
+
+ pixmapData->gl_surface = (Qt::HANDLE)glxPixmap;
+
+ // Make sure the cleanup hook gets called so we can delete the glx pixmap
+ pixmapData->is_cached = true;
+ }
+
+ GLuint textureId;
+ glGenTextures(1, &textureId);
+ glBindTexture(GL_TEXTURE_2D, textureId);
+ glXBindTexImageEXT(x11Info.display(), (GLXPixmap)pixmapData->gl_surface, GLX_FRONT_LEFT_EXT, 0);
+
+ glBindTexture(GL_TEXTURE_2D, textureId);
+
+ if (!((hasAlpha && RGBAConfigInverted) || (!hasAlpha && RGBConfigInverted)))
+ options &= ~QGLContext::InvertedYBindOption;
+
+ QGLTexture *texture = new QGLTexture(q, textureId, GL_TEXTURE_2D, options);
+ if (texture->options & QGLContext::InvertedYBindOption)
+ pixmapData->flags |= QX11PixmapData::InvertedWhenBoundToTexture;
+
+ // We assume the cost of bound pixmaps is zero
+ QGLTextureCache::instance()->insert(q, key, texture, 0);
+
+ return texture;
+#endif //!defined(GLX_VERSION_1_3) || defined(Q_OS_HPUX)
+}
+
+
+void QGLContextPrivate::destroyGlSurfaceForPixmap(QPixmapData* pmd)
+{
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+ Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
+ QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
+ if (pixmapData->gl_surface) {
+ glXDestroyPixmap(QX11Info::display(), (GLXPixmap)pixmapData->gl_surface);
+ pixmapData->gl_surface = 0;
+ }
+#endif
+}
+
+void QGLContextPrivate::unbindPixmapFromTexture(QPixmapData* pmd)
+{
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+ Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
+ Q_ASSERT(QGLContext::currentContext());
+ QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
+ if (pixmapData->gl_surface)
+ glXReleaseTexImageEXT(QX11Info::display(), (GLXPixmap)pixmapData->gl_surface, GLX_FRONT_LEFT_EXT);
+#endif
+}
+
+QT_END_NAMESPACE