git.mutantstargoat.com Git - freeglut/blob - src/freeglut_init.c

   1 /*
   2  * freeglut_init.c
   3  *
   4  * Various freeglut initialization functions.
   5  *
   6  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
   7  * Written by Pawel W. Olszta, <olszta@sourceforge.net>
   8  * Creation date: Thu Dec 2 1999
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a
  11  * copy of this software and associated documentation files (the "Software"),
  12  * to deal in the Software without restriction, including without limitation
  13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  14  * and/or sell copies of the Software, and to permit persons to whom the
  15  * Software is furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included
  18  * in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  24  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  25  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #include "../include/GL/freeglut.h"
  33 #include "freeglut_internal.h"
  34
  35 /*
  36  * TODO BEFORE THE STABLE RELEASE:
  37  *
  38  *  fgDeinitialize()        -- Win32's OK, X11 needs the OS-specific
  39  *                             deinitialization done
  40  *  glutInitDisplayString() -- display mode string parsing
  41  *
  42  * Wouldn't it be cool to use gettext() for error messages? I just love
  43  * bash saying  "nie znaleziono pliku" instead of "file not found" :)
  44  * Is gettext easily portable?
  45  */
  46
  47 /* -- GLOBAL VARIABLES ----------------------------------------------------- */
  48
  49 /*
  50  * A structure pointed by g_pDisplay holds all information
  51  * regarding the display, screen, root window etc.
  52  */
  53 SFG_Display fgDisplay;
  54
  55 /*
  56  * The settings for the current freeglut session
  57  */
  58 SFG_State fgState = { { -1, -1, GL_FALSE },  /* Position */
  59                       { 300, 300, GL_TRUE }, /* Size */
  60                       GLUT_RGBA | GLUT_SINGLE | GLUT_DEPTH,  /* DisplayMode */
  61                       GL_FALSE,              /* Initialised */
  62                       GL_FALSE,              /* ForceDirectContext */
  63                       GL_TRUE,               /* TryDirectContext */
  64                       GL_FALSE,              /* ForceIconic */
  65                       GL_FALSE,              /* UseCurrentContext */
  66                       GL_FALSE,              /* GLDebugSwitch */
  67                       GL_FALSE,              /* XSyncSwitch */
  68                       GL_TRUE,               /* IgnoreKeyRepeat */
  69                       0xffffffff,            /* Modifiers */
  70                       0,                     /* FPSInterval */
  71                       0,                     /* SwapCount */
  72                       0,                     /* SwapTime */
  73 #if TARGET_HOST_WIN32
  74                       { 0, GL_FALSE },       /* Time */
  75 #else
  76                       { { 0, 0 }, GL_FALSE },
  77 #endif
  78                       { NULL, NULL },         /* Timers */
  79                       NULL,                   /* IdleCallback */
  80                       0,                      /* ActiveMenus */
  81                       NULL,                   /* MenuStateCallback */
  82                       NULL,                   /* MenuStatusCallback */
  83                       { 640, 480, GL_TRUE },  /* GameModeSize */
  84                       16,                     /* GameModeDepth */
  85                       72,                     /* GameModeRefresh */
  86                       GLUT_ACTION_EXIT,       /* ActionOnWindowClose */
  87                       GLUT_EXEC_STATE_INIT,   /* ExecState */
  88                       NULL                    /* ProgramName */
  89 };
  90
  91
  92 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
  93
  94 /*
  95  * A call to this function should initialize all the display stuff...
  96  */
  97 void fgInitialize( const char* displayName )
  98 {
  99 #if TARGET_HOST_UNIX_X11
 100     fgDisplay.Display = XOpenDisplay( displayName );
 101
 102     if( fgDisplay.Display == NULL )
 103         fgError( "failed to open display '%s'", XDisplayName( displayName ) );
 104
 105     if( !glXQueryExtension( fgDisplay.Display, NULL, NULL ) )
 106         fgError( "OpenGL GLX extension not supported by display '%s'",
 107             XDisplayName( displayName ) );
 108
 109     fgDisplay.Screen = DefaultScreen( fgDisplay.Display );
 110     fgDisplay.RootWindow = RootWindow(
 111         fgDisplay.Display,
 112         fgDisplay.Screen
 113     );
 114
 115     fgDisplay.ScreenWidth  = DisplayWidth(
 116         fgDisplay.Display,
 117         fgDisplay.Screen
 118     );
 119     fgDisplay.ScreenHeight = DisplayHeight(
 120         fgDisplay.Display,
 121         fgDisplay.Screen
 122     );
 123
 124     fgDisplay.ScreenWidthMM = DisplayWidthMM(
 125         fgDisplay.Display,
 126         fgDisplay.Screen
 127     );
 128     fgDisplay.ScreenHeightMM = DisplayHeightMM(
 129         fgDisplay.Display,
 130         fgDisplay.Screen
 131     );
 132
 133     fgDisplay.Connection = ConnectionNumber( fgDisplay.Display );
 134
 135     /*
 136      * Create the window deletion atom
 137      */
 138     fgDisplay.DeleteWindow = XInternAtom(
 139         fgDisplay.Display,
 140         "WM_DELETE_WINDOW",
 141         FALSE
 142     );
 143
 144 #elif TARGET_HOST_WIN32
 145
 146     WNDCLASS wc;
 147     ATOM atom;
 148
 149     /*
 150      * What we need to do is to initialize the fgDisplay global structure here...
 151      */
 152     fgDisplay.Instance = GetModuleHandle( NULL );
 153
 154     atom = GetClassInfo( fgDisplay.Instance, "FREEGLUT", &wc );
 155     if( atom == 0 )
 156     {
 157         ZeroMemory( &wc, sizeof(WNDCLASS) );
 158
 159         /*
 160          * Each of the windows should have its own device context...
 161          */
 162         wc.style          = CS_OWNDC /* | CS_DBLCLKS */;
 163         wc.lpfnWndProc    = fgWindowProc;
 164         wc.cbClsExtra     = 0;
 165         wc.cbWndExtra     = 0;
 166         wc.hInstance      = fgDisplay.Instance;
 167         wc.hIcon          = LoadIcon( fgDisplay.Instance, "GLUT_ICON" );
 168         if (!wc.hIcon)
 169           wc.hIcon        = LoadIcon( NULL, IDI_WINLOGO );
 170
 171         wc.hCursor        = LoadCursor( NULL, IDC_ARROW );
 172         wc.hbrBackground  = NULL;
 173         wc.lpszMenuName   = NULL;
 174         wc.lpszClassName  = "FREEGLUT";
 175
 176         /*
 177          * Register the window class
 178          */
 179         atom = RegisterClass( &wc );
 180         assert( atom );
 181     }
 182
 183     /*
 184      * The screen dimensions can be obtained via GetSystemMetrics() calls
 185      */
 186     fgDisplay.ScreenWidth  = GetSystemMetrics( SM_CXSCREEN );
 187     fgDisplay.ScreenHeight = GetSystemMetrics( SM_CYSCREEN );
 188
 189     {
 190         HWND desktop = GetDesktopWindow( );
 191         HDC  context = GetDC( desktop );
 192
 193         fgDisplay.ScreenWidthMM  = GetDeviceCaps( context, HORZSIZE );
 194         fgDisplay.ScreenHeightMM = GetDeviceCaps( context, VERTSIZE );
 195
 196         ReleaseDC( desktop, context );
 197     }
 198
 199 #endif
 200
 201     fgJoystickInit( 0 );
 202
 203     fgState.Initialised = GL_TRUE;
 204 }
 205
 206 /*
 207  * Perform the freeglut deinitialization...
 208  */
 209 void fgDeinitialize( void )
 210 {
 211     SFG_Timer *timer;
 212
 213     if( !fgState.Initialised )
 214     {
 215         fgWarning( "fgDeinitialize(): "
 216                    "no valid initialization has been performed" );
 217         return;
 218     }
 219
 220     /* fgState.Initialised = GL_FALSE; */
 221
 222     /*
 223      * If there was a menu created, destroy the rendering context
 224      */
 225     if( fgStructure.MenuContext )
 226     {
 227         free( fgStructure.MenuContext );
 228         fgStructure.MenuContext = NULL;
 229     }
 230
 231     fgDestroyStructure( );
 232
 233     while( (timer = ( SFG_Timer * )fgState.Timers.First) )
 234     {
 235         fgListRemove ( &fgState.Timers, &timer->Node );
 236         free( timer );
 237     }
 238
 239     fgJoystickClose( );
 240
 241     fgState.Initialised = GL_FALSE;
 242
 243     fgState.Position.X = -1;
 244     fgState.Position.Y = -1;
 245     fgState.Position.Use = GL_FALSE;
 246
 247     fgState.Size.X = 300;
 248     fgState.Size.Y = 300;
 249     fgState.Size.Use = GL_TRUE;
 250
 251     fgState.DisplayMode = GLUT_RGBA | GLUT_SINGLE | GLUT_DEPTH;
 252
 253     fgState.ForceDirectContext  = GL_FALSE;
 254     fgState.TryDirectContext    = GL_TRUE;
 255     fgState.ForceIconic         = GL_FALSE;
 256     fgState.UseCurrentContext   = GL_FALSE;
 257     fgState.GLDebugSwitch       = GL_FALSE;
 258     fgState.XSyncSwitch         = GL_FALSE;
 259     fgState.ActionOnWindowClose = GLUT_ACTION_EXIT;
 260     fgState.ExecState           = GLUT_EXEC_STATE_INIT;
 261
 262     fgState.IgnoreKeyRepeat = GL_TRUE;
 263     fgState.Modifiers       = 0xffffffff;
 264
 265     fgState.GameModeSize.X  = 640;
 266     fgState.GameModeSize.Y  = 480;
 267     fgState.GameModeDepth   =  16;
 268     fgState.GameModeRefresh =  72;
 269
 270     fgState.Time.Set = GL_FALSE;
 271
 272     fgState.Timers.First = fgState.Timers.Last = NULL;
 273     fgState.IdleCallback = NULL;
 274     fgState.MenuStateCallback = ( FGCBMenuState )NULL;
 275     fgState.MenuStatusCallback = ( FGCBMenuStatus )NULL;
 276
 277     fgState.SwapCount   = 0;
 278     fgState.SwapTime    = 0;
 279     fgState.FPSInterval = 0;
 280
 281     if( fgState.ProgramName )
 282     {
 283         free( fgState.ProgramName );
 284         fgState.ProgramName = NULL;
 285     }
 286
 287
 288 #if TARGET_HOST_UNIX_X11
 289
 290     /*
 291      * Make sure all X-client data we have created will be destroyed on
 292      * display closing
 293      */
 294     XSetCloseDownMode( fgDisplay.Display, DestroyAll );
 295
 296     /*
 297      * Close the display connection, destroying all windows we have
 298      * created so far
 299      */
 300     XCloseDisplay( fgDisplay.Display );
 301
 302 #endif
 303 }
 304
 305 /*
 306  * Everything inside the following #ifndef is copied from the X sources.
 307  */
 308
 309 #if TARGET_HOST_WIN32
 310
 311 /*
 312
 313 Copyright 1985, 1986, 1987,1998  The Open Group
 314
 315 Permission to use, copy, modify, distribute, and sell this software and its
 316 documentation for any purpose is hereby granted without fee, provided that
 317 the above copyright notice appear in all copies and that both that
 318 copyright notice and this permission notice appear in supporting
 319 documentation.
 320
 321 The above copyright notice and this permission notice shall be included
 322 in all copies or substantial portions of the Software.
 323
 324 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 325 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 326 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 327 IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
 328 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 329 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 330 OTHER DEALINGS IN THE SOFTWARE.
 331
 332 Except as contained in this notice, the name of The Open Group shall
 333 not be used in advertising or otherwise to promote the sale, use or
 334 other dealings in this Software without prior written authorization
 335 from The Open Group.
 336
 337 */
 338
 339 #define NoValue         0x0000
 340 #define XValue          0x0001
 341 #define YValue          0x0002
 342 #define WidthValue      0x0004
 343 #define HeightValue     0x0008
 344 #define AllValues       0x000F
 345 #define XNegative       0x0010
 346 #define YNegative       0x0020
 347
 348 /*
 349  *    XParseGeometry parses strings of the form
 350  *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
 351  *   width, height, xoffset, and yoffset are unsigned integers.
 352  *   Example:  "=80x24+300-49"
 353  *   The equal sign is optional.
 354  *   It returns a bitmask that indicates which of the four values
 355  *   were actually found in the string.  For each value found,
 356  *   the corresponding argument is updated;  for each value
 357  *   not found, the corresponding argument is left unchanged.
 358  */
 359
 360 static int
 361 ReadInteger(char *string, char **NextString)
 362 {
 363     register int Result = 0;
 364     int Sign = 1;
 365
 366     if (*string == '+')
 367         string++;
 368     else if (*string == '-')
 369     {
 370         string++;
 371         Sign = -1;
 372     }
 373     for (; (*string >= '0') && (*string <= '9'); string++)
 374     {
 375         Result = (Result * 10) + (*string - '0');
 376     }
 377     *NextString = string;
 378     if (Sign >= 0)
 379         return (Result);
 380     else
 381         return (-Result);
 382 }
 383
 384 static int XParseGeometry (
 385     const char *string,
 386     int *x,
 387     int *y,
 388     unsigned int *width,    /* RETURN */
 389     unsigned int *height)    /* RETURN */
 390 {
 391     int mask = NoValue;
 392     register char *strind;
 393     unsigned int tempWidth = 0, tempHeight = 0;
 394     int tempX = 0, tempY = 0;
 395     char *nextCharacter;
 396
 397     if ( (string == NULL) || (*string == '\0')) return(mask);
 398     if (*string == '=')
 399         string++;  /* ignore possible '=' at beg of geometry spec */
 400
 401     strind = (char *)string;
 402     if (*strind != '+' && *strind != '-' && *strind != 'x') {
 403         tempWidth = ReadInteger(strind, &nextCharacter);
 404         if (strind == nextCharacter)
 405             return (0);
 406         strind = nextCharacter;
 407         mask |= WidthValue;
 408     }
 409
 410     if (*strind == 'x' || *strind == 'X') {
 411         strind++;
 412         tempHeight = ReadInteger(strind, &nextCharacter);
 413         if (strind == nextCharacter)
 414             return (0);
 415         strind = nextCharacter;
 416         mask |= HeightValue;
 417     }
 418
 419     if ((*strind == '+') || (*strind == '-')) {
 420         if (*strind == '-') {
 421             strind++;
 422             tempX = -ReadInteger(strind, &nextCharacter);
 423             if (strind == nextCharacter)
 424                 return (0);
 425             strind = nextCharacter;
 426             mask |= XNegative;
 427         }
 428         else
 429         {
 430             strind++;
 431             tempX = ReadInteger(strind, &nextCharacter);
 432             if (strind == nextCharacter)
 433                 return(0);
 434             strind = nextCharacter;
 435         }
 436         mask |= XValue;
 437         if ((*strind == '+') || (*strind == '-')) {
 438             if (*strind == '-') {
 439                 strind++;
 440                 tempY = -ReadInteger(strind, &nextCharacter);
 441                 if (strind == nextCharacter)
 442                     return(0);
 443                 strind = nextCharacter;
 444                 mask |= YNegative;
 445             }
 446             else
 447             {
 448                 strind++;
 449                 tempY = ReadInteger(strind, &nextCharacter);
 450                 if (strind == nextCharacter)
 451                     return(0);
 452                 strind = nextCharacter;
 453             }
 454             mask |= YValue;
 455         }
 456     }
 457
 458     /* If strind isn't at the end of the string the it's an invalid
 459        geometry specification. */
 460
 461     if (*strind != '\0') return (0);
 462
 463     if (mask & XValue)
 464         *x = tempX;
 465     if (mask & YValue)
 466         *y = tempY;
 467     if (mask & WidthValue)
 468         *width = tempWidth;
 469     if (mask & HeightValue)
 470         *height = tempHeight;
 471     return (mask);
 472 }
 473 #endif
 474
 475 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
 476
 477 /*
 478  * Perform initialization. This usually happens on the program startup
 479  * and restarting after glutMainLoop termination...
 480  */
 481 void FGAPIENTRY glutInit( int* pargc, char** argv )
 482 {
 483     char* displayName = NULL;
 484     char* geometry = NULL;
 485     int i, j, argc = *pargc;
 486
 487     if( fgState.Initialised )
 488         fgError( "illegal glutInit() reinitialization attempt" );
 489
 490     if (pargc && *pargc && argv && *argv && **argv)
 491     {
 492         fgState.ProgramName = strdup (*argv);
 493
 494         if( !fgState.ProgramName )
 495             fgError ("Could not allocate space for the program's name.");
 496     }
 497
 498     fgCreateStructure( );
 499
 500     fgElapsedTime( );
 501
 502     /* check if GLUT_FPS env var is set */
 503     {
 504         const char *fps = getenv( "GLUT_FPS" );
 505         if( fps )
 506         {
 507             sscanf( fps, "%d", &fgState.FPSInterval );
 508             if( fgState.FPSInterval <= 0 )
 509                 fgState.FPSInterval = 5000;  /* 5000 milliseconds */
 510         }
 511     }
 512
 513     displayName = getenv( "DISPLAY");
 514
 515     for( i = 1; i < argc; i++ )
 516     {
 517         if( strcmp( argv[ i ], "-display" ) == 0 )
 518         {
 519             if( ++i >= argc )
 520                 fgError( "-display parameter must be followed by display name" );
 521
 522             displayName = argv[ i ];
 523
 524             argv[ i - 1 ] = NULL;
 525             argv[ i     ] = NULL;
 526             ( *pargc ) -= 2;
 527         }
 528         else if( strcmp( argv[ i ], "-geometry" ) == 0 )
 529         {
 530             if( ++i >= argc )
 531                 fgError( "-geometry parameter must be followed by window "
 532                          "geometry settings" );
 533
 534             geometry = argv[ i ];
 535
 536             argv[ i - 1 ] = NULL;
 537             argv[ i     ] = NULL;
 538             ( *pargc ) -= 2;
 539         }
 540         else if( strcmp( argv[ i ], "-direct" ) == 0)
 541         {
 542             if( ! fgState.TryDirectContext )
 543                 fgError( "parameters ambiguity, -direct and -indirect "
 544                     "cannot be both specified" );
 545
 546             fgState.ForceDirectContext = GL_TRUE;
 547             argv[ i ] = NULL;
 548             ( *pargc )--;
 549         }
 550         else if( strcmp( argv[ i ], "-indirect" ) == 0 )
 551         {
 552             if( fgState.ForceDirectContext )
 553                 fgError( "parameters ambiguity, -direct and -indirect "
 554                     "cannot be both specified" );
 555
 556             fgState.TryDirectContext = GL_FALSE;
 557             argv[ i ] = NULL;
 558             (*pargc)--;
 559         }
 560         else if( strcmp( argv[ i ], "-iconic" ) == 0 )
 561         {
 562             fgState.ForceIconic = GL_TRUE;
 563             argv[ i ] = NULL;
 564             ( *pargc )--;
 565         }
 566         else if( strcmp( argv[ i ], "-gldebug" ) == 0 )
 567         {
 568             fgState.GLDebugSwitch = GL_TRUE;
 569             argv[ i ] = NULL;
 570             ( *pargc )--;
 571         }
 572         else if( strcmp( argv[ i ], "-sync" ) == 0 )
 573         {
 574             fgState.XSyncSwitch = GL_TRUE;
 575             argv[ i ] = NULL;
 576             ( *pargc )--;
 577         }
 578     }
 579
 580     /*
 581      * Compact {argv}.
 582      */
 583     j = 2;
 584     for( i = 1; i < *pargc; i++, j++ )
 585     {
 586         if( argv[ i ] == NULL )
 587         {
 588             /* Guaranteed to end because there are "*pargc" arguments left */
 589             while ( argv[ j ] == NULL )
 590                 j++;
 591             argv[ i ] = argv[ j ];
 592         }
 593     }
 594
 595     /*
 596      * Have the display created now. As I am too lazy to implement
 597      * the program arguments parsing, we will have the DISPLAY
 598      * environment variable used for opening the X display:
 599      *
 600      * XXX The above comment is rather unclear.  We have just
 601      * XXX completed parsing of the program arguments for GLUT
 602      * XXX parameters.  We obviously canNOT parse the application-
 603      * XXX specific parameters.  Can someone re-write the above
 604      * XXX more clearly?
 605      */
 606     fgInitialize( displayName );
 607
 608     /*
 609      * Geometry parsing deffered until here because we may need the screen
 610      * size.
 611      */
 612
 613     if (geometry )
 614     {
 615         int mask = XParseGeometry( geometry,
 616                                    &fgState.Position.X, &fgState.Position.Y,
 617                                    &fgState.Size.X, &fgState.Size.Y );
 618
 619         if( (mask & (WidthValue|HeightValue)) == (WidthValue|HeightValue) )
 620             fgState.Size.Use = GL_TRUE;
 621
 622         if( mask & XNegative )
 623             fgState.Position.X += fgDisplay.ScreenWidth - fgState.Size.X;
 624
 625         if( mask & YNegative )
 626             fgState.Position.Y += fgDisplay.ScreenHeight - fgState.Size.Y;
 627
 628         if( (mask & (XValue|YValue)) == (XValue|YValue) )
 629             fgState.Position.Use = GL_TRUE;
 630     }
 631 }
 632
 633 /*
 634  * Sets the default initial window position for new windows
 635  */
 636 void FGAPIENTRY glutInitWindowPosition( int x, int y )
 637 {
 638     fgState.Position.X = x;
 639     fgState.Position.Y = y;
 640
 641     if( ( x >= 0 ) && ( y >= 0 ) )
 642         fgState.Position.Use = GL_TRUE;
 643     else
 644         fgState.Position.Use = GL_FALSE;
 645 }
 646
 647 /*
 648  * Sets the default initial window size for new windows
 649  */
 650 void FGAPIENTRY glutInitWindowSize( int width, int height )
 651 {
 652     fgState.Size.X = width;
 653     fgState.Size.Y = height;
 654
 655     if( ( width > 0 ) && ( height > 0 ) )
 656         fgState.Size.Use = GL_TRUE;
 657     else
 658         fgState.Size.Use = GL_FALSE;
 659 }
 660
 661 /*
 662  * Sets the default display mode for all new windows
 663  */
 664 void FGAPIENTRY glutInitDisplayMode( unsigned int displayMode )
 665 {
 666     /*
 667      * We will make use of this value when creating a new OpenGL context...
 668      */
 669     fgState.DisplayMode = displayMode;
 670 }
 671
 672
 673 /* -- INIT DISPLAY STRING PARSING ------------------------------------------ */
 674
 675 #define NUM_TOKENS             28
 676 static char* Tokens[] =
 677 {
 678     "alpha", "acca", "acc", "blue", "buffer", "conformant", "depth", "double",
 679     "green", "index", "num", "red", "rgba", "rgb", "luminance", "stencil",
 680     "single", "stereo", "samples", "slow", "win32pdf", "xvisual",
 681     "xstaticgray", "xgrayscale", "xstaticcolor", "xpseudocolor",
 682     "xtruecolor", "xdirectcolor"
 683 };
 684
 685 static int TokenLengths[] =
 686 {
 687     5,       4,      3,     4,      6,        10,           5,       6,
 688     5,       5,       3,     3,     4,      3,     9,           7,
 689     6,        6,        7,         4,      8,          7,
 690     11,            10,           12,             12,
 691     10,           12
 692 };
 693
 694 void FGAPIENTRY glutInitDisplayString( const char* displayMode )
 695 {
 696     int glut_state_flag = 0 ;
 697     /*
 698      * Unpack a lot of options from a character string.  The options are
 699      * delimited by blanks or tabs.
 700      */
 701     char *token ;
 702     int len = strlen ( displayMode ) ;
 703     char *buffer = (char *)malloc ( (len+1) * sizeof(char) ) ;
 704     memcpy ( buffer, displayMode, len ) ;
 705     buffer[len] = '\0' ;
 706
 707     token = strtok ( buffer, " \t" ) ;
 708     while ( token )
 709     {
 710         /*
 711          * Process this token
 712          */
 713         int i ;
 714         for ( i = 0; i < NUM_TOKENS; i++ )
 715         {
 716             if ( strncmp ( token, Tokens[i], TokenLengths[i] ) == 0 ) break ;
 717         }
 718
 719         switch ( i )
 720         {
 721         case 0 :  /* "alpha":  Alpha color buffer precision in bits */
 722             glut_state_flag |= GLUT_ALPHA ;  /* Somebody fix this for me! */
 723             break ;
 724
 725         case 1 :  /* "acca":  Red, green, blue, and alpha accumulation buffer
 726                      precision in bits */
 727             break ;
 728
 729         case 2 :  /* "acc":  Red, green, and blue accumulation buffer precision
 730                      in bits with zero bits alpha */
 731             glut_state_flag |= GLUT_ACCUM ;  /* Somebody fix this for me! */
 732             break ;
 733
 734         case 3 :  /* "blue":  Blue color buffer precision in bits */
 735             break ;
 736
 737         case 4 :  /* "buffer":  Number of bits in the color index color buffer
 738                    */
 739             break ;
 740
 741         case 5 :  /* "conformant":  Boolean indicating if the frame buffer
 742                      configuration is conformant or not */
 743             break ;
 744
 745         case 6 : /* "depth":  Number of bits of precsion in the depth buffer */
 746             glut_state_flag |= GLUT_DEPTH ;  /* Somebody fix this for me! */
 747             break ;
 748
 749         case 7 :  /* "double":  Boolean indicating if the color buffer is
 750                      double buffered */
 751             glut_state_flag |= GLUT_DOUBLE ;
 752             break ;
 753
 754         case 8 :  /* "green":  Green color buffer precision in bits */
 755             break ;
 756
 757         case 9 :  /* "index":  Boolean if the color model is color index or not
 758                    */
 759             glut_state_flag |= GLUT_INDEX ;
 760             break ;
 761
 762         case 10 :  /* "num":  A special capability  name indicating where the
 763                       value represents the Nth frame buffer configuration
 764                       matching the description string */
 765             break ;
 766
 767         case 11 :  /* "red":  Red color buffer precision in bits */
 768             break ;
 769
 770         case 12 :  /* "rgba":  Number of bits of red, green, blue, and alpha in
 771                       the RGBA color buffer */
 772             glut_state_flag |= GLUT_RGBA ;  /* Somebody fix this for me! */
 773             break ;
 774
 775         case 13 :  /* "rgb":  Number of bits of red, green, and blue in the
 776                       RGBA color buffer with zero bits alpha */
 777             glut_state_flag |= GLUT_RGB ;  /* Somebody fix this for me! */
 778             break ;
 779
 780         case 14 :  /* "luminance":  Number of bits of red in the RGBA and zero
 781                       bits of green, blue (alpha not specified) of color buffer
 782                       precision */
 783             glut_state_flag |= GLUT_LUMINANCE ; /* Somebody fix this for me! */
 784             break ;
 785
 786         case 15 :  /* "stencil":  Number of bits in the stencil buffer */
 787             glut_state_flag |= GLUT_STENCIL;  /* Somebody fix this for me! */
 788             break ;
 789
 790         case 16 :  /* "single":  Boolean indicate the color buffer is single
 791                       buffered */
 792             glut_state_flag |= GLUT_SINGLE ;
 793             break ;
 794
 795         case 17 :  /* "stereo":  Boolean indicating the color buffer supports
 796                       OpenGL-style stereo */
 797             glut_state_flag |= GLUT_STEREO ;
 798             break ;
 799
 800         case 18 :  /* "samples":  Indicates the number of multisamples to use
 801                       based on GLX's SGIS_multisample extension (for
 802                       antialiasing) */
 803             glut_state_flag |= GLUT_MULTISAMPLE ; /*Somebody fix this for me!*/
 804             break ;
 805
 806         case 19 :  /* "slow":  Boolean indicating if the frame buffer
 807                       configuration is slow or not */
 808             break ;
 809
 810         case 20 :  /* "win32pdf":  matches the Win32 Pixel Format Descriptor by
 811                       number */
 812 #if TARGET_HOST_WIN32
 813 #endif
 814             break ;
 815
 816         case 21 :  /* "xvisual":  matches the X visual ID by number */
 817 #if TARGET_HOST_UNIX_X11
 818 #endif
 819             break ;
 820
 821         case 22 :  /* "xstaticgray":  boolean indicating if the frame buffer
 822                       configuration's X visual is of type StaticGray */
 823 #if TARGET_HOST_UNIX_X11
 824 #endif
 825             break ;
 826
 827         case 23 :  /* "xgrayscale":  boolean indicating if the frame buffer
 828                       configuration's X visual is of type GrayScale */
 829 #if TARGET_HOST_UNIX_X11
 830 #endif
 831             break ;
 832
 833         case 24 :  /* "xstaticcolor":  boolean indicating if the frame buffer
 834                       configuration's X visual is of type StaticColor */
 835 #if TARGET_HOST_UNIX_X11
 836 #endif
 837             break ;
 838
 839         case 25 :  /* "xpseudocolor":  boolean indicating if the frame buffer
 840                       configuration's X visual is of type PseudoColor */
 841 #if TARGET_HOST_UNIX_X11
 842 #endif
 843             break ;
 844
 845         case 26 :  /* "xtruecolor":  boolean indicating if the frame buffer
 846                       configuration's X visual is of type TrueColor */
 847 #if TARGET_HOST_UNIX_X11
 848 #endif
 849             break ;
 850
 851         case 27 :  /* "xdirectcolor":  boolean indicating if the frame buffer
 852                       configuration's X visual is of type DirectColor */
 853 #if TARGET_HOST_UNIX_X11
 854 #endif
 855             break ;
 856
 857         case 28 :  /* Unrecognized */
 858             printf ( "WARNING - Display string token not recognized:  %s\n",
 859                      token ) ;
 860             break ;
 861         }
 862
 863         token = strtok ( NULL, " \t" ) ;
 864     }
 865
 866     free ( buffer ) ;
 867
 868     /*
 869      * We will make use of this value when creating a new OpenGL context...
 870      */
 871     fgState.DisplayMode = glut_state_flag;
 872 }
 873
 874 /*** END OF FILE ***/