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