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