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
 394     /* Avoid registering atexit callback on Win32 as it results in an access
 395      * violation due to calling into a module which has been unloaded. */
 396 #if ( TARGET_HOST_MS_WINDOWS == 0 )
 397     atexit(fgDeinitialize);
 398 #endif
 399
 400     /* InputDevice uses GlutTimerFunc(), so fgState.Initialised must be TRUE */
 401     fgInitialiseInputDevices();
 402 }
 403
 404 /*
 405  * Perform the freeglut deinitialization...
 406  */
 407 void fgDeinitialize( void )
 408 {
 409     SFG_Timer *timer;
 410
 411     if( !fgState.Initialised )
 412     {
 413         return;
 414     }
 415
 416         /* If we're in game mode, we want to leave game mode */
 417     if( fgStructure.GameModeWindow ) {
 418         glutLeaveGameMode();
 419     }
 420
 421     /* If there was a menu created, destroy the rendering context */
 422     if( fgStructure.MenuContext )
 423     {
 424 #if TARGET_HOST_POSIX_X11
 425         /* Note that the MVisualInfo is not owned by the MenuContext! */
 426         glXDestroyContext( fgDisplay.Display, fgStructure.MenuContext->MContext );
 427 #endif
 428         free( fgStructure.MenuContext );
 429         fgStructure.MenuContext = NULL;
 430     }
 431
 432     fgDestroyStructure( );
 433
 434     while( ( timer = fgState.Timers.First) )
 435     {
 436         fgListRemove( &fgState.Timers, &timer->Node );
 437         free( timer );
 438     }
 439
 440     while( ( timer = fgState.FreeTimers.First) )
 441     {
 442         fgListRemove( &fgState.FreeTimers, &timer->Node );
 443         free( timer );
 444     }
 445
 446 #if !defined(_WIN32_WCE)
 447     if ( fgState.JoysticksInitialised )
 448         fgJoystickClose( );
 449
 450     if ( fgState.InputDevsInitialised )
 451         fgInputDeviceClose( );
 452 #endif /* !defined(_WIN32_WCE) */
 453     fgState.JoysticksInitialised = GL_FALSE;
 454     fgState.InputDevsInitialised = GL_FALSE;
 455
 456         fgState.MouseWheelTicks = 0;
 457
 458     fgState.MajorVersion = 1;
 459     fgState.MinorVersion = 0;
 460     fgState.ContextFlags = 0;
 461     fgState.ContextProfile = 0;
 462
 463     fgState.Initialised = GL_FALSE;
 464
 465     fgState.Position.X = -1;
 466     fgState.Position.Y = -1;
 467     fgState.Position.Use = GL_FALSE;
 468
 469     fgState.Size.X = 300;
 470     fgState.Size.Y = 300;
 471     fgState.Size.Use = GL_TRUE;
 472
 473     fgState.DisplayMode = GLUT_RGBA | GLUT_SINGLE | GLUT_DEPTH;
 474
 475     fgState.DirectContext  = GLUT_TRY_DIRECT_CONTEXT;
 476     fgState.ForceIconic         = GL_FALSE;
 477     fgState.UseCurrentContext   = GL_FALSE;
 478     fgState.GLDebugSwitch       = GL_FALSE;
 479     fgState.XSyncSwitch         = GL_FALSE;
 480     fgState.ActionOnWindowClose = GLUT_ACTION_EXIT;
 481     fgState.ExecState           = GLUT_EXEC_STATE_INIT;
 482
 483     fgState.KeyRepeat       = GLUT_KEY_REPEAT_ON;
 484     fgState.Modifiers       = INVALID_MODIFIERS;
 485
 486     fgState.GameModeSize.X  = 640;
 487     fgState.GameModeSize.Y  = 480;
 488     fgState.GameModeDepth   =  16;
 489     fgState.GameModeRefresh =  72;
 490
 491     fgListInit( &fgState.Timers );
 492     fgListInit( &fgState.FreeTimers );
 493
 494     fgState.IdleCallback = NULL;
 495     fgState.MenuStateCallback = ( FGCBMenuState )NULL;
 496     fgState.MenuStatusCallback = ( FGCBMenuStatus )NULL;
 497
 498     fgState.SwapCount   = 0;
 499     fgState.SwapTime    = 0;
 500     fgState.FPSInterval = 0;
 501
 502     if( fgState.ProgramName )
 503     {
 504         free( fgState.ProgramName );
 505         fgState.ProgramName = NULL;
 506     }
 507
 508 #if TARGET_HOST_POSIX_X11
 509
 510     /*
 511      * Make sure all X-client data we have created will be destroyed on
 512      * display closing
 513      */
 514     XSetCloseDownMode( fgDisplay.Display, DestroyAll );
 515
 516     /*
 517      * Close the display connection, destroying all windows we have
 518      * created so far
 519      */
 520     XCloseDisplay( fgDisplay.Display );
 521
 522 #elif TARGET_HOST_MS_WINDOWS
 523     if( fgDisplay.DisplayName )
 524     {
 525         free( fgDisplay.DisplayName );
 526         fgDisplay.DisplayName = NULL;
 527     }
 528
 529     /* Reset the timer granularity */
 530     timeEndPeriod ( 1 );
 531
 532 #endif
 533
 534     fgState.Initialised = GL_FALSE;
 535 }
 536
 537 /*
 538  * Everything inside the following #ifndef is copied from the X sources.
 539  */
 540
 541 #if TARGET_HOST_MS_WINDOWS
 542
 543 /*
 544
 545 Copyright 1985, 1986, 1987,1998  The Open Group
 546
 547 Permission to use, copy, modify, distribute, and sell this software and its
 548 documentation for any purpose is hereby granted without fee, provided that
 549 the above copyright notice appear in all copies and that both that
 550 copyright notice and this permission notice appear in supporting
 551 documentation.
 552
 553 The above copyright notice and this permission notice shall be included
 554 in all copies or substantial portions of the Software.
 555
 556 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 557 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 558 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 559 IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
 560 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 561 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 562 OTHER DEALINGS IN THE SOFTWARE.
 563
 564 Except as contained in this notice, the name of The Open Group shall
 565 not be used in advertising or otherwise to promote the sale, use or
 566 other dealings in this Software without prior written authorization
 567 from The Open Group.
 568
 569 */
 570
 571 #define NoValue         0x0000
 572 #define XValue          0x0001
 573 #define YValue          0x0002
 574 #define WidthValue      0x0004
 575 #define HeightValue     0x0008
 576 #define AllValues       0x000F
 577 #define XNegative       0x0010
 578 #define YNegative       0x0020
 579
 580 /*
 581  *    XParseGeometry parses strings of the form
 582  *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
 583  *   width, height, xoffset, and yoffset are unsigned integers.
 584  *   Example:  "=80x24+300-49"
 585  *   The equal sign is optional.
 586  *   It returns a bitmask that indicates which of the four values
 587  *   were actually found in the string.  For each value found,
 588  *   the corresponding argument is updated;  for each value
 589  *   not found, the corresponding argument is left unchanged.
 590  */
 591
 592 static int
 593 ReadInteger(char *string, char **NextString)
 594 {
 595     register int Result = 0;
 596     int Sign = 1;
 597
 598     if (*string == '+')
 599         string++;
 600     else if (*string == '-')
 601     {
 602         string++;
 603         Sign = -1;
 604     }
 605     for (; (*string >= '0') && (*string <= '9'); string++)
 606     {
 607         Result = (Result * 10) + (*string - '0');
 608     }
 609     *NextString = string;
 610     if (Sign >= 0)
 611         return Result;
 612     else
 613         return -Result;
 614 }
 615
 616 static int XParseGeometry (
 617     const char *string,
 618     int *x,
 619     int *y,
 620     unsigned int *width,    /* RETURN */
 621     unsigned int *height)    /* RETURN */
 622 {
 623     int mask = NoValue;
 624     register char *strind;
 625     unsigned int tempWidth = 0, tempHeight = 0;
 626     int tempX = 0, tempY = 0;
 627     char *nextCharacter;
 628
 629     if ( (string == NULL) || (*string == '\0'))
 630       return mask;
 631     if (*string == '=')
 632         string++;  /* ignore possible '=' at beg of geometry spec */
 633
 634     strind = (char *)string;
 635     if (*strind != '+' && *strind != '-' && *strind != 'x') {
 636         tempWidth = ReadInteger(strind, &nextCharacter);
 637         if (strind == nextCharacter)
 638             return 0;
 639         strind = nextCharacter;
 640         mask |= WidthValue;
 641     }
 642
 643     if (*strind == 'x' || *strind == 'X') {
 644         strind++;
 645         tempHeight = ReadInteger(strind, &nextCharacter);
 646         if (strind == nextCharacter)
 647             return 0;
 648         strind = nextCharacter;
 649         mask |= HeightValue;
 650     }
 651
 652     if ((*strind == '+') || (*strind == '-')) {
 653         if (*strind == '-') {
 654             strind++;
 655             tempX = -ReadInteger(strind, &nextCharacter);
 656             if (strind == nextCharacter)
 657                 return 0;
 658             strind = nextCharacter;
 659             mask |= XNegative;
 660         }
 661         else
 662         {
 663             strind++;
 664             tempX = ReadInteger(strind, &nextCharacter);
 665             if (strind == nextCharacter)
 666                 return 0;
 667             strind = nextCharacter;
 668         }
 669         mask |= XValue;
 670         if ((*strind == '+') || (*strind == '-')) {
 671             if (*strind == '-') {
 672                 strind++;
 673                 tempY = -ReadInteger(strind, &nextCharacter);
 674                 if (strind == nextCharacter)
 675                     return 0;
 676                 strind = nextCharacter;
 677                 mask |= YNegative;
 678             }
 679             else
 680             {
 681                 strind++;
 682                 tempY = ReadInteger(strind, &nextCharacter);
 683                 if (strind == nextCharacter)
 684                     return 0;
 685                 strind = nextCharacter;
 686             }
 687             mask |= YValue;
 688         }
 689     }
 690
 691     /* If strind isn't at the end of the string the it's an invalid
 692        geometry specification. */
 693
 694     if (*strind != '\0') return 0;
 695
 696     if (mask & XValue)
 697         *x = tempX;
 698     if (mask & YValue)
 699         *y = tempY;
 700     if (mask & WidthValue)
 701         *width = tempWidth;
 702     if (mask & HeightValue)
 703         *height = tempHeight;
 704     return mask;
 705 }
 706 #endif
 707
 708 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
 709
 710 /*
 711  * Perform initialization. This usually happens on the program startup
 712  * and restarting after glutMainLoop termination...
 713  */
 714 void FGAPIENTRY glutInit( int* pargc, char** argv )
 715 {
 716     char* displayName = NULL;
 717     char* geometry = NULL;
 718     int i, j, argc = *pargc;
 719
 720     if( fgState.Initialised )
 721         fgError( "illegal glutInit() reinitialization attempt" );
 722
 723     if (pargc && *pargc && argv && *argv && **argv)
 724     {
 725         fgState.ProgramName = strdup (*argv);
 726
 727         if( !fgState.ProgramName )
 728             fgError ("Could not allocate space for the program's name.");
 729     }
 730
 731     fgCreateStructure( );
 732
 733     /* Get start time */
 734     fgState.Time = fgSystemTime();
 735
 736     /* check if GLUT_FPS env var is set */
 737 #ifndef _WIN32_WCE
 738     {
 739         const char *fps = getenv( "GLUT_FPS" );
 740
 741         if( fps )
 742         {
 743             int interval;
 744             sscanf( fps, "%d", &interval );
 745
 746             if( interval <= 0 )
 747                 fgState.FPSInterval = 5000;  /* 5000 millisecond default */
 748             else
 749                 fgState.FPSInterval = interval;
 750         }
 751     }
 752
 753     displayName = getenv( "DISPLAY" );
 754
 755     for( i = 1; i < argc; i++ )
 756     {
 757         if( strcmp( argv[ i ], "-display" ) == 0 )
 758         {
 759             if( ++i >= argc )
 760                 fgError( "-display parameter must be followed by display name" );
 761
 762             displayName = argv[ i ];
 763
 764             argv[ i - 1 ] = NULL;
 765             argv[ i     ] = NULL;
 766             ( *pargc ) -= 2;
 767         }
 768         else if( strcmp( argv[ i ], "-geometry" ) == 0 )
 769         {
 770             if( ++i >= argc )
 771                 fgError( "-geometry parameter must be followed by window "
 772                          "geometry settings" );
 773
 774             geometry = argv[ i ];
 775
 776             argv[ i - 1 ] = NULL;
 777             argv[ i     ] = NULL;
 778             ( *pargc ) -= 2;
 779         }
 780         else if( strcmp( argv[ i ], "-direct" ) == 0)
 781         {
 782             if( fgState.DirectContext == GLUT_FORCE_INDIRECT_CONTEXT )
 783                 fgError( "parameters ambiguity, -direct and -indirect "
 784                     "cannot be both specified" );
 785
 786             fgState.DirectContext = GLUT_FORCE_DIRECT_CONTEXT;
 787             argv[ i ] = NULL;
 788             ( *pargc )--;
 789         }
 790         else if( strcmp( argv[ i ], "-indirect" ) == 0 )
 791         {
 792             if( fgState.DirectContext == GLUT_FORCE_DIRECT_CONTEXT )
 793                 fgError( "parameters ambiguity, -direct and -indirect "
 794                     "cannot be both specified" );
 795
 796             fgState.DirectContext = GLUT_FORCE_INDIRECT_CONTEXT;
 797             argv[ i ] = NULL;
 798             (*pargc)--;
 799         }
 800         else if( strcmp( argv[ i ], "-iconic" ) == 0 )
 801         {
 802             fgState.ForceIconic = GL_TRUE;
 803             argv[ i ] = NULL;
 804             ( *pargc )--;
 805         }
 806         else if( strcmp( argv[ i ], "-gldebug" ) == 0 )
 807         {
 808             fgState.GLDebugSwitch = GL_TRUE;
 809             argv[ i ] = NULL;
 810             ( *pargc )--;
 811         }
 812         else if( strcmp( argv[ i ], "-sync" ) == 0 )
 813         {
 814             fgState.XSyncSwitch = GL_TRUE;
 815             argv[ i ] = NULL;
 816             ( *pargc )--;
 817         }
 818     }
 819
 820     /* Compact {argv}. */
 821     for( i = j = 1; i < *pargc; i++, j++ )
 822     {
 823         /* Guaranteed to end because there are "*pargc" arguments left */
 824         while ( argv[ j ] == NULL )
 825             j++;
 826         if ( i != j )
 827             argv[ i ] = argv[ j ];
 828     }
 829
 830 #endif /* _WIN32_WCE */
 831
 832     /*
 833      * Have the display created now. If there wasn't a "-display"
 834      * in the program arguments, we will use the DISPLAY environment
 835      * variable for opening the X display (see code above):
 836      */
 837     fghInitialize( displayName );
 838
 839     /*
 840      * Geometry parsing deffered until here because we may need the screen
 841      * size.
 842      */
 843
 844     if (geometry )
 845     {
 846         unsigned int parsedWidth, parsedHeight;
 847         int mask = XParseGeometry( geometry,
 848                                    &fgState.Position.X, &fgState.Position.Y,
 849                                    &parsedWidth, &parsedHeight );
 850         /* TODO: Check for overflow? */
 851         fgState.Size.X = parsedWidth;
 852         fgState.Size.Y = parsedHeight;
 853
 854         if( (mask & (WidthValue|HeightValue)) == (WidthValue|HeightValue) )
 855             fgState.Size.Use = GL_TRUE;
 856
 857         if( mask & XNegative )
 858             fgState.Position.X += fgDisplay.ScreenWidth - fgState.Size.X;
 859
 860         if( mask & YNegative )
 861             fgState.Position.Y += fgDisplay.ScreenHeight - fgState.Size.Y;
 862
 863         if( (mask & (XValue|YValue)) == (XValue|YValue) )
 864             fgState.Position.Use = GL_TRUE;
 865     }
 866 }
 867
 868 #if TARGET_HOST_MS_WINDOWS
 869 void (__cdecl *__glutExitFunc)( int return_value ) = NULL;
 870
 871 void FGAPIENTRY __glutInitWithExit( int *pargc, char **argv, void (__cdecl *exit_function)(int) )
 872 {
 873   __glutExitFunc = exit_function;
 874   glutInit(pargc, argv);
 875 }
 876 #endif
 877
 878 /*
 879  * Undoes all the "glutInit" stuff
 880  */
 881 void FGAPIENTRY glutExit ( void )
 882 {
 883   fgDeinitialize ();
 884 }
 885
 886 /*
 887  * Sets the default initial window position for new windows
 888  */
 889 void FGAPIENTRY glutInitWindowPosition( int x, int y )
 890 {
 891     fgState.Position.X = x;
 892     fgState.Position.Y = y;
 893
 894     if( ( x >= 0 ) && ( y >= 0 ) )
 895         fgState.Position.Use = GL_TRUE;
 896     else
 897         fgState.Position.Use = GL_FALSE;
 898 }
 899
 900 /*
 901  * Sets the default initial window size for new windows
 902  */
 903 void FGAPIENTRY glutInitWindowSize( int width, int height )
 904 {
 905     fgState.Size.X = width;
 906     fgState.Size.Y = height;
 907
 908     if( ( width > 0 ) && ( height > 0 ) )
 909         fgState.Size.Use = GL_TRUE;
 910     else
 911         fgState.Size.Use = GL_FALSE;
 912 }
 913
 914 /*
 915  * Sets the default display mode for all new windows
 916  */
 917 void FGAPIENTRY glutInitDisplayMode( unsigned int displayMode )
 918 {
 919     /* We will make use of this value when creating a new OpenGL context... */
 920     fgState.DisplayMode = displayMode;
 921 }
 922
 923
 924 /* -- INIT DISPLAY STRING PARSING ------------------------------------------ */
 925
 926 static char* Tokens[] =
 927 {
 928     "alpha", "acca", "acc", "blue", "buffer", "conformant", "depth", "double",
 929     "green", "index", "num", "red", "rgba", "rgb", "luminance", "stencil",
 930     "single", "stereo", "samples", "slow", "win32pdf", "win32pfd", "xvisual",
 931     "xstaticgray", "xgrayscale", "xstaticcolor", "xpseudocolor",
 932     "xtruecolor", "xdirectcolor",
 933     "xstaticgrey", "xgreyscale", "xstaticcolour", "xpseudocolour",
 934     "xtruecolour", "xdirectcolour", "borderless", "aux"
 935 };
 936 #define NUM_TOKENS             (sizeof(Tokens) / sizeof(*Tokens))
 937
 938 void FGAPIENTRY glutInitDisplayString( const char* displayMode )
 939 {
 940     int glut_state_flag = 0 ;
 941     /*
 942      * Unpack a lot of options from a character string.  The options are
 943      * delimited by blanks or tabs.
 944      */
 945     char *token ;
 946     size_t len = strlen ( displayMode );
 947     char *buffer = (char *)malloc ( (len+1) * sizeof(char) );
 948     memcpy ( buffer, displayMode, len );
 949     buffer[len] = '\0';
 950
 951     token = strtok ( buffer, " \t" );
 952
 953     while ( token )
 954     {
 955         /* Process this token */
 956         int i ;
 957
 958         /* Temporary fix:  Ignore any length specifications and at least
 959          * process the basic token
 960          * TODO:  Fix this permanently
 961          */
 962         size_t cleanlength = strcspn ( token, "=<>~!" );
 963
 964         for ( i = 0; i < NUM_TOKENS; i++ )
 965         {
 966             if ( strncmp ( token, Tokens[i], cleanlength ) == 0 ) break ;
 967         }
 968
 969         switch ( i )
 970         {
 971         case 0 :  /* "alpha":  Alpha color buffer precision in bits */
 972             glut_state_flag |= GLUT_ALPHA ;  /* Somebody fix this for me! */
 973             break ;
 974
 975         case 1 :  /* "acca":  Red, green, blue, and alpha accumulation buffer
 976                      precision in bits */
 977             break ;
 978
 979         case 2 :  /* "acc":  Red, green, and blue accumulation buffer precision
 980                      in bits with zero bits alpha */
 981             glut_state_flag |= GLUT_ACCUM ;  /* Somebody fix this for me! */
 982             break ;
 983
 984         case 3 :  /* "blue":  Blue color buffer precision in bits */
 985             break ;
 986
 987         case 4 :  /* "buffer":  Number of bits in the color index color buffer
 988                    */
 989             break ;
 990
 991         case 5 :  /* "conformant":  Boolean indicating if the frame buffer
 992                      configuration is conformant or not */
 993             break ;
 994
 995         case 6 : /* "depth":  Number of bits of precsion in the depth buffer */
 996             glut_state_flag |= GLUT_DEPTH ;  /* Somebody fix this for me! */
 997             break ;
 998
 999         case 7 :  /* "double":  Boolean indicating if the color buffer is
1000                      double buffered */
1001             glut_state_flag |= GLUT_DOUBLE ;
1002             break ;
1003
1004         case 8 :  /* "green":  Green color buffer precision in bits */
1005             break ;
1006
1007         case 9 :  /* "index":  Boolean if the color model is color index or not
1008                    */
1009             glut_state_flag |= GLUT_INDEX ;
1010             break ;
1011
1012         case 10 :  /* "num":  A special capability  name indicating where the
1013                       value represents the Nth frame buffer configuration
1014                       matching the description string */
1015             break ;
1016
1017         case 11 :  /* "red":  Red color buffer precision in bits */
1018             break ;
1019
1020         case 12 :  /* "rgba":  Number of bits of red, green, blue, and alpha in
1021                       the RGBA color buffer */
1022             glut_state_flag |= GLUT_RGBA ;  /* Somebody fix this for me! */
1023             break ;
1024
1025         case 13 :  /* "rgb":  Number of bits of red, green, and blue in the
1026                       RGBA color buffer with zero bits alpha */
1027             glut_state_flag |= GLUT_RGB ;  /* Somebody fix this for me! */
1028             break ;
1029
1030         case 14 :  /* "luminance":  Number of bits of red in the RGBA and zero
1031                       bits of green, blue (alpha not specified) of color buffer
1032                       precision */
1033             glut_state_flag |= GLUT_LUMINANCE ; /* Somebody fix this for me! */
1034             break ;
1035
1036         case 15 :  /* "stencil":  Number of bits in the stencil buffer */
1037             glut_state_flag |= GLUT_STENCIL;  /* Somebody fix this for me! */
1038             break ;
1039
1040         case 16 :  /* "single":  Boolean indicate the color buffer is single
1041                       buffered */
1042             glut_state_flag |= GLUT_SINGLE ;
1043             break ;
1044
1045         case 17 :  /* "stereo":  Boolean indicating the color buffer supports
1046                       OpenGL-style stereo */
1047             glut_state_flag |= GLUT_STEREO ;
1048             break ;
1049
1050         case 18 :  /* "samples":  Indicates the number of multisamples to use
1051                       based on GLX's SGIS_multisample extension (for
1052                       antialiasing) */
1053             glut_state_flag |= GLUT_MULTISAMPLE ; /*Somebody fix this for me!*/
1054             break ;
1055
1056         case 19 :  /* "slow":  Boolean indicating if the frame buffer
1057                       configuration is slow or not */
1058             break ;
1059
1060         case 20 :  /* "win32pdf": (incorrect spelling but was there before */
1061         case 21 :  /* "win32pfd":  matches the Win32 Pixel Format Descriptor by
1062                       number */
1063 #if TARGET_HOST_MS_WINDOWS
1064 #endif
1065             break ;
1066
1067         case 22 :  /* "xvisual":  matches the X visual ID by number */
1068 #if TARGET_HOST_POSIX_X11
1069 #endif
1070             break ;
1071
1072         case 23 :  /* "xstaticgray": */
1073         case 29 :  /* "xstaticgrey":  boolean indicating if the frame buffer
1074                       configuration's X visual is of type StaticGray */
1075 #if TARGET_HOST_POSIX_X11
1076 #endif
1077             break ;
1078
1079         case 24 :  /* "xgrayscale": */
1080         case 30 :  /* "xgreyscale":  boolean indicating if the frame buffer
1081                       configuration's X visual is of type GrayScale */
1082 #if TARGET_HOST_POSIX_X11
1083 #endif
1084             break ;
1085
1086         case 25 :  /* "xstaticcolor": */
1087         case 31 :  /* "xstaticcolour":  boolean indicating if the frame buffer
1088                       configuration's X visual is of type StaticColor */
1089 #if TARGET_HOST_POSIX_X11
1090 #endif
1091             break ;
1092
1093         case 26 :  /* "xpseudocolor": */
1094         case 32 :  /* "xpseudocolour":  boolean indicating if the frame buffer
1095                       configuration's X visual is of type PseudoColor */
1096 #if TARGET_HOST_POSIX_X11
1097 #endif
1098             break ;
1099
1100         case 27 :  /* "xtruecolor": */
1101         case 33 :  /* "xtruecolour":  boolean indicating if the frame buffer
1102                       configuration's X visual is of type TrueColor */
1103 #if TARGET_HOST_POSIX_X11
1104 #endif
1105             break ;
1106
1107         case 28 :  /* "xdirectcolor": */
1108         case 34 :  /* "xdirectcolour":  boolean indicating if the frame buffer
1109                       configuration's X visual is of type DirectColor */
1110 #if TARGET_HOST_POSIX_X11
1111 #endif
1112             break ;
1113
1114         case 35 :  /* "borderless":  windows should not have borders */
1115 #if TARGET_HOST_POSIX_X11
1116 #endif
1117             break ;
1118
1119         case 36 :  /* "aux":  some number of aux buffers */
1120             glut_state_flag |= GLUT_AUX;
1121             break ;
1122
1123         case 37 :  /* Unrecognized */
1124             fgWarning ( "WARNING - Display string token not recognized:  %s",
1125                         token );
1126             break ;
1127         }
1128
1129         token = strtok ( NULL, " \t" );
1130     }
1131
1132     free ( buffer );
1133
1134     /* We will make use of this value when creating a new OpenGL context... */
1135     fgState.DisplayMode = glut_state_flag;
1136 }
1137
1138 /* -- SETTING OPENGL 3.0 CONTEXT CREATION PARAMETERS ---------------------- */
1139
1140 void FGAPIENTRY glutInitContextVersion( int majorVersion, int minorVersion )
1141 {
1142     /* We will make use of these valuse when creating a new OpenGL context... */
1143     fgState.MajorVersion = majorVersion;
1144     fgState.MinorVersion = minorVersion;
1145 }
1146
1147
1148 void FGAPIENTRY glutInitContextFlags( int flags )
1149 {
1150     /* We will make use of this value when creating a new OpenGL context... */
1151     fgState.ContextFlags = flags;
1152 }
1153
1154 void FGAPIENTRY glutInitContextProfile( int profile )
1155 {
1156     /* We will make use of this value when creating a new OpenGL context... */
1157     fgState.ContextProfile = profile;
1158 }
1159
1160 /* -------------- User Defined Error/Warning Handler Support -------------- */
1161
1162 /*
1163  * Sets the user error handler (note the use of va_list for the args to the fmt)
1164  */
1165 void FGAPIENTRY glutInitErrorFunc( void (* vfgError) ( const char *fmt, va_list ap ) )
1166 {
1167     /* This allows user programs to handle freeglut errors */
1168     fgState.ErrorFunc = vfgError;
1169 }
1170
1171 /*
1172  * Sets the user warning handler (note the use of va_list for the args to the fmt)
1173  */
1174 void FGAPIENTRY glutInitWarningFunc( void (* vfgWarning) ( const char *fmt, va_list ap ) )
1175 {
1176     /* This allows user programs to handle freeglut warnings */
1177     fgState.WarningFunc = vfgWarning;
1178 }
1179
1180 /*** END OF FILE ***/