Convert crlf->lf line endings.

Windows/DOS users should enable core.autocrlf from now on:

  git config --global core.autocrlf true

1 files changed, 1399 insertions, 1399 deletions

diff --git a/src/glut/os2/glut_event.cpp b/src/glut/os2/glut_event.cpp
index c556ef28265..4ece82e52b6 100644
--- a/src/glut/os2/glut_event.cpp
+++ b/src/glut/os2/glut_event.cpp
@@ -1,1399 +1,1399 @@
-/* glut_event.c */

-/* Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1997, 1998. */

-

-/* This program is freely distributable without licensing fees

-   and is provided without guarantee or warrantee expressed or

-   implied. This program is -not- in the public domain. */

-

-#ifdef __VMS

-#include <GL/vms_x_fix.h>

-#endif

-

-#include <stdlib.h>

-#include <stdio.h>

-#include <errno.h>

-#include <assert.h>

-#include <string.h>  /* Some FD_ZERO macros use memset without

-                        prototyping memset. */

-

-/* Much of the following #ifdef logic to include the proper

-   prototypes for the select system call is based on logic

-   from the X11R6.3 version of <X11/Xpoll.h>. */

-

-#if !defined(_WIN32)

-# ifdef __sgi

-#  include <bstring.h>    /* prototype for bzero used by FD_ZERO */

-# endif

-# if (defined(SVR4) || defined(CRAY) || defined(AIXV3)) && !defined(FD_SETSIZE)

-#  include <sys/select.h> /* select system call interface */

-#  ifdef luna

-#   include <sysent.h>

-#  endif

-# endif

-  /* AIX 4.2 fubar-ed <sys/select.h>, so go to heroic measures to get it */

-# if defined(AIXV4) && !defined(NFDBITS)

-#  include <sys/select.h>

-# endif

-#endif /* !_WIN32 */

-

-#include <sys/types.h>

-

-#if defined(__OS2__)

-//??? ��䨣� ??     #   include <sys/time.h>

-#elif !defined(_WIN32)

-# if defined(__vms) && ( __VMS_VER < 70000000 )

-#  include <sys/time.h>

-# else

-#  ifndef __vms

-#   include <sys/time.h>

-#  endif

-# endif

-# include <unistd.h>

-# include <X11/Xlib.h>

-# include <X11/keysym.h>

-#else

-# ifdef __CYGWIN32__

-#  include <sys/time.h>

-# else

-#  include <sys/timeb.h>

-# endif

-# ifdef __hpux

-   /* XXX Bert Gijsbers <[email protected]> reports that HP-UX

-      needs different keysyms for the End, Insert, and Delete keys

-      to work on an HP 715.  It would be better if HP generated

-      standard keysyms for standard keys. */

-#  include <X11/HPkeysym.h>

-# endif

-#endif /* !_WIN32 */

-

-#include "glutint.h"

-

-#if defined(__vms) && ( __VMS_VER < 70000000 )

-#include <ssdef.h>

-#include <psldef.h>

-extern int SYS$CLREF(int efn);

-extern int SYS$SETIMR(unsigned int efn, struct timeval6 *timeout, void *ast,

-  unsigned int request_id, unsigned int flags);

-extern int SYS$WFLOR(unsigned int efn, unsigned int mask);

-extern int SYS$CANTIM(unsigned int request_id, unsigned int mode);

-#endif /* __vms, VMs 6.2 or earlier */

-

-static GLUTtimer *freeTimerList = NULL;

-

-GLUTidleCB __glutIdleFunc = NULL;

-GLUTtimer *__glutTimerList = NULL;

-#ifdef SUPPORT_FORTRAN

-GLUTtimer *__glutNewTimer;

-#endif

-GLUTwindow *__glutWindowWorkList = NULL;

-GLUTmenu *__glutMappedMenu;

-GLUTmenu *__glutCurrentMenu = NULL;

-

-void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *);

-#if !defined(_WIN32) && !defined(__OS2__)

-void (*__glutMenuItemEnterOrLeave)(GLUTmenuItem * item, int num, int type) = NULL;

-void (*__glutFinishMenu)(Window win, int x, int y);

-void (*__glutPaintMenu)(GLUTmenu * menu);

-void (*__glutStartMenu)(GLUTmenu * menu, GLUTwindow * window, int x, int y, int x_win, int y_win);

-GLUTmenu * (*__glutGetMenuByNum)(int menunum);

-GLUTmenuItem * (*__glutGetMenuItem)(GLUTmenu * menu, Window win, int *which);

-GLUTmenu * (*__glutGetMenu)(Window win);

-#endif

-

-Atom __glutMotifHints = None;

-/* Modifier mask of ~0 implies not in core input callback. */

-unsigned int __glutModifierMask = (unsigned int) ~0;

-int __glutWindowDamaged = 0;

-

-void GLUTAPIENTRY

-glutIdleFunc(GLUTidleCB idleFunc)

-{

-  __glutIdleFunc = idleFunc;

-}

-

-void GLUTAPIENTRY

-glutTimerFunc(unsigned int interval, GLUTtimerCB timerFunc, int value)

-{

-  GLUTtimer *timer, *other;

-  GLUTtimer **prevptr;

-#ifdef OLD_VMS

-   struct timeval6 now;

-#else

-   struct timeval now;

-#endif

-

-  if (!timerFunc)

-    return;

-

-  if (freeTimerList) {

-    timer = freeTimerList;

-    freeTimerList = timer->next;

-  } else {

-    timer = (GLUTtimer *) malloc(sizeof(GLUTtimer));

-    if (!timer)

-      __glutFatalError("out of memory.");

-  }

-

-  timer->func = timerFunc;

-#if defined(__vms) && ( __VMS_VER < 70000000 )

-  /* VMS time is expressed in units of 100 ns */

-  timer->timeout.val = interval * TICKS_PER_MILLISECOND;

-#else

-  timer->timeout.tv_sec = (int) interval / 1000;

-  timer->timeout.tv_usec = (int) (interval % 1000) * 1000;

-#endif

-  timer->value = value;

-  timer->next = NULL;

-  GETTIMEOFDAY(&now);

-  ADD_TIME(timer->timeout, timer->timeout, now);

-  prevptr = &__glutTimerList;

-  other = *prevptr;

-  while (other && IS_AFTER(other->timeout, timer->timeout)) {

-    prevptr = &other->next;

-    other = *prevptr;

-  }

-  timer->next = other;

-#ifdef SUPPORT_FORTRAN

-  __glutNewTimer = timer;  /* for Fortran binding! */

-#endif

-  *prevptr = timer;

-}

-

-void

-handleTimeouts(void)

-{

-#ifdef OLD_VMS

-   struct timeval6 now;

-#else

-   struct timeval now;

-#endif

-   GLUTtimer *timer;

-

-  /* Assumption is that __glutTimerList is already determined

-     to be non-NULL. */

-  GETTIMEOFDAY(&now);

-  while (IS_AT_OR_AFTER(__glutTimerList->timeout, now)) {

-    timer = __glutTimerList;

-    timer->func(timer->value);

-    __glutTimerList = timer->next;

-    timer->next = freeTimerList;

-    freeTimerList = timer;

-    if (!__glutTimerList)

-      break;

-  }

-}

-

-void

-__glutPutOnWorkList(GLUTwindow * window, int workMask)

-{

-  if (window->workMask) {

-    /* Already on list; just OR in new workMask. */

-    window->workMask |= workMask;

-  } else {

-    /* Update work mask and add to window work list. */

-    window->workMask = workMask;

-    /* Assert that if the window does not have a

-       workMask already, the window should definitely

-       not be the head of the work list. */

-    assert(window != __glutWindowWorkList);

-    window->prevWorkWin = __glutWindowWorkList;

-    __glutWindowWorkList = window;

-  }

-}

-

-void

-__glutPostRedisplay(GLUTwindow * window, int layerMask)

-{

-  int shown = (layerMask & (GLUT_REDISPLAY_WORK | GLUT_REPAIR_WORK)) ?

-    window->shownState : window->overlay->shownState;

-

-  /* Post a redisplay if the window is visible (or the

-     visibility of the window is unknown, ie. window->visState

-     == -1) _and_ the layer is known to be shown. */

-  if (window->visState != GLUT_HIDDEN

-    && window->visState != GLUT_FULLY_COVERED && shown) {

-    __glutPutOnWorkList(window, layerMask);

-  }

-}

-

-/* CENTRY */

-void GLUTAPIENTRY

-glutPostRedisplay(void)

-{

-  __glutPostRedisplay(__glutCurrentWindow, GLUT_REDISPLAY_WORK);

-}

-

-/* The advantage of this routine is that it saves the cost of a

-   glutSetWindow call (entailing an expensive OpenGL context switch),

-   particularly useful when multiple windows need redisplays posted at

-   the same times.  See also glutPostWindowOverlayRedisplay. */

-void GLUTAPIENTRY

-glutPostWindowRedisplay(int win)

-{

-  __glutPostRedisplay(__glutWindowList[win - 1], GLUT_REDISPLAY_WORK);

-}

-

-/* ENDCENTRY */

-static GLUTeventParser *eventParserList = NULL;

-

-/* __glutRegisterEventParser allows another module to register

-   to intercept X events types not otherwise acted on by the

-   GLUT processEventsAndTimeouts routine.  The X Input

-   extension support code uses an event parser for handling X

-   Input extension events.  */

-

-void

-__glutRegisterEventParser(GLUTeventParser * parser)

-{

-  parser->next = eventParserList;

-  eventParserList = parser;

-}

-

-static void

-markWindowHidden(GLUTwindow * window)

-{

-  if (GLUT_HIDDEN != window->visState) {

-    GLUTwindow *child;

-

-    if (window->windowStatus) {

-      window->visState = GLUT_HIDDEN;

-      __glutSetWindow(window);

-      window->windowStatus(GLUT_HIDDEN);

-    }

-    /* An unmap is only reported on a single window; its

-       descendents need to know they are no longer visible. */

-    child = window->children;

-    while (child) {

-      markWindowHidden(child);

-      child = child->siblings;

-    }

-  }

-}

-

-#if !defined(_WIN32) && !defined(__OS2__)

-

-static void

-purgeStaleWindow(Window win)

-{

-  GLUTstale **pEntry = &__glutStaleWindowList;

-  GLUTstale *entry = __glutStaleWindowList;

-

-  /* Tranverse singly-linked stale window list look for the

-     window ID. */

-  while (entry) {

-    if (entry->win == win) {

-      /* Found it; delete it. */

-      *pEntry = entry->next;

-      free(entry);

-      return;

-    } else {

-      pEntry = &entry->next;

-      entry = *pEntry;

-    }

-  }

-}

-

-/* Unlike XNextEvent, if a signal arrives,

-   interruptibleXNextEvent will return (with a zero return

-   value).  This helps GLUT drop out of XNextEvent if a signal

-   is delivered.  The intent is so that a GLUT program can call

-   glutIdleFunc in a signal handler to register an idle func

-   and then immediately get dropped into the idle func (after

-   returning from the signal handler).  The idea is to make

-   GLUT's main loop reliably interruptible by signals. */

-static int

-interruptibleXNextEvent(Display * dpy, XEvent * event)

-{

-  fd_set fds;

-  int rc;

-

-  /* Flush X protocol since XPending does not do this

-     implicitly. */

-  XFlush(__glutDisplay);

-  for (;;) {

-    if (XPending(__glutDisplay)) {

-      XNextEvent(dpy, event);

-      return 1;

-    }

-#ifndef VMS

-    /* the combination ConectionNumber-select is buggy on VMS. Sometimes it

-     * fails. This part of the code hangs the program on VMS7.2. But even

-     * without it the program seems to run correctly.

-     * Note that this is a bug in the VMS/DECWindows run-time-libraries.

-     * Compaq engeneering does not want or is not able to make a fix.

-     * (last sentence is a quotation from Compaq when I reported the

-     * problem January 2000) */

-    FD_ZERO(&fds);

-    FD_SET(__glutConnectionFD, &fds);

-    rc = select(__glutConnectionFD + 1, &fds, NULL, NULL, NULL);

-    if (rc < 0) {

-      if (errno == EINTR) {

-        return 0;

-      } else {

-        __glutFatalError("select error.");

-      }

-    }

-#endif

-  }

-}

-

-#endif

-

-static void

-processEventsAndTimeouts(void)

-{

-  do {

-#if defined(__OS2__)

-   QMSG  qmsg;   /* message from message queue     */

-   extern HAB   hab;      /* PM anchor block handle         */

-

-   if(! WinGetMsg( hab, &qmsg, 0UL, 0UL, 0UL ) )

-                 exit(0);

-    WinDispatchMsg( hab,     /* PM anchor block handle  */

-                    &qmsg ); /* pointer to message      */

-

-#elif defined(_WIN32)

-    MSG event;

-

-    if(!GetMessage(&event, NULL, 0, 0))        /* bail if no more messages */

-      exit(0);

-    TranslateMessage(&event);          /* translate virtual-key messages */

-    DispatchMessage(&event);           /* call the window proc */

-    /* see win32_event.c for event (message) processing procedures */

-#else

-    static int mappedMenuButton;

-    GLUTeventParser *parser;

-    XEvent event, ahead;

-    GLUTwindow *window;

-    GLUTkeyboardCB keyboard;

-    GLUTspecialCB special;

-    int gotEvent, width, height;

-

-    gotEvent = interruptibleXNextEvent(__glutDisplay, &event);

-    if (gotEvent) {

-      switch (event.type) {

-      case MappingNotify:

-        XRefreshKeyboardMapping((XMappingEvent *) & event);

-        break;

-      case ConfigureNotify:

-        window = __glutGetWindow(event.xconfigure.window);

-        if (window) {

-          if (window->win != event.xconfigure.window) {

-            /* Ignore ConfigureNotify sent to the overlay

-               planes. GLUT could get here because overlays

-               select for StructureNotify events to receive

-               DestroyNotify. */

-            break;

-          }

-          width = event.xconfigure.width;

-          height = event.xconfigure.height;

-          if (width != window->width || height != window->height) {

-            if (window->overlay) {

-              XResizeWindow(__glutDisplay, window->overlay->win, width, height);

-            }

-            window->width = width;

-            window->height = height;

-            __glutSetWindow(window);

-            /* Do not execute OpenGL out of sequence with

-               respect to the XResizeWindow request! */

-            glXWaitX();

-            window->reshape(width, height);

-            window->forceReshape = False;

-            /* A reshape should be considered like posting a

-               repair; this is necessary for the "Mesa

-               glXSwapBuffers to repair damage" hack to operate

-               correctly.  Without it, there's not an initial

-               back buffer render from which to blit from when

-               damage happens to the window. */

-            __glutPostRedisplay(window, GLUT_REPAIR_WORK);

-          }

-        }

-        break;

-      case Expose:

-        /* compress expose events */

-        while (XEventsQueued(__glutDisplay, QueuedAfterReading)

-          > 0) {

-          XPeekEvent(__glutDisplay, &ahead);

-          if (ahead.type != Expose ||

-            ahead.xexpose.window != event.xexpose.window) {

-            break;

-          }

-          XNextEvent(__glutDisplay, &event);

-        }

-        if (event.xexpose.count == 0) {

-          GLUTmenu *menu;

-

-          if (__glutMappedMenu &&

-            (menu = __glutGetMenu(event.xexpose.window))) {

-            __glutPaintMenu(menu);

-          } else {

-            window = __glutGetWindow(event.xexpose.window);

-            if (window) {

-              if (window->win == event.xexpose.window) {

-                __glutPostRedisplay(window, GLUT_REPAIR_WORK);

-              } else if (window->overlay && window->overlay->win == event.xexpose.window) {

-                __glutPostRedisplay(window, GLUT_OVERLAY_REPAIR_WORK);

-              }

-            }

-          }

-        } else {

-          /* there are more exposes to read; wait to redisplay */

-        }

-        break;

-      case ButtonPress:

-      case ButtonRelease:

-        if (__glutMappedMenu && event.type == ButtonRelease

-          && mappedMenuButton == event.xbutton.button) {

-          /* Menu is currently popped up and its button is

-             released. */

-          __glutFinishMenu(event.xbutton.window, event.xbutton.x, event.xbutton.y);

-        } else {

-          window = __glutGetWindow(event.xbutton.window);

-          if (window) {

-            GLUTmenu *menu;

-           int menuNum;

-

-            menuNum = window->menu[event.xbutton.button - 1];

-            /* Make sure that __glutGetMenuByNum is only called if there

-              really is a menu present. */

-            if ((menuNum > 0) && (menu = __glutGetMenuByNum(menuNum))) {

-              if (event.type == ButtonPress && !__glutMappedMenu) {

-                __glutStartMenu(menu, window,

-                  event.xbutton.x_root, event.xbutton.y_root,

-                  event.xbutton.x, event.xbutton.y);

-                mappedMenuButton = event.xbutton.button;

-              } else {

-                /* Ignore a release of a button with a menu

-                   attatched to it when no menu is popped up,

-                   or ignore a press when another menu is

-                   already popped up. */

-              }

-            } else if (window->mouse) {

-              __glutSetWindow(window);

-              __glutModifierMask = event.xbutton.state;

-              window->mouse(event.xbutton.button - 1,

-                event.type == ButtonRelease ?

-                GLUT_UP : GLUT_DOWN,

-                event.xbutton.x, event.xbutton.y);

-              __glutModifierMask = ~0;

-            } else {

-              /* Stray mouse events.  Ignore. */

-            }

-          } else {

-            /* Window might have been destroyed and all the

-               events for the window may not yet be received. */

-          }

-        }

-        break;

-      case MotionNotify:

-        if (!__glutMappedMenu) {

-          window = __glutGetWindow(event.xmotion.window);

-          if (window) {

-            /* If motion function registered _and_ buttons held

-               * down, call motion function...  */

-            if (window->motion && event.xmotion.state &

-              (Button1Mask | Button2Mask | Button3Mask)) {

-              __glutSetWindow(window);

-              window->motion(event.xmotion.x, event.xmotion.y);

-            }

-            /* If passive motion function registered _and_

-               buttons not held down, call passive motion

-               function...  */

-            else if (window->passive &&

-                ((event.xmotion.state &

-                    (Button1Mask | Button2Mask | Button3Mask)) ==

-                0)) {

-              __glutSetWindow(window);

-              window->passive(event.xmotion.x,

-                event.xmotion.y);

-            }

-          }

-        } else {

-          /* Motion events are thrown away when a pop up menu

-             is active. */

-        }

-        break;

-      case KeyPress:

-      case KeyRelease:

-        window = __glutGetWindow(event.xkey.window);

-        if (!window) {

-          break;

-        }

-       if (event.type == KeyPress) {

-         keyboard = window->keyboard;

-       } else {

-

-         /* If we are ignoring auto repeated keys for this window,

-            check if the next event in the X event queue is a KeyPress

-            for the exact same key (and at the exact same time) as the

-            key being released.  The X11 protocol will send auto

-            repeated keys as such KeyRelease/KeyPress pairs. */

-

-         if (window->ignoreKeyRepeat) {

-           if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {

-             XPeekEvent(__glutDisplay, &ahead);

-             if (ahead.type == KeyPress

-               && ahead.xkey.window == event.xkey.window

-               && ahead.xkey.keycode == event.xkey.keycode

-               && ahead.xkey.time == event.xkey.time) {

-               /* Pop off the repeated KeyPress and ignore

-                  the auto repeated KeyRelease/KeyPress pair. */

-               XNextEvent(__glutDisplay, &event);

-               break;

-             }

-           }

-         }

-         keyboard = window->keyboardUp;

-       }

-        if (keyboard) {

-          char tmp[1];

-          int rc;

-

-          rc = XLookupString(&event.xkey, tmp, sizeof(tmp),

-            NULL, NULL);

-          if (rc) {

-            __glutSetWindow(window);

-            __glutModifierMask = event.xkey.state;

-            keyboard(tmp[0],

-              event.xkey.x, event.xkey.y);

-            __glutModifierMask = ~0;

-            break;

-          }

-        }

-       if (event.type == KeyPress) {

-         special = window->special;

-        } else {

-         special = window->specialUp;

-       }

-        if (special) {

-          KeySym ks;

-          int key;

-

-/* Introduced in X11R6:  (Partial list of) Keypad Functions.  Define

-   in place in case compiling against an older pre-X11R6

-   X11/keysymdef.h file. */

-#ifndef XK_KP_Home

-#define XK_KP_Home              0xFF95

-#endif

-#ifndef XK_KP_Left

-#define XK_KP_Left              0xFF96

-#endif

-#ifndef XK_KP_Up

-#define XK_KP_Up                0xFF97

-#endif

-#ifndef XK_KP_Right

-#define XK_KP_Right             0xFF98

-#endif

-#ifndef XK_KP_Down

-#define XK_KP_Down              0xFF99

-#endif

-#ifndef XK_KP_Prior

-#define XK_KP_Prior             0xFF9A

-#endif

-#ifndef XK_KP_Next

-#define XK_KP_Next              0xFF9B

-#endif

-#ifndef XK_KP_End

-#define XK_KP_End               0xFF9C

-#endif

-#ifndef XK_KP_Insert

-#define XK_KP_Insert            0xFF9E

-#endif

-#ifndef XK_KP_Delete

-#define XK_KP_Delete            0xFF9F

-#endif

-

-          ks = XLookupKeysym((XKeyEvent *) & event, 0);

-          /* XXX Verbose, but makes no assumptions about keysym

-             layout. */

-          switch (ks) {

-/* *INDENT-OFF* */

-          /* function keys */

-          case XK_F1:    key = GLUT_KEY_F1; break;

-          case XK_F2:    key = GLUT_KEY_F2; break;

-          case XK_F3:    key = GLUT_KEY_F3; break;

-          case XK_F4:    key = GLUT_KEY_F4; break;

-          case XK_F5:    key = GLUT_KEY_F5; break;

-          case XK_F6:    key = GLUT_KEY_F6; break;

-          case XK_F7:    key = GLUT_KEY_F7; break;

-          case XK_F8:    key = GLUT_KEY_F8; break;

-          case XK_F9:    key = GLUT_KEY_F9; break;

-          case XK_F10:   key = GLUT_KEY_F10; break;

-          case XK_F11:   key = GLUT_KEY_F11; break;

-          case XK_F12:   key = GLUT_KEY_F12; break;

-          /* directional keys */

-         case XK_KP_Left:

-          case XK_Left:  key = GLUT_KEY_LEFT; break;

-         case XK_KP_Up: /* Introduced in X11R6. */

-          case XK_Up:    key = GLUT_KEY_UP; break;

-         case XK_KP_Right: /* Introduced in X11R6. */

-          case XK_Right: key = GLUT_KEY_RIGHT; break;

-         case XK_KP_Down: /* Introduced in X11R6. */

-          case XK_Down:  key = GLUT_KEY_DOWN; break;

-/* *INDENT-ON* */

-

-         case XK_KP_Prior: /* Introduced in X11R6. */

-          case XK_Prior:

-            /* XK_Prior same as X11R6's XK_Page_Up */

-            key = GLUT_KEY_PAGE_UP;

-            break;

-         case XK_KP_Next: /* Introduced in X11R6. */

-          case XK_Next:

-            /* XK_Next same as X11R6's XK_Page_Down */

-            key = GLUT_KEY_PAGE_DOWN;

-            break;

-         case XK_KP_Home: /* Introduced in X11R6. */

-          case XK_Home:

-            key = GLUT_KEY_HOME;

-            break;

-#ifdef __hpux

-          case XK_Select:

-#endif

-         case XK_KP_End: /* Introduced in X11R6. */

-          case XK_End:

-            key = GLUT_KEY_END;

-            break;

-#ifdef __hpux

-          case XK_InsertChar:

-#endif

-         case XK_KP_Insert: /* Introduced in X11R6. */

-          case XK_Insert:

-            key = GLUT_KEY_INSERT;

-            break;

-#ifdef __hpux

-          case XK_DeleteChar:

-#endif

-         case XK_KP_Delete: /* Introduced in X11R6. */

-            /* The Delete character is really an ASCII key. */

-            __glutSetWindow(window);

-            keyboard(127,  /* ASCII Delete character. */

-              event.xkey.x, event.xkey.y);

-            goto skip;

-          default:

-            goto skip;

-          }

-          __glutSetWindow(window);

-          __glutModifierMask = event.xkey.state;

-          special(key, event.xkey.x, event.xkey.y);

-          __glutModifierMask = ~0;

-        skip:;

-        }

-        break;

-      case EnterNotify:

-      case LeaveNotify:

-        if (event.xcrossing.mode != NotifyNormal ||

-          event.xcrossing.detail == NotifyNonlinearVirtual ||

-          event.xcrossing.detail == NotifyVirtual) {

-

-          /* Careful to ignore Enter/LeaveNotify events that

-             come from the pop-up menu pointer grab and ungrab.

-             Also, ignore "virtual" Enter/LeaveNotify events

-             since they represent the pointer passing through

-             the window hierarchy without actually entering or

-             leaving the actual real estate of a window.  */

-

-          break;

-        }

-        if (__glutMappedMenu) {

-          GLUTmenuItem *item;

-          int num;

-

-          item = __glutGetMenuItem(__glutMappedMenu,

-            event.xcrossing.window, &num);

-          if (item) {

-            __glutMenuItemEnterOrLeave(item, num, event.type);

-            break;

-          }

-        }

-        window = __glutGetWindow(event.xcrossing.window);

-        if (window) {

-          if (window->entry) {

-            if (event.type == EnterNotify) {

-

-              /* With overlays established, X can report two

-                 enter events for both the overlay and normal

-                 plane window. Do not generate a second enter

-                 callback if we reported one without an

-                 intervening leave. */

-

-              if (window->entryState != EnterNotify) {

-                int num = window->num;

-                Window xid = window->win;

-

-                window->entryState = EnterNotify;

-                __glutSetWindow(window);

-                window->entry(GLUT_ENTERED);

-

-                if (__glutMappedMenu) {

-

-                  /* Do not generate any passive motion events

-                     when menus are in use. */

-

-                } else {

-

-                  /* An EnterNotify event can result in a

-                     "compound" callback if a passive motion

-                     callback is also registered. In this case,

-                     be a little paranoid about the possibility

-                     the window could have been destroyed in the

-                     entry callback. */

-

-                  window = __glutWindowList[num];

-                  if (window && window->passive && window->win == xid) {

-                    __glutSetWindow(window);

-                    window->passive(event.xcrossing.x, event.xcrossing.y);

-                  }

-                }

-              }

-            } else {

-              if (window->entryState != LeaveNotify) {

-

-                /* When an overlay is established for a window

-                   already mapped and with the pointer in it,

-                   the X server will generate a leave/enter

-                   event pair as the pointer leaves (without

-                   moving) from the normal plane X window to

-                   the newly mapped overlay  X window (or vice

-                   versa). This enter/leave pair should not be

-                   reported to the GLUT program since the pair

-                   is a consequence of creating (or destroying)

-                   the overlay, not an actual leave from the

-                   GLUT window. */

-

-                if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {

-                  XPeekEvent(__glutDisplay, &ahead);

-                  if (ahead.type == EnterNotify &&

-                    __glutGetWindow(ahead.xcrossing.window) == window) {

-                    XNextEvent(__glutDisplay, &event);

-                    break;

-                  }

-                }

-                window->entryState = LeaveNotify;

-                __glutSetWindow(window);

-                window->entry(GLUT_LEFT);

-              }

-            }

-          } else if (window->passive) {

-            __glutSetWindow(window);

-            window->passive(event.xcrossing.x, event.xcrossing.y);

-          }

-        }

-        break;

-      case UnmapNotify:

-        /* MapNotify events are not needed to maintain

-           visibility state since VisibilityNotify events will

-           be delivered when a window becomes visible from

-           mapping.  However, VisibilityNotify events are not

-           delivered when a window is unmapped (for the window

-           or its children). */

-        window = __glutGetWindow(event.xunmap.window);

-        if (window) {

-          if (window->win != event.xconfigure.window) {

-            /* Ignore UnmapNotify sent to the overlay planes.

-               GLUT could get here because overlays select for

-               StructureNotify events to receive DestroyNotify.

-             */

-            break;

-          }

-          markWindowHidden(window);

-        }

-        break;

-      case VisibilityNotify:

-        window = __glutGetWindow(event.xvisibility.window);

-        if (window) {

-          /* VisibilityUnobscured+1 = GLUT_FULLY_RETAINED,

-             VisibilityPartiallyObscured+1 =

-             GLUT_PARTIALLY_RETAINED, VisibilityFullyObscured+1

-             =  GLUT_FULLY_COVERED. */

-          int visState = event.xvisibility.state + 1;

-

-          if (visState != window->visState) {

-            if (window->windowStatus) {

-              window->visState = visState;

-              __glutSetWindow(window);

-              window->windowStatus(visState);

-            }

-          }

-        }

-        break;

-      case ClientMessage:

-        if (event.xclient.data.l[0] == __glutWMDeleteWindow)

-          exit(0);

-        break;

-      case DestroyNotify:

-        purgeStaleWindow(event.xdestroywindow.window);

-        break;

-      case CirculateNotify:

-      case CreateNotify:

-      case GravityNotify:

-      case ReparentNotify:

-        /* Uninteresting to GLUT (but possible for GLUT to

-           receive). */

-        break;

-      default:

-        /* Pass events not directly handled by the GLUT main

-           event loop to any event parsers that have been

-           registered.  In this way, X Input extension events

-           are passed to the correct handler without forcing

-           all GLUT programs to support X Input event handling.

-         */

-        parser = eventParserList;

-        while (parser) {

-          if (parser->func(&event))

-            break;

-          parser = parser->next;

-        }

-        break;

-      }

-    }

-#endif /* _WIN32 */

-    if (__glutTimerList) {

-      handleTimeouts();

-    }

-  }

-  while (XPending(__glutDisplay));

-}

-

-static void

-waitForSomething(void)

-{

-#if defined(__vms) && ( __VMS_VER < 70000000 )

-  static struct timeval6 zerotime =

-  {0};

-  unsigned int timer_efn;

-#define timer_id 'glut' /* random :-) number */

-  unsigned int wait_mask;

-#else

-  static struct timeval zerotime =

-  {0, 0};

-#if defined(__OS2__)

-

-#elif !defined(_WIN32)

-  fd_set fds;

-#endif

-#endif

-#ifdef OLD_VMS

-   struct timeval6 now, timeout, waittime;

-#else

-   struct timeval now, timeout, waittime;

-#endif

-#if !defined(_WIN32)

-  int rc;

-#endif

-

-  /* Flush X protocol since XPending does not do this

-     implicitly. */

-  XFlush(__glutDisplay);

-  if (XPending(__glutDisplay)) {

-    /* It is possible (but quite rare) that XFlush may have

-       needed to wait for a writable X connection file

-       descriptor, and in the process, may have had to read off

-       X protocol from the file descriptor. If XPending is true,

-       this case occured and we should avoid waiting in select

-       since X protocol buffered within Xlib is due to be

-       processed and potentially no more X protocol is on the

-       file descriptor, so we would risk waiting improperly in

-       select. */

-    goto immediatelyHandleXinput;

-  }

-#if defined(__vms) && ( __VMS_VER < 70000000 )

-  timeout = __glutTimerList->timeout;

-  GETTIMEOFDAY(&now);

-  wait_mask = 1 << (__glutConnectionFD & 31);

-  if (IS_AFTER(now, timeout)) {

-    /* We need an event flag for the timer. */

-    /* XXX The `right' way to do this is to use LIB$GET_EF, but

-       since it needs to be in the same cluster as the EFN for

-       the display, we will have hack it. */

-    timer_efn = __glutConnectionFD - 1;

-    if ((timer_efn / 32) != (__glutConnectionFD / 32)) {

-      timer_efn = __glutConnectionFD + 1;

-    }

-    rc = SYS$CLREF(timer_efn);

-    rc = SYS$SETIMR(timer_efn, &timeout, NULL, timer_id, 0);

-    wait_mask |= 1 << (timer_efn & 31);

-  } else {

-    timer_efn = 0;

-  }

-  rc = SYS$WFLOR(__glutConnectionFD, wait_mask);

-  if (timer_efn != 0 && SYS$CLREF(timer_efn) == SS$_WASCLR) {

-    rc = SYS$CANTIM(timer_id, PSL$C_USER);

-  }

-  /* XXX There does not seem to be checking of "rc" in the code

-     above.  Can any of the SYS$ routines above fail? */

-#else /* not vms6.2 or lower */

-#if defined(__OS2__)

-

-#elif !defined(_WIN32)

-  FD_ZERO(&fds);

-  FD_SET(__glutConnectionFD, &fds);

-#endif

-  timeout = __glutTimerList->timeout;

-  GETTIMEOFDAY(&now);

-  if (IS_AFTER(now, timeout)) {

-    TIMEDELTA(waittime, timeout, now);

-  } else {

-    waittime = zerotime;

-  }

-

-#if defined(__OS2__)

-  DosSleep(0);

-#elif !defined(_WIN32)

-  rc = select(__glutConnectionFD + 1, &fds,

-    NULL, NULL, &waittime);

-  if (rc < 0 && errno != EINTR)

-    __glutFatalError("select error.");

-#else

-

-  MsgWaitForMultipleObjects(0, NULL, FALSE,

-    waittime.tv_sec*1000 + waittime.tv_usec/1000, QS_ALLINPUT);

-

-#endif

-#endif /* not vms6.2 or lower */

-  /* Without considering the cause of select unblocking, check

-     for pending X events and handle any timeouts (by calling

-     processEventsAndTimeouts).  We always look for X events

-     even if select returned with 0 (indicating a timeout);

-     otherwise we risk starving X event processing by continous

-     timeouts. */

-  if (XPending(__glutDisplay)) {

-  immediatelyHandleXinput:

-    processEventsAndTimeouts();

-  } else {

-    if (__glutTimerList)

-      handleTimeouts();

-  }

-}

-

-static void

-idleWait(void)

-{

-  if (XPending(__glutDisplay)) {

-    processEventsAndTimeouts();

-  } else {

-    if (__glutTimerList) {

-      handleTimeouts();

-    }

-  }

-  /* Make sure idle func still exists! */

-  if (__glutIdleFunc) {

-    __glutIdleFunc();

-  }

-}

-

-static GLUTwindow **beforeEnd;

-

-static GLUTwindow *

-processWindowWorkList(GLUTwindow * window)

-{

-  int workMask;

-

-  if (window->prevWorkWin) {

-    window->prevWorkWin = processWindowWorkList(window->prevWorkWin);

-  } else {

-    beforeEnd = &window->prevWorkWin;

-  }

-

-  /* Capture work mask for work that needs to be done to this

-     window, then clear the window's work mask (excepting the

-     dummy work bit, see below).  Then, process the captured

-     work mask.  This allows callbacks in the processing the

-     captured work mask to set the window's work mask for

-     subsequent processing. */

-

-  workMask = window->workMask;

-  assert((workMask & GLUT_DUMMY_WORK) == 0);

-

-  /* Set the dummy work bit, clearing all other bits, to

-     indicate that the window is currently on the window work

-     list _and_ that the window's work mask is currently being

-     processed.  This convinces __glutPutOnWorkList that this

-     window is on the work list still. */

-  window->workMask = GLUT_DUMMY_WORK;

-

-  /* Optimization: most of the time, the work to do is a

-     redisplay and not these other types of work.  Check for

-     the following cases as a group to before checking each one

-     individually one by one. This saves about 25 MIPS

-     instructions in the common redisplay only case. */

-  if (workMask & (GLUT_EVENT_MASK_WORK | GLUT_DEVICE_MASK_WORK |

-      GLUT_CONFIGURE_WORK | GLUT_COLORMAP_WORK | GLUT_MAP_WORK)) {

-

-#if !defined(_WIN32) && !defined(__OS2__)

-    /* Be sure to set event mask BEFORE map window is done. */

-    if (workMask & GLUT_EVENT_MASK_WORK) {

-      long eventMask;

-

-      /* Make sure children are not propogating events this

-         window is selecting for.  Be sure to do this before

-         enabling events on the children's parent. */

-      if (window->children) {

-        GLUTwindow *child = window->children;

-        unsigned long attribMask = CWDontPropagate;

-        XSetWindowAttributes wa;

-

-        wa.do_not_propagate_mask = window->eventMask & GLUT_DONT_PROPAGATE_FILTER_MASK;

-        if (window->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK) {

-          wa.event_mask = child->eventMask | (window->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK);

-          attribMask |= CWEventMask;

-        }

-        do {

-          XChangeWindowAttributes(__glutDisplay, child->win,

-            attribMask, &wa);

-          child = child->siblings;

-        } while (child);

-      }

-      eventMask = window->eventMask;

-      if (window->parent && window->parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK)

-        eventMask |= (window->parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK);

-      XSelectInput(__glutDisplay, window->win, eventMask);

-      if (window->overlay)

-        XSelectInput(__glutDisplay, window->overlay->win,

-          window->eventMask & GLUT_OVERLAY_EVENT_FILTER_MASK);

-    }

-#endif /* !_WIN32 */

-    /* Be sure to set device mask BEFORE map window is done. */

-    if (workMask & GLUT_DEVICE_MASK_WORK) {

-      __glutUpdateInputDeviceMaskFunc(window);

-    }

-    /* Be sure to configure window BEFORE map window is done. */

-    if (workMask & GLUT_CONFIGURE_WORK) {

-#if defined(__OS2__)

-      RECTL changes;

-

-#elif defined(_WIN32)

-      RECT changes;

-      POINT point;

-      UINT flags = SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOOWNERZORDER

-       | SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOZORDER;

-

-      GetClientRect(window->win, &changes);

-

-      /* If this window is a toplevel window, translate the 0,0 client

-         coordinate into a screen coordinate for proper placement. */

-      if (!window->parent) {

-        point.x = 0;

-        point.y = 0;

-        ClientToScreen(window->win, &point);

-        changes.left = point.x;

-        changes.top = point.y;

-      }

-      if (window->desiredConfMask & (CWX | CWY)) {

-        changes.left = window->desiredX;

-        changes.top = window->desiredY;

-       flags &= ~SWP_NOMOVE;

-      }

-      if (window->desiredConfMask & (CWWidth | CWHeight)) {

-        changes.right = changes.left + window->desiredWidth;

-        changes.bottom = changes.top + window->desiredHeight;

-       flags &= ~SWP_NOSIZE;

-       /* XXX If overlay exists, resize the overlay here, ie.

-          if (window->overlay) ... */

-      }

-      if (window->desiredConfMask & CWStackMode) {

-       flags &= ~SWP_NOZORDER;

-       /* XXX Overlay support might require something special here. */

-      }

-

-      /* Adjust the window rectangle because Win32 thinks that the x, y,

-         width & height are the WHOLE window (including decorations),

-         whereas GLUT treats the x, y, width & height as only the CLIENT

-         area of the window.  Only do this to top level windows

-         that are not in game mode (since game mode windows do

-         not have any decorations). */

-      if (!window->parent && window != __glutGameModeWindow) {

-        AdjustWindowRect(&changes,

-          WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,

-          FALSE);

-      }

-

-      /* Do the repositioning, moving, and push/pop. */

-      SetWindowPos(window->win,

-        window->desiredStack == Above ? HWND_TOP : HWND_NOTOPMOST,

-        changes.left, changes.top,

-        changes.right - changes.left, changes.bottom - changes.top,

-        flags);

-

-      /* Zero out the mask. */

-      window->desiredConfMask = 0;

-

-      /* This hack causes the window to go back to the right position

-         when it is taken out of fullscreen mode. */

-      if (workMask & GLUT_FULL_SCREEN_WORK) {

-        window->desiredConfMask |= CWX | CWY;

-        window->desiredX = point.x;

-        window->desiredY = point.y;

-      }

-#else /* !_WIN32 */

-      XWindowChanges changes;

-

-      changes.x = window->desiredX;

-      changes.y = window->desiredY;

-      if (window->desiredConfMask & (CWWidth | CWHeight)) {

-        changes.width = window->desiredWidth;

-        changes.height = window->desiredHeight;

-        if (window->overlay)

-          XResizeWindow(__glutDisplay, window->overlay->win,

-            window->desiredWidth, window->desiredHeight);

-        if (__glutMotifHints != None) {

-          if (workMask & GLUT_FULL_SCREEN_WORK) {

-            MotifWmHints hints;

-

-            hints.flags = MWM_HINTS_DECORATIONS;

-            hints.decorations = 0;  /* Absolutely no

-                                       decorations. */

-            XChangeProperty(__glutDisplay, window->win,

-              __glutMotifHints, __glutMotifHints, 32,

-              PropModeReplace, (unsigned char *) &hints, 4);

-            if (workMask & GLUT_MAP_WORK) {

-              /* Handle case where glutFullScreen is called

-                 before the first time that the window is

-                 mapped. Some window managers will randomly or

-                 interactively position the window the first

-                 time it is mapped if the window's

-                 WM_NORMAL_HINTS property does not request an

-                 explicit position. We don't want any such

-                 window manager interaction when going

-                 fullscreen.  Overwrite the WM_NORMAL_HINTS

-                 property installed by glutCreateWindow's

-                 XSetWMProperties property with one explicitly

-                 requesting a fullscreen window. */

-              XSizeHints hints;

-

-              hints.flags = USPosition | USSize;

-              hints.x = 0;

-              hints.y = 0;

-              hints.width = window->desiredWidth;

-              hints.height = window->desiredHeight;

-              XSetWMNormalHints(__glutDisplay, window->win, &hints);

-            }

-          } else {

-            XDeleteProperty(__glutDisplay, window->win, __glutMotifHints);

-          }

-        }

-      }

-      if (window->desiredConfMask & CWStackMode) {

-        changes.stack_mode = window->desiredStack;

-        /* Do not let glutPushWindow push window beneath the

-           underlay. */

-        if (window->parent && window->parent->overlay

-          && window->desiredStack == Below) {

-          changes.stack_mode = Above;

-          changes.sibling = window->parent->overlay->win;

-          window->desiredConfMask |= CWSibling;

-        }

-      }

-      XConfigureWindow(__glutDisplay, window->win,

-        window->desiredConfMask, &changes);

-      window->desiredConfMask = 0;

-#endif

-    }

-#if !defined(_WIN32) && !defined(__OS2__)

-    /* Be sure to establish the colormaps BEFORE map window is

-       done. */

-    if (workMask & GLUT_COLORMAP_WORK) {

-      __glutEstablishColormapsProperty(window);

-    }

-#endif

-    if (workMask & GLUT_MAP_WORK) {

-      switch (window->desiredMapState) {

-      case WithdrawnState:

-        if (window->parent) {

-          XUnmapWindow(__glutDisplay, window->win);

-        } else {

-          XWithdrawWindow(__glutDisplay, window->win,

-            __glutScreen);

-        }

-        window->shownState = 0;

-        break;

-      case NormalState:

-        XMapWindow(__glutDisplay, window->win);

-        window->shownState = 1;

-        break;

-#ifdef _WIN32

-      case GameModeState:  /* Not an Xlib value. */

-        ShowWindow(window->win, SW_SHOW);

-        window->shownState = 1;

-        break;

-#endif

-      case IconicState:

-        XIconifyWindow(__glutDisplay, window->win, __glutScreen);

-        window->shownState = 0;

-        break;

-      }

-    }

-  }

-  if (workMask & (GLUT_REDISPLAY_WORK | GLUT_OVERLAY_REDISPLAY_WORK | GLUT_REPAIR_WORK | GLUT_OVERLAY_REPAIR_WORK)) {

-    if (window->forceReshape) {

-      /* Guarantee that before a display callback is generated

-         for a window, a reshape callback must be generated. */

-      __glutSetWindow(window);

-      window->reshape(window->width, window->height);

-      window->forceReshape = False;

-

-      /* Setting the redisplay bit on the first reshape is

-         necessary to make the "Mesa glXSwapBuffers to repair

-         damage" hack operate correctly.  Without indicating a

-         redisplay is necessary, there's not an initial back

-         buffer render from which to blit from when damage

-         happens to the window. */

-      workMask |= GLUT_REDISPLAY_WORK;

-    }

-    /* The code below is more involved than otherwise necessary

-       because it is paranoid about the overlay or entire window

-       being removed or destroyed in the course of the callbacks.

-       Notice how the global __glutWindowDamaged is used to record

-       the layers' damage status.  See the code in glutLayerGet for

-       how __glutWindowDamaged is used. The  point is to not have to

-       update the "damaged" field after  the callback since the

-       window (or overlay) may be destroyed (or removed) when the

-       callback returns. */

-

-    if (window->overlay && window->overlay->display) {

-      int num = window->num;

-      Window xid = window->overlay ? window->overlay->win : None;

-

-      /* If an overlay display callback is registered, we

-         differentiate between a redisplay needed for the

-         overlay and/or normal plane.  If there is no overlay

-         display callback registered, we simply use the

-         standard display callback. */

-

-      if (workMask & (GLUT_REDISPLAY_WORK | GLUT_REPAIR_WORK)) {

-        if (__glutMesaSwapHackSupport) {

-          if (window->usedSwapBuffers) {

-            if ((workMask & (GLUT_REPAIR_WORK | GLUT_REDISPLAY_WORK)) == GLUT_REPAIR_WORK) {

-             SWAP_BUFFERS_WINDOW(window);

-              goto skippedDisplayCallback1;

-            }

-          }

-        }

-        /* Render to normal plane. */

-#ifdef _WIN32

-        window->renderDc = window->hdc;

-#endif

-        window->renderWin = window->win;

-        window->renderCtx = window->ctx;

-        __glutWindowDamaged = (workMask & GLUT_REPAIR_WORK);

-        __glutSetWindow(window);

-        window->usedSwapBuffers = 0;

-        window->display();

-        __glutWindowDamaged = 0;

-

-      skippedDisplayCallback1:;

-      }

-      if (workMask & (GLUT_OVERLAY_REDISPLAY_WORK | GLUT_OVERLAY_REPAIR_WORK)) {

-        window = __glutWindowList[num];

-        if (window && window->overlay &&

-          window->overlay->win == xid && window->overlay->display) {

-

-          /* Render to overlay. */

-#ifdef _WIN32

-          window->renderDc = window->overlay->hdc;

-#endif

-          window->renderWin = window->overlay->win;

-          window->renderCtx = window->overlay->ctx;

-          __glutWindowDamaged = (workMask & GLUT_OVERLAY_REPAIR_WORK);

-          __glutSetWindow(window);

-          window->overlay->display();

-          __glutWindowDamaged = 0;

-        } else {

-          /* Overlay may have since been destroyed or the

-             overlay callback may have been disabled during

-             normal display callback. */

-        }

-      }

-    } else {

-      if (__glutMesaSwapHackSupport) {

-        if (!window->overlay && window->usedSwapBuffers) {

-          if ((workMask & (GLUT_REPAIR_WORK | GLUT_REDISPLAY_WORK)) == GLUT_REPAIR_WORK) {

-           SWAP_BUFFERS_WINDOW(window);

-            goto skippedDisplayCallback2;

-          }

-        }

-      }

-      /* Render to normal plane (and possibly overlay). */

-      __glutWindowDamaged = (workMask & (GLUT_OVERLAY_REPAIR_WORK | GLUT_REPAIR_WORK));

-      __glutSetWindow(window);

-      window->usedSwapBuffers = 0;

-      window->display();

-      __glutWindowDamaged = 0;

-

-    skippedDisplayCallback2:;

-    }

-  }

-  /* Combine workMask with window->workMask to determine what

-     finish and debug work there is. */

-  workMask |= window->workMask;

-

-  if (workMask & GLUT_FINISH_WORK) {

-    /* Finish work makes sure a glFinish gets done to indirect

-       rendering contexts.  Indirect contexts tend to have much

-       longer latency because lots of OpenGL extension requests

-       can queue up in the X protocol stream. __glutSetWindow

-       is where the finish works gets queued for indirect

-       contexts. */

-    __glutSetWindow(window);

-    glFinish();

-  }

-  if (workMask & GLUT_DEBUG_WORK) {

-    __glutSetWindow(window);

-    glutReportErrors();

-  }

-  /* Strip out dummy, finish, and debug work bits. */

-  window->workMask &= ~(GLUT_DUMMY_WORK | GLUT_FINISH_WORK | GLUT_DEBUG_WORK);

-  if (window->workMask) {

-    /* Leave on work list. */

-    return window;

-  } else {

-    /* Remove current window from work list. */

-    return window->prevWorkWin;

-  }

-}

-

-#ifndef _WIN32

-static  /* X11 implementations do not need this global. */

-#endif

-void

-__glutProcessWindowWorkLists(void)

-{

-  if (__glutWindowWorkList) {

-    GLUTwindow *remainder, *work;

-

-    work = __glutWindowWorkList;

-    __glutWindowWorkList = NULL;

-    if (work) {

-      remainder = processWindowWorkList(work);

-      if (remainder) {

-        *beforeEnd = __glutWindowWorkList;

-        __glutWindowWorkList = remainder;

-      }

-    }

-  }

-}

-

-/* CENTRY */

-void GLUTAPIENTRY

-glutMainLoop(void)

-{

-#if !defined(_WIN32)

-  if (!__glutDisplay)

-    __glutFatalUsage("main loop entered with out proper initialization.");

-#endif

-  if (!__glutWindowListSize)

-    __glutFatalUsage(

-      "main loop entered with no windows created.");

-  for (;;) {

-    __glutProcessWindowWorkLists();

-    if (__glutIdleFunc || __glutWindowWorkList) {

-      idleWait();

-    } else {

-      if (__glutTimerList) {

-        waitForSomething();

-      } else {

-        processEventsAndTimeouts();

-      }

-    }

-  }

-}

-/* ENDCENTRY */

+/* glut_event.c */
+/* Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1997, 1998. */
+
+/* This program is freely distributable without licensing fees
+   and is provided without guarantee or warrantee expressed or
+   implied. This program is -not- in the public domain. */
+
+#ifdef __VMS
+#include <GL/vms_x_fix.h>
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <assert.h>
+#include <string.h>  /* Some FD_ZERO macros use memset without
+                        prototyping memset. */
+
+/* Much of the following #ifdef logic to include the proper
+   prototypes for the select system call is based on logic
+   from the X11R6.3 version of <X11/Xpoll.h>. */
+
+#if !defined(_WIN32)
+# ifdef __sgi
+#  include <bstring.h>    /* prototype for bzero used by FD_ZERO */
+# endif
+# if (defined(SVR4) || defined(CRAY) || defined(AIXV3)) && !defined(FD_SETSIZE)
+#  include <sys/select.h> /* select system call interface */
+#  ifdef luna
+#   include <sysent.h>
+#  endif
+# endif
+  /* AIX 4.2 fubar-ed <sys/select.h>, so go to heroic measures to get it */
+# if defined(AIXV4) && !defined(NFDBITS)
+#  include <sys/select.h>
+# endif
+#endif /* !_WIN32 */
+
+#include <sys/types.h>
+
+#if defined(__OS2__)
+//??? ��䨣� ??     #   include <sys/time.h>
+#elif !defined(_WIN32)
+# if defined(__vms) && ( __VMS_VER < 70000000 )
+#  include <sys/time.h>
+# else
+#  ifndef __vms
+#   include <sys/time.h>
+#  endif
+# endif
+# include <unistd.h>
+# include <X11/Xlib.h>
+# include <X11/keysym.h>
+#else
+# ifdef __CYGWIN32__
+#  include <sys/time.h>
+# else
+#  include <sys/timeb.h>
+# endif
+# ifdef __hpux
+   /* XXX Bert Gijsbers <[email protected]> reports that HP-UX
+      needs different keysyms for the End, Insert, and Delete keys
+      to work on an HP 715.  It would be better if HP generated
+      standard keysyms for standard keys. */
+#  include <X11/HPkeysym.h>
+# endif
+#endif /* !_WIN32 */
+
+#include "glutint.h"
+
+#if defined(__vms) && ( __VMS_VER < 70000000 )
+#include <ssdef.h>
+#include <psldef.h>
+extern int SYS$CLREF(int efn);
+extern int SYS$SETIMR(unsigned int efn, struct timeval6 *timeout, void *ast,
+  unsigned int request_id, unsigned int flags);
+extern int SYS$WFLOR(unsigned int efn, unsigned int mask);
+extern int SYS$CANTIM(unsigned int request_id, unsigned int mode);
+#endif /* __vms, VMs 6.2 or earlier */
+
+static GLUTtimer *freeTimerList = NULL;
+
+GLUTidleCB __glutIdleFunc = NULL;
+GLUTtimer *__glutTimerList = NULL;
+#ifdef SUPPORT_FORTRAN
+GLUTtimer *__glutNewTimer;
+#endif
+GLUTwindow *__glutWindowWorkList = NULL;
+GLUTmenu *__glutMappedMenu;
+GLUTmenu *__glutCurrentMenu = NULL;
+
+void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *);
+#if !defined(_WIN32) && !defined(__OS2__)
+void (*__glutMenuItemEnterOrLeave)(GLUTmenuItem * item, int num, int type) = NULL;
+void (*__glutFinishMenu)(Window win, int x, int y);
+void (*__glutPaintMenu)(GLUTmenu * menu);
+void (*__glutStartMenu)(GLUTmenu * menu, GLUTwindow * window, int x, int y, int x_win, int y_win);
+GLUTmenu * (*__glutGetMenuByNum)(int menunum);
+GLUTmenuItem * (*__glutGetMenuItem)(GLUTmenu * menu, Window win, int *which);
+GLUTmenu * (*__glutGetMenu)(Window win);
+#endif
+
+Atom __glutMotifHints = None;
+/* Modifier mask of ~0 implies not in core input callback. */
+unsigned int __glutModifierMask = (unsigned int) ~0;
+int __glutWindowDamaged = 0;
+
+void GLUTAPIENTRY
+glutIdleFunc(GLUTidleCB idleFunc)
+{
+  __glutIdleFunc = idleFunc;
+}
+
+void GLUTAPIENTRY
+glutTimerFunc(unsigned int interval, GLUTtimerCB timerFunc, int value)
+{
+  GLUTtimer *timer, *other;
+  GLUTtimer **prevptr;
+#ifdef OLD_VMS
+   struct timeval6 now;
+#else
+   struct timeval now;
+#endif
+
+  if (!timerFunc)
+    return;
+
+  if (freeTimerList) {
+    timer = freeTimerList;
+    freeTimerList = timer->next;
+  } else {
+    timer = (GLUTtimer *) malloc(sizeof(GLUTtimer));
+    if (!timer)
+      __glutFatalError("out of memory.");
+  }
+
+  timer->func = timerFunc;
+#if defined(__vms) && ( __VMS_VER < 70000000 )
+  /* VMS time is expressed in units of 100 ns */
+  timer->timeout.val = interval * TICKS_PER_MILLISECOND;
+#else
+  timer->timeout.tv_sec = (int) interval / 1000;
+  timer->timeout.tv_usec = (int) (interval % 1000) * 1000;
+#endif
+  timer->value = value;
+  timer->next = NULL;
+  GETTIMEOFDAY(&now);
+  ADD_TIME(timer->timeout, timer->timeout, now);
+  prevptr = &__glutTimerList;
+  other = *prevptr;
+  while (other && IS_AFTER(other->timeout, timer->timeout)) {
+    prevptr = &other->next;
+    other = *prevptr;
+  }
+  timer->next = other;
+#ifdef SUPPORT_FORTRAN
+  __glutNewTimer = timer;  /* for Fortran binding! */
+#endif
+  *prevptr = timer;
+}
+
+void
+handleTimeouts(void)
+{
+#ifdef OLD_VMS
+   struct timeval6 now;
+#else
+   struct timeval now;
+#endif
+   GLUTtimer *timer;
+
+  /* Assumption is that __glutTimerList is already determined
+     to be non-NULL. */
+  GETTIMEOFDAY(&now);
+  while (IS_AT_OR_AFTER(__glutTimerList->timeout, now)) {
+    timer = __glutTimerList;
+    timer->func(timer->value);
+    __glutTimerList = timer->next;
+    timer->next = freeTimerList;
+    freeTimerList = timer;
+    if (!__glutTimerList)
+      break;
+  }
+}
+
+void
+__glutPutOnWorkList(GLUTwindow * window, int workMask)
+{
+  if (window->workMask) {
+    /* Already on list; just OR in new workMask. */
+    window->workMask |= workMask;
+  } else {
+    /* Update work mask and add to window work list. */
+    window->workMask = workMask;
+    /* Assert that if the window does not have a
+       workMask already, the window should definitely
+       not be the head of the work list. */
+    assert(window != __glutWindowWorkList);
+    window->prevWorkWin = __glutWindowWorkList;
+    __glutWindowWorkList = window;
+  }
+}
+
+void
+__glutPostRedisplay(GLUTwindow * window, int layerMask)
+{
+  int shown = (layerMask & (GLUT_REDISPLAY_WORK | GLUT_REPAIR_WORK)) ?
+    window->shownState : window->overlay->shownState;
+
+  /* Post a redisplay if the window is visible (or the
+     visibility of the window is unknown, ie. window->visState
+     == -1) _and_ the layer is known to be shown. */
+  if (window->visState != GLUT_HIDDEN
+    && window->visState != GLUT_FULLY_COVERED && shown) {
+    __glutPutOnWorkList(window, layerMask);
+  }
+}
+
+/* CENTRY */
+void GLUTAPIENTRY
+glutPostRedisplay(void)
+{
+  __glutPostRedisplay(__glutCurrentWindow, GLUT_REDISPLAY_WORK);
+}
+
+/* The advantage of this routine is that it saves the cost of a
+   glutSetWindow call (entailing an expensive OpenGL context switch),
+   particularly useful when multiple windows need redisplays posted at
+   the same times.  See also glutPostWindowOverlayRedisplay. */
+void GLUTAPIENTRY
+glutPostWindowRedisplay(int win)
+{
+  __glutPostRedisplay(__glutWindowList[win - 1], GLUT_REDISPLAY_WORK);
+}
+
+/* ENDCENTRY */
+static GLUTeventParser *eventParserList = NULL;
+
+/* __glutRegisterEventParser allows another module to register
+   to intercept X events types not otherwise acted on by the
+   GLUT processEventsAndTimeouts routine.  The X Input
+   extension support code uses an event parser for handling X
+   Input extension events.  */
+
+void
+__glutRegisterEventParser(GLUTeventParser * parser)
+{
+  parser->next = eventParserList;
+  eventParserList = parser;
+}
+
+static void
+markWindowHidden(GLUTwindow * window)
+{
+  if (GLUT_HIDDEN != window->visState) {
+    GLUTwindow *child;
+
+    if (window->windowStatus) {
+      window->visState = GLUT_HIDDEN;
+      __glutSetWindow(window);
+      window->windowStatus(GLUT_HIDDEN);
+    }
+    /* An unmap is only reported on a single window; its
+       descendents need to know they are no longer visible. */
+    child = window->children;
+    while (child) {
+      markWindowHidden(child);
+      child = child->siblings;
+    }
+  }
+}
+
+#if !defined(_WIN32) && !defined(__OS2__)
+
+static void
+purgeStaleWindow(Window win)
+{
+  GLUTstale **pEntry = &__glutStaleWindowList;
+  GLUTstale *entry = __glutStaleWindowList;
+
+  /* Tranverse singly-linked stale window list look for the
+     window ID. */
+  while (entry) {
+    if (entry->win == win) {
+      /* Found it; delete it. */
+      *pEntry = entry->next;
+      free(entry);
+      return;
+    } else {
+      pEntry = &entry->next;
+      entry = *pEntry;
+    }
+  }
+}
+
+/* Unlike XNextEvent, if a signal arrives,
+   interruptibleXNextEvent will return (with a zero return
+   value).  This helps GLUT drop out of XNextEvent if a signal
+   is delivered.  The intent is so that a GLUT program can call
+   glutIdleFunc in a signal handler to register an idle func
+   and then immediately get dropped into the idle func (after
+   returning from the signal handler).  The idea is to make
+   GLUT's main loop reliably interruptible by signals. */
+static int
+interruptibleXNextEvent(Display * dpy, XEvent * event)
+{
+  fd_set fds;
+  int rc;
+
+  /* Flush X protocol since XPending does not do this
+     implicitly. */
+  XFlush(__glutDisplay);
+  for (;;) {
+    if (XPending(__glutDisplay)) {
+      XNextEvent(dpy, event);
+      return 1;
+    }
+#ifndef VMS
+    /* the combination ConectionNumber-select is buggy on VMS. Sometimes it
+     * fails. This part of the code hangs the program on VMS7.2. But even
+     * without it the program seems to run correctly.
+     * Note that this is a bug in the VMS/DECWindows run-time-libraries.
+     * Compaq engeneering does not want or is not able to make a fix.
+     * (last sentence is a quotation from Compaq when I reported the
+     * problem January 2000) */
+    FD_ZERO(&fds);
+    FD_SET(__glutConnectionFD, &fds);
+    rc = select(__glutConnectionFD + 1, &fds, NULL, NULL, NULL);
+    if (rc < 0) {
+      if (errno == EINTR) {
+        return 0;
+      } else {
+        __glutFatalError("select error.");
+      }
+    }
+#endif
+  }
+}
+
+#endif
+
+static void
+processEventsAndTimeouts(void)
+{
+  do {
+#if defined(__OS2__)
+   QMSG  qmsg;   /* message from message queue     */
+   extern HAB   hab;      /* PM anchor block handle         */
+
+   if(! WinGetMsg( hab, &qmsg, 0UL, 0UL, 0UL ) )
+                 exit(0);
+    WinDispatchMsg( hab,     /* PM anchor block handle  */
+                    &qmsg ); /* pointer to message      */
+
+#elif defined(_WIN32)
+    MSG event;
+
+    if(!GetMessage(&event, NULL, 0, 0))        /* bail if no more messages */
+      exit(0);
+    TranslateMessage(&event);          /* translate virtual-key messages */
+    DispatchMessage(&event);           /* call the window proc */
+    /* see win32_event.c for event (message) processing procedures */
+#else
+    static int mappedMenuButton;
+    GLUTeventParser *parser;
+    XEvent event, ahead;
+    GLUTwindow *window;
+    GLUTkeyboardCB keyboard;
+    GLUTspecialCB special;
+    int gotEvent, width, height;
+
+    gotEvent = interruptibleXNextEvent(__glutDisplay, &event);
+    if (gotEvent) {
+      switch (event.type) {
+      case MappingNotify:
+        XRefreshKeyboardMapping((XMappingEvent *) & event);
+        break;
+      case ConfigureNotify:
+        window = __glutGetWindow(event.xconfigure.window);
+        if (window) {
+          if (window->win != event.xconfigure.window) {
+            /* Ignore ConfigureNotify sent to the overlay
+               planes. GLUT could get here because overlays
+               select for StructureNotify events to receive
+               DestroyNotify. */
+            break;
+          }
+          width = event.xconfigure.width;
+          height = event.xconfigure.height;
+          if (width != window->width || height != window->height) {
+            if (window->overlay) {
+              XResizeWindow(__glutDisplay, window->overlay->win, width, height);
+            }
+            window->width = width;
+            window->height = height;
+            __glutSetWindow(window);
+            /* Do not execute OpenGL out of sequence with
+               respect to the XResizeWindow request! */
+            glXWaitX();
+            window->reshape(width, height);
+            window->forceReshape = False;
+            /* A reshape should be considered like posting a
+               repair; this is necessary for the "Mesa
+               glXSwapBuffers to repair damage" hack to operate
+               correctly.  Without it, there's not an initial
+               back buffer render from which to blit from when
+               damage happens to the window. */
+            __glutPostRedisplay(window, GLUT_REPAIR_WORK);
+          }
+        }
+        break;
+      case Expose:
+        /* compress expose events */
+        while (XEventsQueued(__glutDisplay, QueuedAfterReading)
+          > 0) {
+          XPeekEvent(__glutDisplay, &ahead);
+          if (ahead.type != Expose ||
+            ahead.xexpose.window != event.xexpose.window) {
+            break;
+          }
+          XNextEvent(__glutDisplay, &event);
+        }
+        if (event.xexpose.count == 0) {
+          GLUTmenu *menu;
+
+          if (__glutMappedMenu &&
+            (menu = __glutGetMenu(event.xexpose.window))) {
+            __glutPaintMenu(menu);
+          } else {
+            window = __glutGetWindow(event.xexpose.window);
+            if (window) {
+              if (window->win == event.xexpose.window) {
+                __glutPostRedisplay(window, GLUT_REPAIR_WORK);
+              } else if (window->overlay && window->overlay->win == event.xexpose.window) {
+                __glutPostRedisplay(window, GLUT_OVERLAY_REPAIR_WORK);
+              }
+            }
+          }
+        } else {
+          /* there are more exposes to read; wait to redisplay */
+        }
+        break;
+      case ButtonPress:
+      case ButtonRelease:
+        if (__glutMappedMenu && event.type == ButtonRelease
+          && mappedMenuButton == event.xbutton.button) {
+          /* Menu is currently popped up and its button is
+             released. */
+          __glutFinishMenu(event.xbutton.window, event.xbutton.x, event.xbutton.y);
+        } else {
+          window = __glutGetWindow(event.xbutton.window);
+          if (window) {
+            GLUTmenu *menu;
+           int menuNum;
+
+            menuNum = window->menu[event.xbutton.button - 1];
+            /* Make sure that __glutGetMenuByNum is only called if there
+              really is a menu present. */
+            if ((menuNum > 0) && (menu = __glutGetMenuByNum(menuNum))) {
+              if (event.type == ButtonPress && !__glutMappedMenu) {
+                __glutStartMenu(menu, window,
+                  event.xbutton.x_root, event.xbutton.y_root,
+                  event.xbutton.x, event.xbutton.y);
+                mappedMenuButton = event.xbutton.button;
+              } else {
+                /* Ignore a release of a button with a menu
+                   attatched to it when no menu is popped up,
+                   or ignore a press when another menu is
+                   already popped up. */
+              }
+            } else if (window->mouse) {
+              __glutSetWindow(window);
+              __glutModifierMask = event.xbutton.state;
+              window->mouse(event.xbutton.button - 1,
+                event.type == ButtonRelease ?
+                GLUT_UP : GLUT_DOWN,
+                event.xbutton.x, event.xbutton.y);
+              __glutModifierMask = ~0;
+            } else {
+              /* Stray mouse events.  Ignore. */
+            }
+          } else {
+            /* Window might have been destroyed and all the
+               events for the window may not yet be received. */
+          }
+        }
+        break;
+      case MotionNotify:
+        if (!__glutMappedMenu) {
+          window = __glutGetWindow(event.xmotion.window);
+          if (window) {
+            /* If motion function registered _and_ buttons held
+               * down, call motion function...  */
+            if (window->motion && event.xmotion.state &
+              (Button1Mask | Button2Mask | Button3Mask)) {
+              __glutSetWindow(window);
+              window->motion(event.xmotion.x, event.xmotion.y);
+            }
+            /* If passive motion function registered _and_
+               buttons not held down, call passive motion
+               function...  */
+            else if (window->passive &&
+                ((event.xmotion.state &
+                    (Button1Mask | Button2Mask | Button3Mask)) ==
+                0)) {
+              __glutSetWindow(window);
+              window->passive(event.xmotion.x,
+                event.xmotion.y);
+            }
+          }
+        } else {
+          /* Motion events are thrown away when a pop up menu
+             is active. */
+        }
+        break;
+      case KeyPress:
+      case KeyRelease:
+        window = __glutGetWindow(event.xkey.window);
+        if (!window) {
+          break;
+        }
+       if (event.type == KeyPress) {
+         keyboard = window->keyboard;
+       } else {
+
+         /* If we are ignoring auto repeated keys for this window,
+            check if the next event in the X event queue is a KeyPress
+            for the exact same key (and at the exact same time) as the
+            key being released.  The X11 protocol will send auto
+            repeated keys as such KeyRelease/KeyPress pairs. */
+
+         if (window->ignoreKeyRepeat) {
+           if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {
+             XPeekEvent(__glutDisplay, &ahead);
+             if (ahead.type == KeyPress
+               && ahead.xkey.window == event.xkey.window
+               && ahead.xkey.keycode == event.xkey.keycode
+               && ahead.xkey.time == event.xkey.time) {
+               /* Pop off the repeated KeyPress and ignore
+                  the auto repeated KeyRelease/KeyPress pair. */
+               XNextEvent(__glutDisplay, &event);
+               break;
+             }
+           }
+         }
+         keyboard = window->keyboardUp;
+       }
+        if (keyboard) {
+          char tmp[1];
+          int rc;
+
+          rc = XLookupString(&event.xkey, tmp, sizeof(tmp),
+            NULL, NULL);
+          if (rc) {
+            __glutSetWindow(window);
+            __glutModifierMask = event.xkey.state;
+            keyboard(tmp[0],
+              event.xkey.x, event.xkey.y);
+            __glutModifierMask = ~0;
+            break;
+          }
+        }
+       if (event.type == KeyPress) {
+         special = window->special;
+        } else {
+         special = window->specialUp;
+       }
+        if (special) {
+          KeySym ks;
+          int key;
+
+/* Introduced in X11R6:  (Partial list of) Keypad Functions.  Define
+   in place in case compiling against an older pre-X11R6
+   X11/keysymdef.h file. */
+#ifndef XK_KP_Home
+#define XK_KP_Home              0xFF95
+#endif
+#ifndef XK_KP_Left
+#define XK_KP_Left              0xFF96
+#endif
+#ifndef XK_KP_Up
+#define XK_KP_Up                0xFF97
+#endif
+#ifndef XK_KP_Right
+#define XK_KP_Right             0xFF98
+#endif
+#ifndef XK_KP_Down
+#define XK_KP_Down              0xFF99
+#endif
+#ifndef XK_KP_Prior
+#define XK_KP_Prior             0xFF9A
+#endif
+#ifndef XK_KP_Next
+#define XK_KP_Next              0xFF9B
+#endif
+#ifndef XK_KP_End
+#define XK_KP_End               0xFF9C
+#endif
+#ifndef XK_KP_Insert
+#define XK_KP_Insert            0xFF9E
+#endif
+#ifndef XK_KP_Delete
+#define XK_KP_Delete            0xFF9F
+#endif
+
+          ks = XLookupKeysym((XKeyEvent *) & event, 0);
+          /* XXX Verbose, but makes no assumptions about keysym
+             layout. */
+          switch (ks) {
+/* *INDENT-OFF* */
+          /* function keys */
+          case XK_F1:    key = GLUT_KEY_F1; break;
+          case XK_F2:    key = GLUT_KEY_F2; break;
+          case XK_F3:    key = GLUT_KEY_F3; break;
+          case XK_F4:    key = GLUT_KEY_F4; break;
+          case XK_F5:    key = GLUT_KEY_F5; break;
+          case XK_F6:    key = GLUT_KEY_F6; break;
+          case XK_F7:    key = GLUT_KEY_F7; break;
+          case XK_F8:    key = GLUT_KEY_F8; break;
+          case XK_F9:    key = GLUT_KEY_F9; break;
+          case XK_F10:   key = GLUT_KEY_F10; break;
+          case XK_F11:   key = GLUT_KEY_F11; break;
+          case XK_F12:   key = GLUT_KEY_F12; break;
+          /* directional keys */
+         case XK_KP_Left:
+          case XK_Left:  key = GLUT_KEY_LEFT; break;
+         case XK_KP_Up: /* Introduced in X11R6. */
+          case XK_Up:    key = GLUT_KEY_UP; break;
+         case XK_KP_Right: /* Introduced in X11R6. */
+          case XK_Right: key = GLUT_KEY_RIGHT; break;
+         case XK_KP_Down: /* Introduced in X11R6. */
+          case XK_Down:  key = GLUT_KEY_DOWN; break;
+/* *INDENT-ON* */
+
+         case XK_KP_Prior: /* Introduced in X11R6. */
+          case XK_Prior:
+            /* XK_Prior same as X11R6's XK_Page_Up */
+            key = GLUT_KEY_PAGE_UP;
+            break;
+         case XK_KP_Next: /* Introduced in X11R6. */
+          case XK_Next:
+            /* XK_Next same as X11R6's XK_Page_Down */
+            key = GLUT_KEY_PAGE_DOWN;
+            break;
+         case XK_KP_Home: /* Introduced in X11R6. */
+          case XK_Home:
+            key = GLUT_KEY_HOME;
+            break;
+#ifdef __hpux
+          case XK_Select:
+#endif
+         case XK_KP_End: /* Introduced in X11R6. */
+          case XK_End:
+            key = GLUT_KEY_END;
+            break;
+#ifdef __hpux
+          case XK_InsertChar:
+#endif
+         case XK_KP_Insert: /* Introduced in X11R6. */
+          case XK_Insert:
+            key = GLUT_KEY_INSERT;
+            break;
+#ifdef __hpux
+          case XK_DeleteChar:
+#endif
+         case XK_KP_Delete: /* Introduced in X11R6. */
+            /* The Delete character is really an ASCII key. */
+            __glutSetWindow(window);
+            keyboard(127,  /* ASCII Delete character. */
+              event.xkey.x, event.xkey.y);
+            goto skip;
+          default:
+            goto skip;
+          }
+          __glutSetWindow(window);
+          __glutModifierMask = event.xkey.state;
+          special(key, event.xkey.x, event.xkey.y);
+          __glutModifierMask = ~0;
+        skip:;
+        }
+        break;
+      case EnterNotify:
+      case LeaveNotify:
+        if (event.xcrossing.mode != NotifyNormal ||
+          event.xcrossing.detail == NotifyNonlinearVirtual ||
+          event.xcrossing.detail == NotifyVirtual) {
+
+          /* Careful to ignore Enter/LeaveNotify events that
+             come from the pop-up menu pointer grab and ungrab.
+             Also, ignore "virtual" Enter/LeaveNotify events
+             since they represent the pointer passing through
+             the window hierarchy without actually entering or
+             leaving the actual real estate of a window.  */
+
+          break;
+        }
+        if (__glutMappedMenu) {
+          GLUTmenuItem *item;
+          int num;
+
+          item = __glutGetMenuItem(__glutMappedMenu,
+            event.xcrossing.window, &num);
+          if (item) {
+            __glutMenuItemEnterOrLeave(item, num, event.type);
+            break;
+          }
+        }
+        window = __glutGetWindow(event.xcrossing.window);
+        if (window) {
+          if (window->entry) {
+            if (event.type == EnterNotify) {
+
+              /* With overlays established, X can report two
+                 enter events for both the overlay and normal
+                 plane window. Do not generate a second enter
+                 callback if we reported one without an
+                 intervening leave. */
+
+              if (window->entryState != EnterNotify) {
+                int num = window->num;
+                Window xid = window->win;
+
+                window->entryState = EnterNotify;
+                __glutSetWindow(window);
+                window->entry(GLUT_ENTERED);
+
+                if (__glutMappedMenu) {
+
+                  /* Do not generate any passive motion events
+                     when menus are in use. */
+
+                } else {
+
+                  /* An EnterNotify event can result in a
+                     "compound" callback if a passive motion
+                     callback is also registered. In this case,
+                     be a little paranoid about the possibility
+                     the window could have been destroyed in the
+                     entry callback. */
+
+                  window = __glutWindowList[num];
+                  if (window && window->passive && window->win == xid) {
+                    __glutSetWindow(window);
+                    window->passive(event.xcrossing.x, event.xcrossing.y);
+                  }
+                }
+              }
+            } else {
+              if (window->entryState != LeaveNotify) {
+
+                /* When an overlay is established for a window
+                   already mapped and with the pointer in it,
+                   the X server will generate a leave/enter
+                   event pair as the pointer leaves (without
+                   moving) from the normal plane X window to
+                   the newly mapped overlay  X window (or vice
+                   versa). This enter/leave pair should not be
+                   reported to the GLUT program since the pair
+                   is a consequence of creating (or destroying)
+                   the overlay, not an actual leave from the
+                   GLUT window. */
+
+                if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {
+                  XPeekEvent(__glutDisplay, &ahead);
+                  if (ahead.type == EnterNotify &&
+                    __glutGetWindow(ahead.xcrossing.window) == window) {
+                    XNextEvent(__glutDisplay, &event);
+                    break;
+                  }
+                }
+                window->entryState = LeaveNotify;
+                __glutSetWindow(window);
+                window->entry(GLUT_LEFT);
+              }
+            }
+          } else if (window->passive) {
+            __glutSetWindow(window);
+            window->passive(event.xcrossing.x, event.xcrossing.y);
+          }
+        }
+        break;
+      case UnmapNotify:
+        /* MapNotify events are not needed to maintain
+           visibility state since VisibilityNotify events will
+           be delivered when a window becomes visible from
+           mapping.  However, VisibilityNotify events are not
+           delivered when a window is unmapped (for the window
+           or its children). */
+        window = __glutGetWindow(event.xunmap.window);
+        if (window) {
+          if (window->win != event.xconfigure.window) {
+            /* Ignore UnmapNotify sent to the overlay planes.
+               GLUT could get here because overlays select for
+               StructureNotify events to receive DestroyNotify.
+             */
+            break;
+          }
+          markWindowHidden(window);
+        }
+        break;
+      case VisibilityNotify:
+        window = __glutGetWindow(event.xvisibility.window);
+        if (window) {
+          /* VisibilityUnobscured+1 = GLUT_FULLY_RETAINED,
+             VisibilityPartiallyObscured+1 =
+             GLUT_PARTIALLY_RETAINED, VisibilityFullyObscured+1
+             =  GLUT_FULLY_COVERED. */
+          int visState = event.xvisibility.state + 1;
+
+          if (visState != window->visState) {
+            if (window->windowStatus) {
+              window->visState = visState;
+              __glutSetWindow(window);
+              window->windowStatus(visState);
+            }
+          }
+        }
+        break;
+      case ClientMessage:
+        if (event.xclient.data.l[0] == __glutWMDeleteWindow)
+          exit(0);
+        break;
+      case DestroyNotify:
+        purgeStaleWindow(event.xdestroywindow.window);
+        break;
+      case CirculateNotify:
+      case CreateNotify:
+      case GravityNotify:
+      case ReparentNotify:
+        /* Uninteresting to GLUT (but possible for GLUT to
+           receive). */
+        break;
+      default:
+        /* Pass events not directly handled by the GLUT main
+           event loop to any event parsers that have been
+           registered.  In this way, X Input extension events
+           are passed to the correct handler without forcing
+           all GLUT programs to support X Input event handling.
+         */
+        parser = eventParserList;
+        while (parser) {
+          if (parser->func(&event))
+            break;
+          parser = parser->next;
+        }
+        break;
+      }
+    }
+#endif /* _WIN32 */
+    if (__glutTimerList) {
+      handleTimeouts();
+    }
+  }
+  while (XPending(__glutDisplay));
+}
+
+static void
+waitForSomething(void)
+{
+#if defined(__vms) && ( __VMS_VER < 70000000 )
+  static struct timeval6 zerotime =
+  {0};
+  unsigned int timer_efn;
+#define timer_id 'glut' /* random :-) number */
+  unsigned int wait_mask;
+#else
+  static struct timeval zerotime =
+  {0, 0};
+#if defined(__OS2__)
+
+#elif !defined(_WIN32)
+  fd_set fds;
+#endif
+#endif
+#ifdef OLD_VMS
+   struct timeval6 now, timeout, waittime;
+#else
+   struct timeval now, timeout, waittime;
+#endif
+#if !defined(_WIN32)
+  int rc;
+#endif
+
+  /* Flush X protocol since XPending does not do this
+     implicitly. */
+  XFlush(__glutDisplay);
+  if (XPending(__glutDisplay)) {
+    /* It is possible (but quite rare) that XFlush may have
+       needed to wait for a writable X connection file
+       descriptor, and in the process, may have had to read off
+       X protocol from the file descriptor. If XPending is true,
+       this case occured and we should avoid waiting in select
+       since X protocol buffered within Xlib is due to be
+       processed and potentially no more X protocol is on the
+       file descriptor, so we would risk waiting improperly in
+       select. */
+    goto immediatelyHandleXinput;
+  }
+#if defined(__vms) && ( __VMS_VER < 70000000 )
+  timeout = __glutTimerList->timeout;
+  GETTIMEOFDAY(&now);
+  wait_mask = 1 << (__glutConnectionFD & 31);
+  if (IS_AFTER(now, timeout)) {
+    /* We need an event flag for the timer. */
+    /* XXX The `right' way to do this is to use LIB$GET_EF, but
+       since it needs to be in the same cluster as the EFN for
+       the display, we will have hack it. */
+    timer_efn = __glutConnectionFD - 1;
+    if ((timer_efn / 32) != (__glutConnectionFD / 32)) {
+      timer_efn = __glutConnectionFD + 1;
+    }
+    rc = SYS$CLREF(timer_efn);
+    rc = SYS$SETIMR(timer_efn, &timeout, NULL, timer_id, 0);
+    wait_mask |= 1 << (timer_efn & 31);
+  } else {
+    timer_efn = 0;
+  }
+  rc = SYS$WFLOR(__glutConnectionFD, wait_mask);
+  if (timer_efn != 0 && SYS$CLREF(timer_efn) == SS$_WASCLR) {
+    rc = SYS$CANTIM(timer_id, PSL$C_USER);
+  }
+  /* XXX There does not seem to be checking of "rc" in the code
+     above.  Can any of the SYS$ routines above fail? */
+#else /* not vms6.2 or lower */
+#if defined(__OS2__)
+
+#elif !defined(_WIN32)
+  FD_ZERO(&fds);
+  FD_SET(__glutConnectionFD, &fds);
+#endif
+  timeout = __glutTimerList->timeout;
+  GETTIMEOFDAY(&now);
+  if (IS_AFTER(now, timeout)) {
+    TIMEDELTA(waittime, timeout, now);
+  } else {
+    waittime = zerotime;
+  }
+
+#if defined(__OS2__)
+  DosSleep(0);
+#elif !defined(_WIN32)
+  rc = select(__glutConnectionFD + 1, &fds,
+    NULL, NULL, &waittime);
+  if (rc < 0 && errno != EINTR)
+    __glutFatalError("select error.");
+#else
+
+  MsgWaitForMultipleObjects(0, NULL, FALSE,
+    waittime.tv_sec*1000 + waittime.tv_usec/1000, QS_ALLINPUT);
+
+#endif
+#endif /* not vms6.2 or lower */
+  /* Without considering the cause of select unblocking, check
+     for pending X events and handle any timeouts (by calling
+     processEventsAndTimeouts).  We always look for X events
+     even if select returned with 0 (indicating a timeout);
+     otherwise we risk starving X event processing by continous
+     timeouts. */
+  if (XPending(__glutDisplay)) {
+  immediatelyHandleXinput:
+    processEventsAndTimeouts();
+  } else {
+    if (__glutTimerList)
+      handleTimeouts();
+  }
+}
+
+static void
+idleWait(void)
+{
+  if (XPending(__glutDisplay)) {
+    processEventsAndTimeouts();
+  } else {
+    if (__glutTimerList) {
+      handleTimeouts();
+    }
+  }
+  /* Make sure idle func still exists! */
+  if (__glutIdleFunc) {
+    __glutIdleFunc();
+  }
+}
+
+static GLUTwindow **beforeEnd;
+
+static GLUTwindow *
+processWindowWorkList(GLUTwindow * window)
+{
+  int workMask;
+
+  if (window->prevWorkWin) {
+    window->prevWorkWin = processWindowWorkList(window->prevWorkWin);
+  } else {
+    beforeEnd = &window->prevWorkWin;
+  }
+
+  /* Capture work mask for work that needs to be done to this
+     window, then clear the window's work mask (excepting the
+     dummy work bit, see below).  Then, process the captured
+     work mask.  This allows callbacks in the processing the
+     captured work mask to set the window's work mask for
+     subsequent processing. */
+
+  workMask = window->workMask;
+  assert((workMask & GLUT_DUMMY_WORK) == 0);
+
+  /* Set the dummy work bit, clearing all other bits, to
+     indicate that the window is currently on the window work
+     list _and_ that the window's work mask is currently being
+     processed.  This convinces __glutPutOnWorkList that this
+     window is on the work list still. */
+  window->workMask = GLUT_DUMMY_WORK;
+
+  /* Optimization: most of the time, the work to do is a
+     redisplay and not these other types of work.  Check for
+     the following cases as a group to before checking each one
+     individually one by one. This saves about 25 MIPS
+     instructions in the common redisplay only case. */
+  if (workMask & (GLUT_EVENT_MASK_WORK | GLUT_DEVICE_MASK_WORK |
+      GLUT_CONFIGURE_WORK | GLUT_COLORMAP_WORK | GLUT_MAP_WORK)) {
+
+#if !defined(_WIN32) && !defined(__OS2__)
+    /* Be sure to set event mask BEFORE map window is done. */
+    if (workMask & GLUT_EVENT_MASK_WORK) {
+      long eventMask;
+
+      /* Make sure children are not propogating events this
+         window is selecting for.  Be sure to do this before
+         enabling events on the children's parent. */
+      if (window->children) {
+        GLUTwindow *child = window->children;
+        unsigned long attribMask = CWDontPropagate;
+        XSetWindowAttributes wa;
+
+        wa.do_not_propagate_mask = window->eventMask & GLUT_DONT_PROPAGATE_FILTER_MASK;
+        if (window->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK) {
+          wa.event_mask = child->eventMask | (window->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK);
+          attribMask |= CWEventMask;
+        }
+        do {
+          XChangeWindowAttributes(__glutDisplay, child->win,
+            attribMask, &wa);
+          child = child->siblings;
+        } while (child);
+      }
+      eventMask = window->eventMask;
+      if (window->parent && window->parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK)
+        eventMask |= (window->parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK);
+      XSelectInput(__glutDisplay, window->win, eventMask);
+      if (window->overlay)
+        XSelectInput(__glutDisplay, window->overlay->win,
+          window->eventMask & GLUT_OVERLAY_EVENT_FILTER_MASK);
+    }
+#endif /* !_WIN32 */
+    /* Be sure to set device mask BEFORE map window is done. */
+    if (workMask & GLUT_DEVICE_MASK_WORK) {
+      __glutUpdateInputDeviceMaskFunc(window);
+    }
+    /* Be sure to configure window BEFORE map window is done. */
+    if (workMask & GLUT_CONFIGURE_WORK) {
+#if defined(__OS2__)
+      RECTL changes;
+
+#elif defined(_WIN32)
+      RECT changes;
+      POINT point;
+      UINT flags = SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOOWNERZORDER
+       | SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOZORDER;
+
+      GetClientRect(window->win, &changes);
+
+      /* If this window is a toplevel window, translate the 0,0 client
+         coordinate into a screen coordinate for proper placement. */
+      if (!window->parent) {
+        point.x = 0;
+        point.y = 0;
+        ClientToScreen(window->win, &point);
+        changes.left = point.x;
+        changes.top = point.y;
+      }
+      if (window->desiredConfMask & (CWX | CWY)) {
+        changes.left = window->desiredX;
+        changes.top = window->desiredY;
+       flags &= ~SWP_NOMOVE;
+      }
+      if (window->desiredConfMask & (CWWidth | CWHeight)) {
+        changes.right = changes.left + window->desiredWidth;
+        changes.bottom = changes.top + window->desiredHeight;
+       flags &= ~SWP_NOSIZE;
+       /* XXX If overlay exists, resize the overlay here, ie.
+          if (window->overlay) ... */
+      }
+      if (window->desiredConfMask & CWStackMode) {
+       flags &= ~SWP_NOZORDER;
+       /* XXX Overlay support might require something special here. */
+      }
+
+      /* Adjust the window rectangle because Win32 thinks that the x, y,
+         width & height are the WHOLE window (including decorations),
+         whereas GLUT treats the x, y, width & height as only the CLIENT
+         area of the window.  Only do this to top level windows
+         that are not in game mode (since game mode windows do
+         not have any decorations). */
+      if (!window->parent && window != __glutGameModeWindow) {
+        AdjustWindowRect(&changes,
+          WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
+          FALSE);
+      }
+
+      /* Do the repositioning, moving, and push/pop. */
+      SetWindowPos(window->win,
+        window->desiredStack == Above ? HWND_TOP : HWND_NOTOPMOST,
+        changes.left, changes.top,
+        changes.right - changes.left, changes.bottom - changes.top,
+        flags);
+
+      /* Zero out the mask. */
+      window->desiredConfMask = 0;
+
+      /* This hack causes the window to go back to the right position
+         when it is taken out of fullscreen mode. */
+      if (workMask & GLUT_FULL_SCREEN_WORK) {
+        window->desiredConfMask |= CWX | CWY;
+        window->desiredX = point.x;
+        window->desiredY = point.y;
+      }
+#else /* !_WIN32 */
+      XWindowChanges changes;
+
+      changes.x = window->desiredX;
+      changes.y = window->desiredY;
+      if (window->desiredConfMask & (CWWidth | CWHeight)) {
+        changes.width = window->desiredWidth;
+        changes.height = window->desiredHeight;
+        if (window->overlay)
+          XResizeWindow(__glutDisplay, window->overlay->win,
+            window->desiredWidth, window->desiredHeight);
+        if (__glutMotifHints != None) {
+          if (workMask & GLUT_FULL_SCREEN_WORK) {
+            MotifWmHints hints;
+
+            hints.flags = MWM_HINTS_DECORATIONS;
+            hints.decorations = 0;  /* Absolutely no
+                                       decorations. */
+            XChangeProperty(__glutDisplay, window->win,
+              __glutMotifHints, __glutMotifHints, 32,
+              PropModeReplace, (unsigned char *) &hints, 4);
+            if (workMask & GLUT_MAP_WORK) {
+              /* Handle case where glutFullScreen is called
+                 before the first time that the window is
+                 mapped. Some window managers will randomly or
+                 interactively position the window the first
+                 time it is mapped if the window's
+                 WM_NORMAL_HINTS property does not request an
+                 explicit position. We don't want any such
+                 window manager interaction when going
+                 fullscreen.  Overwrite the WM_NORMAL_HINTS
+                 property installed by glutCreateWindow's
+                 XSetWMProperties property with one explicitly
+                 requesting a fullscreen window. */
+              XSizeHints hints;
+
+              hints.flags = USPosition | USSize;
+              hints.x = 0;
+              hints.y = 0;
+              hints.width = window->desiredWidth;
+              hints.height = window->desiredHeight;
+              XSetWMNormalHints(__glutDisplay, window->win, &hints);
+            }
+          } else {
+            XDeleteProperty(__glutDisplay, window->win, __glutMotifHints);
+          }
+        }
+      }
+      if (window->desiredConfMask & CWStackMode) {
+        changes.stack_mode = window->desiredStack;
+        /* Do not let glutPushWindow push window beneath the
+           underlay. */
+        if (window->parent && window->parent->overlay
+          && window->desiredStack == Below) {
+          changes.stack_mode = Above;
+          changes.sibling = window->parent->overlay->win;
+          window->desiredConfMask |= CWSibling;
+        }
+      }
+      XConfigureWindow(__glutDisplay, window->win,
+        window->desiredConfMask, &changes);
+      window->desiredConfMask = 0;
+#endif
+    }
+#if !defined(_WIN32) && !defined(__OS2__)
+    /* Be sure to establish the colormaps BEFORE map window is
+       done. */
+    if (workMask & GLUT_COLORMAP_WORK) {
+      __glutEstablishColormapsProperty(window);
+    }
+#endif
+    if (workMask & GLUT_MAP_WORK) {
+      switch (window->desiredMapState) {
+      case WithdrawnState:
+        if (window->parent) {
+          XUnmapWindow(__glutDisplay, window->win);
+        } else {
+          XWithdrawWindow(__glutDisplay, window->win,
+            __glutScreen);
+        }
+        window->shownState = 0;
+        break;
+      case NormalState:
+        XMapWindow(__glutDisplay, window->win);
+        window->shownState = 1;
+        break;
+#ifdef _WIN32
+      case GameModeState:  /* Not an Xlib value. */
+        ShowWindow(window->win, SW_SHOW);
+        window->shownState = 1;
+        break;
+#endif
+      case IconicState:
+        XIconifyWindow(__glutDisplay, window->win, __glutScreen);
+        window->shownState = 0;
+        break;
+      }
+    }
+  }
+  if (workMask & (GLUT_REDISPLAY_WORK | GLUT_OVERLAY_REDISPLAY_WORK | GLUT_REPAIR_WORK | GLUT_OVERLAY_REPAIR_WORK)) {
+    if (window->forceReshape) {
+      /* Guarantee that before a display callback is generated
+         for a window, a reshape callback must be generated. */
+      __glutSetWindow(window);
+      window->reshape(window->width, window->height);
+      window->forceReshape = False;
+
+      /* Setting the redisplay bit on the first reshape is
+         necessary to make the "Mesa glXSwapBuffers to repair
+         damage" hack operate correctly.  Without indicating a
+         redisplay is necessary, there's not an initial back
+         buffer render from which to blit from when damage
+         happens to the window. */
+      workMask |= GLUT_REDISPLAY_WORK;
+    }
+    /* The code below is more involved than otherwise necessary
+       because it is paranoid about the overlay or entire window
+       being removed or destroyed in the course of the callbacks.
+       Notice how the global __glutWindowDamaged is used to record
+       the layers' damage status.  See the code in glutLayerGet for
+       how __glutWindowDamaged is used. The  point is to not have to
+       update the "damaged" field after  the callback since the
+       window (or overlay) may be destroyed (or removed) when the
+       callback returns. */
+
+    if (window->overlay && window->overlay->display) {
+      int num = window->num;
+      Window xid = window->overlay ? window->overlay->win : None;
+
+      /* If an overlay display callback is registered, we
+         differentiate between a redisplay needed for the
+         overlay and/or normal plane.  If there is no overlay
+         display callback registered, we simply use the
+         standard display callback. */
+
+      if (workMask & (GLUT_REDISPLAY_WORK | GLUT_REPAIR_WORK)) {
+        if (__glutMesaSwapHackSupport) {
+          if (window->usedSwapBuffers) {
+            if ((workMask & (GLUT_REPAIR_WORK | GLUT_REDISPLAY_WORK)) == GLUT_REPAIR_WORK) {
+             SWAP_BUFFERS_WINDOW(window);
+              goto skippedDisplayCallback1;
+            }
+          }
+        }
+        /* Render to normal plane. */
+#ifdef _WIN32
+        window->renderDc = window->hdc;
+#endif
+        window->renderWin = window->win;
+        window->renderCtx = window->ctx;
+        __glutWindowDamaged = (workMask & GLUT_REPAIR_WORK);
+        __glutSetWindow(window);
+        window->usedSwapBuffers = 0;
+        window->display();
+        __glutWindowDamaged = 0;
+
+      skippedDisplayCallback1:;
+      }
+      if (workMask & (GLUT_OVERLAY_REDISPLAY_WORK | GLUT_OVERLAY_REPAIR_WORK)) {
+        window = __glutWindowList[num];
+        if (window && window->overlay &&
+          window->overlay->win == xid && window->overlay->display) {
+
+          /* Render to overlay. */
+#ifdef _WIN32
+          window->renderDc = window->overlay->hdc;
+#endif
+          window->renderWin = window->overlay->win;
+          window->renderCtx = window->overlay->ctx;
+          __glutWindowDamaged = (workMask & GLUT_OVERLAY_REPAIR_WORK);
+          __glutSetWindow(window);
+          window->overlay->display();
+          __glutWindowDamaged = 0;
+        } else {
+          /* Overlay may have since been destroyed or the
+             overlay callback may have been disabled during
+             normal display callback. */
+        }
+      }
+    } else {
+      if (__glutMesaSwapHackSupport) {
+        if (!window->overlay && window->usedSwapBuffers) {
+          if ((workMask & (GLUT_REPAIR_WORK | GLUT_REDISPLAY_WORK)) == GLUT_REPAIR_WORK) {
+           SWAP_BUFFERS_WINDOW(window);
+            goto skippedDisplayCallback2;
+          }
+        }
+      }
+      /* Render to normal plane (and possibly overlay). */
+      __glutWindowDamaged = (workMask & (GLUT_OVERLAY_REPAIR_WORK | GLUT_REPAIR_WORK));
+      __glutSetWindow(window);
+      window->usedSwapBuffers = 0;
+      window->display();
+      __glutWindowDamaged = 0;
+
+    skippedDisplayCallback2:;
+    }
+  }
+  /* Combine workMask with window->workMask to determine what
+     finish and debug work there is. */
+  workMask |= window->workMask;
+
+  if (workMask & GLUT_FINISH_WORK) {
+    /* Finish work makes sure a glFinish gets done to indirect
+       rendering contexts.  Indirect contexts tend to have much
+       longer latency because lots of OpenGL extension requests
+       can queue up in the X protocol stream. __glutSetWindow
+       is where the finish works gets queued for indirect
+       contexts. */
+    __glutSetWindow(window);
+    glFinish();
+  }
+  if (workMask & GLUT_DEBUG_WORK) {
+    __glutSetWindow(window);
+    glutReportErrors();
+  }
+  /* Strip out dummy, finish, and debug work bits. */
+  window->workMask &= ~(GLUT_DUMMY_WORK | GLUT_FINISH_WORK | GLUT_DEBUG_WORK);
+  if (window->workMask) {
+    /* Leave on work list. */
+    return window;
+  } else {
+    /* Remove current window from work list. */
+    return window->prevWorkWin;
+  }
+}
+
+#ifndef _WIN32
+static  /* X11 implementations do not need this global. */
+#endif
+void
+__glutProcessWindowWorkLists(void)
+{
+  if (__glutWindowWorkList) {
+    GLUTwindow *remainder, *work;
+
+    work = __glutWindowWorkList;
+    __glutWindowWorkList = NULL;
+    if (work) {
+      remainder = processWindowWorkList(work);
+      if (remainder) {
+        *beforeEnd = __glutWindowWorkList;
+        __glutWindowWorkList = remainder;
+      }
+    }
+  }
+}
+
+/* CENTRY */
+void GLUTAPIENTRY
+glutMainLoop(void)
+{
+#if !defined(_WIN32)
+  if (!__glutDisplay)
+    __glutFatalUsage("main loop entered with out proper initialization.");
+#endif
+  if (!__glutWindowListSize)
+    __glutFatalUsage(
+      "main loop entered with no windows created.");
+  for (;;) {
+    __glutProcessWindowWorkLists();
+    if (__glutIdleFunc || __glutWindowWorkList) {
+      idleWait();
+    } else {
+      if (__glutTimerList) {
+        waitForSomething();
+      } else {
+        processEventsAndTimeouts();
+      }
+    }
+  }
+}
+/* ENDCENTRY */