qgl_x11.cpp File Reference

#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>
#include <private/qimagepixmapcleanuphooks_p.h>
#include <private/qunicodetables_p.h>
#include <GL/glx.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xos.h>
#include <X11/Xatom.h>
#include <dlfcn.h>
#include "qgl_x11.moc"

Go to the source code of this file.

Classes
struct	QCMapEntry
struct	QGLCMapCleanupHandler
class	QGLOverlayWidget
class	QGLTemporaryContextPrivate
struct	QTransColor

Macros
#define	GLX_BIND_TO_MIPMAP_TEXTURE_EXT   0x20D2
#define	GLX_BIND_TO_TEXTURE_RGB_EXT   0x20D0
#define	GLX_BIND_TO_TEXTURE_RGBA_EXT   0x20D1
#define	GLX_BIND_TO_TEXTURE_TARGETS_EXT   0x20D3
#define	GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB   0x00000002
#define	GLX_CONTEXT_CORE_PROFILE_BIT_ARB   0x00000001
#define	GLX_CONTEXT_DEBUG_BIT_ARB   0x00000001
#define	GLX_CONTEXT_FLAGS_ARB   0x2094
#define	GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB   0x00000002
#define	GLX_CONTEXT_MAJOR_VERSION_ARB   0x2091
#define	GLX_CONTEXT_MINOR_VERSION_ARB   0x2092
#define	GLX_CONTEXT_PROFILE_MASK_ARB   0x9126
#define	GLX_EXT_texture_from_pixmap   1
#define	GLX_FRONT_LEFT_EXT   0x20DE
#define	GLX_MIPMAP_TEXTURE_EXT   0x20D7
#define	GLX_SAMPLE_BUFFERS_ARB   100000
#define	GLX_SAMPLES_ARB   100001
#define	GLX_TEXTURE_2D_BIT_EXT   0x00000002
#define	GLX_TEXTURE_2D_EXT   0x20DC
#define	GLX_TEXTURE_FORMAT_EXT   0x20D5
#define	GLX_TEXTURE_FORMAT_NONE_EXT   0x20D8
#define	GLX_TEXTURE_FORMAT_RGB_EXT   0x20D9
#define	GLX_TEXTURE_FORMAT_RGBA_EXT   0x20DA
#define	GLX_TEXTURE_RECTANGLE_BIT_EXT   0x00000004
#define	GLX_TEXTURE_RECTANGLE_EXT   0x20DD
#define	GLX_TEXTURE_TARGET_EXT   0x20D6
#define	GLX_Y_INVERTED_EXT   0x20D4
#define	INT32   dummy_INT32
#define	INT8   dummy_INT8

Typedefs
typedef QHash< int, QCMapEntry * >	CMapEntryHash
typedef QHash< int, QMap< int, QRgb > >	GLCMapHash

Functions
static bool	buildSpec (int *spec, const QGLFormat &f, QPaintDevice *paintDevice, int bufDepth, bool onlyFBConfig=false)
static void	cleanup_cmaps ()
static void	find_trans_colors ()
static bool	qCanAllocColors (QWidget *w)
static void	qgl_use_font (QFontEngineFT *engine, int first, int count, int listBase)
	This is basically a substitute for glxUseXFont() which can only handle XLFD fonts. More...
void *	qglx_getProcAddress (const char *procName)
static void	qStoreColors (QWidget *tlw, Colormap cmap, const QGLColormap &cols)
Colormap	qt_gl_choose_cmap (Display *dpy, XVisualInfo *vi)
static uint	qt_transparent_pixel (VisualID id, int screen)
Drawable	qt_x11Handle (const QPaintDevice *pd)
	Returns the X11 Drawable of the paint device. More...
const QX11Info *	qt_x11Info (const QPaintDevice *pd)

Variables
static bool	first_time = true
static bool	mesa_gl = false
static QVector< QTransColor >	trans_colors
static int	trans_colors_init = false

Macro Definition Documentation

GLX_BIND_TO_MIPMAP_TEXTURE_EXT

#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT   0x20D2

Definition at line 105 of file qgl_x11.cpp.

GLX_BIND_TO_TEXTURE_RGB_EXT

#define GLX_BIND_TO_TEXTURE_RGB_EXT   0x20D0

Definition at line 103 of file qgl_x11.cpp.

Referenced by QGLContextPrivate::bindTextureFromNativePixmap().

GLX_BIND_TO_TEXTURE_RGBA_EXT

#define GLX_BIND_TO_TEXTURE_RGBA_EXT   0x20D1

Definition at line 104 of file qgl_x11.cpp.

Referenced by QGLContextPrivate::bindTextureFromNativePixmap().

GLX_BIND_TO_TEXTURE_TARGETS_EXT

#define GLX_BIND_TO_TEXTURE_TARGETS_EXT   0x20D3

Definition at line 106 of file qgl_x11.cpp.

Referenced by QGLContextPrivate::bindTextureFromNativePixmap().

GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB

#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB   0x00000002

Definition at line 129 of file qgl_x11.cpp.

Referenced by buildSpec().

GLX_CONTEXT_CORE_PROFILE_BIT_ARB

#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB   0x00000001

Definition at line 128 of file qgl_x11.cpp.

Referenced by buildSpec().

GLX_CONTEXT_DEBUG_BIT_ARB

#define GLX_CONTEXT_DEBUG_BIT_ARB   0x00000001

Definition at line 120 of file qgl_x11.cpp.

GLX_CONTEXT_FLAGS_ARB

#define GLX_CONTEXT_FLAGS_ARB   0x2094

Definition at line 124 of file qgl_x11.cpp.

GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB

#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB   0x00000002

Definition at line 121 of file qgl_x11.cpp.

GLX_CONTEXT_MAJOR_VERSION_ARB

#define GLX_CONTEXT_MAJOR_VERSION_ARB   0x2091

Definition at line 122 of file qgl_x11.cpp.

Referenced by buildSpec().

GLX_CONTEXT_MINOR_VERSION_ARB

#define GLX_CONTEXT_MINOR_VERSION_ARB   0x2092

Definition at line 123 of file qgl_x11.cpp.

Referenced by buildSpec().

GLX_CONTEXT_PROFILE_MASK_ARB

#define GLX_CONTEXT_PROFILE_MASK_ARB   0x9126

Definition at line 130 of file qgl_x11.cpp.

Referenced by buildSpec().

GLX_EXT_texture_from_pixmap

#define GLX_EXT_texture_from_pixmap   1

Definition at line 65 of file qgl_x11.cpp.

GLX_FRONT_LEFT_EXT

#define GLX_FRONT_LEFT_EXT   0x20DE

Definition at line 116 of file qgl_x11.cpp.

Referenced by QGLContextPrivate::bindTextureFromNativePixmap(), and QGLContextPrivate::unbindPixmapFromTexture().

GLX_MIPMAP_TEXTURE_EXT

#define GLX_MIPMAP_TEXTURE_EXT   0x20D7

Definition at line 110 of file qgl_x11.cpp.

Referenced by QGLContextPrivate::bindTextureFromNativePixmap().

GLX_SAMPLE_BUFFERS_ARB

#define GLX_SAMPLE_BUFFERS_ARB   100000

Definition at line 96 of file qgl_x11.cpp.

Referenced by buildSpec(), ShivaVGWindowSurfacePrivate::ensureContext(), and qglx_buildSpec().

GLX_SAMPLES_ARB

#define GLX_SAMPLES_ARB   100001

Definition at line 97 of file qgl_x11.cpp.

Referenced by buildSpec(), ShivaVGWindowSurfacePrivate::ensureContext(), qglx_buildSpec(), and qglx_platformWindowFromGLXFBConfig().

GLX_TEXTURE_2D_BIT_EXT

#define GLX_TEXTURE_2D_BIT_EXT   0x00000002

Definition at line 101 of file qgl_x11.cpp.

Referenced by QGLContextPrivate::bindTextureFromNativePixmap().

GLX_TEXTURE_2D_EXT

#define GLX_TEXTURE_2D_EXT   0x20DC

Definition at line 114 of file qgl_x11.cpp.

Referenced by QGLContextPrivate::bindTextureFromNativePixmap().

GLX_TEXTURE_FORMAT_EXT

#define GLX_TEXTURE_FORMAT_EXT   0x20D5

Definition at line 108 of file qgl_x11.cpp.

Referenced by QGLContextPrivate::bindTextureFromNativePixmap().

GLX_TEXTURE_FORMAT_NONE_EXT

#define GLX_TEXTURE_FORMAT_NONE_EXT   0x20D8

Definition at line 111 of file qgl_x11.cpp.

GLX_TEXTURE_FORMAT_RGB_EXT

#define GLX_TEXTURE_FORMAT_RGB_EXT   0x20D9

Definition at line 112 of file qgl_x11.cpp.

Referenced by QGLContextPrivate::bindTextureFromNativePixmap().

GLX_TEXTURE_FORMAT_RGBA_EXT

#define GLX_TEXTURE_FORMAT_RGBA_EXT   0x20DA

Definition at line 113 of file qgl_x11.cpp.

Referenced by QGLContextPrivate::bindTextureFromNativePixmap().

GLX_TEXTURE_RECTANGLE_BIT_EXT

#define GLX_TEXTURE_RECTANGLE_BIT_EXT   0x00000004

Definition at line 102 of file qgl_x11.cpp.

GLX_TEXTURE_RECTANGLE_EXT

#define GLX_TEXTURE_RECTANGLE_EXT   0x20DD

Definition at line 115 of file qgl_x11.cpp.

GLX_TEXTURE_TARGET_EXT

#define GLX_TEXTURE_TARGET_EXT   0x20D6

Definition at line 109 of file qgl_x11.cpp.

Referenced by QGLContextPrivate::bindTextureFromNativePixmap().

GLX_Y_INVERTED_EXT

#define GLX_Y_INVERTED_EXT   0x20D4

Definition at line 107 of file qgl_x11.cpp.

Referenced by QGLContextPrivate::bindTextureFromNativePixmap().

INT32

#define INT32   dummy_INT32

Definition at line 68 of file qgl_x11.cpp.

INT8

#define INT8   dummy_INT8

Definition at line 67 of file qgl_x11.cpp.

Typedef Documentation

CMapEntryHash

typedef QHash<int, QCMapEntry *> CMapEntryHash

Definition at line 162 of file qgl_x11.cpp.

GLCMapHash

typedef QHash<int, QMap<int, QRgb> > GLCMapHash

Definition at line 163 of file qgl_x11.cpp.

Function Documentation

buildSpec()

static bool buildSpec ( int *  spec, const QGLFormat &  f, QPaintDevice *  paintDevice, int  bufDepth, bool  onlyFBConfig = false  )

static

Definition at line 421 of file qgl_x11.cpp.

Referenced by QGLContext::tryVisual().

{
    int i = 0;
    spec[i++] = GLX_LEVEL;
    spec[i++] = f.plane();
    const QX11Info *xinfo = qt_x11Info(paintDevice);
    bool useFBConfig = onlyFBConfig;

#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 (paintDevice->devType() == QInternal::Widget)
        widget = static_cast<QWidget*>(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 && paintDevice) {
        QGLExtensionMatcher extensions(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
        useTranspExt = extensions.match("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(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", paintDevice->devType());
            // Fall-through & assume it's a window
        case QInternal::Widget:
            spec[i++] = GLX_WINDOW_BIT;
            break;
        };
    }
#endif

    spec[i] = XNone;
    return useFBConfig;
}

cleanup_cmaps()

static void cleanup_cmaps ( )

static

Definition at line 183 of file qgl_x11.cpp.

Referenced by qt_gl_choose_cmap().

{
    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();
}

find_trans_colors()

static void find_trans_colors ( )

static

Definition at line 288 of file qgl_x11.cpp.

Referenced by qglx_getProcAddress().

{
    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);
    }
}

qCanAllocColors()

static bool qCanAllocColors ( QWidget *  w )

static

Definition at line 1629 of file qgl_x11.cpp.

{
    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;
}

qgl_use_font()

static void qgl_use_font ( QFontEngineFT *  engine, int  first, int  count, int  listBase  )

static

This is basically a substitute for glxUseXFont() which can only handle XLFD fonts.

Warning

This function is not part of the public interface. 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.

Definition at line 1073 of file qgl_x11.cpp.

{
    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);
}

qglx_getProcAddress()

void* qglx_getProcAddress

(

const char *

procName

)

Definition at line 350 of file qgl_x11.cpp.

Referenced by buildSpec(), qt_resolve_pbuffer_extensions(), and QGLContext::tryVisual().

{
    // 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;
        QGLExtensionMatcher extensions(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS));
        if (extensions.match("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());
                lib.setLoadHints(QLibrary::ImprovedSearchHeuristics);
                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());
        lib.setLoadHints(QLibrary::ImprovedSearchHeuristics);
        procAddress = lib.resolve(procName);
    }
#endif

    return procAddress;
}

qStoreColors()

static void qStoreColors ( QWidget *  tlw, Colormap  cmap, const QGLColormap &  cols  )

static

Definition at line 1608 of file qgl_x11.cpp.

Referenced by qCanAllocColors().

{
    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);
    }
}

qt_gl_choose_cmap()

Colormap qt_gl_choose_cmap	(	Display *	dpy,
		XVisualInfo *	vi
	)

Definition at line 196 of file qgl_x11.cpp.

Referenced by buildSpec(), and QGLOverlayWidget::paintGL().

{
    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;
}

qt_transparent_pixel()

static uint qt_transparent_pixel ( VisualID  id, int  screen  )

static

Definition at line 991 of file qgl_x11.cpp.

{
    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;
}

qt_x11Handle()

Drawable qt_x11Handle

(

const QPaintDevice *

pd

)

Returns the X11 Drawable of the paint device.

Warning

This function is not part of the public interface.

0 is returned if it can't be obtained.

Definition at line 61 of file qpaintdevice_x11.cpp.

Referenced by buildSpec().

{
    if (!pd) return 0;
    if (pd->devType() == QInternal::Widget)
        return static_cast<const QWidget *>(pd)->handle();
    else if (pd->devType() == QInternal::Pixmap)
        return static_cast<const QPixmap *>(pd)->handle();
    return 0;
}

qt_x11Info()

const QX11Info* qt_x11Info ( const QPaintDevice *  pd )

related

Referenced by buildSpec(), and QGLContext::tryVisual().

Variable Documentation

first_time

bool first_time = true

static

Definition at line 165 of file qgl_x11.cpp.

Referenced by qt_gl_choose_cmap().

mesa_gl

bool mesa_gl = false

static

Definition at line 164 of file qgl_x11.cpp.

Referenced by qt_gl_choose_cmap().

trans_colors

QVector<QTransColor> trans_colors

static

Definition at line 285 of file qgl_x11.cpp.

trans_colors_init

int trans_colors_init = false

static

Definition at line 286 of file qgl_x11.cpp.

Referenced by find_trans_colors(), and qglx_getProcAddress().