src/opengl/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_p.h>
#include <private/qt_x11_p.h>
#include <GL/glx.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xos.h>
#include <X11/Xatom.h>
#include "qgl_x11.moc"

Include dependency graph for qgl_x11.cpp:

Go to the source code of this file.

Classes
struct	QCMapEntry
struct	QGLCMapCleanupHandler
struct	QTransColor
class	QGLOverlayWidget
Defines
#define	INT8   dummy_INT8
#define	INT32   dummy_INT32
#define	GLX_SAMPLE_BUFFERS_ARB   100000
#define	GLX_SAMPLES_ARB   100001
Typedefs
typedef QHash< int, QCMapEntry * >	CMapEntryHash
typedef QHash< int, QMap< int, QRgb > >	GLCMapHash
Functions
Drawable	qt_x11Handle (const QPaintDevice *pd)
const QX11Info *	qt_x11Info (const QPaintDevice *pd)
static void	cleanup_cmaps ()
	Q_GLOBAL_STATIC (QGLCMapCleanupHandler, cmap_handler)
static Colormap	choose_cmap (Display *dpy, XVisualInfo *vi)
static void	find_trans_colors ()
static void	qgl_use_font (QFontEngineFT *engine, int first, int count, int listBase)
static void	qStoreColors (QWidget *tlw, Colormap cmap, const QGLColormap &cols)
static bool	qCanAllocColors (QWidget *w)
Variables
static bool	mesa_gl = false
static bool	first_time = true
static QVector< QTransColor >	trans_colors
static int	trans_colors_init = false

---

Define Documentation

#define GLX_SAMPLE_BUFFERS_ARB   100000

Definition at line 52 of file qgl_x11.cpp.

Referenced by QGLContext::chooseContext(), QGLPixelBufferPrivate::init(), and qt_format_to_attrib_list().

#define GLX_SAMPLES_ARB   100001

Definition at line 53 of file qgl_x11.cpp.

Referenced by QGLContext::chooseContext(), QGLPixelBufferPrivate::init(), and qt_format_to_attrib_list().

#define INT32   dummy_INT32

Definition at line 39 of file qgl_x11.cpp.

#define INT8   dummy_INT8

Definition at line 38 of file qgl_x11.cpp.

---

Typedef Documentation

typedef QHash<int, QCMapEntry *> CMapEntryHash

Definition at line 85 of file qgl_x11.cpp.

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

Definition at line 86 of file qgl_x11.cpp.

---

Function Documentation

static Colormap choose_cmap	(	Display *	dpy,
		XVisualInfo *	vi
	)			[static]

Definition at line 125 of file qgl_x11.cpp.

References QX11Info::appColormap(), QX11Info::appVisual(), c, QHash< Key, T >::constEnd(), QHash< Key, T >::constFind(), first_time, i, mesa_gl, n, QHash< Key, T >::const_iterator::value(), and x.

Referenced by QGLContext::chooseContext(), QGLContext::overlayTransparentColor(), QGLWidgetPrivate::renderCxPm(), and QGLWidget::setContext().

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

    // associate cmap with visualid
    hash->insert((long) vi->visualid + (vi->screen * 256), x);
    return x->cmap;
}

Here is the call graph for this function:

static void cleanup_cmaps

(

)

[static]

Definition at line 111 of file qgl_x11.cpp.

References QHash< Key, T >::clear(), QHash< Key, T >::constBegin(), QHash< Key, T >::constEnd(), and QHash< Key, T >::value().

Referenced by QGLCMapCleanupHandler::QGLCMapCleanupHandler(), and QGLCMapCleanupHandler::~QGLCMapCleanupHandler().

{
    if (!cmap_handler()->cleaned_up) {
        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()->cleaned_up = true;
    }
}

Here is the call graph for this function:

static void find_trans_colors

(

)

[static]

Definition at line 213 of file qgl_x11.cpp.

References QApplication::desktop(), i, int, j, QDesktopWidget::screen(), Success, trans_colors, type, value, X11, and XNone.

Referenced by QGLFormat::hasOpenGLOverlays(), and QGLContext::overlayTransparentColor().

{
    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;
        OverlayProp* overlayProps = 0;
        int res = XGetWindowProperty(appDisplay, rootWin->winId(),
                                      overlayVisualsAtom, 0, 10000, False,
                                      overlayVisualsAtom, &actualType,
                                      &actualFormat, &nItems, &bytesAfter,
                                      (uchar**)&overlayProps);

        if (res != Success || actualType != overlayVisualsAtom
             || actualFormat != 32 || nItems < 4 || !overlayProps)
            return;                                        // Error reading property

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

Here is the call graph for this function:

Q_GLOBAL_STATIC	(	QGLCMapCleanupHandler	,
		cmap_handler
	)

static bool qCanAllocColors

(

QWidget *

w

)

[static]

Definition at line 1242 of file qgl_x11.cpp.

References mask, w, X11, and XGrayScale.

Referenced by QGLWidget::setColormap().

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

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

Definition at line 759 of file qgl_x11.cpp.

References FT_Bitmap_::buffer, FT_Get_Char_Index(), FT_LOAD_DEFAULT, FT_Load_Glyph(), FT_Render_Glyph(), ft_render_mode_mono, ft_render_mode_normal, GLint, QFontEngineFT::lockFace(), QFontEngineFT::pattern(), FT_Bitmap_::pitch, qDebug(), FT_Bitmap_::rows, QFontEngineFT::unlockFace(), x, and y.

Referenced by QGLContext::generateFontDisplayLists().

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

    FcBool antialiased = True;
    FcPatternGetBool(engine->pattern(), FC_ANTIALIAS, 0, &antialiased);
    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);
}

Here is the call graph for this function:

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

Definition at line 1221 of file qgl_x11.cpp.

References c, QGLColormap::entryRgb(), QColor::qBlue(), QColor::qGreen(), QColor::qRed(), QColor::QRgb(), QGLColormap::size(), and X11.

Referenced by QGLWidget::setColormap().

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

Here is the call graph for this function:

Drawable qt_x11Handle

(

const QPaintDevice *

pd

)

Definition at line 182 of file qpaintdevice_x11.cpp.

References QPaintDevice::devType(), QInternal::Pixmap, and QInternal::Widget.

Referenced by QX11PaintEngine::begin(), and QGLContext::chooseContext().

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

Here is the call graph for this function:

const QX11Info* qt_x11Info

(

const QPaintDevice *

pd

)

[related]

---

Variable Documentation

bool first_time = true [static]

Definition at line 88 of file qgl_x11.cpp.

Referenced by choose_cmap().

bool mesa_gl = false [static]

Definition at line 87 of file qgl_x11.cpp.

Referenced by choose_cmap().

QVector<QTransColor> trans_colors [static]

Definition at line 210 of file qgl_x11.cpp.

Referenced by find_trans_colors(), QGLFormat::hasOpenGLOverlays(), and QGLContext::overlayTransparentColor().

int trans_colors_init = false [static]

Definition at line 211 of file qgl_x11.cpp.

---