Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebase@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 673 insertions, 0 deletions

diff --git a/kcontrol/info/opengl.cpp b/kcontrol/info/opengl.cpp
new file mode 100644
index 000000000..66266abdf
--- /dev/null
+++ b/kcontrol/info/opengl.cpp
@@ -0,0 +1,673 @@
+/***************************************************************************
+ *                                                                         *
+ *   Copyright (C) 2004 by Ilya Korniyko  <[email protected]>                 *
+ *   Adapted from Brian Paul's glxinfo from Mesa demos (http:/www.mesa3d.org)
+ *   Copyright (C) 1999-2002  Brian Paul                                   *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
+ ***************************************************************************/
+
+#if defined(INFO_OPENGL_AVAILABLE)
+
+#define KCMGL_DO_GLU
+
+#include <qregexp.h>
+#include <qlistview.h>
+#include <qfile.h>
+#include <qstring.h>
+
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <kdebug.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+#ifdef KCMGL_DO_GLU
+#include <GL/glu.h>
+#endif
+
+#include <GL/gl.h>
+#include <GL/glext.h>
+#include <GL/glx.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+static bool IsDirect;
+
+static struct glinfo {
+      const char *serverVendor;
+      const char *serverVersion;
+      const char *serverExtensions;
+      const char *clientVendor;
+      const char *clientVersion;
+      const char *clientExtensions;
+      const char *glxExtensions;
+      const char *glVendor;
+      const char *glRenderer;
+      const char *glVersion;
+      const char *glExtensions;
+      const char *gluVersion;
+      const char *gluExtensions;
+      char *displayName;
+} gli;
+
+static struct {
+	QString module,
+		pci,
+		vendor,
+		device,
+		subvendor,
+		rev;
+} dri_info;
+
+static int ReadPipe(QString FileName, QStringList &list)
+{
+    FILE *pipe;
+
+    if ((pipe = popen(FileName.ascii(), "r")) == NULL) {
+	pclose(pipe);
+	return 0;
+    }
+
+    QTextStream t(pipe, IO_ReadOnly);
+
+    while (!t.atEnd()) list.append(t.readLine());
+
+    pclose(pipe);
+    return list.count();
+}
+
+#if defined(Q_OS_LINUX)
+
+#define INFO_DRI "/proc/dri/0/name"
+
+static bool get_dri_device()
+{
+    QFile file;
+    file.setName(INFO_DRI);
+    if (!file.exists() || !file.open(IO_ReadOnly))
+	return false;
+
+    QTextStream stream(&file);
+    QString line = stream.readLine();
+    if (!line.isEmpty()) {
+	dri_info.module = line.mid(0, line.find(0x20));
+
+	// possible formats, for regression testing
+	// line = " PCI:01:00:0";
+	// line = " pci:0000:01:00.0"
+	QRegExp rx = QRegExp("\\b[Pp][Cc][Ii][:]([0-9a-fA-F]+[:])?([0-9a-fA-F]+[:][0-9a-fA-F]+[:.][0-9a-fA-F]+)\\b");
+	if (rx.search(line)>0)	 {
+		dri_info.pci = rx.cap(2);
+		int end = dri_info.pci.findRev(':');
+		int end2 = dri_info.pci.findRev('.');
+		if (end2>end) end=end2;
+		dri_info.pci[end]='.';
+
+		QString cmd = QString("lspci -m -v -s ") + dri_info.pci;
+		QStringList pci_info;
+		int num;
+		if (((num = ReadPipe(cmd, pci_info)) ||
+		(num = ReadPipe("/sbin/"+cmd, pci_info)) ||
+		(num = ReadPipe("/usr/sbin/"+cmd, pci_info)) ||
+		(num = ReadPipe("/usr/local/sbin/"+cmd, pci_info))) && num>=7) {
+			for (int i=2; i<=6; i++) {
+				line = pci_info[i];
+				line.remove(QRegExp("[^:]*:[ ]*"));
+				switch (i){
+					case 2: dri_info.vendor = line;    break;
+					case 3: dri_info.device = line;    break;
+					case 4: dri_info.subvendor = line; break;
+					case 6: dri_info.rev = line;       break;
+				}
+			}
+			return true;
+		}
+	}
+    }
+
+    return false;
+}
+
+#elif defined(Q_OS_FREEBSD)
+
+static bool get_dri_device() {
+
+	QStringList pci_info;
+	if (ReadPipe("sysctl -n hw.dri.0.name",pci_info)) {
+		dri_info.module = pci_info[0].mid(0, pci_info[0].find(0x20));
+		}
+	return false;
+}
+
+#else
+
+static bool get_dri_device() { return false; }
+
+#endif
+
+static void
+mesa_hack(Display *dpy, int scrnum)
+{
+   static int attribs[] = {
+      GLX_RGBA,
+      GLX_RED_SIZE, 1,
+      GLX_GREEN_SIZE, 1,
+      GLX_BLUE_SIZE, 1,
+      GLX_DEPTH_SIZE, 1,
+      GLX_STENCIL_SIZE, 1,
+      GLX_ACCUM_RED_SIZE, 1,
+      GLX_ACCUM_GREEN_SIZE, 1,
+      GLX_ACCUM_BLUE_SIZE, 1,
+      GLX_ACCUM_ALPHA_SIZE, 1,
+      GLX_DOUBLEBUFFER,
+      None
+   };
+   XVisualInfo *visinfo;
+
+   visinfo = glXChooseVisual(dpy, scrnum, attribs);
+   if (visinfo)
+      XFree(visinfo);
+}
+
+
+static void
+print_extension_list(const char *ext, QListViewItem *l1)
+{
+   int i, j;
+
+   if (!ext || !ext[0])
+      return;
+   QString qext = QString::fromLatin1(ext);
+   QListViewItem *l2 = NULL;
+
+   i = j = 0;
+   while (1) {
+      if (ext[j] == ' ' || ext[j] == 0) {
+         /* found end of an extension name */
+         const int len = j - i;
+         /* print the extension name between ext[i] and ext[j] */
+	 if (!l2) l2 = new QListViewItem(l1, qext.mid(i, len));
+	 else l2 = new QListViewItem(l1, l2, qext.mid(i, len));
+	 i=j;
+         if (ext[j] == 0) {
+            break;
+         }
+         else {
+            i++;
+            j++;
+            if (ext[j] == 0)
+               break;
+         }
+      }
+      j++;
+   }
+}
+
+#if defined(GLX_ARB_get_proc_address) && defined(__GLXextFuncPtr)
+extern "C" {
+	extern __GLXextFuncPtr glXGetProcAddressARB (const GLubyte *);
+}
+#endif
+
+static void
+print_limits(QListViewItem *l1, const char * glExtensions, bool GetProcAddress)
+{
+ /*  TODO
+      GL_SAMPLE_BUFFERS
+      GL_SAMPLES
+      GL_COMPRESSED_TEXTURE_FORMATS
+*/
+
+  if (!glExtensions)
+	return;
+
+  struct token_name {
+      GLuint type;  // count and flags, !!! count must be <=2 for now
+      GLenum token;
+      const QString name;
+   };
+
+   struct token_group {
+   	int count;
+	int type;
+	const token_name *group;
+	const QString descr;
+	const char *ext;
+   };
+
+   QListViewItem *l2 = NULL, *l3 = NULL;
+#if defined(PFNGLGETPROGRAMIVARBPROC)
+   PFNGLGETPROGRAMIVARBPROC kcm_glGetProgramivARB = NULL;
+#endif
+
+   #define KCMGL_FLOAT 128
+   #define KCMGL_PROG 256
+   #define KCMGL_COUNT_MASK(x) (x & 127)
+   #define KCMGL_SIZE(x) (sizeof(x)/sizeof(x[0]))
+
+   const struct token_name various_limits[] = {
+      { 1, GL_MAX_LIGHTS, 		i18n("Max. number of light sources") },
+      { 1, GL_MAX_CLIP_PLANES,		i18n("Max. number of clipping planes") },
+      { 1, GL_MAX_PIXEL_MAP_TABLE, 	i18n("Max. pixel map table size") },
+      { 1, GL_MAX_LIST_NESTING, 	i18n("Max. display list nesting level") },
+      { 1, GL_MAX_EVAL_ORDER, 		i18n("Max. evaluator order") },
+      { 1, GL_MAX_ELEMENTS_VERTICES, 	i18n("Max. recommended vertex count") },
+      { 1, GL_MAX_ELEMENTS_INDICES, 	i18n("Max. recommended index count") },
+#ifdef GL_QUERY_COUNTER_BITS
+      { 1, GL_QUERY_COUNTER_BITS, 	i18n("Occlusion query counter bits")},
+#endif
+#ifdef GL_MAX_VERTEX_UNITS_ARB
+      { 1, GL_MAX_VERTEX_UNITS_ARB, 	i18n("Max. vertex blend matrices") },
+#endif
+#ifdef GL_MAX_PALETTE_MATRICES_ARB
+      { 1, GL_MAX_PALETTE_MATRICES_ARB, i18n("Max. vertex blend matrix palette size") },
+#endif
+      {0,0,0}
+     };
+
+   const struct token_name texture_limits[] = {
+      { 1, GL_MAX_TEXTURE_SIZE, 	i18n("Max. texture size") },
+      { 1, GL_MAX_TEXTURE_UNITS_ARB, 	i18n("Num. of texture units") },
+      { 1, GL_MAX_3D_TEXTURE_SIZE, 		i18n("Max. 3D texture size") },
+#ifdef GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB
+      { 1, GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, 	i18n("Max. cube map texture size") },
+#endif
+#ifdef GL_MAX_RECTANGLE_TEXTURE_SIZE_NV
+      { 1, GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, 	i18n("Max. rectangular texture size") },
+#endif
+#ifdef GL_MAX_TEXTURE_LOD_BIAS_EXT
+      { 1 | KCMGL_FLOAT, GL_MAX_TEXTURE_LOD_BIAS_EXT, i18n("Max. texture LOD bias") },
+#endif
+#ifdef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
+      { 1, GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, 	i18n("Max. anisotropy filtering level") },
+#endif
+#ifdef GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB
+      { 1, GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, i18n("Num. of compressed texture formats") },
+#endif
+      {0,0,0}
+     };
+
+   const struct token_name float_limits[] = {
+      { 2 | KCMGL_FLOAT, GL_ALIASED_POINT_SIZE_RANGE, 	"ALIASED_POINT_SIZE_RANGE" },
+      { 2 | KCMGL_FLOAT, GL_SMOOTH_POINT_SIZE_RANGE, 	"SMOOTH_POINT_SIZE_RANGE" },
+      { 1 | KCMGL_FLOAT, GL_SMOOTH_POINT_SIZE_GRANULARITY,"SMOOTH_POINT_SIZE_GRANULARITY"},
+      { 2 | KCMGL_FLOAT, GL_ALIASED_LINE_WIDTH_RANGE, 	"ALIASED_LINE_WIDTH_RANGE" },
+      { 2 | KCMGL_FLOAT, GL_SMOOTH_LINE_WIDTH_RANGE, 	"SMOOTH_LINE_WIDTH_RANGE" },
+      { 1 | KCMGL_FLOAT, GL_SMOOTH_LINE_WIDTH_GRANULARITY,"SMOOTH_LINE_WIDTH_GRANULARITY"},
+      {0,0,0}
+     };
+
+   const struct token_name stack_depth[] = {
+      { 1, GL_MAX_MODELVIEW_STACK_DEPTH, 	"MAX_MODELVIEW_STACK_DEPTH" },
+      { 1, GL_MAX_PROJECTION_STACK_DEPTH, 	"MAX_PROJECTION_STACK_DEPTH" },
+      { 1, GL_MAX_TEXTURE_STACK_DEPTH, 		"MAX_TEXTURE_STACK_DEPTH" },
+      { 1, GL_MAX_NAME_STACK_DEPTH, 		"MAX_NAME_STACK_DEPTH" },
+      { 1, GL_MAX_ATTRIB_STACK_DEPTH, 		"MAX_ATTRIB_STACK_DEPTH" },
+      { 1, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, 	"MAX_CLIENT_ATTRIB_STACK_DEPTH" },
+      { 1, GL_MAX_COLOR_MATRIX_STACK_DEPTH, 	"MAX_COLOR_MATRIX_STACK_DEPTH" },
+#ifdef GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB
+      { 1, GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB,"MAX_MATRIX_PALETTE_STACK_DEPTH"},
+#endif
+      {0,0,0}
+   };
+
+#ifdef GL_ARB_fragment_program
+   const struct token_name arb_fp[] = {
+    { 1, GL_MAX_TEXTURE_COORDS_ARB, "MAX_TEXTURE_COORDS" },
+    { 1, GL_MAX_TEXTURE_IMAGE_UNITS_ARB, "MAX_TEXTURE_IMAGE_UNITS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, "MAX_PROGRAM_ENV_PARAMETERS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, "MAX_PROGRAM_LOCAL_PARAMETERS" },
+    { 1, GL_MAX_PROGRAM_MATRICES_ARB, "MAX_PROGRAM_MATRICES" },
+    { 1, GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB, "MAX_PROGRAM_MATRIX_STACK_DEPTH" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, "MAX_PROGRAM_INSTRUCTIONS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, "MAX_PROGRAM_ALU_INSTRUCTIONS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, "MAX_PROGRAM_TEX_INSTRUCTIONS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, "MAX_PROGRAM_TEX_INDIRECTIONS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_TEMPORARIES_ARB, "MAX_PROGRAM_TEMPORARIES" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_PARAMETERS_ARB, "MAX_PROGRAM_PARAMETERS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_ATTRIBS_ARB, "MAX_PROGRAM_ATTRIBS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, "MAX_PROGRAM_NATIVE_INSTRUCTIONS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, "MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, "MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, "MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, "MAX_PROGRAM_NATIVE_TEMPORARIES" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, "MAX_PROGRAM_NATIVE_PARAMETERS" },
+    { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, "MAX_PROGRAM_NATIVE_ATTRIBS" },
+    {0,0,0}
+   };
+#endif
+
+#ifdef GL_ARB_vertex_program
+   const struct token_name arb_vp[] = {
+{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB,"MAX_PROGRAM_ENV_PARAMETERS"},
+{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB,"MAX_PROGRAM_LOCAL_PARAMETERS"},
+{ 1, GL_MAX_VERTEX_ATTRIBS_ARB, "MAX_VERTEX_ATTRIBS"},
+{ 1, GL_MAX_PROGRAM_MATRICES_ARB,"MAX_PROGRAM_MATRICES"},
+{ 1, GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB,"MAX_PROGRAM_MATRIX_STACK_DEPTH"},
+{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_INSTRUCTIONS_ARB,"MAX_PROGRAM_INSTRUCTIONS"},
+{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_TEMPORARIES_ARB,"MAX_PROGRAM_TEMPORARIES"},
+{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_PARAMETERS_ARB,"MAX_PROGRAM_PARAMETERS"},
+{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_ATTRIBS_ARB,"MAX_PROGRAM_ATTRIBS"},
+{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB,"MAX_PROGRAM_ADDRESS_REGISTERS"},
+{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB,"MAX_PROGRAM_NATIVE_INSTRUCTIONS"},
+{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB,"MAX_PROGRAM_NATIVE_TEMPORARIES"},
+{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB,"MAX_PROGRAM_NATIVE_PARAMETERS"},
+{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB,"MAX_PROGRAM_NATIVE_ATTRIBS"},
+{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB ,"MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS"},
+{0,0,0}
+};
+#endif
+
+#ifdef GL_ARB_vertex_shader
+   const struct token_name arb_vs[] = {
+    { 1, GL_MAX_VERTEX_ATTRIBS_ARB,"MAX_VERTEX_ATTRIBS"},
+    { 1, GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB,"MAX_VERTEX_UNIFORM_COMPONENTS"},
+    { 1, GL_MAX_VARYING_FLOATS_ARB,"MAX_VARYING_FLOATS"},
+    { 1, GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB,"MAX_COMBINED_TEXTURE_IMAGE_UNITS"},
+    { 1, GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB,"MAX_VERTEX_TEXTURE_IMAGE_UNITS"},
+    { 1, GL_MAX_TEXTURE_IMAGE_UNITS_ARB,"MAX_TEXTURE_IMAGE_UNITS"},
+    { 1, GL_MAX_TEXTURE_COORDS_ARB,"MAX_TEXTURE_COORDS"},
+    {0,0,0}
+   };
+#endif
+
+#ifdef GL_ARB_fragment_shader
+   const struct token_name arb_fs[] = {
+    { 1, GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB,"MAX_FRAGMENT_UNIFORM_COMPONENTS"},
+    { 1, GL_MAX_TEXTURE_IMAGE_UNITS_ARB,"MAX_TEXTURE_IMAGE_UNITS"},
+    { 1, GL_MAX_TEXTURE_COORDS_ARB,"MAX_TEXTURE_COORDS"},
+    {0,0,0}
+   };
+#endif
+
+   const struct token_name frame_buffer_props[] = {
+      { 2, GL_MAX_VIEWPORT_DIMS, 	i18n("Max. viewport dimensions") },
+      { 1, GL_SUBPIXEL_BITS, 		i18n("Subpixel bits") },
+      { 1, GL_AUX_BUFFERS, 		i18n("Aux. buffers")},
+      {0,0,0}
+    };
+
+   const struct token_group groups[] =
+   {
+    {KCMGL_SIZE(frame_buffer_props), 0, frame_buffer_props, i18n("Frame buffer properties"), NULL},
+    {KCMGL_SIZE(various_limits), 0, texture_limits, i18n("Texturing"), NULL},
+    {KCMGL_SIZE(various_limits), 0, various_limits, i18n("Various limits"), NULL},
+    {KCMGL_SIZE(float_limits), 0, float_limits, i18n("Points and lines"), NULL},
+    {KCMGL_SIZE(stack_depth), 0, stack_depth, i18n("Stack depth limits"), NULL},
+#ifdef GL_ARB_vertex_program
+    {KCMGL_SIZE(arb_vp), GL_VERTEX_PROGRAM_ARB, arb_vp, "ARB_vertex_program", "GL_ARB_vertex_program"},
+#endif
+#ifdef GL_ARB_fragment_program
+    {KCMGL_SIZE(arb_fp), GL_FRAGMENT_PROGRAM_ARB, arb_fp, "ARB_fragment_program", "GL_ARB_fragment_program"},
+#endif
+#ifdef GL_ARB_vertex_shader
+    {KCMGL_SIZE(arb_vs), 0, arb_vs, "ARB_vertex_shader", "GL_ARB_vertex_shader"},
+#endif
+#ifdef GL_ARB_fragment_shader
+    {KCMGL_SIZE(arb_fs), 0, arb_fs, "ARB_fragment_shader", "GL_ARB_fragment_shader"},
+#endif
+   };
+
+#if defined(GLX_ARB_get_proc_address) && defined(PFNGLGETPROGRAMIVARBPROC)
+   if (GetProcAddress && strstr(glExtensions, "GL_ARB_vertex_program"))
+   kcm_glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC) glXGetProcAddressARB((const GLubyte *)"glGetProgramivARB");
+#endif
+
+   for (uint i = 0; i<KCMGL_SIZE(groups); i++) {
+   	if (groups[i].ext && !strstr(glExtensions, groups[i].ext)) continue;
+
+	if (l2) l2 = new QListViewItem(l1, l2, groups[i].descr);
+   	   else l2 = new QListViewItem(l1, groups[i].descr);
+	l3 = NULL;
+   	const struct token_name *cur_token;
+	for (cur_token = groups[i].group; cur_token->type; cur_token++) {
+
+   		bool tfloat = cur_token->type & KCMGL_FLOAT;
+		int count = KCMGL_COUNT_MASK(cur_token->type);
+		GLint max[2]={0,0};
+   		GLfloat fmax[2]={0.0,0.0};
+
+#if defined(PFNGLGETPROGRAMIVARBPROC) && defined(GL_ARB_vertex_program)
+   		bool tprog = cur_token->type & KCMGL_PROG;
+		if (tprog && kcm_glGetProgramivARB)
+			kcm_glGetProgramivARB(groups[i].type, cur_token->token, max);
+		else
+#endif
+		if (tfloat) glGetFloatv(cur_token->token, fmax);
+   			else glGetIntegerv(cur_token->token, max);
+
+		if (glGetError() == GL_NONE) {
+			QString s;
+		 	if (!tfloat && count == 1) s = QString::number(max[0]); else
+		 	if (!tfloat && count == 2) s = QString("%1, %2").arg(max[0]).arg(max[1]); else
+		 	if (tfloat && count == 2) s = QString("%1 - %2").arg(fmax[0],0,'f',6).arg(fmax[1],0,'f',6); else
+			if (tfloat && count == 1) s = QString::number(fmax[0],'f',6);
+   			if (l3) l3 = new QListViewItem(l2, l3, cur_token->name, s);
+   	   			else l3 = new QListViewItem(l2, cur_token->name, s);
+
+		}
+	}
+
+     }
+}
+
+
+static QListViewItem *print_screen_info(QListViewItem *l1, QListViewItem *after)
+{
+   	QListViewItem *l2 = NULL, *l3 = NULL;
+
+   	if (after) l1= new QListViewItem(l1,after,IsDirect ? i18n("Direct Rendering") : i18n("Indirect Rendering"));
+         	else l1= new QListViewItem(l1,IsDirect ? i18n("Direct Rendering") : i18n("Indirect Rendering"));
+   	if (IsDirect)
+   	 	if (get_dri_device())  {
+      			l2 = new QListViewItem(l1, i18n("3D Accelerator"));
+    			l2->setOpen(true);
+   			l3 = new QListViewItem(l2, l3, i18n("Vendor"), dri_info.vendor);
+   			l3 = new QListViewItem(l2, l3, i18n("Device"), dri_info.device);
+   			l3 = new QListViewItem(l2, l3, i18n("Subvendor"), dri_info.subvendor);
+   			l3 = new QListViewItem(l2, l3, i18n("Revision"), dri_info.rev);
+		}
+		else l2=new QListViewItem(l1, l2, i18n("3D Accelerator"),i18n("unknown"));
+    	if (l2) l2 = new QListViewItem(l1, l2, i18n("Driver"));
+       		else l2 = new QListViewItem(l1, i18n("Driver"));
+    	l2->setOpen(true);
+
+  	l3 = new QListViewItem(l2, i18n("Vendor"),gli.glVendor);
+    	l3 = new QListViewItem(l2, l3, i18n("Renderer"), gli.glRenderer);
+    	l3 = new QListViewItem(l2, l3, i18n("OpenGL version"), gli.glVersion);
+
+    	if (IsDirect) {
+    		if (!dri_info.module) dri_info.module = i18n("unknown");
+    		l3 = new QListViewItem(l2, l3, i18n("Kernel module"), dri_info.module);
+    	}
+
+    	l3 = new QListViewItem(l2, l3, i18n("OpenGL extensions"));
+    	print_extension_list(gli.glExtensions,l3);
+
+    	l3 = new QListViewItem(l2, l3, i18n("Implementation specific"));
+    	print_limits(l3, gli.glExtensions, strstr(gli.clientExtensions, "GLX_ARB_get_proc_address") != NULL);
+
+        return l1;
+}
+
+void print_glx_glu(QListViewItem *l1, QListViewItem *l2)
+{
+   QListViewItem *l3;
+
+   l2=new QListViewItem(l1, l2, i18n("GLX"));
+   l3 = new QListViewItem(l2, i18n("server GLX vendor"),gli.serverVendor);
+   l3 = new QListViewItem(l2, l3, i18n("server GLX version"),gli.serverVersion);
+   l3 = new QListViewItem(l2, l3, i18n("server GLX extensions"));
+   print_extension_list(gli.serverExtensions,l3);
+
+    l3 = new QListViewItem(l2, l3, i18n("client GLX vendor"),gli.clientVendor);
+    l3 = new QListViewItem(l2, l3, i18n("client GLX version"),gli.clientVersion);
+    l3 = new QListViewItem(l2, l3, i18n("client GLX extensions"));
+    print_extension_list(gli.clientExtensions,l3);
+    l3 = new QListViewItem(l2, l3, i18n("GLX extensions"));
+    print_extension_list(gli.glxExtensions,l3);
+
+#ifdef KCMGL_DO_GLU
+    l2 = new QListViewItem(l1, l2, i18n("GLU"));
+    l3 = new QListViewItem(l2, i18n("GLU version"), gli.gluVersion);
+    l3 = new QListViewItem(l2, l3, i18n("GLU extensions"));
+    print_extension_list(gli.gluExtensions,l3);
+#endif
+
+}
+
+static QListViewItem *get_gl_info(Display *dpy, int scrnum, Bool allowDirect,QListViewItem *l1, QListViewItem *after)
+{
+   Window win;
+   int attribSingle[] = {
+      GLX_RGBA,
+      GLX_RED_SIZE, 1,
+      GLX_GREEN_SIZE, 1,
+      GLX_BLUE_SIZE, 1,
+      None };
+   int attribDouble[] = {
+      GLX_RGBA,
+      GLX_RED_SIZE, 1,
+      GLX_GREEN_SIZE, 1,
+      GLX_BLUE_SIZE, 1,
+      GLX_DOUBLEBUFFER,
+      None };
+
+   XSetWindowAttributes attr;
+   unsigned long mask;
+   Window root;
+   GLXContext ctx;
+   XVisualInfo *visinfo;
+   int width = 100, height = 100;
+   QListViewItem *result = after;
+
+   root = RootWindow(dpy, scrnum);
+
+   visinfo = glXChooseVisual(dpy, scrnum, attribSingle);
+   if (!visinfo) {
+      visinfo = glXChooseVisual(dpy, scrnum, attribDouble);
+      if (!visinfo) {
+		   kdDebug() << "Error: couldn't find RGB GLX visual\n";
+         return result;
+      }
+   }
+
+   attr.background_pixel = 0;
+   attr.border_pixel = 0;
+   attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
+   attr.event_mask = StructureNotifyMask | ExposureMask;
+   mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+   win = XCreateWindow(dpy, root, 0, 0, width, height,
+   			0, visinfo->depth, InputOutput,
+		       visinfo->visual, mask, &attr);
+
+   ctx = glXCreateContext( dpy, visinfo, NULL, allowDirect );
+   if (!ctx) {
+		kdDebug() << "Error: glXCreateContext failed\n";
+      XDestroyWindow(dpy, win);
+      return result;
+   }
+
+   if (glXMakeCurrent(dpy, win, ctx)) {
+      gli.serverVendor = glXQueryServerString(dpy, scrnum, GLX_VENDOR);
+      gli.serverVersion = glXQueryServerString(dpy, scrnum, GLX_VERSION);
+      gli.serverExtensions = glXQueryServerString(dpy, scrnum, GLX_EXTENSIONS);
+      gli.clientVendor = glXGetClientString(dpy, GLX_VENDOR);
+      gli.clientVersion = glXGetClientString(dpy, GLX_VERSION);
+      gli.clientExtensions = glXGetClientString(dpy, GLX_EXTENSIONS);
+      gli.glxExtensions = glXQueryExtensionsString(dpy, scrnum);
+      gli.glVendor = (const char *) glGetString(GL_VENDOR);
+      gli.glRenderer = (const char *) glGetString(GL_RENDERER);
+      gli.glVersion = (const char *) glGetString(GL_VERSION);
+      gli.glExtensions = (const char *) glGetString(GL_EXTENSIONS);
+      gli.displayName = NULL;
+#ifdef KCMGL_DO_GLU
+      gli.gluVersion = (const char *) gluGetString(GLU_VERSION);
+      gli.gluExtensions = (const char *) gluGetString(GLU_EXTENSIONS);
+#endif
+      IsDirect = glXIsDirect(dpy, ctx);
+
+      result = print_screen_info(l1, after);
+   }
+   else {
+      kdDebug() << "Error: glXMakeCurrent failed\n";
+   }
+
+   glXDestroyContext(dpy, ctx);
+   XDestroyWindow(dpy, win);
+   return result;
+
+}
+
+
+static bool GetInfo_OpenGL_Generic( QListView *lBox )
+{
+   QListViewItem *l1, *l2 = NULL;
+
+   char *displayName = NULL;
+   Display *dpy;
+   int numScreens, scrnum;
+
+   dpy = XOpenDisplay(displayName);
+   if (!dpy) {
+//      kdDebug() << "Error: unable to open display " << displayName << endl;
+      return false;
+   }
+
+    lBox->addColumn(i18n("Information") );
+    lBox->addColumn(i18n("Value") );
+
+    l1 = new QListViewItem(lBox, i18n("Name of the Display"), DisplayString(dpy));
+    l1->setOpen(true);
+    l1->setSelectable(false);
+    l1->setExpandable(false);
+
+    numScreens = ScreenCount(dpy);
+
+  scrnum = 0;
+#ifdef KCMGL_MANY_SCREENS
+      for (; scrnum < numScreens; scrnum++)
+#endif
+      {
+         mesa_hack(dpy, scrnum);
+
+	 l2 = get_gl_info(dpy, scrnum, true, l1, l2);
+	 if (l2) l2->setOpen(true);
+
+	 if (IsDirect) l2 = get_gl_info(dpy, scrnum, false, l1, l2);
+
+//   TODO      print_visual_info(dpy, scrnum, mode);
+      }
+    if (l2)
+	print_glx_glu(l1, l2);
+    else
+	KMessageBox::error(0, i18n("Could not initialize OpenGL"));
+
+    XCloseDisplay(dpy);
+    return true;
+   }
+
+bool GetInfo_OpenGL(QListView * lBox)
+{
+    return GetInfo_OpenGL_Generic(lBox);
+}
+
+#endif /* INFO_OPENGL_AVAILABLE */
+