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