Added a new state variable "Initalized".
[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, FALSE },  /* Position */
59                       { 300, 300, TRUE }, /* Size */
60                       GLUT_RGBA | GLUT_SINGLE | GLUT_DEPTH,  /* DisplayMode */
61                       FALSE,              /* Initalized */
62                       FALSE,              /* ForceDirectContext */
63                       TRUE,               /* TryDirectContext */
64                       FALSE,              /* ForceIconic */
65                       FALSE,              /* UseCurrentContext */
66                       FALSE,              /* GLDebugSwitch */
67                       FALSE,              /* XSyncSwitch */
68                       TRUE,               /* IgnoreKeyRepeat */
69                       0,                  /* FPSInterval */
70                       0,                  /* SwapCount */
71                       0,                  /* SwapTime */
72 #if TARGET_HOST_WIN32
73                       { 0, FALSE },       /* Time */
74 #else
75                       { { 0, 0 }, FALSE },
76 #endif
77                       { NULL, NULL }  ,    /* Timers */
78                       NULL,                /* IdleCallback */
79                       FALSE,               /* BuildingAMenu */
80                       0,                   /* ActiveMenus */
81                       NULL,                /* MenuStateCallback */
82                       NULL,                /* MenuStatusCallback */
83                       { 640, 480, TRUE },  /* GameModeSize */
84                       16,                  /* GameModeDepth */
85                       72,                  /* GameModeRefresh */
86                       GLUT_ACTION_EXIT,    /* ActionOnWindowClose */
87                       GLUT_EXEC_STATE_INIT /* ExecState */
88 } ;
89
90
91 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
92
93 /*
94  * A call to this function should initialize all the display stuff...
95  */
96 void fgInitialize( const char* displayName )
97 {
98 #if TARGET_HOST_UNIX_X11
99     fgDisplay.Display = XOpenDisplay( displayName );
100
101     if( fgDisplay.Display == NULL )
102         fgError( "failed to open display '%s'", XDisplayName( displayName ) );
103
104     if( !glXQueryExtension( fgDisplay.Display, NULL, NULL ) )
105         fgError( "OpenGL GLX extension not supported by display '%s'",
106             XDisplayName( displayName ) );
107
108     fgDisplay.Screen = DefaultScreen( fgDisplay.Display );
109     fgDisplay.RootWindow = RootWindow(
110         fgDisplay.Display,
111         fgDisplay.Screen
112     );
113
114     fgDisplay.ScreenWidth  = DisplayWidth(
115         fgDisplay.Display,
116         fgDisplay.Screen
117     );
118     fgDisplay.ScreenHeight = DisplayHeight(
119         fgDisplay.Display,
120         fgDisplay.Screen
121     );
122
123     fgDisplay.ScreenWidthMM = DisplayWidthMM(
124         fgDisplay.Display,
125         fgDisplay.Screen
126     );
127     fgDisplay.ScreenHeightMM = DisplayHeightMM(
128         fgDisplay.Display,
129         fgDisplay.Screen
130     );
131
132     fgDisplay.Connection = ConnectionNumber( fgDisplay.Display );
133
134     /*
135      * Create the window deletion atom
136      */
137     fgDisplay.DeleteWindow = XInternAtom(
138         fgDisplay.Display,
139         "WM_DELETE_WINDOW",
140         FALSE
141     );
142
143 #elif TARGET_HOST_WIN32
144
145     WNDCLASS wc;
146     ATOM atom;
147
148     /*
149      * What we need to do is to initialize the fgDisplay global structure here...
150      */
151     fgDisplay.Instance = GetModuleHandle( NULL );
152
153     atom = GetClassInfo( fgDisplay.Instance, "FREEGLUT", &wc );
154     if( atom == 0 )
155     {
156         ZeroMemory( &wc, sizeof(WNDCLASS) );
157
158         /*
159          * Each of the windows should have its own device context...
160          */
161         wc.style          = CS_OWNDC;
162         wc.lpfnWndProc    = fgWindowProc;
163         wc.cbClsExtra     = 0;
164         wc.cbWndExtra     = 0;
165         wc.hInstance      = fgDisplay.Instance;
166         wc.hIcon          = LoadIcon( fgDisplay.Instance, "GLUT_ICON" );
167         if (!wc.hIcon)
168           wc.hIcon        = LoadIcon( NULL, IDI_WINLOGO );
169
170         wc.hCursor        = LoadCursor( NULL, IDC_ARROW );
171         wc.hbrBackground  = NULL;
172         wc.lpszMenuName   = NULL;
173         wc.lpszClassName  = "FREEGLUT";
174
175         /*
176          * Register the window class
177          */
178         atom = RegisterClass( &wc );
179         assert( atom );
180     }
181
182     /*
183      * The screen dimensions can be obtained via GetSystemMetrics() calls
184      */
185     fgDisplay.ScreenWidth  = GetSystemMetrics( SM_CXSCREEN );
186     fgDisplay.ScreenHeight = GetSystemMetrics( SM_CYSCREEN );
187
188     {
189         HWND desktop = GetDesktopWindow( );
190         HDC  context = GetDC( desktop );
191
192         fgDisplay.ScreenWidthMM  = GetDeviceCaps( context, HORZSIZE );
193         fgDisplay.ScreenHeightMM = GetDeviceCaps( context, VERTSIZE );
194
195         ReleaseDC( desktop, context );
196     }
197
198 #endif
199
200     fgJoystickInit( 0 );
201
202     fgState.Initalized = GL_TRUE;
203 }
204
205 /*
206  * Perform the freeglut deinitialization...
207  */
208 void fgDeinitialize( void )
209 {
210     SFG_Timer *timer;
211
212     if( !fgState.Initalized )
213     {
214         fgWarning( "fgDeinitialize(): "
215                    "no valid initialization has been performed" );
216         return;
217     }
218
219     fgState.Initalized = GL_FALSE;
220
221     /*
222      * If there was a menu created, destroy the rendering context
223      */
224     if( fgStructure.MenuContext )
225     {
226         free( fgStructure.MenuContext );
227         fgStructure.MenuContext = NULL;
228     }
229
230     fgDestroyStructure( );
231
232     while( timer = ( SFG_Timer * )fgState.Timers.First )
233     {
234         fgListRemove ( &fgState.Timers, &timer->Node );
235         free( timer );
236     }
237
238     fgJoystickClose( );
239
240     fgState.Position.X = -1;
241     fgState.Position.Y = -1;
242     fgState.Position.Use = FALSE;
243
244     fgState.Size.X = 300;
245     fgState.Size.Y = 300;
246     fgState.Size.Use = TRUE;
247
248     fgState.DisplayMode = GLUT_RGBA | GLUT_SINGLE | GLUT_DEPTH;
249
250     fgState.ForceDirectContext  = FALSE;
251     fgState.TryDirectContext    = TRUE;
252     fgState.ForceIconic         = FALSE;
253     fgState.UseCurrentContext   = FALSE;
254     fgState.GLDebugSwitch       = FALSE;
255     fgState.XSyncSwitch         = FALSE;
256     fgState.ActionOnWindowClose = GLUT_ACTION_EXIT ;
257     fgState.ExecState           = GLUT_EXEC_STATE_INIT ;
258
259     fgState.IgnoreKeyRepeat = TRUE;
260
261     fgState.GameModeSize.X  = 640;
262     fgState.GameModeSize.Y  = 480;
263     fgState.GameModeDepth   =  16;
264     fgState.GameModeRefresh =  72;
265
266     fgState.Time.Set = FALSE;
267
268     fgState.Timers.First = fgState.Timers.Last = NULL;
269     fgState.IdleCallback = NULL;
270     fgState.MenuStateCallback = ( FGCBMenuState )NULL;
271     fgState.MenuStatusCallback = ( FGCBMenuStatus )NULL;
272
273     fgState.SwapCount   = 0;
274     fgState.SwapTime    = 0;
275     fgState.FPSInterval = 0;
276
277     if( fgState.ProgramName )
278     {
279         free( fgState.ProgramName );
280         fgState.ProgramName = NULL;
281     }
282     
283
284 #if TARGET_HOST_UNIX_X11
285
286     /*
287      * Make sure all X-client data we have created will be destroyed on
288      * display closing
289      */
290     XSetCloseDownMode( fgDisplay.Display, DestroyAll );
291
292     /*
293      * Close the display connection, destroying all windows we have
294      * created so far
295      */
296     XCloseDisplay( fgDisplay.Display );
297
298 #endif
299 }
300
301
302 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
303
304 /*
305  * Perform initialization. This usually happens on the program startup
306  * and restarting after glutMainLoop termination...
307  */
308 void FGAPIENTRY glutInit( int* pargc, char** argv )
309 {
310     char* displayName = NULL;
311     int i, j, argc = *pargc;
312
313     if (pargc && *pargc && argv && *argv && **argv)
314         fgState.ProgramName = strdup (*argv);
315     else
316         fgState.ProgramName = strdup ("");
317     if( !fgState.ProgramName )
318         fgError ("Could not allocate space for the program's name.");
319
320     if( fgState.Initalized )
321         fgError( "illegal glutInit() reinitialization attemp" );
322
323     fgCreateStructure( );
324
325     fgElapsedTime( );
326
327     /* check if GLUT_FPS env var is set */
328     {
329         const char *fps = getenv( "GLUT_FPS" );
330         if( fps )
331         {
332             sscanf( fps, "%d", &fgState.FPSInterval );
333             if( fgState.FPSInterval <= 0 )
334                 fgState.FPSInterval = 5000;  /* 5000 milliseconds */
335         }
336     }
337
338 #if TARGET_HOST_WIN32
339     if( !getenv( "DISPLAY" ) )
340         displayName = strdup( "" );
341     else
342 #endif
343         displayName = strdup( getenv( "DISPLAY" ) );
344     if( !displayName )
345         fgError( "Could not allocate space for display name." );
346
347     for( i = 1; i < argc; i++ )
348     {
349         if( strcmp( argv[ i ], "-display" ) == 0 )
350         {
351             if( ++i >= argc )
352                 fgError( "-display parameter must be followed by display name" );
353
354             if( displayName )
355                 free( displayName );
356             displayName = strdup( argv[ i ] );
357             if( !displayName )
358                 fgError( "Could not allocate space for display name (%s)",
359                     argv [ i ] );
360
361             argv[ i - 1 ] = NULL;
362             argv[ i     ] = NULL;
363             ( *pargc ) -= 2;
364         }
365         else if( strcmp( argv[ i ], "-geometry" ) == 0 )
366         {
367             int result, x, y;
368             unsigned int w, h;
369
370             if( ++i >= argc )
371                 fgError( "-geometry parameter must be followed by window "
372                          "geometry settings" );
373             result = sscanf( argv[ i ], "%dx%d+%d+%d", &x, &y, &w, &h );
374
375             if( result > 3 )
376                 fgState.Size.Y = h;
377             if( result > 2 )
378                 fgState.Size.X = w;
379
380             if( result > 1 )
381             {
382                 if( y < 0 )
383                     fgState.Position.Y =
384                         fgDisplay.ScreenHeight + y - fgState.Size.Y;
385                 else
386                     fgState.Position.Y = y;
387             }
388
389             if( result > 0 )
390             {
391                 if( x < 0 )
392                     fgState.Position.X =
393                         fgDisplay.ScreenWidth + x - fgState.Size.X;
394                 else
395                     fgState.Position.X = x;
396             }
397
398             argv[ i - 1 ] = NULL;
399             argv[ i     ] = NULL;
400             ( *pargc ) -= 2;
401         }
402         else if( strcmp( argv[ i ], "-direct" ) == 0)
403         {
404             if( fgState.TryDirectContext == FALSE )
405                 fgError( "parameters ambiguity, -direct and -indirect "
406                     "cannot be both specified" );
407
408             fgState.ForceDirectContext = TRUE;
409             argv[ i ] = NULL;
410             ( *pargc )--;
411         }
412         else if( strcmp( argv[ i ], "-indirect" ) == 0 )
413         {
414             if( fgState.ForceDirectContext == TRUE )
415                 fgError( "parameters ambiguity, -direct and -indirect "
416                     "cannot be both specified" );
417
418             fgState.TryDirectContext = FALSE;
419             argv[ i ] = NULL;
420             (*pargc)--;
421         }
422         else if( strcmp( argv[ i ], "-iconic" ) == 0 )
423         {
424             fgState.ForceIconic = TRUE;
425             argv[ i ] = NULL;
426             ( *pargc )--;
427         }
428         else if( strcmp( argv[ i ], "-gldebug" ) == 0 )
429         {
430             fgState.GLDebugSwitch = TRUE;
431             argv[ i ] = NULL;
432             ( *pargc )--;
433         }
434         else if( strcmp( argv[ i ], "-sync" ) == 0 )
435         {
436             fgState.XSyncSwitch = TRUE;
437             argv[ i ] = NULL;
438             ( *pargc )--;
439         }
440     }
441
442     /*
443      * Compact {argv}.
444      */
445     j = 2 ;
446     for( i = 1; i < *pargc; i++, j++ )
447     {
448         if( argv[ i ] == NULL )
449         {
450             /* Guaranteed to end because there are "*pargc" arguments left */
451             while ( argv[ j ] == NULL )
452                 j++;
453             argv[ i ] = argv[ j ] ;
454         }
455     }
456
457     /*
458      * Have the display created now. As I am too lazy to implement
459      * the program arguments parsing, we will have the DISPLAY
460      * environment variable used for opening the X display:
461      *
462      * XXX The above comment is rather unclear.  We have just
463      * XXX completed parsing of the program arguments for GLUT
464      * XXX parameters.  We obviously canNOT parse the application-
465      * XXX specific parameters.  Can someone re-write the above
466      * XXX more clearly?
467      */
468     fgInitialize( displayName );
469
470     /*
471      * Check for the minus one settings for both position and size...
472      */
473     if( fgState.Position.X < 0 || fgState.Position.Y < 0 )
474         fgState.Position.Use = FALSE;
475
476     if( fgState.Size.X < 0 || fgState.Size.Y < 0 )
477         fgState.Size.Use = FALSE;
478
479     if( displayName )
480         free( displayName );
481 }
482
483 /*
484  * Sets the default initial window position for new windows
485  */
486 void FGAPIENTRY glutInitWindowPosition( int x, int y )
487 {
488     if( ( x >= 0 ) && ( y >= 0 ) )
489     {
490         fgState.Position.X   =    x;
491         fgState.Position.Y   =    y;
492         fgState.Position.Use = TRUE;
493     }
494     else
495     {
496         fgState.Position.X   =    -1;
497         fgState.Position.Y   =    -1;
498         fgState.Position.Use = FALSE;
499     }
500 }
501
502 /*
503  * Sets the default initial window size for new windows
504  */
505 void FGAPIENTRY glutInitWindowSize( int width, int height )
506 {
507     if( ( width > 0 ) && ( height > 0 ) )
508     {
509         fgState.Size.X   =  width;
510         fgState.Size.Y   = height;
511         fgState.Size.Use =   TRUE;
512     }
513     else
514     {
515         fgState.Size.X   =    -1;
516         fgState.Size.Y   =    -1;
517         fgState.Size.Use = FALSE;
518     }
519 }
520
521 /*
522  * Sets the default display mode for all new windows
523  */
524 void FGAPIENTRY glutInitDisplayMode( unsigned int displayMode )
525 {
526     /*
527      * We will make use of this value when creating a new OpenGL context...
528      */
529     fgState.DisplayMode = displayMode;
530 }
531
532
533 /* -- INIT DISPLAY STRING PARSING ------------------------------------------ */
534
535 #if 0 /* FIXME: CJP */
536 /*
537  * There is a discrete number of comparison operators we can encounter:
538  *
539  *     comparison ::= "=" | "!=" | "<" | ">" | "<=" | ">=" | "~"
540  */
541 #define  FG_NONE           0x0000
542 #define  FG_EQUAL          0x0001
543 #define  FG_NOT_EQUAL      0x0002
544 #define  FG_LESS           0x0003
545 #define  FG_MORE           0x0004
546 #define  FG_LESS_OR_EQUAL  0x0005
547 #define  FG_MORE_OR_EQUAL  0x0006
548 #define  FG_CLOSEST        0x0007
549
550 /*
551  * The caller can feed us with a number of capability tokens:
552  *
553  * capability ::= "alpha" | "acca" | "acc" | "blue" | "buffer" | "conformant" | "depth" | "double" |
554  *                "green" | "index" | "num" | "red" | "rgba" | "rgb" | "luminance" | "stencil" |
555  *                "single" | "stereo" | "samples" | "slow" | "win32pdf" | "xvisual" | "xstaticgray" |
556  *                "xgrayscale" | "xstaticcolor" | "xpseudocolor" | "xtruecolor" | "xdirectcolor"
557  */
558 static gchar* g_Tokens[] =
559 {
560     "none", "alpha", "acca", "acc", "blue", "buffer", "conformant", "depth", "double", "green",
561     "index", "num", "red", "rgba", "rgb", "luminance", "stencil", "single", "stereo", "samples",
562     "slow", "win32pdf", "xvisual", "xstaticgray", "xgrayscale", "xstaticcolor", "xpseudocolor",
563     "xtruecolor", "xdirectcolor", NULL
564 };
565
566 /*
567  * The structure to hold the parsed display string tokens
568  */
569 typedef struct tagSFG_Capability SFG_Capability;
570 struct tagSFG_Capability
571 {
572     gint capability;        /* the capability token enumerator */
573     gint comparison;        /* the comparison operator used    */
574     gint value;             /* the value we're comparing to    */
575 };
576
577 /*
578  * The scanner configuration for the init display string
579  */
580 static GScannerConfig fgInitDisplayStringScannerConfig =
581 {
582     ( " \t\r\n" )               /* cset_skip_characters     */,
583     (
584         G_CSET_a_2_z
585         "_"
586         G_CSET_A_2_Z
587     )                                        /* cset_identifier_first    */,
588     (
589         G_CSET_a_2_z
590         "_0123456789"
591         G_CSET_A_2_Z
592         G_CSET_LATINS
593         G_CSET_LATINC
594         "<>!=~"
595     )                                        /* cset_identifier_nth      */,
596     ( "#\n" )                            /* cpair_comment_single     */,
597     FALSE                                    /* case_sensitive           */,
598     TRUE                                    /* skip_comment_multi       */,
599     TRUE                                    /* skip_comment_single      */,
600     TRUE                                    /* scan_comment_multi       */,
601     TRUE                                    /* scan_identifier          */,
602     FALSE                                    /* scan_identifier_1char    */,
603     FALSE                                    /* scan_identifier_NULL     */,
604     TRUE                                    /* scan_symbols             */,
605     FALSE                                    /* scan_binary              */,
606     TRUE                                    /* scan_octal               */,
607     TRUE                                    /* scan_float               */,
608     TRUE                                    /* scan_hex                 */,
609     FALSE                                    /* scan_hex_dollar          */,
610     TRUE                                    /* scan_string_sq           */,
611     TRUE                                    /* scan_string_dq           */,
612     TRUE                                    /* numbers_2_int            */,
613     FALSE                                    /* int_2_float              */,
614     FALSE                                    /* identifier_2_string      */,
615     TRUE                                    /* char_2_token             */,
616     FALSE                                    /* symbol_2_token           */,
617     FALSE                                    /* scope_0_fallback         */,
618 };
619
620 /*
621  * Sets the default display mode for all new windows using a string
622  */
623 void FGAPIENTRY glutInitDisplayString( char* displayMode )
624 {
625     /*
626      * display_string ::= (switch)
627      * switch         ::= capability [comparison value]
628      * comparison     ::= "=" | "!=" | "<" | ">" | "<=" | ">=" | "~"
629      * capability     ::= "alpha" | "acca" | "acc" | "blue" | "buffer" | "conformant" |
630      *                    "depth" | "double" | "green" | "index" | "num" | "red" | "rgba" |
631      *                    "rgb" | "luminance" | "stencil" | "single" | "stereo" |
632      *                    "samples" | "slow" | "win32pdf" | "xvisual" | "xstaticgray" |
633      *                    "xgrayscale" | "xstaticcolor" | "xpseudocolor" |
634      *                    "xtruecolor" | "xdirectcolor"
635      * value          ::= 0..9 [value]
636      *
637      * The display string grammar. This should be EBNF, but I couldn't find the definitions so, to
638      * clarify: (expr) means 0 or more times the expression, [expr] means 0 or 1 times expr.
639      *
640      * Create a new GLib lexical analyzer to process the display mode string
641      */
642     GScanner* scanner = g_scanner_new( &fgInitDisplayStringScannerConfig );
643     GList* caps = NULL;
644     gint i;
645
646     /*
647      * Fail if the display mode string is empty or the scanner failed to initialize
648      */
649     freeglut_return_if_fail( (scanner != NULL) && (strlen( displayMode ) > 0) );
650
651     /*
652      * Set the scanner's input name (for debugging)
653      */
654     scanner->input_name = "glutInitDisplayString";
655
656     /*
657      * Start the lexical analysis of the extensions string
658      */
659     g_scanner_input_text( scanner, displayMode, strlen( displayMode ) );
660
661     /*
662      * While there are any more tokens to be checked...
663      */
664     while( !g_scanner_eof( scanner ) )
665     {
666         /*
667          * Actually we're expecting only string tokens
668          */
669         GTokenType tokenType = g_scanner_get_next_token( scanner );
670
671         /*
672          * We are looking for identifiers
673          */
674         if( tokenType == G_TOKEN_IDENTIFIER )
675         {
676             gchar* capability  = NULL;  /* the capability identifier string (always present) */
677             gint   capID       =    0;  /* the capability identifier value (from g_Tokens)   */
678             gint   comparison  =    0;  /* the comparison operator value, see definitions    */
679             gchar* valueString = NULL;  /* if the previous one is present, this is needed    */
680             gint   value       =    0;  /* the integer value converted using a strtol call   */
681             SFG_Capability* capStruct;  /* the capability description structure              */
682
683             /*
684              * OK. The general rule of thumb that we always should be getting a capability identifier
685              * string (see the grammar description). If it is followed by a comparison identifier, then
686              * there must follow an integer value we're comparing the capability to...
687              *
688              * Have the current token analyzed with that in mind...
689              */
690             for( i=0; i<(gint) strlen( scanner->value.v_identifier ); i++ )
691             {
692                 gchar c = scanner->value.v_identifier[ i ];
693
694                 if( (c == '=') || (c == '!') || (c == '<') || (c == '>') || (c == '~') )
695                     break;
696             }
697
698             /*
699              * Here we go with the length of the capability identifier string.
700              * In the worst of cases, it is as long as the token identifier.
701              */
702             capability = g_strndup( scanner->value.v_identifier, i );
703
704             /*
705              * OK. Is there a chance for comparison and value identifiers to follow?
706              * Note: checking against i+1 as this handles two cases: single character
707              * comparison operator and first of value's digits, which must always be
708              * there, or the two-character comparison operators.
709              */
710             if( (i + 1) < (gint) strlen( scanner->value.v_identifier ) )
711             {
712                 /*
713                  * Yeah, indeed, it is the i-th character to start the identifier, then.
714                  */
715                 gchar c1 = scanner->value.v_identifier[ i + 0 ];
716                 gchar c2 = scanner->value.v_identifier[ i + 1 ];
717
718                 if( (c1 == '=')                ) { i += 1; comparison = FG_EQUAL;         } else
719                 if( (c1 == '!') && (c2 == '=') ) { i += 2; comparison = FG_NOT_EQUAL;     } else
720                 if( (c1 == '<') && (c2 == '=') ) { i += 2; comparison = FG_LESS_OR_EQUAL; } else
721                 if( (c1 == '>') && (c2 == '=') ) { i += 2; comparison = FG_MORE_OR_EQUAL; } else
722                 if( (c1 == '<')                ) { i += 1; comparison = FG_LESS;          } else
723                 if( (c1 == '>')                ) { i += 1; comparison = FG_MORE;          } else
724                 if( (c1 == '~')                ) { i += 1; comparison = FG_CLOSEST;       } else
725                 g_warning( "invalid comparison operator in token `%s'", scanner->value.v_identifier );
726             }
727
728             /*
729              * Grab the value string that must follow the comparison operator...
730              */
731             if( comparison != FG_NONE && i < (gint) strlen( scanner->value.v_identifier ) )
732             {
733                 valueString = strdup( scanner->value.v_identifier + i );
734                 if (!valueString)
735                     fgError ("Could not allocate an internal string.");
736             }                
737
738             /*
739              * If there was a value string, convert it to integer...
740              */
741             if( comparison != FG_NONE && strlen( valueString ) > 0 )
742                 value = strtol( valueString, NULL, 0 );
743
744             /*
745              * Now we need to match the capability string and its ID
746              */
747             for( i=0; g_Tokens[ i ]!=NULL; i++ )
748             {
749                 if( strcmp( capability, g_Tokens[ i ] ) == 0 )
750                 {
751                     /*
752                      * Looks like we've found the one we were looking for
753                      */
754                     capID = i;
755                     break;
756                 }
757             }
758
759             /*
760              * Create a new capability description structure
761              */
762             capStruct = g_new0( SFG_Capability, 1 );
763
764             /*
765              * Fill in the cap's values, as we have parsed it:
766              */
767             capStruct->capability =      capID;
768             capStruct->comparison = comparison;
769             capStruct->value      =      value;
770
771             /*
772              * Add the new capabaility to the caps list
773              */
774             caps = g_list_append( caps, capStruct );
775
776             /*
777              * Clean up the local mess and keep rolling on
778              */
779             g_free( valueString );
780             g_free( capability );
781         }
782     }
783
784     /*
785      * Now that we have converted the string into somewhat more machine-friendly
786      * form, proceed with matching the frame buffer configuration...
787      *
788      * The caps list could be passed to a function that would try finding the closest 
789      * matching pixel format, visual, frame buffer configuration or whatever. It would 
790      * be good to convert the glutInitDisplayMode() to use the same method.
791      */
792 #if 0
793     g_message( "found %i capability preferences", g_list_length( caps ) );
794
795     g_message( "token `%s': cap: %i, com: %i, val: %i",
796         scanner->value.v_identifier,
797         capStruct->capability,
798         capStruct->comparison,
799         capStruct->value
800     );
801 #endif
802
803     /*
804      * Free the capabilities we have parsed
805      */
806     for( i=0; i<(gint) g_list_length( caps ); i++ )
807         g_free( g_list_nth( caps, i )->data );
808
809     /*
810      * Destroy the capabilities list itself
811      */
812     g_list_free( caps );
813
814     /*
815      * Free the lexical scanner now...
816      */
817     g_scanner_destroy( scanner );
818 }
819 #endif
820
821 #define NUM_TOKENS             28
822 static char* Tokens[] =
823 {
824     "alpha", "acca", "acc", "blue", "buffer", "conformant", "depth", "double", "green",
825     "index", "num", "red", "rgba", "rgb", "luminance", "stencil", "single", "stereo", "samples",
826     "slow", "win32pdf", "xvisual", "xstaticgray", "xgrayscale", "xstaticcolor", "xpseudocolor",
827     "xtruecolor", "xdirectcolor"
828 };
829
830 static int TokenLengths[] =
831 {
832          5,      4,     3,      4,        6,           10,       5,        6,       5,
833          5,     3,     3,      4,     3,           9,         7,        6,        6,         7,
834         4,          8,         7,            11,           10,             12,             12,
835              10,             12
836 };
837
838 void FGAPIENTRY glutInitDisplayString( const char* displayMode )
839 {
840   int glut_state_flag = 0 ;
841   /*
842    * Unpack a lot of options from a character string.  The options are delimited by blanks or tabs.
843    */
844   char *token ;
845   int len = strlen ( displayMode ) ;
846   char *buffer = (char *)malloc ( (len+1) * sizeof(char) ) ;
847   memcpy ( buffer, displayMode, len ) ;
848   buffer[len] = '\0' ;
849
850   token = strtok ( buffer, " \t" ) ;
851   while ( token )
852   {
853     /*
854      * Process this token
855      */
856     int i ;
857     for ( i = 0; i < NUM_TOKENS; i++ )
858     {
859       if ( strncmp ( token, Tokens[i], TokenLengths[i] ) == 0 ) break ;
860     }
861
862     switch ( i )
863     {
864     case 0 :  /* "alpha":  Alpha color buffer precision in bits */
865       glut_state_flag |= GLUT_ALPHA ;  /* Somebody fix this for me! */
866       break ;
867
868     case 1 :  /* "acca":  Red, green, blue, and alpha accumulation buffer precision in bits */
869       break ;
870
871     case 2 :  /* "acc":  Red, green, and blue accumulation buffer precision in bits with zero bits alpha */
872       glut_state_flag |= GLUT_ACCUM ;  /* Somebody fix this for me! */
873       break ;
874
875     case 3 :  /* "blue":  Blue color buffer precision in bits */
876       break ;
877
878     case 4 :  /* "buffer":  Number of bits in the color index color buffer */
879       break ;
880
881     case 5 :  /* "conformant":  Boolean indicating if the frame buffer configuration is conformant or not */
882       break ;
883
884     case 6 :  /* "depth":  Number of bits of precsion in the depth buffer */
885       glut_state_flag |= GLUT_DEPTH ;  /* Somebody fix this for me! */
886       break ;
887
888     case 7 :  /* "double":  Boolean indicating if the color buffer is double buffered */
889       glut_state_flag |= GLUT_DOUBLE ;
890       break ;
891
892     case 8 :  /* "green":  Green color buffer precision in bits */
893       break ;
894
895     case 9 :  /* "index":  Boolean if the color model is color index or not */
896       glut_state_flag |= GLUT_INDEX ;
897       break ;
898
899     case 10 :  /* "num":  A special capability  name indicating where the value represents the Nth frame buffer configuration matching the description string */
900       break ;
901
902     case 11 :  /* "red":  Red color buffer precision in bits */
903       break ;
904
905     case 12 :  /* "rgba":  Number of bits of red, green, blue, and alpha in the RGBA color buffer */
906       glut_state_flag |= GLUT_RGBA ;  /* Somebody fix this for me! */
907       break ;
908
909     case 13 :  /* "rgb":  Number of bits of red, green, and blue in the RGBA color buffer with zero bits alpha */
910       glut_state_flag |= GLUT_RGB ;  /* Somebody fix this for me! */
911       break ;
912
913     case 14 :  /* "luminance":  Number of bits of red in the RGBA and zero bits of green, blue (alpha not specified) of color buffer precision */
914       glut_state_flag |= GLUT_LUMINANCE ;  /* Somebody fix this for me! */
915       break ;
916
917     case 15 :  /* "stencil":  Number of bits in the stencil buffer */
918       glut_state_flag |= GLUT_STENCIL ;  /* Somebody fix this for me! */
919       break ;
920
921     case 16 :  /* "single":  Boolean indicate the color buffer is single buffered */
922       glut_state_flag |= GLUT_SINGLE ;
923       break ;
924
925     case 17 :  /* "stereo":  Boolean indicating the color buffer supports OpenGL-style stereo */
926       glut_state_flag |= GLUT_STEREO ;
927       break ;
928
929     case 18 :  /* "samples":  Indicates the number of multisamples to use based on GLX's SGIS_multisample extension (for antialiasing) */
930       glut_state_flag |= GLUT_MULTISAMPLE ;  /* Somebody fix this for me! */
931       break ;
932
933     case 19 :  /* "slow":  Boolean indicating if the frame buffer configuration is slow or not */
934       break ;
935
936     case 20 :  /* "win32pdf":  matches the Win32 Pixel Format Descriptor by number */
937 #if TARGET_HOST_WIN32
938 #endif
939       break ;
940
941     case 21 :  /* "xvisual":  matches the X visual ID by number */
942 #if TARGET_HOST_UNIX_X11
943 #endif
944       break ;
945
946     case 22 :  /* "xstaticgray":  boolean indicating if the frame buffer configuration's X visual is of type StaticGray */
947 #if TARGET_HOST_UNIX_X11
948 #endif
949       break ;
950
951     case 23 :  /* "xgrayscale":  boolean indicating if the frame buffer configuration's X visual is of type GrayScale */
952 #if TARGET_HOST_UNIX_X11
953 #endif
954       break ;
955
956     case 24 :  /* "xstaticcolor":  boolean indicating if the frame buffer configuration's X visual is of type StaticColor */
957 #if TARGET_HOST_UNIX_X11
958 #endif
959       break ;
960
961     case 25 :  /* "xpseudocolor":  boolean indicating if the frame buffer configuration's X visual is of type PseudoColor */
962 #if TARGET_HOST_UNIX_X11
963 #endif
964       break ;
965
966     case 26 :  /* "xtruecolor":  boolean indicating if the frame buffer configuration's X visual is of type TrueColor */
967 #if TARGET_HOST_UNIX_X11
968 #endif
969       break ;
970
971     case 27 :  /* "xdirectcolor":  boolean indicating if the frame buffer configuration's X visual is of type DirectColor */
972 #if TARGET_HOST_UNIX_X11
973 #endif
974       break ;
975
976     case 28 :  /* Unrecognized */
977       printf ( "WARNING - Display string token not recognized:  %s\n", token ) ;
978       break ;
979     }
980
981     token = strtok ( NULL, " \t" ) ;
982   }
983
984   free ( buffer ) ;
985
986   /*
987    * We will make use of this value when creating a new OpenGL context...
988    */
989   fgState.DisplayMode = glut_state_flag;
990 }
991
992 /*** END OF FILE ***/