text: /*
  ** visualinfo.c
  **
  ** Copyright (C) Nate Robins, 1997
  **               Michael Wimmer, 1999
  **               Milan Ikits, 2002-2008
  **               Nigel Stewart, 2008-2013
  **
  ** 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>
  #include <stdlib.h>
  #include <string.h>
  #include <GL/glew.h>
  #if defined(GLEW_OSMESA)
  #define GLAPI extern
  #include <GL/osmesa.h>
  #elif defined(GLEW_EGL)
  #include <GL/eglew.h>
  #elif defined(_WIN32)
  #include <GL/wglew.h>
  #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
  #include <OpenGL/OpenGL.h>
  #include <OpenGL/CGLTypes.h>
  #elif !defined(__HAIKU__)
  #include <GL/glxew.h>
  #endif
  
  #ifdef GLEW_MX
  GLEWContext _glewctx;
  #  define glewGetContext() (&_glewctx)
  #  ifdef _WIN32
  WGLEWContext _wglewctx;
  #    define wglewGetContext() (&_wglewctx)
  #  elif !defined(__APPLE__) && !defined(__HAIKU__) || defined(GLEW_APPLE_GLX)
  GLXEWContext _glxewctx;
  #    define glxewGetContext() (&_glxewctx)
  #  endif
  #endif /* GLEW_MX */
  
  typedef struct GLContextStruct
  {
  #if defined(GLEW_OSMESA)
    OSMesaContext ctx;
  #elif defined(GLEW_EGL)
    EGLContext ctx;
  #elif defined(_WIN32)
    HWND wnd;
    HDC dc;
    HGLRC rc;
  #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
    CGLContextObj ctx, octx;
  #elif !defined(__HAIKU__)
    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");
      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");
      fprintf(stderr, "        -h: this screen\n");
  #else
      fprintf(stderr, "Usage: visualinfo [-h] [-display <display>] [-visual <id>]\n");
      fprintf(stderr, "        -h: this screen\n");
      fprintf(stderr, "        -display <display>: use given display\n");
      fprintf(stderr, "        -visual <id>: use given visual\n");
  #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(__HAIKU__) || 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)
    {
  #if defined(_MSC_VER) && (_MSC_VER >= 1400)
      if (fopen_s(&file, "visualinfo.txt", "w") != 0)
        file = stdout;
  #else
      file = fopen("visualinfo.txt", "w");
  #endif
    }
    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((const 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((const char*)gluGetString(GLU_EXTENSIONS));
  #endif
  
    /* ---------------------------------------------------------------------- */
    /* extensions string */
  #if defined(GLEW_OSMESA)
  #elif defined(GLEW_EGL)
  #elif defined(_WIN32)
    /* WGL extensions */
    if (WGLEW_ARB_extensions_string || WGLEW_EXT_extensions_string)
    {
      fprintf(file, "WGL extensions (WGL_): \n");
      PrintExtensions(wglGetExtensionsStringARB ? 
                      (const char*)wglGetExtensionsStringARB(ctx.dc) :
  		    (const char*)wglGetExtensionsStringEXT());
    }
  #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
    
  #elif defined(__HAIKU__)
  
    /* TODO */
  
  #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);
  #if defined(_MSC_VER) && (_MSC_VER >= 1400)
        strcpy_s(t, sizeof(t), p);
  #else
        strcpy(t, p);
  #endif
      }
      s++;
    }
    t[i] = '\0';
    fprintf(file, "    %s.\n", t);
  }
  
  /* ---------------------------------------------------------------------- */
  
  #if defined(GLEW_OSMESA) || defined(GLEW_EGL)
  
  void
  VisualInfo (GLContext* ctx)
  {
  }
  
  #elif 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 (__attribute__((unused)) 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);
    }
  */
  }
  
  /* ---------------------------------------------------------------------- */
  
  #elif defined(__HAIKU__)
  
  void
  VisualInfo (GLContext* ctx)
  {
    /* TODO */
  }
  
  #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<n_fbc; 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);
          if (Success != ret)
          {
            fprintf(file, " ? ");
          }
          else
          {
            if (value)
              fprintf(file, "%2d ", value);
            else
              fprintf(file, " . ");
          }
          /* accum green size */
          ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_GREEN_SIZE, &value);
          if (Success != ret)
          {
            fprintf(file, " ? ");
          }
          else
          {
            if (value)
              fprintf(file, "%2d ", value);
            else
              fprintf(file, " . ");
          }
          /* accum blue size */
          ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_BLUE_SIZE, &value);
          if (Success != ret)
          {
            fprintf(file, " ? ");
          }
          else
          {
            if (value)
              fprintf(file, "%2d ", value);
            else
              fprintf(file, " . ");
          }
          /* accum alpha size */
          ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_ALPHA_SIZE, &value);
          if (Success != ret)
          {
            fprintf(file, " ? | ");
          }
          else
          {
            if (value)
              fprintf(file, "%2d | ", value);
            else
              fprintf(file, " . | ");
          }
          /* multisample */
          ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_SAMPLES, &value);
          if (Success != ret)
          {
            fprintf(file, " ? ");
          }
          else
          {
            fprintf(file, "%2d ", value);
          }
          ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_SAMPLE_BUFFERS, &value);
          if (Success != ret)
          {
            fprintf(file, " ? | ");
          }
          else
          {
            fprintf(file, "%2d | ", value);
          }
          /* caveat */
          ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_CONFIG_CAVEAT, &value);
          if (Success != ret)
          {
            fprintf(file, "???? |");
          }
          else
          {
            if (GLX_NONE == value)
              fprintf(file, "none |\n");
            else if (GLX_SLOW_CONFIG == value)
              fprintf(file, "slow |\n");
            else if (GLX_NON_CONFORMANT_CONFIG == value)
              fprintf(file, "ncft |\n");
            else
              fprintf(file, "???? |\n");
          }
        }
        /* print table footer */
        fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\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, " |     |        visual           |      color      | ax dp st |    accum    |   ms  |  cav |\n");
        fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");
      }
    }
  }
  
  #endif
  
  /* ------------------------------------------------------------------------ */
  
  #if defined(GLEW_OSMESA)
  void InitContext (GLContext* ctx)
  {
    ctx->ctx = NULL;
  }
  
  static const GLint osmFormat = GL_UNSIGNED_BYTE;
  static const GLint osmWidth = 640;
  static const GLint osmHeight = 480;
  static GLubyte *osmPixels = NULL;
  
  GLboolean CreateContext (GLContext* ctx)
  {
    if (NULL == ctx) return GL_TRUE;
    ctx->ctx = OSMesaCreateContext(OSMESA_RGBA, NULL);
    if (NULL == ctx->ctx) return GL_TRUE;
    if (NULL == osmPixels)
    {
      osmPixels = (GLubyte *) calloc(osmWidth*osmHeight*4, 1);
    }
    if (!OSMesaMakeCurrent(ctx->ctx, osmPixels, GL_UNSIGNED_BYTE, osmWidth, osmHeight))
    {
        return GL_TRUE;
    }
    return GL_FALSE;
  }
  
  void DestroyContext (GLContext* ctx)
  {
    if (NULL == ctx) return;
    if (NULL != ctx->ctx) OSMesaDestroyContext(ctx->ctx);
  }
  /* ------------------------------------------------------------------------ */
  
  #elif defined(GLEW_EGL)
  void InitContext (GLContext* ctx)
  {
    ctx->ctx = NULL;
  }
  
  GLboolean CreateContext (GLContext* ctx)
  {
    return GL_FALSE;
  }
  
  void DestroyContext (GLContext* ctx)
  {
    if (NULL == ctx) return;
    return;
  }
  
  /* ------------------------------------------------------------------------ */
  
  #elif defined(_WIN32)
  
  void InitContext (GLContext* ctx)
  {
    ctx->wnd = NULL;
    ctx->dc = NULL;
    ctx->rc = NULL;
  }
  
  GLboolean CreateContext (GLContext* ctx)
  {
    WNDCLASS wc;
    PIXELFORMATDESCRIPTOR pfd;
    /* check for input */
    if (NULL == ctx) return GL_TRUE;
    /* register window class */
    ZeroMemory(&wc, sizeof(WNDCLASS));
    wc.hInstance = GetModuleHandle(NULL);
    wc.lpfnWndProc = DefWindowProc;
    wc.lpszClassName = "GLEW";
    if (0 == RegisterClass(&wc)) return GL_TRUE;
    /* create window */
    ctx->wnd = CreateWindow("GLEW", "GLEW", 0, CW_USEDEFAULT, CW_USEDEFAULT, 
                            CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, 
                            GetModuleHandle(NULL), NULL);
    if (NULL == ctx->wnd) return GL_TRUE;
    /* get the device context */
    ctx->dc = GetDC(ctx->wnd);
    if (NULL == ctx->dc) return GL_TRUE;
    /* find pixel format */
    ZeroMemory(&pfd, sizeof(PIXELFORMATDESCRIPTOR));
    if (visual == -1) /* find default */
    {
      pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
      pfd.nVersion = 1;
      pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
      visual = ChoosePixelFormat(ctx->dc, &pfd);
      if (0 == visual) return GL_TRUE;
    }
    /* set the pixel format for the dc */
    if (FALSE == SetPixelFormat(ctx->dc, visual, &pfd)) return GL_TRUE;
    /* create rendering context */
    ctx->rc = wglCreateContext(ctx->dc);
    if (NULL == ctx->rc) return GL_TRUE;
    if (FALSE == wglMakeCurrent(ctx->dc, ctx->rc)) return GL_TRUE;
    return GL_FALSE;
  }
  
  void DestroyContext (GLContext* ctx)
  {
    if (NULL == ctx) return;
    if (NULL != ctx->rc) wglMakeCurrent(NULL, NULL);
    if (NULL != ctx->rc) wglDeleteContext(wglGetCurrentContext());
    if (NULL != ctx->wnd && NULL != ctx->dc) ReleaseDC(ctx->wnd, ctx->dc);
    if (NULL != ctx->wnd) DestroyWindow(ctx->wnd);
    UnregisterClass("GLEW", GetModuleHandle(NULL));
  }
  
  /* ------------------------------------------------------------------------ */
  
  #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
  
  void InitContext (GLContext* ctx)
  {
    ctx->ctx = NULL;
    ctx->octx = NULL;
  }
  
  GLboolean CreateContext (GLContext* ctx)
  {
    CGLPixelFormatAttribute attrib[] = { kCGLPFAAccelerated, 0 };
    CGLPixelFormatObj pf;
    GLint npix;
    CGLError error;
    /* check input */
    if (NULL == ctx) return GL_TRUE;
    error = CGLChoosePixelFormat(attrib, &pf, &npix);
    if (error) return GL_TRUE;
    error = CGLCreateContext(pf, NULL, &ctx->ctx);
    if (error) return GL_TRUE;
    CGLReleasePixelFormat(pf);
    ctx->octx = CGLGetCurrentContext();
    error = CGLSetCurrentContext(ctx->ctx);
    if (error) return GL_TRUE;
    return GL_FALSE;
  }
  
  void DestroyContext (GLContext* ctx)
  {
    if (NULL == ctx) return;
    CGLSetCurrentContext(ctx->octx);
    if (NULL != ctx->ctx) CGLReleaseContext(ctx->ctx);
  }
  
  /* ------------------------------------------------------------------------ */
  
  #elif defined(__HAIKU__)
  
  void
  InitContext (GLContext* ctx)
  {
    /* TODO */
  }
  
  GLboolean
  CreateContext (GLContext* ctx)
  {
    /* TODO */
    return GL_FALSE;
  }
  
  void
  DestroyContext (GLContext* ctx)
  {
    /* TODO */
  }
  
  /* ------------------------------------------------------------------------ */
  
  #else /* __UNIX || (__APPLE__ && GLEW_APPLE_GLX) */
  
  void InitContext (GLContext* ctx)
  {
    ctx->dpy = NULL;
    ctx->vi = NULL;
    ctx->ctx = NULL;
    ctx->wnd = 0;
    ctx->cmap = 0;
  }
  
  GLboolean CreateContext (GLContext* ctx)
  {
    int attrib[] = { GLX_RGBA, GLX_DOUBLEBUFFER, None };
    int erb, evb;
    XSetWindowAttributes swa;
    /* check input */
    if (NULL == ctx) return GL_TRUE;
    /* open display */
    ctx->dpy = XOpenDisplay(display);
    if (NULL == ctx->dpy) return GL_TRUE;
    /* query for glx */
    if (!glXQueryExtension(ctx->dpy, &erb, &evb)) return GL_TRUE;
    /* choose visual */
    ctx->vi = glXChooseVisual(ctx->dpy, DefaultScreen(ctx->dpy), attrib);
    if (NULL == ctx->vi) return GL_TRUE;
    /* create context */
    ctx->ctx = glXCreateContext(ctx->dpy, ctx->vi, None, True);
    if (NULL == ctx->ctx) return GL_TRUE;
    /* create window */
    /*wnd = XCreateSimpleWindow(dpy, RootWindow(dpy, vi->screen), 0, 0, 1, 1, 1, 0, 0);*/
    ctx->cmap = XCreateColormap(ctx->dpy, RootWindow(ctx->dpy, ctx->vi->screen),
                                ctx->vi->visual, AllocNone);
    swa.border_pixel = 0;
    swa.colormap = ctx->cmap;
    ctx->wnd = XCreateWindow(ctx->dpy, RootWindow(ctx->dpy, ctx->vi->screen), 
                             0, 0, 1, 1, 0, ctx->vi->depth, InputOutput, ctx->vi->visual, 
                             CWBorderPixel | CWColormap, &swa);
    /* make context current */
    if (!glXMakeCurrent(ctx->dpy, ctx->wnd, ctx->ctx)) return GL_TRUE;
    return GL_FALSE;
  }
  
  void DestroyContext (GLContext* ctx)
  {
    if (NULL != ctx->dpy && NULL != ctx->ctx) glXDestroyContext(ctx->dpy, ctx->ctx);
    if (NULL != ctx->dpy && 0 != ctx->wnd) XDestroyWindow(ctx->dpy, ctx->wnd);
    if (NULL != ctx->dpy && 0 != ctx->cmap) XFreeColormap(ctx->dpy, ctx->cmap);
    if (NULL != ctx->vi) XFree(ctx->vi);
    if (NULL != ctx->dpy) XCloseDisplay(ctx->dpy);
  }
  
  #endif /* __UNIX || (__APPLE__ && GLEW_APPLE_GLX) */
  
  GLboolean ParseArgs (int argc, char** argv)
  {
    int p = 0;
    while (p < argc)
    {
  #if defined(_WIN32)
      if (!strcmp(argv[p], "-pf") || !strcmp(argv[p], "-pixelformat"))
      {
        if (++p >= argc) return GL_TRUE;
        display = NULL;
        visual = strtol(argv[p], NULL, 0);
      }
      else if (!strcmp(argv[p], "-a"))
      {
        showall = 1;
      }
      else if (!strcmp(argv[p], "-s"))
      {
        displaystdout = 1;
      }
      else if (!strcmp(argv[p], "-h"))
      {
        return GL_TRUE;
      }
      else
        return GL_TRUE;
  #else
      if (!strcmp(argv[p], "-display"))
      {
        if (++p >= argc) return GL_TRUE;
        display = argv[p];
      }
      else if (!strcmp(argv[p], "-visual"))
      {
        if (++p >= argc) return GL_TRUE;
        visual = (int)strtol(argv[p], NULL, 0);
      }
      else if (!strcmp(argv[p], "-h"))
      {
        return GL_TRUE;
      }
      else
        return GL_TRUE;
  #endif
      p++;
    }
    return GL_FALSE;
  }
  