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