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 #define FREEGLUT_BUILDING_LIB
  29 #include <GL/freeglut.h>
  30 #include "freeglut_internal.h"
  31
  32 #if TARGET_HOST_POSIX_X11
  33 #include <limits.h>  /* LONG_MAX */
  34 #endif
  35
  36 /*
  37  * TODO BEFORE THE STABLE RELEASE:
  38  *
  39  *  fgDeinitialize()        -- Win32's OK, X11 needs the OS-specific
  40  *                             deinitialization done
  41  *  glutInitDisplayString() -- display mode string parsing
  42  *
  43  * Wouldn't it be cool to use gettext() for error messages? I just love
  44  * bash saying  "nie znaleziono pliku" instead of "file not found" :)
  45  * Is gettext easily portable?
  46  */
  47
  48 /* -- GLOBAL VARIABLES ----------------------------------------------------- */
  49
  50 /*
  51  * A structure pointed by g_pDisplay holds all information
  52  * regarding the display, screen, root window etc.
  53  */
  54 SFG_Display fgDisplay;
  55
  56 /*
  57  * The settings for the current freeglut session
  58  */
  59 SFG_State fgState = { { -1, -1, GL_FALSE },  /* Position */
  60                       { 300, 300, GL_TRUE }, /* Size */
  61                       GLUT_RGBA | GLUT_SINGLE | GLUT_DEPTH,  /* DisplayMode */
  62                       GL_FALSE,              /* Initialised */
  63                       GLUT_TRY_DIRECT_CONTEXT,  /* DirectContext */
  64                       GL_FALSE,              /* ForceIconic */
  65                       GL_FALSE,              /* UseCurrentContext */
  66                       GL_FALSE,              /* GLDebugSwitch */
  67                       GL_FALSE,              /* XSyncSwitch */
  68                       GLUT_KEY_REPEAT_ON,    /* KeyRepeat */
  69                       INVALID_MODIFIERS,     /* Modifiers */
  70                       0,                     /* FPSInterval */
  71                       0,                     /* SwapCount */
  72                       0,                     /* SwapTime */
  73                       0,                     /* Time */
  74                       { NULL, NULL },         /* Timers */
  75                       { NULL, NULL },         /* FreeTimers */
  76                       NULL,                   /* IdleCallback */
  77                       0,                      /* ActiveMenus */
  78                       NULL,                   /* MenuStateCallback */
  79                       NULL,                   /* MenuStatusCallback */
  80                       { 640, 480, GL_TRUE },  /* GameModeSize */
  81                       16,                     /* GameModeDepth */
  82                       72,                     /* GameModeRefresh */
  83                       GLUT_ACTION_EXIT,       /* ActionOnWindowClose */
  84                       GLUT_EXEC_STATE_INIT,   /* ExecState */
  85                       NULL,                   /* ProgramName */
  86                       GL_FALSE,               /* JoysticksInitialised */
  87                       0,                      /* NumActiveJoysticks */
  88                       GL_FALSE,               /* InputDevsInitialised */
  89                       1,                      /* AuxiliaryBufferNumber */
  90                       4,                      /* SampleNumber */
  91                       1,                      /* MajorVersion */
  92                       0,                      /* MinorVersion */
  93                       0,                      /* ContextFlags */
  94                       0,                      /* ContextProfile */
  95                       NULL,                   /* ErrorFunc */
  96                       NULL                    /* WarningFunc */
  97 };
  98
  99
 100 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
 101
 102 #if TARGET_HOST_POSIX_X11
 103
 104 /* Return the atom associated with "name". */
 105 static Atom fghGetAtom(const char * name)
 106 {
 107   return XInternAtom(fgDisplay.Display, name, False);
 108 }
 109
 110 /*
 111  * Check if "property" is set on "window".  The property's values are returned
 112  * through "data".  If the property is set and is of type "type", return the
 113  * number of elements in "data".  Return zero otherwise.  In both cases, use
 114  * "Xfree()" to free "data".
 115  */
 116 static int fghGetWindowProperty(Window window,
 117                                 Atom property,
 118                                 Atom type,
 119                                 unsigned char ** data)
 120 {
 121   /*
 122    * Caller always has to use "Xfree()" to free "data", since
 123    * "XGetWindowProperty() always allocates one extra byte in prop_return
 124    * [i.e. "data"] (even if the property is zero length) [..]".
 125    */
 126
 127   int status;  /*  Returned by "XGetWindowProperty". */
 128
 129   Atom          type_returned;
 130   int           temp_format;             /*  Not used. */
 131   unsigned long number_of_elements;
 132   unsigned long temp_bytes_after;        /*  Not used. */
 133
 134
 135   status = XGetWindowProperty(fgDisplay.Display,
 136                               window,
 137                               property,
 138                               0,
 139                               LONG_MAX,
 140                               False,
 141                               type,
 142                               &type_returned,
 143                               &temp_format,
 144                               &number_of_elements,
 145                               &temp_bytes_after,
 146                               data);
 147
 148   FREEGLUT_INTERNAL_ERROR_EXIT(status == Success,
 149                                "XGetWindowProperty failled",
 150                                "fghGetWindowProperty");
 151
 152   if (type_returned != type)
 153     {
 154       number_of_elements = 0;
 155     }
 156
 157   return number_of_elements;
 158 }
 159
 160 /*  Check if the window manager is NET WM compliant. */
 161 static int fghNetWMSupported(void)
 162 {
 163   Atom wm_check;
 164   Window ** window_ptr_1;
 165
 166   int number_of_windows;
 167   int net_wm_supported;
 168
 169
 170   net_wm_supported = 0;
 171
 172   wm_check = fghGetAtom("_NET_SUPPORTING_WM_CHECK");
 173   window_ptr_1 = malloc(sizeof(Window *));
 174
 175   /*
 176    * Check that the window manager has set this property on the root window.
 177    * The property must be the ID of a child window.
 178    */
 179   number_of_windows = fghGetWindowProperty(fgDisplay.RootWindow,
 180                                            wm_check,
 181                                            XA_WINDOW,
 182                                            (unsigned char **) window_ptr_1);
 183   if (number_of_windows == 1)
 184     {
 185       Window ** window_ptr_2;
 186
 187       window_ptr_2 = malloc(sizeof(Window *));
 188
 189       /* Check that the window has the same property set to the same value. */
 190       number_of_windows = fghGetWindowProperty(**window_ptr_1,
 191                                                wm_check,
 192                                                XA_WINDOW,
 193                                                (unsigned char **) window_ptr_2);
 194       if ((number_of_windows == 1) && (**window_ptr_1 == **window_ptr_2))
 195       {
 196         /* NET WM compliant */
 197         net_wm_supported = 1;
 198       }
 199
 200       XFree(*window_ptr_2);
 201       free(window_ptr_2);
 202     }
 203
 204         XFree(*window_ptr_1);
 205         free(window_ptr_1);
 206
 207         return net_wm_supported;
 208 }
 209
 210 /*  Check if "hint" is present in "property" for "window". */
 211 int fgHintPresent(Window window, Atom property, Atom hint)
 212 {
 213   Atom ** atoms_ptr;
 214   int number_of_atoms;
 215   int supported;
 216   int i;
 217
 218   supported = 0;
 219
 220   atoms_ptr = malloc(sizeof(Atom *));
 221   number_of_atoms = fghGetWindowProperty(window,
 222                                          property,
 223                                          XA_ATOM,
 224                                          (unsigned char **) atoms_ptr);
 225   for (i = 0; i < number_of_atoms; i++)
 226     {
 227       if ((*atoms_ptr)[i] == hint)
 228       {
 229           supported = 1;
 230           break;
 231       }
 232     }
 233
 234   return supported;
 235 }
 236
 237 #endif /*  TARGET_HOST_POSIX_X11  */
 238
 239
 240 /*
 241  * A call to this function should initialize all the display stuff...
 242  */
 243 static void fghInitialize( const char* displayName )
 244 {
 245 #if TARGET_HOST_POSIX_X11
 246     fgDisplay.Display = XOpenDisplay( displayName );
 247
 248     if( fgDisplay.Display == NULL )
 249         fgError( "failed to open display '%s'", XDisplayName( displayName ) );
 250
 251     if( !glXQueryExtension( fgDisplay.Display, NULL, NULL ) )
 252         fgError( "OpenGL GLX extension not supported by display '%s'",
 253             XDisplayName( displayName ) );
 254
 255     fgDisplay.Screen = DefaultScreen( fgDisplay.Display );
 256     fgDisplay.RootWindow = RootWindow(
 257         fgDisplay.Display,
 258         fgDisplay.Screen
 259     );
 260
 261     fgDisplay.ScreenWidth  = DisplayWidth(
 262         fgDisplay.Display,
 263         fgDisplay.Screen
 264     );
 265     fgDisplay.ScreenHeight = DisplayHeight(
 266         fgDisplay.Display,
 267         fgDisplay.Screen
 268     );
 269
 270     fgDisplay.ScreenWidthMM = DisplayWidthMM(
 271         fgDisplay.Display,
 272         fgDisplay.Screen
 273     );
 274     fgDisplay.ScreenHeightMM = DisplayHeightMM(
 275         fgDisplay.Display,
 276         fgDisplay.Screen
 277     );
 278
 279     fgDisplay.Connection = ConnectionNumber( fgDisplay.Display );
 280
 281     /* Create the window deletion atom */
 282     fgDisplay.DeleteWindow = fghGetAtom("WM_DELETE_WINDOW");
 283
 284     /* Create the state and full screen atoms */
 285     fgDisplay.State           = None;
 286     fgDisplay.StateFullScreen = None;
 287
 288     if (fghNetWMSupported())
 289     {
 290       const Atom supported = fghGetAtom("_NET_SUPPORTED");
 291       const Atom state     = fghGetAtom("_NET_WM_STATE");
 292
 293       /* Check if the state hint is supported. */
 294       if (fgHintPresent(fgDisplay.RootWindow, supported, state))
 295       {
 296         const Atom full_screen = fghGetAtom("_NET_WM_STATE_FULLSCREEN");
 297
 298         fgDisplay.State = state;
 299
 300         /* Check if the window manager supports full screen. */
 301         /**  Check "_NET_WM_ALLOWED_ACTIONS" on our window instead? **/
 302         if (fgHintPresent(fgDisplay.RootWindow, supported, full_screen))
 303         {
 304           fgDisplay.StateFullScreen = full_screen;
 305         }
 306       }
 307     }
 308
 309 #elif TARGET_HOST_MS_WINDOWS
 310
 311     WNDCLASS wc;
 312     ATOM atom;
 313
 314     /* What we need to do is to initialize the fgDisplay global structure here. */
 315     fgDisplay.Instance = GetModuleHandle( NULL );
 316     fgDisplay.DisplayName=strdup(displayName);
 317     atom = GetClassInfo( fgDisplay.Instance, _T("FREEGLUT"), &wc );
 318
 319     if( atom == 0 )
 320     {
 321         ZeroMemory( &wc, sizeof(WNDCLASS) );
 322
 323         /*
 324          * Each of the windows should have its own device context, and we
 325          * want redraw events during Vertical and Horizontal Resizes by
 326          * the user.
 327          *
 328          * XXX Old code had "| CS_DBCLCKS" commented out.  Plans for the
 329          * XXX future?  Dead-end idea?
 330          */
 331         wc.lpfnWndProc    = fgWindowProc;
 332         wc.cbClsExtra     = 0;
 333         wc.cbWndExtra     = 0;
 334         wc.hInstance      = fgDisplay.Instance;
 335         wc.hIcon          = LoadIcon( fgDisplay.Instance, _T("GLUT_ICON") );
 336
 337 #if defined(_WIN32_WCE)
 338         wc.style          = CS_HREDRAW | CS_VREDRAW;
 339 #else
 340         wc.style          = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
 341         if (!wc.hIcon)
 342           wc.hIcon        = LoadIcon( NULL, IDI_WINLOGO );
 343 #endif
 344
 345         wc.hCursor        = LoadCursor( NULL, IDC_ARROW );
 346         wc.hbrBackground  = NULL;
 347         wc.lpszMenuName   = NULL;
 348         wc.lpszClassName  = _T("FREEGLUT");
 349
 350         /* Register the window class */
 351         atom = RegisterClass( &wc );
 352         FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Not Registered", "fghInitialize" );
 353     }
 354
 355     /* The screen dimensions can be obtained via GetSystemMetrics() calls */
 356     fgDisplay.ScreenWidth  = GetSystemMetrics( SM_CXSCREEN );
 357     fgDisplay.ScreenHeight = GetSystemMetrics( SM_CYSCREEN );
 358
 359     {
 360         HWND desktop = GetDesktopWindow( );
 361         HDC  context = GetDC( desktop );
 362
 363         fgDisplay.ScreenWidthMM  = GetDeviceCaps( context, HORZSIZE );
 364         fgDisplay.ScreenHeightMM = GetDeviceCaps( context, VERTSIZE );
 365
 366         ReleaseDC( desktop, context );
 367     }
 368     /* If we have a DisplayName try to use it for metrics */
 369     if( fgDisplay.DisplayName )
 370     {
 371         HDC context = CreateDC(fgDisplay.DisplayName,0,0,0);
 372         if( context )
 373         {
 374             fgDisplay.ScreenWidth  = GetDeviceCaps( context, HORZRES );
 375             fgDisplay.ScreenHeight = GetDeviceCaps( context, VERTRES );
 376             fgDisplay.ScreenWidthMM  = GetDeviceCaps( context, HORZSIZE );
 377             fgDisplay.ScreenHeightMM = GetDeviceCaps( context, VERTSIZE );
 378             DeleteDC(context);
 379         }
 380         else
 381             fgWarning("fghInitialize: "
 382                       "CreateDC failed, Screen size info may be incorrect\n"
 383           "This is quite likely caused by a bad '-display' parameter");
 384
 385     }
 386     /* Set the timer granularity to 1 ms */
 387     timeBeginPeriod ( 1 );
 388
 389 #endif
 390
 391     fgState.Initialised = GL_TRUE;
 392
 393     /* InputDevice uses GlutTimerFunc(), so fgState.Initialised must be TRUE */
 394     fgInitialiseInputDevices();
 395 }
 396
 397 /*
 398  * Perform the freeglut deinitialization...
 399  */
 400 void fgDeinitialize( void )
 401 {
 402     SFG_Timer *timer;
 403
 404     if( !fgState.Initialised )
 405     {
 406         fgWarning( "fgDeinitialize(): "
 407                    "no valid initialization has been performed" );
 408         return;
 409     }
 410
 411     /* If there was a menu created, destroy the rendering context */
 412     if( fgStructure.MenuContext )
 413     {
 414 #if TARGET_HOST_POSIX_X11
 415         /* Note that the MVisualInfo is not owned by the MenuContext! */
 416         glXDestroyContext( fgDisplay.Display, fgStructure.MenuContext->MContext );
 417 #endif
 418         free( fgStructure.MenuContext );
 419         fgStructure.MenuContext = NULL;
 420     }
 421
 422     fgDestroyStructure( );
 423
 424     while( ( timer = fgState.Timers.First) )
 425     {
 426         fgListRemove( &fgState.Timers, &timer->Node );
 427         free( timer );
 428     }
 429
 430     while( ( timer = fgState.FreeTimers.First) )
 431     {
 432         fgListRemove( &fgState.FreeTimers, &timer->Node );
 433         free( timer );
 434     }
 435
 436 #if !defined(_WIN32_WCE)
 437     if ( fgState.JoysticksInitialised )
 438         fgJoystickClose( );
 439
 440     if ( fgState.InputDevsInitialised )
 441         fgInputDeviceClose( );
 442 #endif /* !defined(_WIN32_WCE) */
 443     fgState.JoysticksInitialised = GL_FALSE;
 444     fgState.InputDevsInitialised = GL_FALSE;
 445
 446     fgState.MajorVersion = 1;
 447     fgState.MinorVersion = 0;
 448     fgState.ContextFlags = 0;
 449     fgState.ContextProfile = 0;
 450
 451     fgState.Initialised = GL_FALSE;
 452
 453     fgState.Position.X = -1;
 454     fgState.Position.Y = -1;
 455     fgState.Position.Use = GL_FALSE;
 456
 457     fgState.Size.X = 300;
 458     fgState.Size.Y = 300;
 459     fgState.Size.Use = GL_TRUE;
 460
 461     fgState.DisplayMode = GLUT_RGBA | GLUT_SINGLE | GLUT_DEPTH;
 462
 463     fgState.DirectContext  = GLUT_TRY_DIRECT_CONTEXT;
 464     fgState.ForceIconic         = GL_FALSE;
 465     fgState.UseCurrentContext   = GL_FALSE;
 466     fgState.GLDebugSwitch       = GL_FALSE;
 467     fgState.XSyncSwitch         = GL_FALSE;
 468     fgState.ActionOnWindowClose = GLUT_ACTION_EXIT;
 469     fgState.ExecState           = GLUT_EXEC_STATE_INIT;
 470
 471     fgState.KeyRepeat       = GLUT_KEY_REPEAT_ON;
 472     fgState.Modifiers       = INVALID_MODIFIERS;
 473
 474     fgState.GameModeSize.X  = 640;
 475     fgState.GameModeSize.Y  = 480;
 476     fgState.GameModeDepth   =  16;
 477     fgState.GameModeRefresh =  72;
 478
 479     fgListInit( &fgState.Timers );
 480     fgListInit( &fgState.FreeTimers );
 481
 482     fgState.IdleCallback = NULL;
 483     fgState.MenuStateCallback = ( FGCBMenuState )NULL;
 484     fgState.MenuStatusCallback = ( FGCBMenuStatus )NULL;
 485
 486     fgState.SwapCount   = 0;
 487     fgState.SwapTime    = 0;
 488     fgState.FPSInterval = 0;
 489
 490     if( fgState.ProgramName )
 491     {
 492         free( fgState.ProgramName );
 493         fgState.ProgramName = NULL;
 494     }
 495
 496 #if TARGET_HOST_POSIX_X11
 497
 498     /*
 499      * Make sure all X-client data we have created will be destroyed on
 500      * display closing
 501      */
 502     XSetCloseDownMode( fgDisplay.Display, DestroyAll );
 503
 504     /*
 505      * Close the display connection, destroying all windows we have
 506      * created so far
 507      */
 508     XCloseDisplay( fgDisplay.Display );
 509
 510 #elif TARGET_HOST_MS_WINDOWS
 511     if( fgDisplay.DisplayName )
 512     {
 513         free( fgDisplay.DisplayName );
 514         fgDisplay.DisplayName = NULL;
 515     }
 516
 517     /* Reset the timer granularity */
 518     timeEndPeriod ( 1 );
 519
 520 #endif
 521
 522     fgState.Initialised = GL_FALSE;
 523 }
 524
 525 /*
 526  * Everything inside the following #ifndef is copied from the X sources.
 527  */
 528
 529 #if TARGET_HOST_MS_WINDOWS
 530
 531 /*
 532
 533 Copyright 1985, 1986, 1987,1998  The Open Group
 534
 535 Permission to use, copy, modify, distribute, and sell this software and its
 536 documentation for any purpose is hereby granted without fee, provided that
 537 the above copyright notice appear in all copies and that both that
 538 copyright notice and this permission notice appear in supporting
 539 documentation.
 540
 541 The above copyright notice and this permission notice shall be included
 542 in all copies or substantial portions of the Software.
 543
 544 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 545 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 546 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 547 IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
 548 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 549 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 550 OTHER DEALINGS IN THE SOFTWARE.
 551
 552 Except as contained in this notice, the name of The Open Group shall
 553 not be used in advertising or otherwise to promote the sale, use or
 554 other dealings in this Software without prior written authorization
 555 from The Open Group.
 556
 557 */
 558
 559 #define NoValue         0x0000
 560 #define XValue          0x0001
 561 #define YValue          0x0002
 562 #define WidthValue      0x0004
 563 #define HeightValue     0x0008
 564 #define AllValues       0x000F
 565 #define XNegative       0x0010
 566 #define YNegative       0x0020
 567
 568 /*
 569  *    XParseGeometry parses strings of the form
 570  *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
 571  *   width, height, xoffset, and yoffset are unsigned integers.
 572  *   Example:  "=80x24+300-49"
 573  *   The equal sign is optional.
 574  *   It returns a bitmask that indicates which of the four values
 575  *   were actually found in the string.  For each value found,
 576  *   the corresponding argument is updated;  for each value
 577  *   not found, the corresponding argument is left unchanged.
 578  */
 579
 580 static int
 581 ReadInteger(char *string, char **NextString)
 582 {
 583     register int Result = 0;
 584     int Sign = 1;
 585
 586     if (*string == '+')
 587         string++;
 588     else if (*string == '-')
 589     {
 590         string++;
 591         Sign = -1;
 592     }
 593     for (; (*string >= '0') && (*string <= '9'); string++)
 594     {
 595         Result = (Result * 10) + (*string - '0');
 596     }
 597     *NextString = string;
 598     if (Sign >= 0)
 599         return Result;
 600     else
 601         return -Result;
 602 }
 603
 604 static int XParseGeometry (
 605     const char *string,
 606     int *x,
 607     int *y,
 608     unsigned int *width,    /* RETURN */
 609     unsigned int *height)    /* RETURN */
 610 {
 611     int mask = NoValue;
 612     register char *strind;
 613     unsigned int tempWidth = 0, tempHeight = 0;
 614     int tempX = 0, tempY = 0;
 615     char *nextCharacter;
 616
 617     if ( (string == NULL) || (*string == '\0'))
 618       return mask;
 619     if (*string == '=')
 620         string++;  /* ignore possible '=' at beg of geometry spec */
 621
 622     strind = (char *)string;
 623     if (*strind != '+' && *strind != '-' && *strind != 'x') {
 624         tempWidth = ReadInteger(strind, &nextCharacter);
 625         if (strind == nextCharacter)
 626             return 0;
 627         strind = nextCharacter;
 628         mask |= WidthValue;
 629     }
 630
 631     if (*strind == 'x' || *strind == 'X') {
 632         strind++;
 633         tempHeight = ReadInteger(strind, &nextCharacter);
 634         if (strind == nextCharacter)
 635             return 0;
 636         strind = nextCharacter;
 637         mask |= HeightValue;
 638     }
 639
 640     if ((*strind == '+') || (*strind == '-')) {
 641         if (*strind == '-') {
 642             strind++;
 643             tempX = -ReadInteger(strind, &nextCharacter);
 644             if (strind == nextCharacter)
 645                 return 0;
 646             strind = nextCharacter;
 647             mask |= XNegative;
 648         }
 649         else
 650         {
 651             strind++;
 652             tempX = ReadInteger(strind, &nextCharacter);
 653             if (strind == nextCharacter)
 654                 return 0;
 655             strind = nextCharacter;
 656         }
 657         mask |= XValue;
 658         if ((*strind == '+') || (*strind == '-')) {
 659             if (*strind == '-') {
 660                 strind++;
 661                 tempY = -ReadInteger(strind, &nextCharacter);
 662                 if (strind == nextCharacter)
 663                     return 0;
 664                 strind = nextCharacter;
 665                 mask |= YNegative;
 666             }
 667             else
 668             {
 669                 strind++;
 670                 tempY = ReadInteger(strind, &nextCharacter);
 671                 if (strind == nextCharacter)
 672                     return 0;
 673                 strind = nextCharacter;
 674             }
 675             mask |= YValue;
 676         }
 677     }
 678
 679     /* If strind isn't at the end of the string the it's an invalid
 680        geometry specification. */
 681
 682     if (*strind != '\0') return 0;
 683
 684     if (mask & XValue)
 685         *x = tempX;
 686     if (mask & YValue)
 687         *y = tempY;
 688     if (mask & WidthValue)
 689         *width = tempWidth;
 690     if (mask & HeightValue)
 691         *height = tempHeight;
 692     return mask;
 693 }
 694 #endif
 695
 696 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
 697
 698 /*
 699  * Perform initialization. This usually happens on the program startup
 700  * and restarting after glutMainLoop termination...
 701  */
 702 void FGAPIENTRY glutInit( int* pargc, char** argv )
 703 {
 704     char* displayName = NULL;
 705     char* geometry = NULL;
 706     int i, j, argc = *pargc;
 707
 708     if( fgState.Initialised )
 709         fgError( "illegal glutInit() reinitialization attempt" );
 710
 711     if (pargc && *pargc && argv && *argv && **argv)
 712     {
 713         fgState.ProgramName = strdup (*argv);
 714
 715         if( !fgState.ProgramName )
 716             fgError ("Could not allocate space for the program's name.");
 717     }
 718
 719     fgCreateStructure( );
 720
 721     /* Get start time */
 722     fgState.Time = fgSystemTime();
 723
 724     /* check if GLUT_FPS env var is set */
 725 #ifndef _WIN32_WCE
 726     {
 727         const char *fps = getenv( "GLUT_FPS" );
 728
 729         if( fps )
 730         {
 731             int interval;
 732             sscanf( fps, "%d", &interval );
 733
 734             if( interval <= 0 )
 735                 fgState.FPSInterval = 5000;  /* 5000 millisecond default */
 736             else
 737                 fgState.FPSInterval = interval;
 738         }
 739     }
 740
 741     displayName = getenv( "DISPLAY" );
 742
 743     for( i = 1; i < argc; i++ )
 744     {
 745         if( strcmp( argv[ i ], "-display" ) == 0 )
 746         {
 747             if( ++i >= argc )
 748                 fgError( "-display parameter must be followed by display name" );
 749
 750             displayName = argv[ i ];
 751
 752             argv[ i - 1 ] = NULL;
 753             argv[ i     ] = NULL;
 754             ( *pargc ) -= 2;
 755         }
 756         else if( strcmp( argv[ i ], "-geometry" ) == 0 )
 757         {
 758             if( ++i >= argc )
 759                 fgError( "-geometry parameter must be followed by window "
 760                          "geometry settings" );
 761
 762             geometry = argv[ i ];
 763
 764             argv[ i - 1 ] = NULL;
 765             argv[ i     ] = NULL;
 766             ( *pargc ) -= 2;
 767         }
 768         else if( strcmp( argv[ i ], "-direct" ) == 0)
 769         {
 770             if( fgState.DirectContext == GLUT_FORCE_INDIRECT_CONTEXT )
 771                 fgError( "parameters ambiguity, -direct and -indirect "
 772                     "cannot be both specified" );
 773
 774             fgState.DirectContext = GLUT_FORCE_DIRECT_CONTEXT;
 775             argv[ i ] = NULL;
 776             ( *pargc )--;
 777         }
 778         else if( strcmp( argv[ i ], "-indirect" ) == 0 )
 779         {
 780             if( fgState.DirectContext == GLUT_FORCE_DIRECT_CONTEXT )
 781                 fgError( "parameters ambiguity, -direct and -indirect "
 782                     "cannot be both specified" );
 783
 784             fgState.DirectContext = GLUT_FORCE_INDIRECT_CONTEXT;
 785             argv[ i ] = NULL;
 786             (*pargc)--;
 787         }
 788         else if( strcmp( argv[ i ], "-iconic" ) == 0 )
 789         {
 790             fgState.ForceIconic = GL_TRUE;
 791             argv[ i ] = NULL;
 792             ( *pargc )--;
 793         }
 794         else if( strcmp( argv[ i ], "-gldebug" ) == 0 )
 795         {
 796             fgState.GLDebugSwitch = GL_TRUE;
 797             argv[ i ] = NULL;
 798             ( *pargc )--;
 799         }
 800         else if( strcmp( argv[ i ], "-sync" ) == 0 )
 801         {
 802             fgState.XSyncSwitch = GL_TRUE;
 803             argv[ i ] = NULL;
 804             ( *pargc )--;
 805         }
 806     }
 807
 808     /* Compact {argv}. */
 809     for( i = j = 1; i < *pargc; i++, j++ )
 810     {
 811         /* Guaranteed to end because there are "*pargc" arguments left */
 812         while ( argv[ j ] == NULL )
 813             j++;
 814         if ( i != j )
 815             argv[ i ] = argv[ j ];
 816     }
 817
 818 #endif /* _WIN32_WCE */
 819
 820     /*
 821      * Have the display created now. If there wasn't a "-display"
 822      * in the program arguments, we will use the DISPLAY environment
 823      * variable for opening the X display (see code above):
 824      */
 825     fghInitialize( displayName );
 826
 827     /*
 828      * Geometry parsing deffered until here because we may need the screen
 829      * size.
 830      */
 831
 832     if (geometry )
 833     {
 834         unsigned int parsedWidth, parsedHeight;
 835         int mask = XParseGeometry( geometry,
 836                                    &fgState.Position.X, &fgState.Position.Y,
 837                                    &parsedWidth, &parsedHeight );
 838         /* TODO: Check for overflow? */
 839         fgState.Size.X = parsedWidth;
 840         fgState.Size.Y = parsedHeight;
 841
 842         if( (mask & (WidthValue|HeightValue)) == (WidthValue|HeightValue) )
 843             fgState.Size.Use = GL_TRUE;
 844
 845         if( mask & XNegative )
 846             fgState.Position.X += fgDisplay.ScreenWidth - fgState.Size.X;
 847
 848         if( mask & YNegative )
 849             fgState.Position.Y += fgDisplay.ScreenHeight - fgState.Size.Y;
 850
 851         if( (mask & (XValue|YValue)) == (XValue|YValue) )
 852             fgState.Position.Use = GL_TRUE;
 853     }
 854 }
 855
 856 #if TARGET_HOST_MS_WINDOWS
 857 void (__cdecl *__glutExitFunc)( int return_value ) = NULL;
 858
 859 void FGAPIENTRY __glutInitWithExit( int *pargc, char **argv, void (__cdecl *exit_function)(int) )
 860 {
 861   __glutExitFunc = exit_function;
 862   glutInit(pargc, argv);
 863 }
 864 #endif
 865
 866 /*
 867  * Undoes all the "glutInit" stuff
 868  */
 869 void FGAPIENTRY glutExit ( void )
 870 {
 871   fgDeinitialize ();
 872 }
 873
 874 /*
 875  * Sets the default initial window position for new windows
 876  */
 877 void FGAPIENTRY glutInitWindowPosition( int x, int y )
 878 {
 879     fgState.Position.X = x;
 880     fgState.Position.Y = y;
 881
 882     if( ( x >= 0 ) && ( y >= 0 ) )
 883         fgState.Position.Use = GL_TRUE;
 884     else
 885         fgState.Position.Use = GL_FALSE;
 886 }
 887
 888 /*
 889  * Sets the default initial window size for new windows
 890  */
 891 void FGAPIENTRY glutInitWindowSize( int width, int height )
 892 {
 893     fgState.Size.X = width;
 894     fgState.Size.Y = height;
 895
 896     if( ( width > 0 ) && ( height > 0 ) )
 897         fgState.Size.Use = GL_TRUE;
 898     else
 899         fgState.Size.Use = GL_FALSE;
 900 }
 901
 902 /*
 903  * Sets the default display mode for all new windows
 904  */
 905 void FGAPIENTRY glutInitDisplayMode( unsigned int displayMode )
 906 {
 907     /* We will make use of this value when creating a new OpenGL context... */
 908     fgState.DisplayMode = displayMode;
 909 }
 910
 911
 912 /* -- INIT DISPLAY STRING PARSING ------------------------------------------ */
 913
 914 static char* Tokens[] =
 915 {
 916     "alpha", "acca", "acc", "blue", "buffer", "conformant", "depth", "double",
 917     "green", "index", "num", "red", "rgba", "rgb", "luminance", "stencil",
 918     "single", "stereo", "samples", "slow", "win32pdf", "win32pfd", "xvisual",
 919     "xstaticgray", "xgrayscale", "xstaticcolor", "xpseudocolor",
 920     "xtruecolor", "xdirectcolor",
 921     "xstaticgrey", "xgreyscale", "xstaticcolour", "xpseudocolour",
 922     "xtruecolour", "xdirectcolour", "borderless", "aux"
 923 };
 924 #define NUM_TOKENS             (sizeof(Tokens) / sizeof(*Tokens))
 925
 926 void FGAPIENTRY glutInitDisplayString( const char* displayMode )
 927 {
 928     int glut_state_flag = 0 ;
 929     /*
 930      * Unpack a lot of options from a character string.  The options are
 931      * delimited by blanks or tabs.
 932      */
 933     char *token ;
 934     size_t len = strlen ( displayMode );
 935     char *buffer = (char *)malloc ( (len+1) * sizeof(char) );
 936     memcpy ( buffer, displayMode, len );
 937     buffer[len] = '\0';
 938
 939     token = strtok ( buffer, " \t" );
 940
 941     while ( token )
 942     {
 943         /* Process this token */
 944         int i ;
 945
 946         /* Temporary fix:  Ignore any length specifications and at least
 947          * process the basic token
 948          * TODO:  Fix this permanently
 949          */
 950         size_t cleanlength = strcspn ( token, "=<>~!" );
 951
 952         for ( i = 0; i < NUM_TOKENS; i++ )
 953         {
 954             if ( strncmp ( token, Tokens[i], cleanlength ) == 0 ) break ;
 955         }
 956
 957         switch ( i )
 958         {
 959         case 0 :  /* "alpha":  Alpha color buffer precision in bits */
 960             glut_state_flag |= GLUT_ALPHA ;  /* Somebody fix this for me! */
 961             break ;
 962
 963         case 1 :  /* "acca":  Red, green, blue, and alpha accumulation buffer
 964                      precision in bits */
 965             break ;
 966
 967         case 2 :  /* "acc":  Red, green, and blue accumulation buffer precision
 968                      in bits with zero bits alpha */
 969             glut_state_flag |= GLUT_ACCUM ;  /* Somebody fix this for me! */
 970             break ;
 971
 972         case 3 :  /* "blue":  Blue color buffer precision in bits */
 973             break ;
 974
 975         case 4 :  /* "buffer":  Number of bits in the color index color buffer
 976                    */
 977             break ;
 978
 979         case 5 :  /* "conformant":  Boolean indicating if the frame buffer
 980                      configuration is conformant or not */
 981             break ;
 982
 983         case 6 : /* "depth":  Number of bits of precsion in the depth buffer */
 984             glut_state_flag |= GLUT_DEPTH ;  /* Somebody fix this for me! */
 985             break ;
 986
 987         case 7 :  /* "double":  Boolean indicating if the color buffer is
 988                      double buffered */
 989             glut_state_flag |= GLUT_DOUBLE ;
 990             break ;
 991
 992         case 8 :  /* "green":  Green color buffer precision in bits */
 993             break ;
 994
 995         case 9 :  /* "index":  Boolean if the color model is color index or not
 996                    */
 997             glut_state_flag |= GLUT_INDEX ;
 998             break ;
 999
1000         case 10 :  /* "num":  A special capability  name indicating where the
1001                       value represents the Nth frame buffer configuration
1002                       matching the description string */
1003             break ;
1004
1005         case 11 :  /* "red":  Red color buffer precision in bits */
1006             break ;
1007
1008         case 12 :  /* "rgba":  Number of bits of red, green, blue, and alpha in
1009                       the RGBA color buffer */
1010             glut_state_flag |= GLUT_RGBA ;  /* Somebody fix this for me! */
1011             break ;
1012
1013         case 13 :  /* "rgb":  Number of bits of red, green, and blue in the
1014                       RGBA color buffer with zero bits alpha */
1015             glut_state_flag |= GLUT_RGB ;  /* Somebody fix this for me! */
1016             break ;
1017
1018         case 14 :  /* "luminance":  Number of bits of red in the RGBA and zero
1019                       bits of green, blue (alpha not specified) of color buffer
1020                       precision */
1021             glut_state_flag |= GLUT_LUMINANCE ; /* Somebody fix this for me! */
1022             break ;
1023
1024         case 15 :  /* "stencil":  Number of bits in the stencil buffer */
1025             glut_state_flag |= GLUT_STENCIL;  /* Somebody fix this for me! */
1026             break ;
1027
1028         case 16 :  /* "single":  Boolean indicate the color buffer is single
1029                       buffered */
1030             glut_state_flag |= GLUT_SINGLE ;
1031             break ;
1032
1033         case 17 :  /* "stereo":  Boolean indicating the color buffer supports
1034                       OpenGL-style stereo */
1035             glut_state_flag |= GLUT_STEREO ;
1036             break ;
1037
1038         case 18 :  /* "samples":  Indicates the number of multisamples to use
1039                       based on GLX's SGIS_multisample extension (for
1040                       antialiasing) */
1041             glut_state_flag |= GLUT_MULTISAMPLE ; /*Somebody fix this for me!*/
1042             break ;
1043
1044         case 19 :  /* "slow":  Boolean indicating if the frame buffer
1045                       configuration is slow or not */
1046             break ;
1047
1048         case 20 :  /* "win32pdf": (incorrect spelling but was there before */
1049         case 21 :  /* "win32pfd":  matches the Win32 Pixel Format Descriptor by
1050                       number */
1051 #if TARGET_HOST_MS_WINDOWS
1052 #endif
1053             break ;
1054
1055         case 22 :  /* "xvisual":  matches the X visual ID by number */
1056 #if TARGET_HOST_POSIX_X11
1057 #endif
1058             break ;
1059
1060         case 23 :  /* "xstaticgray": */
1061         case 29 :  /* "xstaticgrey":  boolean indicating if the frame buffer
1062                       configuration's X visual is of type StaticGray */
1063 #if TARGET_HOST_POSIX_X11
1064 #endif
1065             break ;
1066
1067         case 24 :  /* "xgrayscale": */
1068         case 30 :  /* "xgreyscale":  boolean indicating if the frame buffer
1069                       configuration's X visual is of type GrayScale */
1070 #if TARGET_HOST_POSIX_X11
1071 #endif
1072             break ;
1073
1074         case 25 :  /* "xstaticcolor": */
1075         case 31 :  /* "xstaticcolour":  boolean indicating if the frame buffer
1076                       configuration's X visual is of type StaticColor */
1077 #if TARGET_HOST_POSIX_X11
1078 #endif
1079             break ;
1080
1081         case 26 :  /* "xpseudocolor": */
1082         case 32 :  /* "xpseudocolour":  boolean indicating if the frame buffer
1083                       configuration's X visual is of type PseudoColor */
1084 #if TARGET_HOST_POSIX_X11
1085 #endif
1086             break ;
1087
1088         case 27 :  /* "xtruecolor": */
1089         case 33 :  /* "xtruecolour":  boolean indicating if the frame buffer
1090                       configuration's X visual is of type TrueColor */
1091 #if TARGET_HOST_POSIX_X11
1092 #endif
1093             break ;
1094
1095         case 28 :  /* "xdirectcolor": */
1096         case 34 :  /* "xdirectcolour":  boolean indicating if the frame buffer
1097                       configuration's X visual is of type DirectColor */
1098 #if TARGET_HOST_POSIX_X11
1099 #endif
1100             break ;
1101
1102         case 35 :  /* "borderless":  windows should not have borders */
1103 #if TARGET_HOST_POSIX_X11
1104 #endif
1105             break ;
1106
1107         case 36 :  /* "aux":  some number of aux buffers */
1108             glut_state_flag |= GLUT_AUX;
1109             break ;
1110
1111         case 37 :  /* Unrecognized */
1112             fgWarning ( "WARNING - Display string token not recognized:  %s",
1113                         token );
1114             break ;
1115         }
1116
1117         token = strtok ( NULL, " \t" );
1118     }
1119
1120     free ( buffer );
1121
1122     /* We will make use of this value when creating a new OpenGL context... */
1123     fgState.DisplayMode = glut_state_flag;
1124 }
1125
1126 /* -- SETTING OPENGL 3.0 CONTEXT CREATION PARAMETERS ---------------------- */
1127
1128 void FGAPIENTRY glutInitContextVersion( int majorVersion, int minorVersion )
1129 {
1130     /* We will make use of these valuse when creating a new OpenGL context... */
1131     fgState.MajorVersion = majorVersion;
1132     fgState.MinorVersion = minorVersion;
1133 }
1134
1135
1136 void FGAPIENTRY glutInitContextFlags( int flags )
1137 {
1138     /* We will make use of this value when creating a new OpenGL context... */
1139     fgState.ContextFlags = flags;
1140 }
1141
1142 void FGAPIENTRY glutInitContextProfile( int profile )
1143 {
1144     /* We will make use of this value when creating a new OpenGL context... */
1145     fgState.ContextProfile = profile;
1146 }
1147
1148 /* -------------- User Defined Error/Warning Handler Support -------------- */
1149
1150 /*
1151  * Sets the user error handler (note the use of va_list for the args to the fmt)
1152  */
1153 void FGAPIENTRY glutInitErrorFunc( void (* vfgError) ( const char *fmt, va_list ap ) )
1154 {
1155     /* This allows user programs to handle freeglut errors */
1156     fgState.ErrorFunc = vfgError;
1157 }
1158
1159 /*
1160  * Sets the user warning handler (note the use of va_list for the args to the fmt)
1161  */
1162 void FGAPIENTRY glutInitWarningFunc( void (* vfgWarning) ( const char *fmt, va_list ap ) )
1163 {
1164     /* This allows user programs to handle freeglut warnings */
1165     fgState.ErrorFunc = vfgWarning;
1166 }
1167
1168 /*** END OF FILE ***/