Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

qgl_x11.cpp

Last change on this file was 846, checked in by Dmitry A. Kuminov, 14 years ago
trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
File size: 63.0 KB

Rev	Line
[2]	1	/****************************************************************************
	2	**
[846]	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
[561]	4	** All rights reserved.
	5	** Contact: Nokia Corporation (qt-info@nokia.com)
[2]	6	**
	7	** This file is part of the QtOpenGL module of the Qt Toolkit.
	8	**
	9	** $QT_BEGIN_LICENSE:LGPL$
	10	** Commercial Usage
	11	** Licensees holding valid Qt Commercial licenses may use this file in
	12	** accordance with the Qt Commercial License Agreement provided with the
	13	** Software or, alternatively, in accordance with the terms contained in
	14	** a written agreement between you and Nokia.
	15	**
	16	** GNU Lesser General Public License Usage
	17	** Alternatively, this file may be used under the terms of the GNU Lesser
	18	** General Public License version 2.1 as published by the Free Software
	19	** Foundation and appearing in the file LICENSE.LGPL included in the
	20	** packaging of this file. Please review the following information to
	21	** ensure the GNU Lesser General Public License version 2.1 requirements
	22	** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
	23	**
[561]	24	** In addition, as a special exception, Nokia gives you certain additional
	25	** rights. These rights are described in the Nokia Qt LGPL Exception
	26	** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
[2]	27	**
	28	** GNU General Public License Usage
	29	** Alternatively, this file may be used under the terms of the GNU
	30	** General Public License version 3.0 as published by the Free Software
	31	** Foundation and appearing in the file LICENSE.GPL included in the
	32	** packaging of this file. Please review the following information to
	33	** ensure the GNU General Public License version 3.0 requirements will be
	34	** met: http://www.gnu.org/copyleft/gpl.html.
	35	**
[561]	36	** If you have questions regarding the use of this file, please contact
	37	** Nokia at qt-info@nokia.com.
[2]	38	** $QT_END_LICENSE$
	39	**
	40	****************************************************************************/
	41
	42	#include "qgl.h"
	43	#include "qgl_p.h"
	44
	45	#include "qmap.h"
	46	#include "qapplication.h"
	47	#include "qcolormap.h"
	48	#include "qdesktopwidget.h"
	49	#include "qpixmap.h"
	50	#include "qhash.h"
	51	#include "qlibrary.h"
	52	#include "qdebug.h"
	53	#include <private/qfontengine_ft_p.h>
	54	#include <private/qt_x11_p.h>
[561]	55	#include <private/qpixmap_x11_p.h>
	56	#include <private/qimagepixmapcleanuphooks_p.h>
[846]	57	#include <private/qunicodetables_p.h>
[2]	58	#ifdef Q_OS_HPUX
	59	// for GLXPBuffer
	60	#include <private/qglpixelbuffer_p.h>
	61	#endif
	62
[561]	63	// We always define GLX_EXT_texture_from_pixmap ourselves because
	64	// we can't trust system headers to do it properly
	65	#define GLX_EXT_texture_from_pixmap 1
	66
[2]	67	#define INT8 dummy_INT8
	68	#define INT32 dummy_INT32
	69	#include <GL/glx.h>
	70	#undef INT8
	71	#undef INT32
[561]	72
[2]	73	#include <X11/Xlib.h>
	74	#include <X11/Xutil.h>
	75	#include <X11/Xos.h>
[561]	76	#ifdef Q_OS_VXWORS
	77	# ifdef open
	78	# undef open
	79	# endif
	80	# ifdef getpid
	81	# undef getpid
	82	# endif
	83	#endif // Q_OS_VXWORKS
[2]	84	#include <X11/Xatom.h>
	85
	86	#if defined(Q_OS_LINUX) \|\| defined(Q_OS_BSD4)
	87	#include <dlfcn.h>
	88	#endif
	89
	90	QT_BEGIN_NAMESPACE
	91
	92	extern Drawable qt_x11Handle(const QPaintDevice *pd);
	93	extern const QX11Info qt_x11Info(const QPaintDevice pd);
	94
	95	#ifndef GLX_ARB_multisample
	96	#define GLX_SAMPLE_BUFFERS_ARB 100000
	97	#define GLX_SAMPLES_ARB 100001
	98	#endif
	99
[561]	100	#ifndef GLX_TEXTURE_2D_BIT_EXT
	101	#define GLX_TEXTURE_2D_BIT_EXT 0x00000002
	102	#define GLX_TEXTURE_RECTANGLE_BIT_EXT 0x00000004
	103	#define GLX_BIND_TO_TEXTURE_RGB_EXT 0x20D0
	104	#define GLX_BIND_TO_TEXTURE_RGBA_EXT 0x20D1
	105	#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT 0x20D2
	106	#define GLX_BIND_TO_TEXTURE_TARGETS_EXT 0x20D3
	107	#define GLX_Y_INVERTED_EXT 0x20D4
	108	#define GLX_TEXTURE_FORMAT_EXT 0x20D5
	109	#define GLX_TEXTURE_TARGET_EXT 0x20D6
	110	#define GLX_MIPMAP_TEXTURE_EXT 0x20D7
	111	#define GLX_TEXTURE_FORMAT_NONE_EXT 0x20D8
	112	#define GLX_TEXTURE_FORMAT_RGB_EXT 0x20D9
	113	#define GLX_TEXTURE_FORMAT_RGBA_EXT 0x20DA
	114	#define GLX_TEXTURE_2D_EXT 0x20DC
	115	#define GLX_TEXTURE_RECTANGLE_EXT 0x20DD
	116	#define GLX_FRONT_LEFT_EXT 0x20DE
	117	#endif
	118
[846]	119	#ifndef GLX_ARB_create_context
	120	#define GLX_CONTEXT_DEBUG_BIT_ARB 0x00000001
	121	#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
	122	#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
	123	#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
	124	#define GLX_CONTEXT_FLAGS_ARB 0x2094
	125	#endif
	126
	127	#ifndef GLX_ARB_create_context_profile
	128	#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
	129	#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
	130	#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
	131	#endif
	132
[2]	133	/*
	134	The qt_gl_choose_cmap function is internal and used by QGLWidget::setContext()
	135	and GLX (not Windows). If the application can't find any sharable
	136	colormaps, it must at least create as few colormaps as possible. The
	137	dictionary solution below ensures only one colormap is created per visual.
	138	Colormaps are also deleted when the application terminates.
	139	*/
	140
	141	struct QCMapEntry {
	142	QCMapEntry();
	143	~QCMapEntry();
	144
	145	Colormap cmap;
	146	bool alloc;
	147	XStandardColormap scmap;
	148	};
	149
	150	QCMapEntry::QCMapEntry()
	151	{
	152	cmap = 0;
	153	alloc = false;
	154	scmap.colormap = 0;
	155	}
	156
	157	QCMapEntry::~QCMapEntry()
	158	{
	159	if (alloc)
	160	XFreeColormap(X11->display, cmap);
	161	}
	162	typedef QHash<int, QCMapEntry *> CMapEntryHash;
	163	typedef QHash<int, QMap<int, QRgb> > GLCMapHash;
	164	static bool mesa_gl = false;
	165	static bool first_time = true;
	166
	167	static void cleanup_cmaps();
	168
	169	struct QGLCMapCleanupHandler {
	170	QGLCMapCleanupHandler() {
	171	cmap_hash = new CMapEntryHash;
	172	qglcmap_hash = new GLCMapHash;
	173	}
	174	~QGLCMapCleanupHandler() {
	175	delete cmap_hash;
	176	delete qglcmap_hash;
	177	}
	178	CMapEntryHash *cmap_hash;
	179	GLCMapHash *qglcmap_hash;
	180	};
[561]	181	Q_GLOBAL_STATIC(QGLCMapCleanupHandler, cmap_handler)
[2]	182
	183	static void cleanup_cmaps()
	184	{
	185	CMapEntryHash *hash = cmap_handler()->cmap_hash;
	186	QHash<int, QCMapEntry *>::ConstIterator it = hash->constBegin();
	187	while (it != hash->constEnd()) {
	188	delete it.value();
	189	++it;
	190	}
	191
	192	hash->clear();
	193	cmap_handler()->qglcmap_hash->clear();
	194	}
	195
	196	Colormap qt_gl_choose_cmap(Display dpy, XVisualInfo vi)
	197	{
	198	if (first_time) {
	199	const char *v = glXQueryServerString(dpy, vi->screen, GLX_VERSION);
	200	if (v)
	201	mesa_gl = (strstr(v, "Mesa") != 0);
	202	first_time = false;
	203	}
	204
	205	CMapEntryHash *hash = cmap_handler()->cmap_hash;
	206	CMapEntryHash::ConstIterator it = hash->constFind((long) vi->visualid + (vi->screen * 256));
	207	if (it != hash->constEnd())
	208	return it.value()->cmap; // found colormap for visual
	209
	210	if (vi->visualid ==
	211	XVisualIDFromVisual((Visual *) QX11Info::appVisual(vi->screen))) {
	212	// qDebug("Using x11AppColormap");
	213	return QX11Info::appColormap(vi->screen);
	214	}
	215
	216	QCMapEntry *x = new QCMapEntry();
	217
	218	XStandardColormap *c;
	219	int n, i;
	220
	221	// qDebug("Choosing cmap for vID %0x", vi->visualid);
	222
	223	if (mesa_gl) { // we're using MesaGL
	224	Atom hp_cmaps = XInternAtom(dpy, "_HP_RGB_SMOOTH_MAP_LIST", true);
	225	if (hp_cmaps && vi->visual->c_class == TrueColor && vi->depth == 8) {
	226	if (XGetRGBColormaps(dpy,RootWindow(dpy,vi->screen),&c,&n,
	227	hp_cmaps)) {
	228	i = 0;
	229	while (i < n && x->cmap == 0) {
	230	if (c[i].visualid == vi->visual->visualid) {
	231	x->cmap = c[i].colormap;
	232	x->scmap = c[i];
	233	//qDebug("Using HP_RGB scmap");
	234
	235	}
	236	i++;
	237	}
	238	XFree((char *)c);
	239	}
	240	}
	241	}
	242	if (!x->cmap) {
	243	if (XGetRGBColormaps(dpy,RootWindow(dpy,vi->screen),&c,&n,
	244	XA_RGB_DEFAULT_MAP)) {
	245	for (int i = 0; i < n && x->cmap == 0; ++i) {
	246	if (!c[i].red_max \|\|
	247	!c[i].green_max \|\|
	248	!c[i].blue_max \|\|
	249	!c[i].red_mult \|\|
	250	!c[i].green_mult \|\|
	251	!c[i].blue_mult)
	252	continue; // invalid stdcmap
	253	if (c[i].visualid == vi->visualid) {
	254	x->cmap = c[i].colormap;
	255	x->scmap = c[i];
	256	//qDebug("Using RGB_DEFAULT scmap");
	257	}
	258	}
	259	XFree((char *)c);
	260	}
	261	}
	262	if (!x->cmap) { // no shared cmap found
	263	x->cmap = XCreateColormap(dpy, RootWindow(dpy,vi->screen), vi->visual,
	264	AllocNone);
	265	x->alloc = true;
	266	// qDebug("Allocating cmap");
	267	}
	268
	269	// colormap hash should be cleanup only when the QApplication dtor is called
	270	if (hash->isEmpty())
	271	qAddPostRoutine(cleanup_cmaps);
	272
	273	// associate cmap with visualid
	274	hash->insert((long) vi->visualid + (vi->screen * 256), x);
	275	return x->cmap;
	276	}
	277
	278	struct QTransColor
	279	{
	280	VisualID vis;
	281	int screen;
	282	long color;
	283	};
	284
	285	static QVector<QTransColor> trans_colors;
	286	static int trans_colors_init = false;
	287
	288	static void find_trans_colors()
	289	{
	290	struct OverlayProp {
	291	long visual;
	292	long type;
	293	long value;
	294	long layer;
	295	};
	296
	297	trans_colors_init = true;
	298
	299	Display* appDisplay = X11->display;
	300
	301	int scr;
	302	int lastsize = 0;
	303	for (scr = 0; scr < ScreenCount(appDisplay); scr++) {
	304	QWidget* rootWin = QApplication::desktop()->screen(scr);
	305	if (!rootWin)
	306	return; // Should not happen
	307	Atom overlayVisualsAtom = XInternAtom(appDisplay,
	308	"SERVER_OVERLAY_VISUALS", True);
	309	if (overlayVisualsAtom == XNone)
	310	return; // Server has no overlays
	311
	312	Atom actualType;
	313	int actualFormat;
	314	ulong nItems;
	315	ulong bytesAfter;
	316	unsigned char *retval = 0;
	317	int res = XGetWindowProperty(appDisplay, rootWin->winId(),
	318	overlayVisualsAtom, 0, 10000, False,
	319	overlayVisualsAtom, &actualType,
	320	&actualFormat, &nItems, &bytesAfter,
	321	&retval);
	322
	323	if (res != Success \|\| actualType != overlayVisualsAtom
	324	\|\| actualFormat != 32 \|\| nItems < 4 \|\| !retval)
	325	return; // Error reading property
	326
	327	OverlayProp overlayProps = (OverlayProp )retval;
	328
	329	int numProps = nItems / 4;
	330	trans_colors.resize(lastsize + numProps);
	331	int j = lastsize;
	332	for (int i = 0; i < numProps; i++) {
	333	if (overlayProps[i].type == 1) {
	334	trans_colors[j].vis = (VisualID)overlayProps[i].visual;
	335	trans_colors[j].screen = scr;
	336	trans_colors[j].color = (int)overlayProps[i].value;
	337	j++;
	338	}
	339	}
	340	XFree(overlayProps);
	341	lastsize = j;
	342	trans_colors.resize(lastsize);
	343	}
	344	}
	345
	346	/*****************************************************************************
	347	QGLFormat UNIX/GLX-specific code
	348	*****************************************************************************/
	349
[561]	350	void* qglx_getProcAddress(const char* procName)
	351	{
	352	// On systems where the GL driver is pluggable (like Mesa), we have to use
	353	// the glXGetProcAddressARB extension to resolve other function pointers as
	354	// the symbols wont be in the GL library, but rather in a plugin loaded by
	355	// the GL library.
	356	typedef void* (qt_glXGetProcAddressARB)(const char );
	357	static qt_glXGetProcAddressARB glXGetProcAddressARB = 0;
	358	static bool triedResolvingGlxGetProcAddress = false;
	359	if (!triedResolvingGlxGetProcAddress) {
	360	triedResolvingGlxGetProcAddress = true;
	361	QGLExtensionMatcher extensions(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS));
	362	if (extensions.match("GLX_ARB_get_proc_address")) {
	363	#if defined(Q_OS_LINUX) \|\| defined(Q_OS_BSD4)
	364	void *handle = dlopen(NULL, RTLD_LAZY);
	365	if (handle) {
	366	glXGetProcAddressARB = (qt_glXGetProcAddressARB) dlsym(handle, "glXGetProcAddressARB");
	367	dlclose(handle);
	368	}
	369	if (!glXGetProcAddressARB)
	370	#endif
	371	{
	372	#if !defined(QT_NO_LIBRARY)
	373	extern const QString qt_gl_library_name();
	374	QLibrary lib(qt_gl_library_name());
	375	glXGetProcAddressARB = (qt_glXGetProcAddressARB) lib.resolve("glXGetProcAddressARB");
	376	#endif
	377	}
	378	}
	379	}
	380
	381	void *procAddress = 0;
	382	if (glXGetProcAddressARB)
	383	procAddress = glXGetProcAddressARB(procName);
	384
	385	// If glXGetProcAddress didn't work, try looking the symbol up in the GL library
	386	#if defined(Q_OS_LINUX) \|\| defined(Q_OS_BSD4)
	387	if (!procAddress) {
	388	void *handle = dlopen(NULL, RTLD_LAZY);
	389	if (handle) {
	390	procAddress = dlsym(handle, procName);
	391	dlclose(handle);
	392	}
	393	}
	394	#endif
	395	#if !defined(QT_NO_LIBRARY)
	396	if (!procAddress) {
	397	extern const QString qt_gl_library_name();
	398	QLibrary lib(qt_gl_library_name());
	399	procAddress = lib.resolve(procName);
	400	}
	401	#endif
	402
	403	return procAddress;
	404	}
	405
[2]	406	bool QGLFormat::hasOpenGL()
	407	{
	408	return glXQueryExtension(X11->display, 0, 0) != 0;
	409	}
	410
	411
	412	bool QGLFormat::hasOpenGLOverlays()
	413	{
	414	if (!trans_colors_init)
	415	find_trans_colors();
	416	return trans_colors.size() > 0;
	417	}
	418
[846]	419	static bool buildSpec(int* spec, const QGLFormat& f, QPaintDevice* paintDevice,
	420	int bufDepth, bool onlyFBConfig = false)
	421	{
	422	int i = 0;
	423	spec[i++] = GLX_LEVEL;
	424	spec[i++] = f.plane();
	425	const QX11Info *xinfo = qt_x11Info(paintDevice);
	426	bool useFBConfig = onlyFBConfig;
	427
	428	#if defined(GLX_VERSION_1_3) && !defined(QT_NO_XRENDER) && !defined(Q_OS_HPUX)
	429	/*
	430	HPUX defines GLX_VERSION_1_3 but does not implement the corresponding functions.
	431	Specifically glXChooseFBConfig and glXGetVisualFromFBConfig are not implemented.
	432	*/
	433	QWidget* widget = 0;
	434	if (paintDevice->devType() == QInternal::Widget)
	435	widget = static_cast<QWidget*>(paintDevice);
	436
	437	// Only use glXChooseFBConfig for widgets if we're trying to get an ARGB visual
	438	if (widget && widget->testAttribute(Qt::WA_TranslucentBackground) && X11->use_xrender)
	439	useFBConfig = true;
	440	#endif
	441
	442	#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
	443	static bool useTranspExt = false;
	444	static bool useTranspExtChecked = false;
	445	if (f.plane() && !useTranspExtChecked && paintDevice) {
	446	QGLExtensionMatcher extensions(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
	447	useTranspExt = extensions.match("GLX_EXT_visual_info");
	448	//# (A bit simplistic; that could theoretically be a substring)
	449	if (useTranspExt) {
	450	QByteArray cstr(glXGetClientString(xinfo->display(), GLX_VENDOR));
	451	useTranspExt = !cstr.contains("Xi Graphics"); // bug workaround
	452	if (useTranspExt) {
	453	// bug workaround - some systems (eg. FireGL) refuses to return an overlay
	454	// visual if the GLX_TRANSPARENT_TYPE_EXT attribute is specified, even if
	455	// the implementation supports transparent overlays
	456	int tmpSpec[] = { GLX_LEVEL, f.plane(), GLX_TRANSPARENT_TYPE_EXT,
	457	f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT,
	458	XNone };
	459	XVisualInfo * vinf = glXChooseVisual(xinfo->display(), xinfo->screen(), tmpSpec);
	460	if (!vinf) {
	461	useTranspExt = false;
	462	}
	463	}
	464	}
	465
	466	useTranspExtChecked = true;
	467	}
	468	if (f.plane() && useTranspExt && !useFBConfig) {
	469	// Required to avoid non-transparent overlay visual(!) on some systems
	470	spec[i++] = GLX_TRANSPARENT_TYPE_EXT;
	471	spec[i++] = f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT;
	472	}
	473	#endif
	474
	475	#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
	476	// GLX_RENDER_TYPE is only in glx >=1.3
	477	if (useFBConfig) {
	478	spec[i++] = GLX_RENDER_TYPE;
	479	spec[i++] = f.rgba() ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
	480	}
	481	#endif
	482
	483	if (f.doubleBuffer())
	484	spec[i++] = GLX_DOUBLEBUFFER;
	485	if (useFBConfig)
	486	spec[i++] = True;
	487	if (f.depth()) {
	488	spec[i++] = GLX_DEPTH_SIZE;
	489	spec[i++] = f.depthBufferSize() == -1 ? 1 : f.depthBufferSize();
	490	}
	491	if (f.stereo()) {
	492	spec[i++] = GLX_STEREO;
	493	if (useFBConfig)
	494	spec[i++] = True;
	495	}
	496	if (f.stencil()) {
	497	spec[i++] = GLX_STENCIL_SIZE;
	498	spec[i++] = f.stencilBufferSize() == -1 ? 1 : f.stencilBufferSize();
	499	}
	500	if (f.rgba()) {
	501	if (!useFBConfig)
	502	spec[i++] = GLX_RGBA;
	503	spec[i++] = GLX_RED_SIZE;
	504	spec[i++] = f.redBufferSize() == -1 ? 1 : f.redBufferSize();
	505	spec[i++] = GLX_GREEN_SIZE;
	506	spec[i++] = f.greenBufferSize() == -1 ? 1 : f.greenBufferSize();
	507	spec[i++] = GLX_BLUE_SIZE;
	508	spec[i++] = f.blueBufferSize() == -1 ? 1 : f.blueBufferSize();
	509	if (f.alpha()) {
	510	spec[i++] = GLX_ALPHA_SIZE;
	511	spec[i++] = f.alphaBufferSize() == -1 ? 1 : f.alphaBufferSize();
	512	}
	513	if (f.accum()) {
	514	spec[i++] = GLX_ACCUM_RED_SIZE;
	515	spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
	516	spec[i++] = GLX_ACCUM_GREEN_SIZE;
	517	spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
	518	spec[i++] = GLX_ACCUM_BLUE_SIZE;
	519	spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
	520	if (f.alpha()) {
	521	spec[i++] = GLX_ACCUM_ALPHA_SIZE;
	522	spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
	523	}
	524	}
	525	} else {
	526	spec[i++] = GLX_BUFFER_SIZE;
	527	spec[i++] = bufDepth;
	528	}
	529
	530	if (f.sampleBuffers()) {
	531	spec[i++] = GLX_SAMPLE_BUFFERS_ARB;
	532	spec[i++] = 1;
	533	spec[i++] = GLX_SAMPLES_ARB;
	534	spec[i++] = f.samples() == -1 ? 4 : f.samples();
	535	}
	536
	537	#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
	538	if (useFBConfig) {
	539	spec[i++] = GLX_DRAWABLE_TYPE;
	540	switch(paintDevice->devType()) {
	541	case QInternal::Pixmap:
	542	spec[i++] = GLX_PIXMAP_BIT;
	543	break;
	544	case QInternal::Pbuffer:
	545	spec[i++] = GLX_PBUFFER_BIT;
	546	break;
	547	default:
	548	qWarning("QGLContext: Unknown paint device type %d", paintDevice->devType());
	549	// Fall-through & assume it's a window
	550	case QInternal::Widget:
	551	spec[i++] = GLX_WINDOW_BIT;
	552	break;
	553	};
	554	}
	555	#endif
	556
	557	spec[i] = XNone;
	558	return useFBConfig;
	559	}
	560
[2]	561	/*****************************************************************************
	562	QGLContext UNIX/GLX-specific code
	563	*****************************************************************************/
	564
	565	bool QGLContext::chooseContext(const QGLContext* shareContext)
	566	{
	567	Q_D(QGLContext);
	568	const QX11Info *xinfo = qt_x11Info(d->paintDevice);
	569
	570	Display* disp = xinfo->display();
	571	d->vi = chooseVisual();
	572	if (!d->vi)
	573	return false;
	574
	575	if (deviceIsPixmap() &&
	576	(((XVisualInfo*)d->vi)->depth != xinfo->depth() \|\|
	577	((XVisualInfo*)d->vi)->screen != xinfo->screen()))
	578	{
	579	XFree(d->vi);
	580	XVisualInfo appVisInfo;
	581	memset(&appVisInfo, 0, sizeof(XVisualInfo));
	582	appVisInfo.visualid = XVisualIDFromVisual((Visual *) xinfo->visual());
	583	appVisInfo.screen = xinfo->screen();
	584	int nvis;
	585	d->vi = XGetVisualInfo(disp, VisualIDMask \| VisualScreenMask, &appVisInfo, &nvis);
	586	if (!d->vi)
	587	return false;
	588
	589	int useGL;
	590	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_USE_GL, &useGL);
	591	if (!useGL)
	592	return false; //# Chickening out already...
	593	}
	594	int res;
	595	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_LEVEL, &res);
	596	d->glFormat.setPlane(res);
	597	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_DOUBLEBUFFER, &res);
	598	d->glFormat.setDoubleBuffer(res);
	599	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_DEPTH_SIZE, &res);
	600	d->glFormat.setDepth(res);
	601	if (d->glFormat.depth())
	602	d->glFormat.setDepthBufferSize(res);
	603	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_RGBA, &res);
	604	d->glFormat.setRgba(res);
	605	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_RED_SIZE, &res);
	606	d->glFormat.setRedBufferSize(res);
	607	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_GREEN_SIZE, &res);
	608	d->glFormat.setGreenBufferSize(res);
	609	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_BLUE_SIZE, &res);
	610	d->glFormat.setBlueBufferSize(res);
	611	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_ALPHA_SIZE, &res);
	612	d->glFormat.setAlpha(res);
	613	if (d->glFormat.alpha())
	614	d->glFormat.setAlphaBufferSize(res);
	615	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_ACCUM_RED_SIZE, &res);
	616	d->glFormat.setAccum(res);
	617	if (d->glFormat.accum())
	618	d->glFormat.setAccumBufferSize(res);
	619	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_STENCIL_SIZE, &res);
	620	d->glFormat.setStencil(res);
	621	if (d->glFormat.stencil())
	622	d->glFormat.setStencilBufferSize(res);
	623	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_STEREO, &res);
	624	d->glFormat.setStereo(res);
	625	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_SAMPLE_BUFFERS_ARB, &res);
	626	d->glFormat.setSampleBuffers(res);
	627	if (d->glFormat.sampleBuffers()) {
	628	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_SAMPLES_ARB, &res);
	629	d->glFormat.setSamples(res);
	630	}
	631
	632	Bool direct = format().directRendering() ? True : False;
	633
	634	if (shareContext &&
	635	(!shareContext->isValid() \|\| !shareContext->d_func()->cx)) {
	636	qWarning("QGLContext::chooseContext(): Cannot share with invalid context");
	637	shareContext = 0;
	638	}
	639
	640	// 1. Sharing between rgba and color-index will give wrong colors.
	641	// 2. Contexts cannot be shared btw. direct/non-direct renderers.
	642	// 3. Pixmaps cannot share contexts that are set up for direct rendering.
	643	// 4. If the contexts are not created on the same screen, they can't be shared
	644
	645	if (shareContext
	646	&& (format().rgba() != shareContext->format().rgba()
	647	\|\| (deviceIsPixmap() && glXIsDirect(disp, (GLXContext)shareContext->d_func()->cx))
	648	\|\| (shareContext->d_func()->screen != xinfo->screen())))
	649	{
	650	shareContext = 0;
	651	}
	652
[846]	653	const int major = d->reqFormat.majorVersion();
	654	const int minor = d->reqFormat.minorVersion();
	655	const int profile = d->reqFormat.profile() == QGLFormat::CompatibilityProfile
	656	? GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB
	657	: GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
	658
[2]	659	d->cx = 0;
[846]	660
	661	#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
	662	/*
	663	HPUX defines GLX_VERSION_1_3 but does not implement the corresponding functions.
	664	Specifically glXChooseFBConfig and glXGetVisualFromFBConfig are not implemented.
	665	*/
	666	if ((major == 3 && minor >= 2) \|\| major > 3) {
	667	QGLTemporaryContext *tmpContext = 0;
	668	if (!QGLContext::currentContext())
	669	tmpContext = new QGLTemporaryContext;
	670
	671	int attributes[] = { GLX_CONTEXT_MAJOR_VERSION_ARB, major,
	672	GLX_CONTEXT_MINOR_VERSION_ARB, minor,
	673	GLX_CONTEXT_PROFILE_MASK_ARB, profile,
	674	0 };
	675
	676	typedef GLXContext ( * Q_PFNGLXCREATECONTEXTATTRIBSARBPROC)
	677	(Display* dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list);
	678
	679
	680	Q_PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribs =
	681	(Q_PFNGLXCREATECONTEXTATTRIBSARBPROC) qglx_getProcAddress("glXCreateContextAttribsARB");
	682
	683	if (glXCreateContextAttribs) {
	684	int spec[45];
	685	glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_BUFFER_SIZE, &res);
	686	buildSpec(spec, format(), d->paintDevice, res, true);
	687
	688	GLXFBConfig *configs;
	689	int configCount = 0;
	690	configs = glXChooseFBConfig(disp, xinfo->screen(), spec, &configCount);
	691
	692	if (configs && configCount > 0) {
	693	d->cx = glXCreateContextAttribs(disp, configs[0],
	694	shareContext ? (GLXContext)shareContext->d_func()->cx : 0, direct, attributes);
	695	if (!d->cx && shareContext) {
	696	shareContext = 0;
	697	d->cx = glXCreateContextAttribs(disp, configs[0], 0, direct, attributes);
	698	}
	699	d->screen = ((XVisualInfo*)d->vi)->screen;
	700	}
	701	XFree(configs);
	702	} else {
	703	qWarning("QGLContext::chooseContext(): OpenGL %d.%d is not supported", major, minor);
	704	}
	705
	706	if (tmpContext)
	707	delete tmpContext;
	708	}
	709	#else
	710	Q_UNUSED(major);
	711	Q_UNUSED(minor);
	712	Q_UNUSED(profile);
	713	#endif
	714
	715	if (!d->cx && shareContext) {
[2]	716	d->cx = glXCreateContext(disp, (XVisualInfo *)d->vi,
	717	(GLXContext)shareContext->d_func()->cx, direct);
	718	d->screen = ((XVisualInfo*)d->vi)->screen;
	719	}
	720	if (!d->cx) {
	721	d->cx = glXCreateContext(disp, (XVisualInfo *)d->vi, NULL, direct);
	722	d->screen = ((XVisualInfo*)d->vi)->screen;
[846]	723	shareContext = 0;
[2]	724	}
[846]	725
	726	if (shareContext && d->cx) {
	727	QGLContext share = const_cast<QGLContext >(shareContext);
	728	d->sharing = true;
	729	share->d_func()->sharing = true;
	730	}
	731
[2]	732	if (!d->cx)
	733	return false;
	734	d->glFormat.setDirectRendering(glXIsDirect(disp, (GLXContext)d->cx));
	735	if (deviceIsPixmap()) {
	736	#if defined(GLX_MESA_pixmap_colormap) && defined(QGL_USE_MESA_EXT)
	737	d->gpm = glXCreateGLXPixmapMESA(disp, (XVisualInfo *)d->vi,
	738	qt_x11Handle(d->paintDevice),
	739	qt_gl_choose_cmap(disp, (XVisualInfo *)d->vi));
	740	#else
	741	d->gpm = (quint32)glXCreateGLXPixmap(disp, (XVisualInfo *)d->vi,
	742	qt_x11Handle(d->paintDevice));
	743	#endif
	744	if (!d->gpm)
	745	return false;
	746	}
[561]	747	QGLExtensionMatcher extensions(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
	748	if (extensions.match("GLX_SGI_video_sync")) {
[2]	749	if (d->glFormat.swapInterval() == -1)
	750	d->glFormat.setSwapInterval(0);
	751	} else {
	752	d->glFormat.setSwapInterval(-1);
	753	}
	754	return true;
	755	}
	756
[561]	757	/*
	758	See qgl.cpp for qdoc comment.
	759	*/
[2]	760	void *QGLContext::chooseVisual()
	761	{
	762	Q_D(QGLContext);
	763	static const int bufDepths[] = { 8, 4, 2, 1 }; // Try 16, 12 also?
	764	//todo: if pixmap, also make sure that vi->depth == pixmap->depth
	765	void* vis = 0;
	766	int i = 0;
	767	bool fail = false;
	768	QGLFormat fmt = format();
	769	bool tryDouble = !fmt.doubleBuffer(); // Some GL impl's only have double
	770	bool triedDouble = false;
	771	bool triedSample = false;
	772	if (fmt.sampleBuffers())
[651]	773	fmt.setSampleBuffers(QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers);
[2]	774	while(!fail && !(vis = tryVisual(fmt, bufDepths[i]))) {
	775	if (!fmt.rgba() && bufDepths[i] > 1) {
	776	i++;
	777	continue;
	778	}
	779	if (tryDouble) {
	780	fmt.setDoubleBuffer(true);
	781	tryDouble = false;
	782	triedDouble = true;
	783	continue;
	784	} else if (triedDouble) {
	785	fmt.setDoubleBuffer(false);
	786	triedDouble = false;
	787	}
	788	if (!triedSample && fmt.sampleBuffers()) {
	789	fmt.setSampleBuffers(false);
	790	triedSample = true;
	791	continue;
	792	}
	793	if (fmt.stereo()) {
	794	fmt.setStereo(false);
	795	continue;
	796	}
	797	if (fmt.accum()) {
	798	fmt.setAccum(false);
	799	continue;
	800	}
	801	if (fmt.stencil()) {
	802	fmt.setStencil(false);
	803	continue;
	804	}
	805	if (fmt.alpha()) {
	806	fmt.setAlpha(false);
	807	continue;
	808	}
	809	if (fmt.depth()) {
	810	fmt.setDepth(false);
	811	continue;
	812	}
	813	if (fmt.doubleBuffer()) {
	814	fmt.setDoubleBuffer(false);
	815	continue;
	816	}
	817	fail = true;
	818	}
	819	d->glFormat = fmt;
	820	return vis;
	821	}
	822
[561]	823	/*
	824	See qgl.cpp for qdoc comment.
	825	*/
[2]	826	void *QGLContext::tryVisual(const QGLFormat& f, int bufDepth)
	827	{
	828	Q_D(QGLContext);
[561]	829	int spec[45];
[2]	830	const QX11Info *xinfo = qt_x11Info(d->paintDevice);
[846]	831	bool useFBConfig = buildSpec(spec, f, d->paintDevice, bufDepth, false);
[2]	832
[561]	833	XVisualInfo* chosenVisualInfo = 0;
	834
	835	#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
	836	while (useFBConfig) {
	837	GLXFBConfig *configs;
	838	int configCount = 0;
	839	configs = glXChooseFBConfig(xinfo->display(), xinfo->screen(), spec, &configCount);
	840
	841	if (!configs)
	842	break; // fallback to trying glXChooseVisual
	843
[846]	844	for (int i = 0; i < configCount; ++i) {
[561]	845	XVisualInfo* vi;
	846	vi = glXGetVisualFromFBConfig(xinfo->display(), configs[i]);
	847	if (!vi)
	848	continue;
	849
	850	#if !defined(QT_NO_XRENDER)
	851	QWidget* w = 0;
	852	if (d->paintDevice->devType() == QInternal::Widget)
	853	w = static_cast<QWidget*>(d->paintDevice);
	854
	855	if (w && w->testAttribute(Qt::WA_TranslucentBackground) && f.alpha()) {
	856	// Attempt to find a config who's visual has a proper alpha channel
	857	XRenderPictFormat *pictFormat;
	858	pictFormat = XRenderFindVisualFormat(xinfo->display(), vi->visual);
	859
	860	if (pictFormat && (pictFormat->type == PictTypeDirect) && pictFormat->direct.alphaMask) {
	861	// The pict format for the visual matching the FBConfig indicates ARGB
	862	if (chosenVisualInfo)
	863	XFree(chosenVisualInfo);
	864	chosenVisualInfo = vi;
	865	break;
	866	}
	867	} else
	868	#endif //QT_NO_XRENDER
	869	if (chosenVisualInfo) {
	870	// If we've got a visual we can use and we're not trying to find one with a
	871	// real alpha channel, we might as well just use the one we've got
	872	break;
	873	}
	874
	875	if (!chosenVisualInfo)
	876	chosenVisualInfo = vi; // Have something to fall back to
	877	else
	878	XFree(vi);
	879	}
	880
	881	XFree(configs);
	882	break;
	883	}
	884	#endif // defined(GLX_VERSION_1_3)
	885
	886	if (!chosenVisualInfo)
	887	chosenVisualInfo = glXChooseVisual(xinfo->display(), xinfo->screen(), spec);
	888
	889	return chosenVisualInfo;
[2]	890	}
	891
	892
	893	void QGLContext::reset()
	894	{
	895	Q_D(QGLContext);
	896	if (!d->valid)
	897	return;
	898	d->cleanup();
	899	const QX11Info *xinfo = qt_x11Info(d->paintDevice);
	900	doneCurrent();
	901	if (d->gpm)
	902	glXDestroyGLXPixmap(xinfo->display(), (GLXPixmap)d->gpm);
	903	d->gpm = 0;
	904	glXDestroyContext(xinfo->display(), (GLXContext)d->cx);
	905	if (d->vi)
	906	XFree(d->vi);
	907	d->vi = 0;
	908	d->cx = 0;
	909	d->crWin = false;
	910	d->sharing = false;
	911	d->valid = false;
	912	d->transpColor = QColor();
	913	d->initDone = false;
[651]	914	QGLContextGroup::removeShare(this);
[2]	915	}
	916
	917
	918	void QGLContext::makeCurrent()
	919	{
	920	Q_D(QGLContext);
	921	if (!d->valid) {
	922	qWarning("QGLContext::makeCurrent(): Cannot make invalid context current.");
	923	return;
	924	}
	925	const QX11Info *xinfo = qt_x11Info(d->paintDevice);
	926	bool ok = true;
	927	if (d->paintDevice->devType() == QInternal::Pixmap) {
	928	ok = glXMakeCurrent(xinfo->display(), (GLXPixmap)d->gpm, (GLXContext)d->cx);
	929	} else if (d->paintDevice->devType() == QInternal::Pbuffer) {
	930	ok = glXMakeCurrent(xinfo->display(), (GLXPbuffer)d->pbuf, (GLXContext)d->cx);
	931	} else if (d->paintDevice->devType() == QInternal::Widget) {
[846]	932	ok = glXMakeCurrent(xinfo->display(), ((QWidget *)d->paintDevice)->internalWinId(), (GLXContext)d->cx);
[2]	933	}
	934	if (!ok)
	935	qWarning("QGLContext::makeCurrent(): Failed.");
	936
[561]	937	if (ok)
	938	QGLContextPrivate::setCurrentContext(this);
[2]	939	}
	940
	941	void QGLContext::doneCurrent()
	942	{
	943	Q_D(QGLContext);
	944	glXMakeCurrent(qt_x11Info(d->paintDevice)->display(), 0, 0);
[561]	945	QGLContextPrivate::setCurrentContext(0);
[2]	946	}
	947
	948
	949	void QGLContext::swapBuffers() const
	950	{
	951	Q_D(const QGLContext);
	952	if (!d->valid)
	953	return;
	954	if (!deviceIsPixmap()) {
	955	int interval = d->glFormat.swapInterval();
	956	if (interval > 0) {
	957	typedef int (qt_glXGetVideoSyncSGI)(uint );
	958	typedef int (qt_glXWaitVideoSyncSGI)(int, int, uint );
	959	static qt_glXGetVideoSyncSGI glXGetVideoSyncSGI = 0;
	960	static qt_glXWaitVideoSyncSGI glXWaitVideoSyncSGI = 0;
	961	static bool resolved = false;
	962	if (!resolved) {
[561]	963	const QX11Info *xinfo = qt_x11Info(d->paintDevice);
	964	QGLExtensionMatcher extensions(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
	965	if (extensions.match("GLX_SGI_video_sync")) {
	966	glXGetVideoSyncSGI = (qt_glXGetVideoSyncSGI)qglx_getProcAddress("glXGetVideoSyncSGI");
	967	glXWaitVideoSyncSGI = (qt_glXWaitVideoSyncSGI)qglx_getProcAddress("glXWaitVideoSyncSGI");
[2]	968	}
	969	resolved = true;
	970	}
	971	if (glXGetVideoSyncSGI && glXWaitVideoSyncSGI) {
	972	uint counter;
	973	if (!glXGetVideoSyncSGI(&counter))
	974	glXWaitVideoSyncSGI(interval + 1, (counter + interval) % (interval + 1), &counter);
	975	}
	976	}
	977	glXSwapBuffers(qt_x11Info(d->paintDevice)->display(),
	978	static_cast<QWidget *>(d->paintDevice)->winId());
	979	}
	980	}
	981
	982	QColor QGLContext::overlayTransparentColor() const
	983	{
	984	if (isValid())
	985	return Qt::transparent;
	986	return QColor(); // Invalid color
	987	}
	988
	989	static uint qt_transparent_pixel(VisualID id, int screen)
	990	{
	991	for (int i = 0; i < trans_colors.size(); i++) {
	992	if (trans_colors[i].vis == id && trans_colors[i].screen == screen)
	993	return trans_colors[i].color;
	994	}
	995	return 0;
	996	}
	997
	998	uint QGLContext::colorIndex(const QColor& c) const
	999	{
	1000	Q_D(const QGLContext);
	1001	int screen = ((XVisualInfo *)d->vi)->screen;
	1002	QColormap colmap = QColormap::instance(screen);
	1003	if (isValid()) {
	1004	if (format().plane() && c == Qt::transparent) {
	1005	return qt_transparent_pixel(((XVisualInfo *)d->vi)->visualid,
	1006	((XVisualInfo *)d->vi)->screen);
	1007	}
	1008	if (((XVisualInfo*)d->vi)->visualid ==
	1009	XVisualIDFromVisual((Visual *) QX11Info::appVisual(screen)))
	1010	return colmap.pixel(c); // We're using QColor's cmap
	1011
	1012	XVisualInfo info = (XVisualInfo ) d->vi;
	1013	CMapEntryHash *hash = cmap_handler()->cmap_hash;
	1014	CMapEntryHash::ConstIterator it = hash->constFind(long(info->visualid)
	1015	+ (info->screen * 256));
	1016	QCMapEntry *x = 0;
	1017	if (it != hash->constEnd())
	1018	x = it.value();
	1019	if (x && !x->alloc) { // It's a standard colormap
	1020	int rf = (int)(((float)c.red() * (x->scmap.red_max+1))/256.0);
	1021	int gf = (int)(((float)c.green() * (x->scmap.green_max+1))/256.0);
	1022	int bf = (int)(((float)c.blue() * (x->scmap.blue_max+1))/256.0);
	1023	uint p = x->scmap.base_pixel
	1024	+ (rf * x->scmap.red_mult)
	1025	+ (gf * x->scmap.green_mult)
	1026	+ (bf * x->scmap.blue_mult);
	1027	return p;
	1028	} else {
	1029	QMap<int, QRgb> &cmap = (*cmap_handler()->qglcmap_hash)[(long)info->visualid];
	1030
	1031	// already in the map?
	1032	QRgb target = c.rgb();
	1033	QMap<int, QRgb>::Iterator it = cmap.begin();
	1034	for (; it != cmap.end(); ++it) {
	1035	if ((*it) == target)
	1036	return it.key();
	1037	}
	1038
	1039	// need to alloc color
	1040	unsigned long plane_mask[2];
	1041	unsigned long color_map_entry;
	1042	if (!XAllocColorCells (QX11Info::display(), x->cmap, true, plane_mask, 0,
	1043	&color_map_entry, 1))
	1044	return colmap.pixel(c);
	1045
	1046	XColor col;
	1047	col.flags = DoRed \| DoGreen \| DoBlue;
	1048	col.pixel = color_map_entry;
	1049	col.red = (ushort)((qRed(c.rgb()) / 255.0) * 65535.0 + 0.5);
	1050	col.green = (ushort)((qGreen(c.rgb()) / 255.0) * 65535.0 + 0.5);
	1051	col.blue = (ushort)((qBlue(c.rgb()) / 255.0) * 65535.0 + 0.5);
	1052	XStoreColor(QX11Info::display(), x->cmap, &col);
	1053
	1054	cmap.insert(color_map_entry, target);
	1055	return color_map_entry;
	1056	}
	1057	}
	1058	return 0;
	1059	}
	1060
	1061	#ifndef QT_NO_FONTCONFIG
	1062	/*! \internal
	1063	This is basically a substitute for glxUseXFont() which can only
	1064	handle XLFD fonts. This version relies on freetype to render the
	1065	glyphs, but it works with all fonts that fontconfig provides - both
	1066	antialiased and aliased bitmap and outline fonts.
	1067	*/
	1068	static void qgl_use_font(QFontEngineFT *engine, int first, int count, int listBase)
	1069	{
	1070	GLfloat color[4];
	1071	glGetFloatv(GL_CURRENT_COLOR, color);
	1072
	1073	// save the pixel unpack state
	1074	GLint gl_swapbytes, gl_lsbfirst, gl_rowlength, gl_skiprows, gl_skippixels, gl_alignment;
	1075	glGetIntegerv (GL_UNPACK_SWAP_BYTES, &gl_swapbytes);
	1076	glGetIntegerv (GL_UNPACK_LSB_FIRST, &gl_lsbfirst);
	1077	glGetIntegerv (GL_UNPACK_ROW_LENGTH, &gl_rowlength);
	1078	glGetIntegerv (GL_UNPACK_SKIP_ROWS, &gl_skiprows);
	1079	glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &gl_skippixels);
	1080	glGetIntegerv (GL_UNPACK_ALIGNMENT, &gl_alignment);
	1081
	1082	glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
	1083	glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
	1084	glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
	1085	glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
	1086	glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
	1087	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	1088
	1089	const bool antialiased = engine->drawAntialiased();
	1090	FT_Face face = engine->lockFace();
	1091
	1092	// start generating font glyphs
	1093	for (int i = first; i < count; ++i) {
	1094	int list = listBase + i;
	1095	GLfloat x0, y0, dx, dy;
	1096
	1097	FT_Error err;
	1098
	1099	err = FT_Load_Glyph(face, FT_Get_Char_Index(face, i), FT_LOAD_DEFAULT);
	1100	if (err) {
	1101	qDebug("failed loading glyph %d from font", i);
	1102	Q_ASSERT(!err);
	1103	}
	1104	err = FT_Render_Glyph(face->glyph, (antialiased ? FT_RENDER_MODE_NORMAL
	1105	: FT_RENDER_MODE_MONO));
	1106	if (err) {
	1107	qDebug("failed rendering glyph %d from font", i);
	1108	Q_ASSERT(!err);
	1109	}
	1110
	1111	FT_Bitmap bm = face->glyph->bitmap;
	1112	x0 = face->glyph->metrics.horiBearingX >> 6;
	1113	y0 = (face->glyph->metrics.height - face->glyph->metrics.horiBearingY) >> 6;
	1114	dx = face->glyph->metrics.horiAdvance >> 6;
	1115	dy = 0;
	1116	int sz = bm.pitch * bm.rows;
	1117	uint *aa_glyph = 0;
	1118	uchar *ua_glyph = 0;
	1119
	1120	if (antialiased)
	1121	aa_glyph = new uint[sz];
	1122	else
	1123	ua_glyph = new uchar[sz];
	1124
	1125	// convert to GL format
	1126	for (int y = 0; y < bm.rows; ++y) {
	1127	for (int x = 0; x < bm.pitch; ++x) {
	1128	int c1 = y*bm.pitch + x;
	1129	int c2 = (bm.rows - y - 1) > 0 ? (bm.rows-y-1)*bm.pitch + x : x;
	1130	if (antialiased) {
	1131	aa_glyph[c1] = (int(color[0]*255) << 24)
	1132	\| (int(color[1]*255) << 16)
	1133	\| (int(color[2]*255) << 8) \| bm.buffer[c2];
	1134	} else {
	1135	ua_glyph[c1] = bm.buffer[c2];
	1136	}
	1137	}
	1138	}
	1139
	1140	glNewList(list, GL_COMPILE);
	1141	if (antialiased) {
	1142	// calling glBitmap() is just a trick to move the current
	1143	// raster pos, since glGet*() won't work in display lists
	1144	glBitmap(0, 0, 0, 0, x0, -y0, 0);
	1145	glDrawPixels(bm.pitch, bm.rows, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, aa_glyph);
	1146	glBitmap(0, 0, 0, 0, dx-x0, y0, 0);
	1147	} else {
	1148	glBitmap(bm.pitch*8, bm.rows, -x0, y0, dx, dy, ua_glyph);
	1149	}
	1150	glEndList();
	1151	antialiased ? delete[] aa_glyph : delete[] ua_glyph;
	1152	}
	1153
	1154	engine->unlockFace();
	1155
	1156	// restore pixel unpack settings
	1157	glPixelStorei(GL_UNPACK_SWAP_BYTES, gl_swapbytes);
	1158	glPixelStorei(GL_UNPACK_LSB_FIRST, gl_lsbfirst);
	1159	glPixelStorei(GL_UNPACK_ROW_LENGTH, gl_rowlength);
	1160	glPixelStorei(GL_UNPACK_SKIP_ROWS, gl_skiprows);
	1161	glPixelStorei(GL_UNPACK_SKIP_PIXELS, gl_skippixels);
	1162	glPixelStorei(GL_UNPACK_ALIGNMENT, gl_alignment);
	1163	}
	1164	#endif
	1165
	1166	#undef d
	1167	void QGLContext::generateFontDisplayLists(const QFont & fnt, int listBase)
	1168	{
	1169	QFont f(fnt);
	1170	QFontEngine *engine = f.d->engineForScript(QUnicodeTables::Common);
	1171
	1172	if (engine->type() == QFontEngine::Multi)
	1173	engine = static_cast<QFontEngineMulti *>(engine)->engine(0);
	1174	#ifndef QT_NO_FONTCONFIG
	1175	if(engine->type() == QFontEngine::Freetype) {
	1176	qgl_use_font(static_cast<QFontEngineFT *>(engine), 0, 256, listBase);
	1177	return;
	1178	}
	1179	#endif
	1180	// glXUseXFont() only works with XLFD font structures and a few GL
	1181	// drivers crash if 0 is passed as the font handle
	1182	f.setStyleStrategy(QFont::OpenGLCompatible);
	1183	if (f.handle() && engine->type() == QFontEngine::XLFD)
	1184	glXUseXFont(static_cast<Font>(f.handle()), 0, 256, listBase);
	1185	}
	1186
	1187	void *QGLContext::getProcAddress(const QString &proc) const
	1188	{
	1189	typedef void (qt_glXGetProcAddressARB)(const GLubyte *);
	1190	static qt_glXGetProcAddressARB glXGetProcAddressARB = 0;
	1191	static bool resolved = false;
	1192
	1193	if (resolved && !glXGetProcAddressARB)
	1194	return 0;
	1195	if (!glXGetProcAddressARB) {
[561]	1196	QGLExtensionMatcher extensions(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS));
	1197	if (extensions.match("GLX_ARB_get_proc_address")) {
[2]	1198	#if defined(Q_OS_LINUX) \|\| defined(Q_OS_BSD4)
	1199	void *handle = dlopen(NULL, RTLD_LAZY);
	1200	if (handle) {
	1201	glXGetProcAddressARB = (qt_glXGetProcAddressARB) dlsym(handle, "glXGetProcAddressARB");
	1202	dlclose(handle);
	1203	}
	1204	if (!glXGetProcAddressARB)
	1205	#endif
	1206	{
[561]	1207	#if !defined(QT_NO_LIBRARY)
[2]	1208	extern const QString qt_gl_library_name();
	1209	QLibrary lib(qt_gl_library_name());
	1210	glXGetProcAddressARB = (qt_glXGetProcAddressARB) lib.resolve("glXGetProcAddressARB");
[561]	1211	#endif
[2]	1212	}
	1213	}
	1214	resolved = true;
	1215	}
	1216	if (!glXGetProcAddressARB)
	1217	return 0;
	1218	return glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(proc.toLatin1().data()));
	1219	}
	1220
[651]	1221	/*
	1222	QGLTemporaryContext implementation
	1223	*/
	1224
	1225	class QGLTemporaryContextPrivate {
	1226	public:
	1227	bool initialized;
	1228	Window drawable;
	1229	GLXContext context;
	1230	GLXDrawable oldDrawable;
	1231	GLXContext oldContext;
	1232	};
	1233
	1234	QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
	1235	: d(new QGLTemporaryContextPrivate)
	1236	{
	1237	d->initialized = false;
	1238	d->oldDrawable = 0;
	1239	d->oldContext = 0;
	1240	int screen = 0;
	1241
	1242	int attribs[] = {GLX_RGBA, XNone};
	1243	XVisualInfo *vi = glXChooseVisual(X11->display, screen, attribs);
	1244	if (!vi) {
	1245	qWarning("QGLTempContext: No GL capable X visuals available.");
	1246	return;
	1247	}
	1248
	1249	int useGL;
	1250	glXGetConfig(X11->display, vi, GLX_USE_GL, &useGL);
	1251	if (!useGL) {
	1252	XFree(vi);
	1253	return;
	1254	}
	1255
	1256	d->oldDrawable = glXGetCurrentDrawable();
	1257	d->oldContext = glXGetCurrentContext();
	1258
	1259	XSetWindowAttributes a;
	1260	a.colormap = qt_gl_choose_cmap(X11->display, vi);
	1261	d->drawable = XCreateWindow(X11->display, RootWindow(X11->display, screen),
	1262	0, 0, 1, 1, 0,
	1263	vi->depth, InputOutput, vi->visual,
	1264	CWColormap, &a);
	1265	d->context = glXCreateContext(X11->display, vi, 0, True);
	1266	if (d->context && glXMakeCurrent(X11->display, d->drawable, d->context)) {
	1267	d->initialized = true;
	1268	} else {
	1269	qWarning("QGLTempContext: Unable to create GL context.");
	1270	XDestroyWindow(X11->display, d->drawable);
	1271	}
	1272	XFree(vi);
	1273	}
	1274
	1275	QGLTemporaryContext::~QGLTemporaryContext()
	1276	{
	1277	if (d->initialized) {
	1278	glXMakeCurrent(X11->display, 0, 0);
	1279	glXDestroyContext(X11->display, d->context);
	1280	XDestroyWindow(X11->display, d->drawable);
	1281	}
	1282	if (d->oldDrawable && d->oldContext)
	1283	glXMakeCurrent(X11->display, d->oldDrawable, d->oldContext);
	1284	}
	1285
[2]	1286	/*****************************************************************************
	1287	QGLOverlayWidget (Internal overlay class for X11)
	1288	*****************************************************************************/
	1289
	1290	class QGLOverlayWidget : public QGLWidget
	1291	{
	1292	Q_OBJECT
	1293	public:
	1294	QGLOverlayWidget(const QGLFormat& format, QGLWidget* parent, const QGLWidget* shareWidget=0);
	1295
	1296	protected:
	1297	void initializeGL();
	1298	void paintGL();
	1299	void resizeGL(int w, int h);
	1300	bool x11Event(XEvent *e) { return realWidget->x11Event(e); }
	1301
	1302	private:
	1303	QGLWidget* realWidget;
	1304
	1305	private:
	1306	Q_DISABLE_COPY(QGLOverlayWidget)
	1307	};
	1308
	1309
	1310	QGLOverlayWidget::QGLOverlayWidget(const QGLFormat& format, QGLWidget* parent,
	1311	const QGLWidget* shareWidget)
	1312	: QGLWidget(format, parent, shareWidget ? shareWidget->d_func()->olw : 0)
	1313	{
	1314	setAttribute(Qt::WA_X11OpenGLOverlay);
	1315	realWidget = parent;
	1316	}
	1317
	1318
	1319
	1320	void QGLOverlayWidget::initializeGL()
	1321	{
	1322	QColor transparentColor = context()->overlayTransparentColor();
	1323	if (transparentColor.isValid())
	1324	qglClearColor(transparentColor);
	1325	else
	1326	qWarning("QGLOverlayWidget::initializeGL(): Could not get transparent color");
	1327	realWidget->initializeOverlayGL();
	1328	}
	1329
	1330
	1331	void QGLOverlayWidget::resizeGL(int w, int h)
	1332	{
	1333	glViewport(0, 0, w, h);
	1334	realWidget->resizeOverlayGL(w, h);
	1335	}
	1336
	1337
	1338	void QGLOverlayWidget::paintGL()
	1339	{
	1340	realWidget->paintOverlayGL();
	1341	}
	1342
	1343	#undef Bool
	1344	QT_BEGIN_INCLUDE_NAMESPACE
	1345	#include "qgl_x11.moc"
	1346	QT_END_INCLUDE_NAMESPACE
	1347
	1348	/*****************************************************************************
	1349	QGLWidget UNIX/GLX-specific code
	1350	*****************************************************************************/
	1351	void QGLWidgetPrivate::init(QGLContext context, const QGLWidget shareWidget)
	1352	{
	1353	Q_Q(QGLWidget);
	1354	initContext(context, shareWidget);
	1355	olw = 0;
	1356
	1357	if (q->isValid() && context->format().hasOverlay()) {
	1358	QString olwName = q->objectName();
	1359	olwName += QLatin1String("-QGL_internal_overlay_widget");
	1360	olw = new QGLOverlayWidget(QGLFormat::defaultOverlayFormat(), q, shareWidget);
	1361	olw->setObjectName(olwName);
	1362	if (olw->isValid()) {
	1363	olw->setAutoBufferSwap(false);
	1364	olw->setFocusProxy(q);
	1365	}
	1366	else {
	1367	delete olw;
	1368	olw = 0;
	1369	glcx->d_func()->glFormat.setOverlay(false);
	1370	}
	1371	}
	1372	}
	1373
	1374	bool QGLWidgetPrivate::renderCxPm(QPixmap* pm)
	1375	{
	1376	Q_Q(QGLWidget);
	1377	if (((XVisualInfo*)glcx->d_func()->vi)->depth != pm->depth())
	1378	return false;
	1379
	1380	GLXPixmap glPm;
	1381	#if defined(GLX_MESA_pixmap_colormap) && defined(QGL_USE_MESA_EXT)
	1382	glPm = glXCreateGLXPixmapMESA(X11->display,
	1383	(XVisualInfo*)glcx->vi,
	1384	(Pixmap)pm->handle(),
	1385	qt_gl_choose_cmap(pm->X11->display,
	1386	(XVisualInfo*)glcx->vi));
	1387	#else
	1388	glPm = (quint32)glXCreateGLXPixmap(X11->display,
	1389	(XVisualInfo*)glcx->d_func()->vi,
	1390	(Pixmap)pm->handle());
	1391	#endif
	1392
	1393	if (!glXMakeCurrent(X11->display, glPm, (GLXContext)glcx->d_func()->cx)) {
	1394	glXDestroyGLXPixmap(X11->display, glPm);
	1395	return false;
	1396	}
	1397
	1398	glDrawBuffer(GL_FRONT);
	1399	if (!glcx->initialized())
	1400	q->glInit();
	1401	q->resizeGL(pm->width(), pm->height());
	1402	q->paintGL();
	1403	glFlush();
	1404	q->makeCurrent();
	1405	glXDestroyGLXPixmap(X11->display, glPm);
	1406	q->resizeGL(q->width(), q->height());
	1407	return true;
	1408	}
	1409
	1410	/*! \internal
	1411	Free up any allocated colormaps. This fn is only called for
	1412	top-level widgets.
	1413	*/
	1414	void QGLWidgetPrivate::cleanupColormaps()
	1415	{
	1416	if (!cmap.handle()) {
	1417	return;
	1418	} else {
	1419	XFreeColormap(X11->display, (Colormap) cmap.handle());
	1420	cmap.setHandle(0);
	1421	}
	1422	}
	1423
	1424	void QGLWidget::setMouseTracking(bool enable)
	1425	{
	1426	Q_D(QGLWidget);
	1427	if (d->olw)
	1428	d->olw->setMouseTracking(enable);
	1429	QWidget::setMouseTracking(enable);
	1430	}
	1431
	1432
	1433	void QGLWidget::resizeEvent(QResizeEvent *)
	1434	{
	1435	Q_D(QGLWidget);
	1436	if (!isValid())
	1437	return;
	1438	makeCurrent();
	1439	if (!d->glcx->initialized())
	1440	glInit();
	1441	glXWaitX();
	1442	resizeGL(width(), height());
	1443	if (d->olw)
	1444	d->olw->setGeometry(rect());
	1445	}
	1446
	1447	const QGLContext* QGLWidget::overlayContext() const
	1448	{
	1449	Q_D(const QGLWidget);
	1450	if (d->olw)
	1451	return d->olw->context();
	1452	else
	1453	return 0;
	1454	}
	1455
	1456
	1457	void QGLWidget::makeOverlayCurrent()
	1458	{
	1459	Q_D(QGLWidget);
	1460	if (d->olw)
	1461	d->olw->makeCurrent();
	1462	}
	1463
	1464
	1465	void QGLWidget::updateOverlayGL()
	1466	{
	1467	Q_D(QGLWidget);
	1468	if (d->olw)
	1469	d->olw->updateGL();
	1470	}
	1471
	1472	/*!
	1473	\internal
	1474
	1475	Sets a new QGLContext, \a context, for this QGLWidget, using the
	1476	shared context, \a shareContext. If \a deleteOldContext is true,
	1477	the original context is deleted; otherwise it is overridden.
	1478	*/
	1479	void QGLWidget::setContext(QGLContext *context,
	1480	const QGLContext* shareContext,
	1481	bool deleteOldContext)
	1482	{
	1483	Q_D(QGLWidget);
	1484	if (context == 0) {
	1485	qWarning("QGLWidget::setContext: Cannot set null context");
	1486	return;
	1487	}
	1488	if (!context->deviceIsPixmap() && context->device() != this) {
	1489	qWarning("QGLWidget::setContext: Context must refer to this widget");
	1490	return;
	1491	}
	1492
	1493	if (d->glcx)
	1494	d->glcx->doneCurrent();
	1495	QGLContext* oldcx = d->glcx;
	1496	d->glcx = context;
	1497
	1498	if (parentWidget()) {
	1499	// force creation of delay-created widgets
	1500	parentWidget()->winId();
	1501	if (parentWidget()->x11Info().screen() != x11Info().screen())
	1502	d_func()->xinfo = parentWidget()->d_func()->xinfo;
	1503	}
	1504
[561]	1505	// If the application has set WA_TranslucentBackground and not explicitly set
	1506	// the alpha buffer size to zero, modify the format so it have an alpha channel
	1507	QGLFormat& fmt = d->glcx->d_func()->glFormat;
	1508	if (testAttribute(Qt::WA_TranslucentBackground) && fmt.alphaBufferSize() == -1)
	1509	fmt.setAlphaBufferSize(1);
	1510
[2]	1511	bool createFailed = false;
	1512	if (!d->glcx->isValid()) {
	1513	if (!d->glcx->create(shareContext ? shareContext : oldcx))
	1514	createFailed = true;
	1515	}
	1516	if (createFailed) {
	1517	if (deleteOldContext)
	1518	delete oldcx;
	1519	return;
	1520	}
	1521
	1522	if (d->glcx->windowCreated() \|\| d->glcx->deviceIsPixmap()) {
	1523	if (deleteOldContext)
	1524	delete oldcx;
	1525	return;
	1526	}
	1527
	1528	bool visible = isVisible();
	1529	if (visible)
	1530	hide();
	1531
	1532	XVisualInfo vi = (XVisualInfo)d->glcx->d_func()->vi;
	1533	XSetWindowAttributes a;
	1534
	1535	QColormap colmap = QColormap::instance(vi->screen);
	1536	a.colormap = qt_gl_choose_cmap(QX11Info::display(), vi); // find best colormap
	1537	a.background_pixel = colmap.pixel(palette().color(backgroundRole()));
	1538	a.border_pixel = colmap.pixel(Qt::black);
	1539	Window p = RootWindow(X11->display, vi->screen);
	1540	if (parentWidget())
	1541	p = parentWidget()->winId();
	1542
	1543	Window w = XCreateWindow(X11->display, p, x(), y(), width(), height(),
	1544	0, vi->depth, InputOutput, vi->visual,
	1545	CWBackPixel\|CWBorderPixel\|CWColormap, &a);
	1546	Window *cmw;
	1547	Window *cmwret;
	1548	int count;
	1549	if (XGetWMColormapWindows(X11->display, window()->winId(),
	1550	&cmwret, &count)) {
	1551	cmw = new Window[count+1];
	1552	memcpy((char )cmw, (char )cmwret, sizeof(Window)*count);
	1553	XFree((char *)cmwret);
	1554	int i;
	1555	for (i=0; i<count; i++) {
	1556	if (cmw[i] == winId()) { // replace old window
	1557	cmw[i] = w;
	1558	break;
	1559	}
	1560	}
	1561	if (i >= count) // append new window
	1562	cmw[count++] = w;
	1563	} else {
	1564	count = 1;
	1565	cmw = new Window[count];
	1566	cmw[0] = w;
	1567	}
	1568
	1569	#if defined(GLX_MESA_release_buffers) && defined(QGL_USE_MESA_EXT)
	1570	if (oldcx && oldcx->windowCreated())
	1571	glXReleaseBuffersMESA(X11->display, winId());
	1572	#endif
	1573	if (deleteOldContext)
	1574	delete oldcx;
	1575	oldcx = 0;
	1576
	1577	if (testAttribute(Qt::WA_WState_Created))
	1578	create(w);
	1579	else
	1580	d->createWinId(w);
	1581	XSetWMColormapWindows(X11->display, window()->winId(), cmw, count);
	1582	delete [] cmw;
	1583
	1584	// calling QWidget::create() will always result in a new paint
	1585	// engine being created - get rid of it and replace it with our
	1586	// own
	1587
	1588	if (visible)
	1589	show();
	1590	XFlush(X11->display);
	1591	d->glcx->setWindowCreated(true);
	1592	}
	1593
	1594	const QGLColormap & QGLWidget::colormap() const
	1595	{
	1596	Q_D(const QGLWidget);
	1597	return d->cmap;
	1598	}
	1599
	1600	/*\internal
	1601	Store color values in the given colormap.
	1602	*/
	1603	static void qStoreColors(QWidget * tlw, Colormap cmap,
	1604	const QGLColormap & cols)
	1605	{
	1606	Q_UNUSED(tlw);
	1607	XColor c;
	1608	QRgb color;
	1609
	1610	for (int i = 0; i < cols.size(); i++) {
	1611	color = cols.entryRgb(i);
	1612	c.pixel = i;
	1613	c.red = (ushort)((qRed(color) / 255.0) * 65535.0 + 0.5);
	1614	c.green = (ushort)((qGreen(color) / 255.0) * 65535.0 + 0.5);
	1615	c.blue = (ushort)((qBlue(color) / 255.0) * 65535.0 + 0.5);
	1616	c.flags = DoRed \| DoGreen \| DoBlue;
	1617	XStoreColor(X11->display, cmap, &c);
	1618	}
	1619	}
	1620
	1621	/*\internal
	1622	Check whether the given visual supports dynamic colormaps or not.
	1623	*/
	1624	static bool qCanAllocColors(QWidget * w)
	1625	{
	1626	bool validVisual = false;
	1627	int numVisuals;
	1628	long mask;
	1629	XVisualInfo templ;
	1630	XVisualInfo * visuals;
	1631	VisualID id = XVisualIDFromVisual((Visual *) w->window()->x11Info().visual());
	1632
	1633	mask = VisualScreenMask;
	1634	templ.screen = w->x11Info().screen();
	1635	visuals = XGetVisualInfo(X11->display, mask, &templ, &numVisuals);
	1636
	1637	for (int i = 0; i < numVisuals; i++) {
	1638	if (visuals[i].visualid == id) {
	1639	switch (visuals[i].c_class) {
	1640	case TrueColor:
	1641	case StaticColor:
	1642	case StaticGray:
	1643	case XGrayScale:
	1644	validVisual = false;
	1645	break;
	1646	case DirectColor:
	1647	case PseudoColor:
	1648	validVisual = true;
	1649	break;
	1650	}
	1651	break;
	1652	}
	1653	}
	1654	XFree(visuals);
	1655
	1656	if (!validVisual)
	1657	return false;
	1658	return true;
	1659	}
	1660
	1661
	1662	void QGLWidget::setColormap(const QGLColormap & c)
	1663	{
	1664	Q_D(QGLWidget);
	1665	QWidget * tlw = window(); // must return a valid widget
	1666
	1667	d->cmap = c;
	1668	if (!d->cmap.handle())
	1669	return;
	1670
	1671	if (!qCanAllocColors(this)) {
	1672	qWarning("QGLWidget::setColormap: Cannot create a read/write "
	1673	"colormap for this visual");
	1674	return;
	1675	}
	1676
	1677	// If the child GL widget is not of the same visual class as the
	1678	// toplevel widget we will get in trouble..
	1679	Window wid = tlw->winId();
	1680	Visual * vis = (Visual *) tlw->x11Info().visual();;
	1681	VisualID cvId = XVisualIDFromVisual((Visual *) x11Info().visual());
	1682	VisualID tvId = XVisualIDFromVisual((Visual *) tlw->x11Info().visual());
	1683	if (cvId != tvId) {
	1684	wid = winId();
	1685	vis = (Visual *) x11Info().visual();
	1686	}
	1687
	1688	if (!d->cmap.handle()) // allocate a cmap if necessary
	1689	d->cmap.setHandle(XCreateColormap(X11->display, wid, vis, AllocAll));
	1690
	1691	qStoreColors(this, (Colormap) d->cmap.handle(), c);
	1692	XSetWindowColormap(X11->display, wid, (Colormap) d->cmap.handle());
	1693
	1694	// tell the wm that this window has a special colormap
	1695	Window * cmw;
	1696	Window * cmwret;
	1697	int count;
	1698	if (XGetWMColormapWindows(X11->display, tlw->winId(), &cmwret, &count))
	1699	{
	1700	cmw = new Window[count+1];
	1701	memcpy((char ) cmw, (char ) cmwret, sizeof(Window) * count);
	1702	XFree((char *) cmwret);
	1703	int i;
	1704	for (i = 0; i < count; i++) {
	1705	if (cmw[i] == winId()) {
	1706	break;
	1707	}
	1708	}
	1709	if (i >= count) // append new window only if not in the list
	1710	cmw[count++] = winId();
	1711	} else {
	1712	count = 1;
	1713	cmw = new Window[count];
	1714	cmw[0] = winId();
	1715	}
	1716	XSetWMColormapWindows(X11->display, tlw->winId(), cmw, count);
	1717	delete [] cmw;
	1718	}
	1719
[561]	1720	// Solaris defines glXBindTexImageEXT as part of the GL library
	1721	#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
	1722	typedef void (qt_glXBindTexImageEXT)(Display, GLXDrawable, int, const int*);
	1723	typedef void (qt_glXReleaseTexImageEXT)(Display, GLXDrawable, int);
	1724	static qt_glXBindTexImageEXT glXBindTexImageEXT = 0;
	1725	static qt_glXReleaseTexImageEXT glXReleaseTexImageEXT = 0;
	1726
	1727	static bool qt_resolveTextureFromPixmap(QPaintDevice *paintDevice)
	1728	{
	1729	static bool resolvedTextureFromPixmap = false;
	1730
	1731	if (!resolvedTextureFromPixmap) {
	1732	resolvedTextureFromPixmap = true;
	1733
	1734	// Check to see if we have NPOT texture support
[651]	1735	if ( !(QGLExtensions::glExtensions() & QGLExtensions::NPOTTextures) &&
[561]	1736	!(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0))
	1737	{
	1738	return false; // Can't use TFP without NPOT
	1739	}
[651]	1740
[561]	1741	const QX11Info *xinfo = qt_x11Info(paintDevice);
[651]	1742	Display *display = xinfo ? xinfo->display() : X11->display;
	1743	int screen = xinfo ? xinfo->screen() : X11->defaultScreen;
	1744
[769]	1745	QGLExtensionMatcher serverExtensions(glXQueryExtensionsString(display, screen));
	1746	QGLExtensionMatcher clientExtensions(glXGetClientString(display, GLX_EXTENSIONS));
	1747	if (serverExtensions.match("GLX_EXT_texture_from_pixmap")
	1748	&& clientExtensions.match("GLX_EXT_texture_from_pixmap"))
	1749	{
[561]	1750	glXBindTexImageEXT = (qt_glXBindTexImageEXT) qglx_getProcAddress("glXBindTexImageEXT");
	1751	glXReleaseTexImageEXT = (qt_glXReleaseTexImageEXT) qglx_getProcAddress("glXReleaseTexImageEXT");
	1752	}
	1753	}
	1754
	1755	return glXBindTexImageEXT && glXReleaseTexImageEXT;
	1756	}
	1757	#endif //defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
	1758
	1759
[846]	1760	QGLTexture QGLContextPrivate::bindTextureFromNativePixmap(QPixmap pixmap, const qint64 key,
[561]	1761	QGLContext::BindOptions options)
	1762	{
	1763	#if !defined(GLX_VERSION_1_3) \|\| defined(Q_OS_HPUX)
	1764	return 0;
	1765	#else
[846]	1766
	1767	// Check we have GLX 1.3, as it is needed for glXCreatePixmap & glXDestroyPixmap
	1768	int majorVersion = 0;
	1769	int minorVersion = 0;
	1770	glXQueryVersion(X11->display, &majorVersion, &minorVersion);
	1771	if (majorVersion < 1 \|\| (majorVersion == 1 && minorVersion < 3))
	1772	return 0;
	1773
[561]	1774	Q_Q(QGLContext);
	1775
[846]	1776	QX11PixmapData pixmapData = static_cast<QX11PixmapData>(pixmap->data_ptr().data());
	1777	Q_ASSERT(pixmapData->classId() == QPixmapData::X11Class);
[561]	1778
[846]	1779	// We can't use TFP if the pixmap has a separate X11 mask
	1780	if (pixmapData->x11_mask)
	1781	return 0;
	1782
[561]	1783	if (!qt_resolveTextureFromPixmap(paintDevice))
	1784	return 0;
	1785
	1786	const QX11Info &x11Info = pixmapData->xinfo;
	1787
	1788	// Store the configs (Can be static because configs aren't dependent on current context)
	1789	static GLXFBConfig glxRGBPixmapConfig = 0;
	1790	static bool RGBConfigInverted = false;
	1791	static GLXFBConfig glxRGBAPixmapConfig = 0;
	1792	static bool RGBAConfigInverted = false;
	1793
	1794	bool hasAlpha = pixmapData->hasAlphaChannel();
	1795
	1796	// Check to see if we need a config
	1797	if ( (hasAlpha && !glxRGBAPixmapConfig) \|\| (!hasAlpha && !glxRGBPixmapConfig) ) {
	1798	GLXFBConfig *configList = 0;
	1799	int configCount = 0;
	1800
	1801	int configAttribs[] = {
	1802	hasAlpha ? GLX_BIND_TO_TEXTURE_RGBA_EXT : GLX_BIND_TO_TEXTURE_RGB_EXT, True,
	1803	GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
	1804	GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
	1805	// QGLContext::bindTexture() can't return an inverted texture, but QPainter::drawPixmap() can:
	1806	GLX_Y_INVERTED_EXT, options & QGLContext::CanFlipNativePixmapBindOption ? GLX_DONT_CARE : False,
	1807	XNone
	1808	};
	1809	configList = glXChooseFBConfig(x11Info.display(), x11Info.screen(), configAttribs, &configCount);
	1810	if (!configList)
	1811	return 0;
	1812
	1813	int yInv;
	1814	glXGetFBConfigAttrib(x11Info.display(), configList[0], GLX_Y_INVERTED_EXT, &yInv);
	1815
	1816	if (hasAlpha) {
	1817	glxRGBAPixmapConfig = configList[0];
	1818	RGBAConfigInverted = yInv;
	1819	}
	1820	else {
	1821	glxRGBPixmapConfig = configList[0];
	1822	RGBConfigInverted = yInv;
	1823	}
	1824
	1825	XFree(configList);
	1826	}
	1827
	1828	// Check to see if the surface is still valid
	1829	if (pixmapData->gl_surface &&
	1830	hasAlpha != (pixmapData->flags & QX11PixmapData::GlSurfaceCreatedWithAlpha))
	1831	{
	1832	// Surface is invalid!
	1833	destroyGlSurfaceForPixmap(pixmapData);
	1834	}
	1835
	1836	// Check to see if we need a surface
	1837	if (!pixmapData->gl_surface) {
	1838	GLXPixmap glxPixmap;
	1839	int pixmapAttribs[] = {
	1840	GLX_TEXTURE_FORMAT_EXT, hasAlpha ? GLX_TEXTURE_FORMAT_RGBA_EXT : GLX_TEXTURE_FORMAT_RGB_EXT,
	1841	GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
	1842	GLX_MIPMAP_TEXTURE_EXT, False, // Maybe needs to be don't care
	1843	XNone
	1844	};
	1845
	1846	// Wrap the X Pixmap into a GLXPixmap:
	1847	glxPixmap = glXCreatePixmap(x11Info.display(),
	1848	hasAlpha ? glxRGBAPixmapConfig : glxRGBPixmapConfig,
	1849	pixmapData->handle(), pixmapAttribs);
	1850
	1851	if (!glxPixmap)
	1852	return 0;
	1853
[846]	1854	pixmapData->gl_surface = (void*)glxPixmap;
[561]	1855
	1856	// Make sure the cleanup hook gets called so we can delete the glx pixmap
	1857	QImagePixmapCleanupHooks::enableCleanupHooks(pixmapData);
	1858	}
	1859
	1860	GLuint textureId;
	1861	glGenTextures(1, &textureId);
	1862	glBindTexture(GL_TEXTURE_2D, textureId);
	1863	glXBindTexImageEXT(x11Info.display(), (GLXPixmap)pixmapData->gl_surface, GLX_FRONT_LEFT_EXT, 0);
	1864
	1865	glBindTexture(GL_TEXTURE_2D, textureId);
[846]	1866	GLuint filtering = (options & QGLContext::LinearFilteringBindOption) ? GL_LINEAR : GL_NEAREST;
	1867	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
	1868	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
[561]	1869
	1870	if (!((hasAlpha && RGBAConfigInverted) \|\| (!hasAlpha && RGBConfigInverted)))
	1871	options &= ~QGLContext::InvertedYBindOption;
	1872
	1873	QGLTexture *texture = new QGLTexture(q, textureId, GL_TEXTURE_2D, options);
	1874	if (texture->options & QGLContext::InvertedYBindOption)
	1875	pixmapData->flags \|= QX11PixmapData::InvertedWhenBoundToTexture;
	1876
	1877	// We assume the cost of bound pixmaps is zero
	1878	QGLTextureCache::instance()->insert(q, key, texture, 0);
	1879
	1880	return texture;
	1881	#endif //!defined(GLX_VERSION_1_3) \|\| defined(Q_OS_HPUX)
	1882	}
	1883
	1884
	1885	void QGLContextPrivate::destroyGlSurfaceForPixmap(QPixmapData* pmd)
	1886	{
	1887	#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
	1888	Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
	1889	QX11PixmapData pixmapData = static_cast<QX11PixmapData>(pmd);
	1890	if (pixmapData->gl_surface) {
	1891	glXDestroyPixmap(QX11Info::display(), (GLXPixmap)pixmapData->gl_surface);
	1892	pixmapData->gl_surface = 0;
	1893	}
	1894	#endif
	1895	}
	1896
	1897	void QGLContextPrivate::unbindPixmapFromTexture(QPixmapData* pmd)
	1898	{
	1899	#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
	1900	Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
	1901	Q_ASSERT(QGLContext::currentContext());
	1902	QX11PixmapData pixmapData = static_cast<QX11PixmapData>(pmd);
	1903	if (pixmapData->gl_surface)
	1904	glXReleaseTexImageEXT(QX11Info::display(), (GLXPixmap)pixmapData->gl_surface, GLX_FRONT_LEFT_EXT);
	1905	#endif
	1906	}
	1907
[2]	1908	QT_END_NAMESPACE

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/src/opengl/qgl_x11.cpp

Download in other formats: