/*

** visualinfo.c

**

** Copyright (C) Nate Robins, 1997

**               Michael Wimmer, 1999

**               Milan Ikits, 2002-2008

**

** visualinfo is a small utility that displays all available visuals,

** aka. pixelformats, in an OpenGL system along with renderer version

** information. It shows a table of all the visuals that support OpenGL

** along with their capabilities. The format of the table is similar to

** that of glxinfo on Unix systems:

**

** visual ~= pixel format descriptor

** id       = visual id (integer from 1 - max visuals)

** tp       = type (wn: window, pb: pbuffer, wp: window & pbuffer, bm: bitmap)

** ac	    = acceleration (ge: generic, fu: full, no: none)

** fm	    = format (i: integer, f: float, c: color index)

** db	    = double buffer (y = yes)

** sw       = swap method (x: exchange, c: copy, u: undefined)

** st	    = stereo (y = yes)

** sz       = total # bits

** r        = # bits of red

** g        = # bits of green

** b        = # bits of blue

** a        = # bits of alpha

** axbf     = # aux buffers

** dpth     = # bits of depth

** stcl     = # bits of stencil

*/

#include <stdio.h></stdio.h>

#include <stdlib.h></stdlib.h>

#include <string.h></string.h>

#include <gl glew.h=""></gl>

#if defined(_WIN32)

#include <gl wglew.h=""></gl>

#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)

#include <agl agl.h=""></agl>

#else

#include <gl glxew.h=""></gl>

#endif

#ifdef GLEW_MX

GLEWContext _glewctx;

#  define glewGetContext() (&_glewctx)

#  ifdef _WIN32

WGLEWContext _wglewctx;

#    define wglewGetContext() (&_wglewctx)

#  elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

GLXEWContext _glxewctx;

#    define glxewGetContext() (&_glxewctx)

#  endif

#endif /* GLEW_MX */

typedef struct GLContextStruct

{

#ifdef _WIN32

  HWND wnd;

  HDC dc;

  HGLRC rc;

#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)

  AGLContext ctx, octx;

#else

  Display* dpy;

  XVisualInfo* vi;

  GLXContext ctx;

  Window wnd;

  Colormap cmap;

#endif

} GLContext;

void InitContext (GLContext* ctx);

GLboolean CreateContext (GLContext* ctx);

void DestroyContext (GLContext* ctx);

void VisualInfo (GLContext* ctx);

void PrintExtensions (const char* s);

GLboolean ParseArgs (int argc, char** argv);

int showall = 0;

int displaystdout = 0;

int verbose = 0;

int drawableonly = 0;

char* display = NULL;

int visual = -1;

FILE* file = 0;

int 

main (int argc, char** argv)

{

  GLenum err;

  GLContext ctx;

  /* ---------------------------------------------------------------------- */

  /* parse arguments */

  if (GL_TRUE == ParseArgs(argc-1, argv+1))

  {

#if defined(_WIN32)

    fprintf(stderr, "Usage: visualinfo [-a] [-s] [-h] [-pf <id>]\n");</id>

    fprintf(stderr, "        -a: show all visuals\n");

    fprintf(stderr, "        -s: display to stdout instead of visualinfo.txt\n");

    fprintf(stderr, "        -pf <id>: use given pixelformat\n");</id>

    fprintf(stderr, "        -h: this screen\n");

#else

    fprintf(stderr, "Usage: visualinfo [-h] [-display <display>] [-visual <id>]\n");</id></display>

    fprintf(stderr, "        -h: this screen\n");

    fprintf(stderr, "        -display <display>: use given display\n");</display>

    fprintf(stderr, "        -visual <id>: use given visual\n");</id>

#endif

    return 1;

  }

  /* ---------------------------------------------------------------------- */

  /* create OpenGL rendering context */

  InitContext(&ctx);

  if (GL_TRUE == CreateContext(&ctx))

  {

    fprintf(stderr, "Error: CreateContext failed\n");

    DestroyContext(&ctx);

    return 1;

  }

  /* ---------------------------------------------------------------------- */

  /* initialize GLEW */

  glewExperimental = GL_TRUE;

#ifdef GLEW_MX

  err = glewContextInit(glewGetContext());

#  ifdef _WIN32

  err = err || wglewContextInit(wglewGetContext());

#  elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

  err = err || glxewContextInit(glxewGetContext());

#  endif

#else

  err = glewInit();

#endif

  if (GLEW_OK != err)

  {

    fprintf(stderr, "Error [main]: glewInit failed: %s\n", glewGetErrorString(err));

    DestroyContext(&ctx);

    return 1;

  }

  /* ---------------------------------------------------------------------- */

  /* open file */

#if defined(_WIN32)

  if (!displaystdout) 

    file = fopen("visualinfo.txt", "w");

  if (file == NULL)

    file = stdout;

#else

  file = stdout;

#endif

  /* ---------------------------------------------------------------------- */

  /* output header information */

  /* OpenGL extensions */

  fprintf(file, "OpenGL vendor string: %s\n", glGetString(GL_VENDOR));

  fprintf(file, "OpenGL renderer string: %s\n", glGetString(GL_RENDERER));

  fprintf(file, "OpenGL version string: %s\n", glGetString(GL_VERSION));

  fprintf(file, "OpenGL extensions (GL_): \n");

  PrintExtensions((char*)glGetString(GL_EXTENSIONS));

#ifndef GLEW_NO_GLU

  /* GLU extensions */

  fprintf(file, "GLU version string: %s\n", gluGetString(GLU_VERSION));

  fprintf(file, "GLU extensions (GLU_): \n");

  PrintExtensions((char*)gluGetString(GLU_EXTENSIONS));

#endif

  /* ---------------------------------------------------------------------- */

  /* extensions string */

#if defined(_WIN32)

  /* WGL extensions */

  if (WGLEW_ARB_extensions_string || WGLEW_EXT_extensions_string)

  {

    fprintf(file, "WGL extensions (WGL_): \n");

    PrintExtensions(wglGetExtensionsStringARB ? 

                    (char*)wglGetExtensionsStringARB(ctx.dc) :

		    (char*)wglGetExtensionsStringEXT());

  }

#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)

#else

  /* GLX extensions */

  fprintf(file, "GLX extensions (GLX_): \n");

  PrintExtensions(glXQueryExtensionsString(glXGetCurrentDisplay(), 

                                           DefaultScreen(glXGetCurrentDisplay())));

#endif

  /* ---------------------------------------------------------------------- */

  /* enumerate all the formats */

  VisualInfo(&ctx);

  /* ---------------------------------------------------------------------- */

  /* release resources */

  DestroyContext(&ctx);

  if (file != stdout)

    fclose(file);

  return 0;

}

/* do the magic to separate all extensions with comma's, except

   for the last one that _may_ terminate in a space. */

void PrintExtensions (const char* s)

{

  char t[80];

  int i=0;

  char* p=0;

  t[79] = '\0';

  while (*s)

  {

    t[i++] = *s;

    if(*s == ' ')

    {

      if (*(s+1) != '\0') {

	t[i-1] = ',';

	t[i] = ' ';

	p = &t[i++];

      }

      else /* zoinks! last one terminated in a space! */

      {

	t[i-1] = '\0';

      }

    }

    if(i > 80 - 5)

    {

      *p = t[i] = '\0';

      fprintf(file, "    %s\n", t);

      p++;

      i = (int)strlen(p);

      strcpy(t, p);

    }

    s++;

  }

  t[i] = '\0';

  fprintf(file, "    %s.\n", t);

}

/* ---------------------------------------------------------------------- */

#if defined(_WIN32)

void

VisualInfoARB (GLContext* ctx)

{

  int attrib[32], value[32], n_attrib, n_pbuffer=0, n_float=0;

  int i, pf, maxpf;

  unsigned int c;

  /* to get pbuffer capable pixel formats */

  attrib[0] = WGL_DRAW_TO_PBUFFER_ARB;

  attrib[1] = GL_TRUE;

  attrib[2] = 0;

  wglChoosePixelFormatARB(ctx->dc, attrib, 0, 1, &pf, &c);

  /* query number of pixel formats */

  attrib[0] = WGL_NUMBER_PIXEL_FORMATS_ARB;

  wglGetPixelFormatAttribivARB(ctx->dc, 0, 0, 1, attrib, value);

  maxpf = value[0];

  for (i=0; i<32; i++)

    value[i] = 0;

  attrib[0] = WGL_SUPPORT_OPENGL_ARB;

  attrib[1] = WGL_DRAW_TO_WINDOW_ARB;

  attrib[2] = WGL_DRAW_TO_BITMAP_ARB;

  attrib[3] = WGL_ACCELERATION_ARB;

  /* WGL_NO_ACCELERATION_ARB, WGL_GENERIC_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB */

  attrib[4] = WGL_SWAP_METHOD_ARB;

  /* WGL_SWAP_EXCHANGE_ARB, WGL_SWAP_COPY_ARB, WGL_SWAP_UNDEFINED_ARB */

  attrib[5] = WGL_DOUBLE_BUFFER_ARB;

  attrib[6] = WGL_STEREO_ARB;

  attrib[7] = WGL_PIXEL_TYPE_ARB;

  /* WGL_TYPE_RGBA_ARB, WGL_TYPE_COLORINDEX_ARB,

     WGL_TYPE_RGBA_FLOAT_ATI (WGL_ATI_pixel_format_float) */

  /* Color buffer information */

  attrib[8] = WGL_COLOR_BITS_ARB;

  attrib[9] = WGL_RED_BITS_ARB;

  attrib[10] = WGL_GREEN_BITS_ARB;

  attrib[11] = WGL_BLUE_BITS_ARB;

  attrib[12] = WGL_ALPHA_BITS_ARB;

  /* Accumulation buffer information */

  attrib[13] = WGL_ACCUM_BITS_ARB;

  attrib[14] = WGL_ACCUM_RED_BITS_ARB;

  attrib[15] = WGL_ACCUM_GREEN_BITS_ARB;

  attrib[16] = WGL_ACCUM_BLUE_BITS_ARB;

  attrib[17] = WGL_ACCUM_ALPHA_BITS_ARB;

  /* Depth, stencil, and aux buffer information */

  attrib[18] = WGL_DEPTH_BITS_ARB;

  attrib[19] = WGL_STENCIL_BITS_ARB;

  attrib[20] = WGL_AUX_BUFFERS_ARB;

  /* Layer information */

  attrib[21] = WGL_NUMBER_OVERLAYS_ARB;

  attrib[22] = WGL_NUMBER_UNDERLAYS_ARB;

  attrib[23] = WGL_SWAP_LAYER_BUFFERS_ARB;

  attrib[24] = WGL_SAMPLES_ARB;

  attrib[25] = WGL_SUPPORT_GDI_ARB;

  n_attrib = 26;

  if (WGLEW_ARB_pbuffer)

  {

    attrib[n_attrib] = WGL_DRAW_TO_PBUFFER_ARB;

    n_pbuffer = n_attrib;

    n_attrib++;

  }

  if (WGLEW_NV_float_buffer)

  {

    attrib[n_attrib] = WGL_FLOAT_COMPONENTS_NV;

    n_float = n_attrib;

    n_attrib++;

  }

  if (!verbose)

  {

    /* print table header */

    fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n");

    fprintf(file, " |     |          visual         |      color      | ax dp st |      accum      |   layer  |\n");

    fprintf(file, " |  id | tp ac gd fm db sw st ms |  sz  r  g  b  a | bf th cl |  sz  r  g  b  a | ov un sw |\n");

    fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n");

    /* loop through all the pixel formats */

    for(i = 1; i <= maxpf; i++)

    {

      wglGetPixelFormatAttribivARB(ctx->dc, i, 0, n_attrib, attrib, value);

      /* only describe this format if it supports OpenGL */

      if (!value[0]) continue;

      /* by default show only fully accelerated window or pbuffer capable visuals */

      if (!showall

	  && ((value[2] && !value[1])

	  || (!WGLEW_ARB_pbuffer || !value[n_pbuffer])

	  || (value[3] != WGL_FULL_ACCELERATION_ARB))) continue;

      /* print out the information for this visual */

      /* visual id */

      fprintf(file, " |% 4d | ", i);

      /* visual type */

      if (value[1])

      {

	if (WGLEW_ARB_pbuffer && value[n_pbuffer]) fprintf(file, "wp ");

	else fprintf(file, "wn ");

      }

      else

      {

	if (value[2]) fprintf(file, "bm ");

	else if (WGLEW_ARB_pbuffer && value[n_pbuffer]) fprintf(file, "pb ");

      }

      /* acceleration */

      fprintf(file, "%s ", value[3] == WGL_FULL_ACCELERATION_ARB ? "fu" : 

	      value[3] == WGL_GENERIC_ACCELERATION_ARB ? "ge" :

	      value[3] == WGL_NO_ACCELERATION_ARB ? "no" : ". ");

      /* gdi support */

      fprintf(file, " %c ", value[25] ? 'y' : '.');

      /* format */

      if (WGLEW_NV_float_buffer && value[n_float]) fprintf(file, " f ");

      else if (WGLEW_ATI_pixel_format_float && value[7] == WGL_TYPE_RGBA_FLOAT_ATI) fprintf(file, " f ");

      else if (value[7] == WGL_TYPE_RGBA_ARB) fprintf(file, " i ");

      else if (value[7] == WGL_TYPE_COLORINDEX_ARB) fprintf(file, " c ");

      else if (value[7] == WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT) fprintf(file," p ");

      else fprintf(file," ? ");

      /* double buffer */

      fprintf(file, " %c ", value[5] ? 'y' : '.');

      /* swap method */

      if (value[4] == WGL_SWAP_EXCHANGE_ARB) fprintf(file, " x ");

      else if (value[4] == WGL_SWAP_COPY_ARB) fprintf(file, " c ");

      else if (value[4] == WGL_SWAP_UNDEFINED_ARB) fprintf(file, " . ");

      else fprintf(file, " . ");

      /* stereo */

      fprintf(file, " %c ", value[6] ? 'y' : '.');

      /* multisample */

      if (value[24] > 0)

	fprintf(file, "%2d | ", value[24]);

      else

	fprintf(file, " . | ");

      /* color size */

      if (value[8]) fprintf(file, "%3d ", value[8]);

      else fprintf(file, "  . ");

      /* red */

      if (value[9]) fprintf(file, "%2d ", value[9]); 

      else fprintf(file, " . ");

      /* green */

      if (value[10]) fprintf(file, "%2d ", value[10]); 

      else fprintf(file, " . ");

      /* blue */

      if (value[11]) fprintf(file, "%2d ", value[11]);

      else fprintf(file, " . ");

      /* alpha */

      if (value[12]) fprintf(file, "%2d | ", value[12]); 

      else fprintf(file, " . | ");

      /* aux buffers */

      if (value[20]) fprintf(file, "%2d ", value[20]);

      else fprintf(file, " . ");

      /* depth */

      if (value[18]) fprintf(file, "%2d ", value[18]);

      else fprintf(file, " . ");

      /* stencil */

      if (value[19]) fprintf(file, "%2d | ", value[19]);

      else fprintf(file, " . | ");

      /* accum size */

      if (value[13]) fprintf(file, "%3d ", value[13]);

      else fprintf(file, "  . ");

      /* accum red */

      if (value[14]) fprintf(file, "%2d ", value[14]);

      else fprintf(file, " . ");

      /* accum green */

      if (value[15]) fprintf(file, "%2d ", value[15]);

      else fprintf(file, " . ");

      /* accum blue */

      if (value[16]) fprintf(file, "%2d ", value[16]);

      else fprintf(file, " . ");

      /* accum alpha */

      if (value[17]) fprintf(file, "%2d | ", value[17]);

      else fprintf(file, " . | ");

      /* overlay */

      if (value[21]) fprintf(file, "%2d ", value[21]);

      else fprintf(file, " . ");

      /* underlay */

      if (value[22]) fprintf(file, "%2d ", value[22]);

      else fprintf(file, " . ");

      /* layer swap */

      if (value[23]) fprintf(file, "y ");

      else fprintf(file, " . ");

      fprintf(file, "|\n");

    }

    /* print table footer */

    fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n");

    fprintf(file, " |     |          visual         |      color      | ax dp st |      accum      |   layer  |\n");

    fprintf(file, " |  id | tp ac gd fm db sw st ms |  sz  r  g  b  a | bf th cl |  sz  r  g  b  a | ov un sw |\n");

    fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n");

  }

  else /* verbose */

  {

#if 0

    fprintf(file, "\n");

    /* loop through all the pixel formats */

    for(i = 1; i <= maxpf; i++)

    {	    

      DescribePixelFormat(ctx->dc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

      /* only describe this format if it supports OpenGL */

      if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL)

	 || (drawableonly && !(pfd.dwFlags & PFD_DRAW_TO_WINDOW))) continue;

      fprintf(file, "Visual ID: %2d  depth=%d  class=%s\n", i, pfd.cDepthBits, 

	     pfd.cColorBits <= 8 ? "PseudoColor" : "TrueColor");

      fprintf(file, "    bufferSize=%d level=%d renderType=%s doubleBuffer=%d stereo=%d\n", pfd.cColorBits, pfd.bReserved, pfd.iPixelType == PFD_TYPE_RGBA ? "rgba" : "ci", pfd.dwFlags & PFD_DOUBLEBUFFER, pfd.dwFlags & PFD_STEREO);

      fprintf(file, "    generic=%d generic accelerated=%d\n", (pfd.dwFlags & PFD_GENERIC_FORMAT) == PFD_GENERIC_FORMAT, (pfd.dwFlags & PFD_GENERIC_ACCELERATED) == PFD_GENERIC_ACCELERATED);

      fprintf(file, "    rgba: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cRedBits, pfd.cGreenBits, pfd.cBlueBits, pfd.cAlphaBits);

      fprintf(file, "    auxBuffers=%d depthSize=%d stencilSize=%d\n", pfd.cAuxBuffers, pfd.cDepthBits, pfd.cStencilBits);

      fprintf(file, "    accum: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cAccumRedBits, pfd.cAccumGreenBits, pfd.cAccumBlueBits, pfd.cAccumAlphaBits);

      fprintf(file, "    multiSample=%d multisampleBuffers=%d\n", 0, 0);

      fprintf(file, "    Opaque.\n");

    }

#endif

  }

}

void

VisualInfoGDI (GLContext* ctx)

{

  int i, maxpf;

  PIXELFORMATDESCRIPTOR pfd;

  /* calling DescribePixelFormat() with NULL pfd (!!!) return maximum

     number of pixel formats */

  maxpf = DescribePixelFormat(ctx->dc, 1, 0, NULL);

  if (!verbose)

  {

    fprintf(file, "-----------------------------------------------------------------------------\n");

    fprintf(file, "   visual   x  bf  lv rg d st ge ge  r  g  b a  ax dp st   accum buffs    ms \n");

    fprintf(file, " id  dep tp sp sz  l  ci b ro ne ac sz sz sz sz bf th cl  sz  r  g  b  a ns b\n");

    fprintf(file, "-----------------------------------------------------------------------------\n");

    /* loop through all the pixel formats */

    for(i = 1; i <= maxpf; i++)

    {

      DescribePixelFormat(ctx->dc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

      /* only describe this format if it supports OpenGL */

      if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL)

	 || (drawableonly && (pfd.dwFlags & PFD_DRAW_TO_BITMAP))) continue;

      /* other criteria could be tested here for actual pixel format

	 choosing in an application:

	 for (...each pixel format...) {

	 if (pfd.dwFlags & PFD_SUPPORT_OPENGL &&

	 pfd.dwFlags & PFD_DOUBLEBUFFER &&

	 pfd.cDepthBits >= 24 &&

	 pfd.cColorBits >= 24)

	 {

	 goto found;

	 }

	 }

	 ... not found so exit ...

	 found:

	 ... found so use it ...

      */

      /* print out the information for this pixel format */

      fprintf(file, "0x%02x ", i);

      fprintf(file, "%3d ", pfd.cColorBits);

      if(pfd.dwFlags & PFD_DRAW_TO_WINDOW) fprintf(file, "wn ");

      else if(pfd.dwFlags & PFD_DRAW_TO_BITMAP) fprintf(file, "bm ");

      else fprintf(file, "pb ");

      /* should find transparent pixel from LAYERPLANEDESCRIPTOR */

      fprintf(file, " . "); 

      fprintf(file, "%3d ", pfd.cColorBits);

      /* bReserved field indicates number of over/underlays */

      if(pfd.bReserved) fprintf(file, " %d ", pfd.bReserved);

      else fprintf(file, " . "); 

      fprintf(file, " %c ", pfd.iPixelType == PFD_TYPE_RGBA ? 'r' : 'c');

      fprintf(file, "%c ", pfd.dwFlags & PFD_DOUBLEBUFFER ? 'y' : '.');

      fprintf(file, " %c ", pfd.dwFlags & PFD_STEREO ? 'y' : '.');

      /* added: */

      fprintf(file, " %c ", pfd.dwFlags & PFD_GENERIC_FORMAT ? 'y' : '.');

      fprintf(file, " %c ", pfd.dwFlags & PFD_GENERIC_ACCELERATED ? 'y' : '.');

      if(pfd.cRedBits && pfd.iPixelType == PFD_TYPE_RGBA) 

	fprintf(file, "%2d ", pfd.cRedBits);

      else fprintf(file, " . ");

      if(pfd.cGreenBits && pfd.iPixelType == PFD_TYPE_RGBA) 

	fprintf(file, "%2d ", pfd.cGreenBits);

      else fprintf(file, " . ");

      if(pfd.cBlueBits && pfd.iPixelType == PFD_TYPE_RGBA) 

	fprintf(file, "%2d ", pfd.cBlueBits);

      else fprintf(file, " . ");

      if(pfd.cAlphaBits && pfd.iPixelType == PFD_TYPE_RGBA) 

	fprintf(file, "%2d ", pfd.cAlphaBits);

      else fprintf(file, " . ");

      if(pfd.cAuxBuffers)     fprintf(file, "%2d ", pfd.cAuxBuffers);

      else fprintf(file, " . ");

      if(pfd.cDepthBits)      fprintf(file, "%2d ", pfd.cDepthBits);

      else fprintf(file, " . ");

      if(pfd.cStencilBits)    fprintf(file, "%2d ", pfd.cStencilBits);

      else fprintf(file, " . ");

      if(pfd.cAccumBits)   fprintf(file, "%3d ", pfd.cAccumBits);

      else fprintf(file, "  . ");

      if(pfd.cAccumRedBits)   fprintf(file, "%2d ", pfd.cAccumRedBits);

      else fprintf(file, " . ");

      if(pfd.cAccumGreenBits) fprintf(file, "%2d ", pfd.cAccumGreenBits);

      else fprintf(file, " . ");

      if(pfd.cAccumBlueBits)  fprintf(file, "%2d ", pfd.cAccumBlueBits);

      else fprintf(file, " . ");

      if(pfd.cAccumAlphaBits) fprintf(file, "%2d ", pfd.cAccumAlphaBits);

      else fprintf(file, " . ");

      /* no multisample in win32 */

      fprintf(file, " . .\n");

    }

    /* print table footer */

    fprintf(file, "-----------------------------------------------------------------------------\n");

    fprintf(file, "   visual   x  bf  lv rg d st ge ge  r  g  b a  ax dp st   accum buffs    ms \n");

    fprintf(file, " id  dep tp sp sz  l  ci b ro ne ac sz sz sz sz bf th cl  sz  r  g  b  a ns b\n");

    fprintf(file, "-----------------------------------------------------------------------------\n");

  }

  else /* verbose */

  {

    fprintf(file, "\n");

    /* loop through all the pixel formats */

    for(i = 1; i <= maxpf; i++)

    {	    

      DescribePixelFormat(ctx->dc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

      /* only describe this format if it supports OpenGL */

      if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL)

	 || (drawableonly && !(pfd.dwFlags & PFD_DRAW_TO_WINDOW))) continue;

      fprintf(file, "Visual ID: %2d  depth=%d  class=%s\n", i, pfd.cDepthBits, 

	     pfd.cColorBits <= 8 ? "PseudoColor" : "TrueColor");

      fprintf(file, "    bufferSize=%d level=%d renderType=%s doubleBuffer=%ld stereo=%ld\n", pfd.cColorBits, pfd.bReserved, pfd.iPixelType == PFD_TYPE_RGBA ? "rgba" : "ci", pfd.dwFlags & PFD_DOUBLEBUFFER, pfd.dwFlags & PFD_STEREO);

      fprintf(file, "    generic=%d generic accelerated=%d\n", (pfd.dwFlags & PFD_GENERIC_FORMAT) == PFD_GENERIC_FORMAT, (pfd.dwFlags & PFD_GENERIC_ACCELERATED) == PFD_GENERIC_ACCELERATED);

      fprintf(file, "    rgba: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cRedBits, pfd.cGreenBits, pfd.cBlueBits, pfd.cAlphaBits);

      fprintf(file, "    auxBuffers=%d depthSize=%d stencilSize=%d\n", pfd.cAuxBuffers, pfd.cDepthBits, pfd.cStencilBits);

      fprintf(file, "    accum: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cAccumRedBits, pfd.cAccumGreenBits, pfd.cAccumBlueBits, pfd.cAccumAlphaBits);

      fprintf(file, "    multiSample=%d multisampleBuffers=%d\n", 0, 0);

      fprintf(file, "    Opaque.\n");

    }

  }

}

void

VisualInfo (GLContext* ctx)

{

  if (WGLEW_ARB_pixel_format)

    VisualInfoARB(ctx);

  else

    VisualInfoGDI(ctx);

}

/* ---------------------------------------------------------------------- */

#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)

void

VisualInfo (GLContext* ctx)

{

/*

  int attrib[] = { AGL_RGBA, AGL_NONE };

  AGLPixelFormat pf;

  GLint value;

  pf = aglChoosePixelFormat(NULL, 0, attrib);

  while (pf != NULL)

  {

    aglDescribePixelFormat(pf, GL_RGBA, &value);

    fprintf(stderr, "%d\n", value);

    pf = aglNextPixelFormat(pf);

  }

*/

}

#else /* GLX */

void

VisualInfo (GLContext* ctx)

{

  int n_fbc;

  GLXFBConfig* fbc;

  int value, ret, i;

  fbc = glXGetFBConfigs(ctx->dpy, DefaultScreen(ctx->dpy), &n_fbc);

  if (fbc)

  {

    if (!verbose)

    {

      /* print table header */

      fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");

      fprintf(file, " |     |        visual           |      color      | ax dp st |    accum    |   ms  |  cav |\n");

      fprintf(file, " |  id | tp xr cl fm db st lv xp |  sz  r  g  b  a | bf th cl | r  g  b  a  | ns  b |  eat |\n");

      fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");

      /* loop through all the fbcs */

      for (i=0; i

      {

        /* print out the information for this fbc */

        /* visual id */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_FBCONFIG_ID, &value);

        if (ret != Success)

        {

          fprintf(file, "|  ?  |");

        }

        else

        {

          fprintf(file, " |% 4d | ", value);

        }

        /* visual type */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_DRAWABLE_TYPE, &value);

        if (ret != Success)

        {

          fprintf(file, " ? ");

        }

        else

        {

          if (value & GLX_WINDOW_BIT)

          {

            if (value & GLX_PBUFFER_BIT)

            {

              fprintf(file, "wp ");

            }

            else

            {

              fprintf(file, "wn ");

            }

          }

          else

          {

            if (value & GLX_PBUFFER_BIT)

            {

              fprintf(file, "pb ");

            }

            else if (value & GLX_PIXMAP_BIT)

            {

              fprintf(file, "pm ");

            }

            else

            {

              fprintf(file, " ? ");

            }

          }

        }

        /* x renderable */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_X_RENDERABLE, &value);

        if (ret != Success)

        {

          fprintf(file, " ? ");

        }

        else

        {

          fprintf(file, value ? " y " : " n ");

        }

        /* class */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_X_VISUAL_TYPE, &value);

        if (ret != Success)

        {

          fprintf(file, " ? ");

        }

        else

        {

          if (GLX_TRUE_COLOR == value)

            fprintf(file, "tc ");

          else if (GLX_DIRECT_COLOR == value)

            fprintf(file, "dc ");

          else if (GLX_PSEUDO_COLOR == value)

            fprintf(file, "pc ");

          else if (GLX_STATIC_COLOR == value)

            fprintf(file, "sc ");

          else if (GLX_GRAY_SCALE == value)

            fprintf(file, "gs ");

          else if (GLX_STATIC_GRAY == value)

            fprintf(file, "sg ");

          else if (GLX_X_VISUAL_TYPE == value)

            fprintf(file, " . ");

          else

            fprintf(file, " ? ");

        }

        /* format */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_RENDER_TYPE, &value);

        if (ret != Success)

        {

          fprintf(file, " ? ");

        }

        else

        {

          if (GLXEW_NV_float_buffer)

          {

            int ret2, value2;

            ret2 = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_FLOAT_COMPONENTS_NV, &value2);

            if (Success == ret2 && GL_TRUE == value2)

            {

              fprintf(file, " f ");

            }

            else if (value & GLX_RGBA_BIT)

              fprintf(file, " i ");

            else if (value & GLX_COLOR_INDEX_BIT)

              fprintf(file, " c ");

            else

              fprintf(file, " ? ");

          }

          else

          {

            if (value & GLX_RGBA_FLOAT_ATI_BIT)

              fprintf(file, " f ");

            else if (value & GLX_RGBA_BIT)

              fprintf(file, " i ");

            else if (value & GLX_COLOR_INDEX_BIT)

              fprintf(file, " c ");

            else

              fprintf(file, " ? ");

          }

        }

        /* double buffer */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_DOUBLEBUFFER, &value);

        fprintf(file, " %c ", Success != ret ? '?' : (value ? 'y' : '.'));

        /* stereo */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_STEREO, &value);

        fprintf(file, " %c ", Success != ret ? '?' : (value ? 'y' : '.'));

        /* level */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_LEVEL, &value);

        if (Success != ret)

        {

          fprintf(file, " ? ");

        }

        else

        {

          fprintf(file, "%2d ", value);

        }

        /* transparency */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_TRANSPARENT_TYPE, &value);

        if (Success != ret)

        {

          fprintf(file, " ? | ");

        }

        else

        {

          if (GLX_TRANSPARENT_RGB == value)

            fprintf(file, " r | ");

          else if (GLX_TRANSPARENT_INDEX == value)

            fprintf(file, " i | ");

          else if (GLX_NONE == value)

            fprintf(file, " . | ");

          else

            fprintf(file, " ? | ");

        }

        /* color size */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_BUFFER_SIZE, &value);

        if (Success != ret)

        {

          fprintf(file, "  ? ");

        }

        else

        {

          if (value)

            fprintf(file, "%3d ", value);

          else

            fprintf(file, "  . ");

        }

        /* red size */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_RED_SIZE, &value);

        if (Success != ret)

        {

          fprintf(file, " ? ");

        }

        else

        {

          if (value)

            fprintf(file, "%2d ", value);

          else

            fprintf(file, " . ");

        }

        /* green size */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_GREEN_SIZE, &value);

        if (Success != ret)

        {

          fprintf(file, " ? ");

        }

        else

        {

          if (value)

            fprintf(file, "%2d ", value);

          else

            fprintf(file, " . ");

        }

        /* blue size */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_BLUE_SIZE, &value);

        if (Success != ret)

        {

          fprintf(file, " ? ");

        }

        else

        {

          if (value)

            fprintf(file, "%2d ", value);

          else

            fprintf(file, " . ");

        }

        /* alpha size */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ALPHA_SIZE, &value);

        if (Success != ret)

        {

          fprintf(file, " ? | ");

        }

        else

        {

          if (value)

            fprintf(file, "%2d | ", value);

          else

            fprintf(file, " . | ");

        }

        /* aux buffers */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_AUX_BUFFERS, &value);

        if (Success != ret)

        {

          fprintf(file, " ? ");

        }

        else

        {

          if (value)

            fprintf(file, "%2d ", value);

          else

            fprintf(file, " . ");

        }

        /* depth size */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_DEPTH_SIZE, &value);

        if (Success != ret)

        {

          fprintf(file, " ? ");

        }

        else

        {

          if (value)

            fprintf(file, "%2d ", value);

          else

            fprintf(file, " . ");

        }

        /* stencil size */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_STENCIL_SIZE, &value);

        if (Success != ret)

        {

          fprintf(file, " ? | ");

        }

        else

        {

          if (value)

            fprintf(file, "%2d | ", value);

          else

            fprintf(file, " . | ");

        }

        /* accum red size */

        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_RED_SIZE, &value);