开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
glut_event.c
资源名称：glut23-src.zip　[点击查看]
上传用户：xk288cn
上传日期：2007-05-28
资源大小：4876k
文件大小：47k
源码类别：

GIS编程

开发平台：

Visual C++

glut_event.c：源码内容
  2. /* Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1997, 1998. */
  4. /* This program is freely distributable without licensing fees
  5.    and is provided without guarantee or warrantee expressed or
  6.    implied. This program is -not- in the public domain. */
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <errno.h>
  11. #include <assert.h>
  12. #include <string.h>  /* Some FD_ZERO macros use memset without
  13.                         prototyping memset. */
  15. /* Much of the following #ifdef logic to include the proper
  16.    prototypes for the select system call is based on logic
  17.    from the X11R6.3 version of <X11/Xpoll.h>. */
  19. #if !defined(_WIN32)
  20. # ifdef __sgi
  21. #  include <bstring.h>    /* prototype for bzero used by FD_ZERO */
  22. # endif
  23. # if (defined(SVR4) || defined(CRAY) || defined(AIXV3)) && !defined(FD_SETSIZE)
  24. #  include <sys/select.h> /* select system call interface */
  25. #  ifdef luna
  26. #   include <sysent.h>
  27. #  endif
  28. # endif
  29.   /* AIX 4.2 fubar-ed <sys/select.h>, so go to heroic measures to get it */
  30. # if defined(AIXV4) && !defined(NFDBITS)
  31. #  include <sys/select.h>
  32. # endif
  33. #endif /* !_WIN32 */
  35. #include <sys/types.h>
  37. #if !defined(_WIN32)
  38. # if defined(__vms) && ( __VMS_VER < 70000000 )
  39. #  include <sys/time.h>
  40. # else
  41. #  ifndef __vms
  42. #   include <sys/time.h>
  43. #  endif
  44. # endif
  45. # include <unistd.h>
  46. # include <X11/Xlib.h>
  47. # include <X11/keysym.h>
  48. #else
  49. # ifdef __CYGWIN32__
  50. #  include <sys/time.h>
  51. # else
  52. #  include <sys/timeb.h>
  53. # endif
  54. # ifdef __hpux
  55.    /* XXX Bert Gijsbers <bert@mc.bio.uva.nl> reports that HP-UX
  56.       needs different keysyms for the End, Insert, and Delete keys
  57.       to work on an HP 715.  It would be better if HP generated
  58.       standard keysyms for standard keys. */
  59. #  include <X11/HPkeysym.h>
  60. # endif
  61. #endif /* !_WIN32 */
  63. #if defined(__vms) && ( __VMS_VER < 70000000 )
  64. #include <ssdef.h>
  65. #include <psldef.h>
  66. extern int SYS$CLREF(int efn);
  67. extern int SYS$SETIMR(unsigned int efn, struct timeval *timeout, void *ast,
  68.   unsigned int request_id, unsigned int flags);
  69. extern int SYS$WFLOR(unsigned int efn, unsigned int mask);
  70. extern int SYS$CANTIM(unsigned int request_id, unsigned int mode);
  71. #endif /* __vms, VMs 6.2 or earlier */
  73. #include "glutint.h"
  75. static GLUTtimer *freeTimerList = NULL;
  77. GLUTidleCB __glutIdleFunc = NULL;
  78. GLUTtimer *__glutTimerList = NULL;
  79. #ifdef SUPPORT_FORTRAN
  80. GLUTtimer *__glutNewTimer;
  81. #endif
  82. GLUTwindow *__glutWindowWorkList = NULL;
  83. GLUTmenu *__glutMappedMenu;
  84. GLUTmenu *__glutCurrentMenu = NULL;
  86. void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *);
  87. #if !defined(_WIN32)
  88. void (*__glutMenuItemEnterOrLeave)(GLUTmenuItem * item, int num, int type) = NULL;
  89. void (*__glutFinishMenu)(Window win, int x, int y);
  90. void (*__glutPaintMenu)(GLUTmenu * menu);
  91. void (*__glutStartMenu)(GLUTmenu * menu, GLUTwindow * window, int x, int y, int x_win, int y_win);
  92. GLUTmenu * (*__glutGetMenuByNum)(int menunum);
  93. GLUTmenuItem * (*__glutGetMenuItem)(GLUTmenu * menu, Window win, int *which);
  94. GLUTmenu * (*__glutGetMenu)(Window win);
  95. #endif
  97. Atom __glutMotifHints = None;
  98. /* Modifier mask of ~0 implies not in core input callback. */
  99. unsigned int __glutModifierMask = (unsigned int) ~0;
  100. int __glutWindowDamaged = 0;
  102. void APIENTRY
  103. glutIdleFunc(GLUTidleCB idleFunc)
  104. {
  105.   __glutIdleFunc = idleFunc;
  106. }
  108. void APIENTRY
  109. glutTimerFunc(unsigned int interval, GLUTtimerCB timerFunc, int value)
  110. {
  111.   GLUTtimer *timer, *other;
  112.   GLUTtimer **prevptr;
  113.   struct timeval now;
  115.   if (!timerFunc)
  116.     return;
  118.   if (freeTimerList) {
  119.     timer = freeTimerList;
  120.     freeTimerList = timer->next;
  121.   } else {
  122.     timer = (GLUTtimer *) malloc(sizeof(GLUTtimer));
  123.     if (!timer)
  124.       __glutFatalError("out of memory.");
  125.   }
  127.   timer->func = timerFunc;
  128. #if defined(__vms) && ( __VMS_VER < 70000000 )
  129.   /* VMS time is expressed in units of 100 ns */
  130.   timer->timeout.val = interval * TICKS_PER_MILLISECOND;
  131. #else
  132.   timer->timeout.tv_sec = (int) interval / 1000;
  133.   timer->timeout.tv_usec = (int) (interval % 1000) * 1000;
  134. #endif
  135.   timer->value = value;
  136.   timer->next = NULL;
  137.   GETTIMEOFDAY(&now);
  138.   ADD_TIME(timer->timeout, timer->timeout, now);
  139.   prevptr = &__glutTimerList;
  140.   other = *prevptr;
  141.   while (other && IS_AFTER(other->timeout, timer->timeout)) {
  142.     prevptr = &other->next;
  143.     other = *prevptr;
  144.   }
  145.   timer->next = other;
  146. #ifdef SUPPORT_FORTRAN
  147.   __glutNewTimer = timer;  /* for Fortran binding! */
  148. #endif
  149.   *prevptr = timer;
  150. }
  152. void
  153. handleTimeouts(void)
  154. {
  155.   struct timeval now;
  156.   GLUTtimer *timer;
  158.   /* Assumption is that __glutTimerList is already determined
  159.      to be non-NULL. */
  160.   GETTIMEOFDAY(&now);
  161.   while (IS_AT_OR_AFTER(__glutTimerList->timeout, now)) {
  162.     timer = __glutTimerList;
  163.     timer->func(timer->value);
  164.     __glutTimerList = timer->next;
  165.     timer->next = freeTimerList;
  166.     freeTimerList = timer;
  167.     if (!__glutTimerList)
  168.       break;
  169.   }
  170. }
  172. void
  173. __glutPutOnWorkList(GLUTwindow * window, int workMask)
  174. {
  175.   if (window->workMask) {
  176.     /* Already on list; just OR in new workMask. */
  177.     window->workMask |= workMask;
  178.   } else {
  179.     /* Update work mask and add to window work list. */
  180.     window->workMask = workMask;
  181.     /* Assert that if the window does not have a
  182.        workMask already, the window should definitely
  183.        not be the head of the work list. */
  184.     assert(window != __glutWindowWorkList);
  185.     window->prevWorkWin = __glutWindowWorkList;
  186.     __glutWindowWorkList = window;
  187.   }
  188. }
  190. void
  191. __glutPostRedisplay(GLUTwindow * window, int layerMask)
  192. {
  193.   int shown = (layerMask & (GLUT_REDISPLAY_WORK | GLUT_REPAIR_WORK)) ?
  194.     window->shownState : window->overlay->shownState;
  196.   /* Post a redisplay if the window is visible (or the
  197.      visibility of the window is unknown, ie. window->visState
  198.      == -1) _and_ the layer is known to be shown. */
  199.   if (window->visState != GLUT_HIDDEN
  200.     && window->visState != GLUT_FULLY_COVERED && shown) {
  201.     __glutPutOnWorkList(window, layerMask);
  202.   }
  203. }
  205. /* CENTRY */
  206. void APIENTRY
  207. glutPostRedisplay(void)
  208. {
  209.   __glutPostRedisplay(__glutCurrentWindow, GLUT_REDISPLAY_WORK);
  210. }
  212. /* The advantage of this routine is that it saves the cost of a
  213.    glutSetWindow call (entailing an expensive OpenGL context switch),
  214.    particularly useful when multiple windows need redisplays posted at
  215.    the same times.  See also glutPostWindowOverlayRedisplay. */
  216. void APIENTRY
  217. glutPostWindowRedisplay(int win)
  218. {
  219.   __glutPostRedisplay(__glutWindowList[win - 1], GLUT_REDISPLAY_WORK);
  220. }
  222. /* ENDCENTRY */
  223. static GLUTeventParser *eventParserList = NULL;
  225. /* __glutRegisterEventParser allows another module to register
  226.    to intercept X events types not otherwise acted on by the
  227.    GLUT processEventsAndTimeouts routine.  The X Input
  228.    extension support code uses an event parser for handling X
  229.    Input extension events.  */
  231. void
  232. __glutRegisterEventParser(GLUTeventParser * parser)
  233. {
  234.   parser->next = eventParserList;
  235.   eventParserList = parser;
  236. }
  238. static void
  239. markWindowHidden(GLUTwindow * window)
  240. {
  241.   if (GLUT_HIDDEN != window->visState) {
  242.     GLUTwindow *child;
  244.     if (window->windowStatus) {
  245.       window->visState = GLUT_HIDDEN;
  246.       __glutSetWindow(window);
  247.       window->windowStatus(GLUT_HIDDEN);
  248.     }
  249.     /* An unmap is only reported on a single window; its
  250.        descendents need to know they are no longer visible. */
  251.     child = window->children;
  252.     while (child) {
  253.       markWindowHidden(child);
  254.       child = child->siblings;
  255.     }
  256.   }
  257. }
  259. #if !defined(_WIN32)
  261. static void
  262. purgeStaleWindow(Window win)
  263. {
  264.   GLUTstale **pEntry = &__glutStaleWindowList;
  265.   GLUTstale *entry = __glutStaleWindowList;
  267.   /* Tranverse singly-linked stale window list look for the
  268.      window ID. */
  269.   while (entry) {
  270.     if (entry->win == win) {
  271.       /* Found it; delete it. */
  272.       *pEntry = entry->next;
  273.       free(entry);
  274.       return;
  275.     } else {
  276.       pEntry = &entry->next;
  277.       entry = *pEntry;
  278.     }
  279.   }
  280. }
  282. /* Unlike XNextEvent, if a signal arrives,
  283.    interruptibleXNextEvent will return (with a zero return
  284.    value).  This helps GLUT drop out of XNextEvent if a signal
  285.    is delivered.  The intent is so that a GLUT program can call 
  286.    glutIdleFunc in a signal handler to register an idle func
  287.    and then immediately get dropped into the idle func (after
  288.    returning from the signal handler).  The idea is to make
  289.    GLUT's main loop reliably interruptible by signals. */
  290. static int
  291. interruptibleXNextEvent(Display * dpy, XEvent * event)
  292. {
  293.   fd_set fds;
  294.   int rc;
  296.   /* Flush X protocol since XPending does not do this
  297.      implicitly. */
  298.   XFlush(__glutDisplay);
  299.   for (;;) {
  300.     if (XPending(__glutDisplay)) {
  301.       XNextEvent(dpy, event);
  302.       return 1;
  303.     }
  304.     FD_ZERO(&fds);
  305.     FD_SET(__glutConnectionFD, &fds);
  306.     rc = select(__glutConnectionFD + 1, &fds,
  307.       NULL, NULL, NULL);
  308.     if (rc < 0) {
  309.       if (errno == EINTR) {
  310.         return 0;
  311.       } else {
  312.         __glutFatalError("select error.");
  313.       }
  314.     }
  315.   }
  316. }
  318. #endif
  320. static void
  321. processEventsAndTimeouts(void)
  322. {
  323. #if defined ( _WIN32 )
  324. MSG msg;
  326. while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
  327. TranslateMessage( &msg );
  328. DispatchMessage( &msg );
  329. if ( msg.message == WM_QUIT ) {
  330. exit( 0 );
  331. }
  332. }
  333. if (__glutTimerList) {
  334. handleTimeouts();
  335. }
  336. #else  /* _WIN32 */
  338.   do {
  339.     static int mappedMenuButton;
  340.     GLUTeventParser *parser;
  341.     XEvent event, ahead;
  342.     GLUTwindow *window;
  343.     GLUTkeyboardCB keyboard;
  344.     GLUTspecialCB special;
  345.     int gotEvent, width, height;
  347.     gotEvent = interruptibleXNextEvent(__glutDisplay, &event);
  348.     if (gotEvent) {
  349.       switch (event.type) {
  350.       case MappingNotify:
  351.         XRefreshKeyboardMapping((XMappingEvent *) & event);
  352.         break;
  353.       case ConfigureNotify:
  354.         window = __glutGetWindow(event.xconfigure.window);
  355.         if (window) {
  356.           if (window->win != event.xconfigure.window) {
  357.             /* Ignore ConfigureNotify sent to the overlay
  358.                planes. GLUT could get here because overlays
  359.                select for StructureNotify events to receive
  360.                DestroyNotify. */
  361.             break;
  362.           }
  363.           width = event.xconfigure.width;
  364.           height = event.xconfigure.height;
  365.           if (width != window->width || height != window->height) {
  366.             if (window->overlay) {
  367.               XResizeWindow(__glutDisplay, window->overlay->win, width, height);
  368.             }
  369.             window->width = width;
  370.             window->height = height;
  371.             __glutSetWindow(window);
  372.             /* Do not execute OpenGL out of sequence with
  373.                respect to the XResizeWindow request! */
  374.             glXWaitX();
  375.             window->reshape(width, height);
  376.             window->forceReshape = False;
  377.             /* A reshape should be considered like posting a
  378.                repair; this is necessary for the "Mesa
  379.                glXSwapBuffers to repair damage" hack to operate
  380.                correctly.  Without it, there's not an initial
  381.                back buffer render from which to blit from when
  382.                damage happens to the window. */
  383.             __glutPostRedisplay(window, GLUT_REPAIR_WORK);
  384.           }
  385.         }
  386.         break;
  387.       case Expose:
  388.         /* compress expose events */
  389.         while (XEventsQueued(__glutDisplay, QueuedAfterReading)
  390.           > 0) {
  391.           XPeekEvent(__glutDisplay, &ahead);
  392.           if (ahead.type != Expose ||
  393.             ahead.xexpose.window != event.xexpose.window) {
  394.             break;
  395.           }
  396.           XNextEvent(__glutDisplay, &event);
  397.         }
  398.         if (event.xexpose.count == 0) {
  399.           GLUTmenu *menu;
  401.           if (__glutMappedMenu &&
  402.             (menu = __glutGetMenu(event.xexpose.window))) {
  403.             __glutPaintMenu(menu);
  404.           } else {
  405.             window = __glutGetWindow(event.xexpose.window);
  406.             if (window) {
  407.               if (window->win == event.xexpose.window) {
  408.                 __glutPostRedisplay(window, GLUT_REPAIR_WORK);
  409.               } else if (window->overlay && window->overlay->win == event.xexpose.window) {
  410.                 __glutPostRedisplay(window, GLUT_OVERLAY_REPAIR_WORK);
  411.               }
  412.             }
  413.           }
  414.         } else {
  415.           /* there are more exposes to read; wait to redisplay */
  416.         }
  417.         break;
  418.       case ButtonPress:
  419.       case ButtonRelease:
  420.         if (__glutMappedMenu && event.type == ButtonRelease
  421.           && mappedMenuButton == event.xbutton.button) {
  422.           /* Menu is currently popped up and its button is
  423.              released. */
  424.           __glutFinishMenu(event.xbutton.window, event.xbutton.x, event.xbutton.y);
  425.         } else {
  426.           window = __glutGetWindow(event.xbutton.window);
  427.           if (window) {
  428.             GLUTmenu *menu;
  429.     int menuNum;
  431.             menuNum = window->menu[event.xbutton.button - 1];
  432.             /* Make sure that __glutGetMenuByNum is only called if there
  433.        really is a menu present. */
  434.             if ((menuNum > 0) && (menu = __glutGetMenuByNum(menuNum))) {
  435.               if (event.type == ButtonPress && !__glutMappedMenu) {
  436.                 __glutStartMenu(menu, window,
  437.                   event.xbutton.x_root, event.xbutton.y_root,
  438.                   event.xbutton.x, event.xbutton.y);
  439.                 mappedMenuButton = event.xbutton.button;
  440.               } else {
  441.                 /* Ignore a release of a button with a menu
  442.                    attatched to it when no menu is popped up,
  443.                    or ignore a press when another menu is
  444.                    already popped up. */
  445.               }
  446.             } else if (window->mouse) {
  447.               __glutSetWindow(window);
  448.               __glutModifierMask = event.xbutton.state;
  449.               window->mouse(event.xbutton.button - 1,
  450.                 event.type == ButtonRelease ?
  451.                 GLUT_UP : GLUT_DOWN,
  452.                 event.xbutton.x, event.xbutton.y);
  453.               __glutModifierMask = ~0;
  454.             } else {
  455.               /* Stray mouse events.  Ignore. */
  456.             }
  457.           } else {
  458.             /* Window might have been destroyed and all the 
  459.                events for the window may not yet be received. */
  460.           }
  461.         }
  462.         break;
  463.       case MotionNotify:
  464.         if (!__glutMappedMenu) {
  465.           window = __glutGetWindow(event.xmotion.window);
  466.           if (window) {
  467.             /* If motion function registered _and_ buttons held 
  468.                * down, call motion function...  */
  469.             if (window->motion && event.xmotion.state &
  470.               (Button1Mask | Button2Mask | Button3Mask)) {
  471.               __glutSetWindow(window);
  472.               window->motion(event.xmotion.x, event.xmotion.y);
  473.             }
  474.             /* If passive motion function registered _and_
  475.                buttons not held down, call passive motion
  476.                function...  */
  477.             else if (window->passive &&
  478.                 ((event.xmotion.state &
  479.                     (Button1Mask | Button2Mask | Button3Mask)) ==
  480.                 0)) {
  481.               __glutSetWindow(window);
  482.               window->passive(event.xmotion.x,
  483.                 event.xmotion.y);
  484.             }
  485.           }
  486.         } else {
  487.           /* Motion events are thrown away when a pop up menu
  488.              is active. */
  489.         }
  490.         break;
  491.       case KeyPress:
  492.       case KeyRelease:
  493.         window = __glutGetWindow(event.xkey.window);
  494.         if (!window) {
  495.           break;
  496.         }
  497. if (event.type == KeyPress) {
  498.   keyboard = window->keyboard;
  499. } else {
  501.   /* If we are ignoring auto repeated keys for this window,
  502.      check if the next event in the X event queue is a KeyPress
  503.      for the exact same key (and at the exact same time) as the
  504.      key being released.  The X11 protocol will send auto
  505.      repeated keys as such KeyRelease/KeyPress pairs. */
  507.   if (window->ignoreKeyRepeat) {
  508.     if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {
  509.       XPeekEvent(__glutDisplay, &ahead);
  510.       if (ahead.type == KeyPress
  511.         && ahead.xkey.window == event.xkey.window
  512.         && ahead.xkey.keycode == event.xkey.keycode
  513.         && ahead.xkey.time == event.xkey.time) {
  514. /* Pop off the repeated KeyPress and ignore
  515.    the auto repeated KeyRelease/KeyPress pair. */
  516.         XNextEvent(__glutDisplay, &event);
  517.         break;
  518.       }
  519.     }
  520.   }
  521.   keyboard = window->keyboardUp;
  522. }
  523.         if (keyboard) {
  524.           char tmp[1];
  525.           int rc;
  527.           rc = XLookupString(&event.xkey, tmp, sizeof(tmp),
  528.             NULL, NULL);
  529.           if (rc) {
  530.             __glutSetWindow(window);
  531.             __glutModifierMask = event.xkey.state;
  532.             keyboard(tmp[0],
  533.               event.xkey.x, event.xkey.y);
  534.             __glutModifierMask = ~0;
  535.             break;
  536.           }
  537.         }
  538. if (event.type == KeyPress) {
  539.   special = window->special;
  540.         } else {
  541.   special = window->specialUp;
  542. }
  543.         if (special) {
  544.           KeySym ks;
  545.           int key;
  547. /* Introduced in X11R6:  (Partial list of) Keypad Functions.  Define
  548.    in place in case compiling against an older pre-X11R6
  549.    X11/keysymdef.h file. */
  550. #ifndef XK_KP_Home
  551. #define XK_KP_Home              0xFF95
  552. #endif
  553. #ifndef XK_KP_Left
  554. #define XK_KP_Left              0xFF96
  555. #endif
  556. #ifndef XK_KP_Up
  557. #define XK_KP_Up                0xFF97
  558. #endif
  559. #ifndef XK_KP_Right
  560. #define XK_KP_Right             0xFF98
  561. #endif
  562. #ifndef XK_KP_Down
  563. #define XK_KP_Down              0xFF99
  564. #endif
  565. #ifndef XK_KP_Prior
  566. #define XK_KP_Prior             0xFF9A
  567. #endif
  568. #ifndef XK_KP_Next
  569. #define XK_KP_Next              0xFF9B
  570. #endif
  571. #ifndef XK_KP_End
  572. #define XK_KP_End               0xFF9C
  573. #endif
  574. #ifndef XK_KP_Insert
  575. #define XK_KP_Insert            0xFF9E
  576. #endif
  577. #ifndef XK_KP_Delete
  578. #define XK_KP_Delete            0xFF9F
  579. #endif
  581.           ks = XLookupKeysym((XKeyEvent *) & event, 0);
  582.           /* XXX Verbose, but makes no assumptions about keysym
  583.              layout. */
  584.           switch (ks) {
  585. /* *INDENT-OFF* */
  586.           /* function keys */
  587.           case XK_F1:    key = GLUT_KEY_F1; break;
  588.           case XK_F2:    key = GLUT_KEY_F2; break;
  589.           case XK_F3:    key = GLUT_KEY_F3; break;
  590.           case XK_F4:    key = GLUT_KEY_F4; break;
  591.           case XK_F5:    key = GLUT_KEY_F5; break;
  592.           case XK_F6:    key = GLUT_KEY_F6; break;
  593.           case XK_F7:    key = GLUT_KEY_F7; break;
  594.           case XK_F8:    key = GLUT_KEY_F8; break;
  595.           case XK_F9:    key = GLUT_KEY_F9; break;
  596.           case XK_F10:   key = GLUT_KEY_F10; break;
  597.           case XK_F11:   key = GLUT_KEY_F11; break;
  598.           case XK_F12:   key = GLUT_KEY_F12; break;
  599.           /* directional keys */
  600.   case XK_KP_Left:
  601.           case XK_Left:  key = GLUT_KEY_LEFT; break;
  602.   case XK_KP_Up: /* Introduced in X11R6. */
  603.           case XK_Up:    key = GLUT_KEY_UP; break;
  604.   case XK_KP_Right: /* Introduced in X11R6. */
  605.           case XK_Right: key = GLUT_KEY_RIGHT; break;
  606.   case XK_KP_Down: /* Introduced in X11R6. */
  607.           case XK_Down:  key = GLUT_KEY_DOWN; break;
  608. /* *INDENT-ON* */
  610.   case XK_KP_Prior: /* Introduced in X11R6. */
  611.           case XK_Prior:
  612.             /* XK_Prior same as X11R6's XK_Page_Up */
  613.             key = GLUT_KEY_PAGE_UP;
  614.             break;
  615.   case XK_KP_Next: /* Introduced in X11R6. */
  616.           case XK_Next:
  617.             /* XK_Next same as X11R6's XK_Page_Down */
  618.             key = GLUT_KEY_PAGE_DOWN;
  619.             break;
  620.   case XK_KP_Home: /* Introduced in X11R6. */
  621.           case XK_Home:
  622.             key = GLUT_KEY_HOME;
  623.             break;
  624. #ifdef __hpux
  625.           case XK_Select:
  626. #endif
  627.   case XK_KP_End: /* Introduced in X11R6. */
  628.           case XK_End:
  629.             key = GLUT_KEY_END;
  630.             break;
  631. #ifdef __hpux
  632.           case XK_InsertChar:
  633. #endif
  634.   case XK_KP_Insert: /* Introduced in X11R6. */
  635.           case XK_Insert:
  636.             key = GLUT_KEY_INSERT;
  637.             break;
  638. #ifdef __hpux
  639.           case XK_DeleteChar:
  640. #endif
  641.   case XK_KP_Delete: /* Introduced in X11R6. */
  642.             /* The Delete character is really an ASCII key. */
  643.             __glutSetWindow(window);
  644.             keyboard(127,  /* ASCII Delete character. */
  645.               event.xkey.x, event.xkey.y);
  646.             goto skip;
  647.           default:
  648.             goto skip;
  649.           }
  650.           __glutSetWindow(window);
  651.           __glutModifierMask = event.xkey.state;
  652.           special(key, event.xkey.x, event.xkey.y);
  653.           __glutModifierMask = ~0;
  654.         skip:;
  655.         }
  656.         break;
  657.       case EnterNotify:
  658.       case LeaveNotify:
  659.         if (event.xcrossing.mode != NotifyNormal ||
  660.           event.xcrossing.detail == NotifyNonlinearVirtual ||
  661.           event.xcrossing.detail == NotifyVirtual) {
  663.           /* Careful to ignore Enter/LeaveNotify events that
  664.              come from the pop-up menu pointer grab and ungrab. 
  665.              Also, ignore "virtual" Enter/LeaveNotify events
  666.              since they represent the pointer passing through
  667.              the window hierarchy without actually entering or
  668.              leaving the actual real estate of a window.  */
  670.           break;
  671.         }
  672.         if (__glutMappedMenu) {
  673.           GLUTmenuItem *item;
  674.           int num;
  676.           item = __glutGetMenuItem(__glutMappedMenu,
  677.             event.xcrossing.window, &num);
  678.           if (item) {
  679.             __glutMenuItemEnterOrLeave(item, num, event.type);
  680.             break;
  681.           }
  682.         }
  683.         window = __glutGetWindow(event.xcrossing.window);
  684.         if (window) {
  685.           if (window->entry) {
  686.             if (event.type == EnterNotify) {
  688.               /* With overlays established, X can report two
  689.                  enter events for both the overlay and normal
  690.                  plane window. Do not generate a second enter
  691.                  callback if we reported one without an
  692.                  intervening leave. */
  694.               if (window->entryState != EnterNotify) {
  695.                 int num = window->num;
  696.                 Window xid = window->win;
  698.                 window->entryState = EnterNotify;
  699.                 __glutSetWindow(window);
  700.                 window->entry(GLUT_ENTERED);
  702.                 if (__glutMappedMenu) {
  704.                   /* Do not generate any passive motion events
  705.                      when menus are in use. */
  707.                 } else {
  709.                   /* An EnterNotify event can result in a
  710.                      "compound" callback if a passive motion
  711.                      callback is also registered. In this case,
  712.                      be a little paranoid about the possibility
  713.                      the window could have been destroyed in the
  714.                      entry callback. */
  716.                   window = __glutWindowList[num];
  717.                   if (window && window->passive && window->win == xid) {
  718.                     __glutSetWindow(window);
  719.                     window->passive(event.xcrossing.x, event.xcrossing.y);
  720.                   }
  721.                 }
  722.               }
  723.             } else {
  724.               if (window->entryState != LeaveNotify) {
  726.                 /* When an overlay is established for a window
  727.                    already mapped and with the pointer in it,
  728.                    the X server will generate a leave/enter
  729.                    event pair as the pointer leaves (without
  730.                    moving) from the normal plane X window to
  731.                    the newly mapped overlay  X window (or vice
  732.                    versa). This enter/leave pair should not be
  733.                    reported to the GLUT program since the pair
  734.                    is a consequence of creating (or destroying) 
  735.                    the overlay, not an actual leave from the
  736.                    GLUT window. */
  738.                 if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {
  739.                   XPeekEvent(__glutDisplay, &ahead);
  740.                   if (ahead.type == EnterNotify &&
  741.                     __glutGetWindow(ahead.xcrossing.window) == window) {
  742.                     XNextEvent(__glutDisplay, &event);
  743.                     break;
  744.                   }
  745.                 }
  746.                 window->entryState = LeaveNotify;
  747.                 __glutSetWindow(window);
  748.                 window->entry(GLUT_LEFT);
  749.               }
  750.             }
  751.           } else if (window->passive) {
  752.             __glutSetWindow(window);
  753.             window->passive(event.xcrossing.x, event.xcrossing.y);
  754.           }
  755.         }
  756.         break;
  757.       case UnmapNotify:
  758.         /* MapNotify events are not needed to maintain
  759.            visibility state since VisibilityNotify events will
  760.            be delivered when a window becomes visible from
  761.            mapping.  However, VisibilityNotify events are not
  762.            delivered when a window is unmapped (for the window
  763.            or its children). */
  764.         window = __glutGetWindow(event.xunmap.window);
  765.         if (window) {
  766.           if (window->win != event.xconfigure.window) {
  767.             /* Ignore UnmapNotify sent to the overlay planes.
  768.                GLUT could get here because overlays select for
  769.                StructureNotify events to receive DestroyNotify. 
  770.              */
  771.             break;
  772.           }
  773.           markWindowHidden(window);
  774.         }
  775.         break;
  776.       case VisibilityNotify:
  777.         window = __glutGetWindow(event.xvisibility.window);
  778.         if (window) {
  779.           /* VisibilityUnobscured+1 = GLUT_FULLY_RETAINED,
  780.              VisibilityPartiallyObscured+1 =
  781.              GLUT_PARTIALLY_RETAINED, VisibilityFullyObscured+1 
  782.              =  GLUT_FULLY_COVERED. */
  783.           int visState = event.xvisibility.state + 1;
  785.           if (visState != window->visState) {
  786.             if (window->windowStatus) {
  787.               window->visState = visState;
  788.               __glutSetWindow(window);
  789.               window->windowStatus(visState);
  790.             }
  791.           }
  792.         }
  793.         break;
  794.       case ClientMessage:
  795.         if (event.xclient.data.l[0] == __glutWMDeleteWindow)
  796.           exit(0);
  797.         break;
  798.       case DestroyNotify:
  799.         purgeStaleWindow(event.xdestroywindow.window);
  800.         break;
  801.       case CirculateNotify:
  802.       case CreateNotify:
  803.       case GravityNotify:
  804.       case ReparentNotify:
  805.         /* Uninteresting to GLUT (but possible for GLUT to
  806.            receive). */
  807.         break;
  808.       default:
  809.         /* Pass events not directly handled by the GLUT main
  810.            event loop to any event parsers that have been
  811.            registered.  In this way, X Input extension events
  812.            are passed to the correct handler without forcing
  813.            all GLUT programs to support X Input event handling. 
  814.          */
  815.         parser = eventParserList;
  816.         while (parser) {
  817.           if (parser->func(&event))
  818.             break;
  819.           parser = parser->next;
  820.         }
  821.         break;
  822.       }
  823.     }
  824.     if (__glutTimerList) {
  825.       handleTimeouts();
  826.     }
  827.   }
  828.   while (XPending(__glutDisplay));
  829. #endif /* _WIN32 */
  830. }
  832. static void
  833. waitForSomething(void)
  834. {
  835. #if defined(__vms) && ( __VMS_VER < 70000000 )
  836.   static struct timeval zerotime =
  837.   {0};
  838.   unsigned int timer_efn;
  839. #define timer_id 'glut' /* random :-) number */
  840.   unsigned int wait_mask;
  841. #else
  842.   static struct timeval zerotime =
  843.   {0, 0};
  844. #if !defined(_WIN32)
  845.   fd_set fds;
  846. #endif
  847. #endif
  848.   struct timeval now, timeout, waittime;
  849. #if !defined(_WIN32)
  850.   int rc;
  851. #endif
  853.   /* Flush X protocol since XPending does not do this
  854.      implicitly. */
  855.   XFlush(__glutDisplay);
  856.   if (XPending(__glutDisplay)) {
  857.     /* It is possible (but quite rare) that XFlush may have
  858.        needed to wait for a writable X connection file
  859.        descriptor, and in the process, may have had to read off
  860.        X protocol from the file descriptor. If XPending is true,
  861.        this case occured and we should avoid waiting in select
  862.        since X protocol buffered within Xlib is due to be
  863.        processed and potentially no more X protocol is on the
  864.        file descriptor, so we would risk waiting improperly in
  865.        select. */
  866.     goto immediatelyHandleXinput;
  867.   }
  868. #if defined(__vms) && ( __VMS_VER < 70000000 )
  869.   timeout = __glutTimerList->timeout;
  870.   GETTIMEOFDAY(&now);
  871.   wait_mask = 1 << (__glutConnectionFD & 31);
  872.   if (IS_AFTER(now, timeout)) {
  873.     /* We need an event flag for the timer. */
  874.     /* XXX The `right' way to do this is to use LIB$GET_EF, but
  875.        since it needs to be in the same cluster as the EFN for
  876.        the display, we will have hack it. */
  877.     timer_efn = __glutConnectionFD - 1;
  878.     if ((timer_efn / 32) != (__glutConnectionFD / 32)) {
  879.       timer_efn = __glutConnectionFD + 1;
  880.     }
  881.     rc = SYS$CLREF(timer_efn);
  882.     rc = SYS$SETIMR(timer_efn, &timeout, NULL, timer_id, 0);
  883.     wait_mask |= 1 << (timer_efn & 31);
  884.   } else {
  885.     timer_efn = 0;
  886.   }
  887.   rc = SYS$WFLOR(__glutConnectionFD, wait_mask);
  888.   if (timer_efn != 0 && SYS$CLREF(timer_efn) == SS$_WASCLR) {
  889.     rc = SYS$CANTIM(timer_id, PSL$C_USER);
  890.   }
  891.   /* XXX There does not seem to be checking of "rc" in the code
  892.      above.  Can any of the SYS$ routines above fail? */
  893. #else /* not vms6.2 or lower */
  894. #if !defined(_WIN32)
  895.   FD_ZERO(&fds);
  896.   FD_SET(__glutConnectionFD, &fds);
  897. #endif
  898.   timeout = __glutTimerList->timeout;
  899.   GETTIMEOFDAY(&now);
  900.   if (IS_AFTER(now, timeout)) {
  901.     TIMEDELTA(waittime, timeout, now);
  902.   } else {
  903.     waittime = zerotime;
  904.   }
  905. #if !defined(_WIN32)
  906.   rc = select(__glutConnectionFD + 1, &fds,
  907.     NULL, NULL, &waittime);
  908.   if (rc < 0 && errno != EINTR)
  909.     __glutFatalError("select error.");
  910. #else
  911.   MsgWaitForMultipleObjects(0, NULL, FALSE, waittime.tv_sec*1000 + waittime.tv_usec/1000, QS_ALLEVENTS);
  912. #endif
  913. #endif /* not vms6.2 or lower */
  914.   /* Without considering the cause of select unblocking, check
  915.      for pending X events and handle any timeouts (by calling
  916.      processEventsAndTimeouts).  We always look for X events
  917.      even if select returned with 0 (indicating a timeout);
  918.      otherwise we risk starving X event processing by continous
  919.      timeouts. */
  920.   if (XPending(__glutDisplay)) {
  921.   immediatelyHandleXinput:
  922.     processEventsAndTimeouts();
  923.   } else {
  924.     if (__glutTimerList)
  925.       handleTimeouts();
  926.   }
  927. }
  929. static void
  930. idleWait(void)
  931. {
  932.   if (XPending(__glutDisplay)) {
  933.     processEventsAndTimeouts();
  934.   } else {
  935.     if (__glutTimerList) {
  936.       handleTimeouts();
  937.     }
  938.   }
  939.   /* Make sure idle func still exists! */
  940.   if (__glutIdleFunc) {
  941.     __glutIdleFunc();
  942.   }
  943. }
  945. static GLUTwindow **beforeEnd;
  947. static GLUTwindow *
  948. processWindowWorkList(GLUTwindow * window)
  949. {
  950.   int workMask;
  952.   if (window->prevWorkWin) {
  953.     window->prevWorkWin = processWindowWorkList(window->prevWorkWin);
  954. if (beforeEnd == 0)
  955.       beforeEnd = &window->prevWorkWin;
  956.   } else {
  957.     beforeEnd = &window->prevWorkWin;
  958.   }
  960.   /* Capture work mask for work that needs to be done to this
  961.      window, then clear the window's work mask (excepting the
  962.      dummy work bit, see below).  Then, process the captured
  963.      work mask.  This allows callbacks in the processing the
  964.      captured work mask to set the window's work mask for
  965.      subsequent processing. */
  967.   workMask = window->workMask;
  968.   assert((workMask & GLUT_DUMMY_WORK) == 0);
  970.   /* Set the dummy work bit, clearing all other bits, to
  971.      indicate that the window is currently on the window work
  972.      list _and_ that the window's work mask is currently being
  973.      processed.  This convinces __glutPutOnWorkList that this
  974.      window is on the work list still. */
  975.   window->workMask = GLUT_DUMMY_WORK;
  977.   /* Optimization: most of the time, the work to do is a
  978.      redisplay and not these other types of work.  Check for
  979.      the following cases as a group to before checking each one
  980.      individually one by one. This saves about 25 MIPS
  981.      instructions in the common redisplay only case. */
  982.   if (workMask & (GLUT_EVENT_MASK_WORK | GLUT_DEVICE_MASK_WORK |
  983.       GLUT_CONFIGURE_WORK | GLUT_COLORMAP_WORK | GLUT_MAP_WORK)) {
  984. #if !defined(_WIN32)
  985.     /* Be sure to set event mask BEFORE map window is done. */
  986.     if (workMask & GLUT_EVENT_MASK_WORK) {
  987.       long eventMask;
  989.       /* Make sure children are not propogating events this
  990.          window is selecting for.  Be sure to do this before
  991.          enabling events on the children's parent. */
  992.       if (window->children) {
  993.         GLUTwindow *child = window->children;
  994.         unsigned long attribMask = CWDontPropagate;
  995.         XSetWindowAttributes wa;
  997.         wa.do_not_propagate_mask = window->eventMask & GLUT_DONT_PROPAGATE_FILTER_MASK;
  998.         if (window->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK) {
  999.           wa.event_mask = child->eventMask | (window->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK);
  1000.           attribMask |= CWEventMask;
  1001.         }
  1002.         do {
  1003.           XChangeWindowAttributes(__glutDisplay, child->win,
  1004.             attribMask, &wa);
  1005.           child = child->siblings;
  1006.         } while (child);
  1007.       }
  1008.       eventMask = window->eventMask;
  1009.       if (window->parent && window->parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK)
  1010.         eventMask |= (window->parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK);
  1011.       XSelectInput(__glutDisplay, window->win, eventMask);
  1012.       if (window->overlay)
  1013.         XSelectInput(__glutDisplay, window->overlay->win,
  1014.           window->eventMask & GLUT_OVERLAY_EVENT_FILTER_MASK);
  1015.     }
  1016. #endif /* !_WIN32 */
  1017.     /* Be sure to set device mask BEFORE map window is done. */
  1018.     if (workMask & GLUT_DEVICE_MASK_WORK) {
  1019.       __glutUpdateInputDeviceMaskFunc(window);
  1020.     }
  1021.     /* Be sure to configure window BEFORE map window is done. */
  1022.     if (workMask & GLUT_CONFIGURE_WORK) {
  1023. #if defined(_WIN32)
  1024.         if ( workMask & GLUT_FULL_SCREEN_WORK ) {
  1025.             DWORD s;
  1026.             RECT r;
  1028.             GetWindowRect(GetDesktopWindow(), &r);
  1029.             s = GetWindowLong(window->win, GWL_STYLE);
  1030.             s &= ~WS_OVERLAPPEDWINDOW;
  1031.             s |= WS_POPUP;
  1032.             SetWindowLong(window->win, GWL_STYLE, s);
  1033.             SetWindowPos(window->win, 
  1034.                 HWND_TOP, /* safer - a lot of people use windows atop a fullscreen GLUT window. */
  1035. //HWND_TOPMOST, /* is better, but no windows atop it */
  1036.                 r.left, r.top, 
  1037.                 r.right-r.left, r.bottom-r.top, 
  1038.                 SWP_FRAMECHANGED);
  1039.             
  1040.             /* This hack causes the window to go back to the right position
  1041.             when it is taken out of fullscreen mode. */
  1042.             {
  1043.                 POINT p;
  1045.                 p.x = 0;
  1046.                 p.y = 0;
  1047.                 ClientToScreen(window->win, &p);
  1048.                 window->desiredConfMask |= CWX | CWY;
  1049.                 window->desiredX = p.x;
  1050.                 window->desiredY = p.y;
  1051.             }
  1052.         } else {
  1053.             RECT changes;
  1054.             POINT point;
  1055.             UINT flags = SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOZORDER;
  1056.             DWORD style;
  1058.             GetClientRect(window->win, &changes);
  1059.             style = GetWindowLong(window->win, GWL_STYLE);
  1060.             
  1061.             /* Get rid of fullscreen mode, if it exists */
  1062.             if ( style & WS_POPUP ) {
  1063.                 style &= ~WS_POPUP;
  1064.                 style |= WS_OVERLAPPEDWINDOW;
  1065.                 SetWindowLong(window->win, GWL_STYLE, style);
  1066.                 flags |= SWP_FRAMECHANGED;
  1067.             }
  1069.             /* If this window is a toplevel window, translate the 0,0 client
  1070.             coordinate into a screen coordinate for proper placement. */
  1071.             if (!window->parent) {
  1072.                 point.x = 0;
  1073.                 point.y = 0;
  1074.                 ClientToScreen(window->win, &point);
  1075.                 changes.left = point.x;
  1076.                 changes.top = point.y;
  1077.             }
  1078.             if (window->desiredConfMask & (CWX | CWY)) {
  1079.                 changes.left = window->desiredX;
  1080.                 changes.top = window->desiredY;
  1081.                 flags &= ~SWP_NOMOVE;
  1082.             }
  1083.             if (window->desiredConfMask & (CWWidth | CWHeight)) {
  1084.                 changes.right = changes.left + window->desiredWidth;
  1085.                 changes.bottom = changes.top + window->desiredHeight;
  1086.                 flags &= ~SWP_NOSIZE;
  1087.                 /* XXX If overlay exists, resize the overlay here, ie.
  1088.                 if (window->overlay) ... */
  1089.             }
  1090.             if (window->desiredConfMask & CWStackMode) {
  1091.                 flags &= ~SWP_NOZORDER;
  1092.                 /* XXX Overlay support might require something special here. */
  1093.             }
  1094.             
  1095.             /* Adjust the window rectangle because Win32 thinks that the x, y,
  1096.             width & height are the WHOLE window (including decorations),
  1097.             whereas GLUT treats the x, y, width & height as only the CLIENT
  1098.             area of the window.  Only do this to top level windows
  1099.             that are not in game mode (since game mode windows do
  1100.             not have any decorations). */
  1101.             if (!window->parent && window != __glutGameModeWindow) {
  1102.                 AdjustWindowRect(&changes, style, FALSE);
  1103.             }
  1104.             
  1105.             /* Do the repositioning, moving, and push/pop. */
  1106.             SetWindowPos(window->win,
  1107.                 window->desiredStack == Above ? HWND_TOP : HWND_BOTTOM,
  1108.                 changes.left, changes.top,
  1109.                 changes.right - changes.left, changes.bottom - changes.top,
  1110.                 flags);
  1111.             
  1112.             /* Zero out the mask. */
  1113.             window->desiredConfMask = 0;
  1114.         }
  1115. #else /* !_WIN32 */
  1116.       XWindowChanges changes;
  1118.       changes.x = window->desiredX;
  1119.       changes.y = window->desiredY;
  1120.       if (window->desiredConfMask & (CWWidth | CWHeight)) {
  1121.         changes.width = window->desiredWidth;
  1122.         changes.height = window->desiredHeight;
  1123.         if (window->overlay)
  1124.           XResizeWindow(__glutDisplay, window->overlay->win,
  1125.             window->desiredWidth, window->desiredHeight);
  1126.         if (__glutMotifHints != None) {
  1127.           if (workMask & GLUT_FULL_SCREEN_WORK) {
  1128.             MotifWmHints hints;
  1130.             hints.flags = MWM_HINTS_DECORATIONS;
  1131.             hints.decorations = 0;  /* Absolutely no
  1132.                                        decorations. */
  1133.             XChangeProperty(__glutDisplay, window->win,
  1134.               __glutMotifHints, __glutMotifHints, 32,
  1135.               PropModeReplace, (unsigned char *) &hints, 4);
  1136.             if (workMask & GLUT_MAP_WORK) {
  1137.               /* Handle case where glutFullScreen is called
  1138.                  before the first time that the window is
  1139.                  mapped. Some window managers will randomly or
  1140.                  interactively position the window the first
  1141.                  time it is mapped if the window's
  1142.                  WM_NORMAL_HINTS property does not request an
  1143.                  explicit position. We don't want any such
  1144.                  window manager interaction when going
  1145.                  fullscreen.  Overwrite the WM_NORMAL_HINTS
  1146.                  property installed by glutCreateWindow's
  1147.                  XSetWMProperties property with one explicitly
  1148.                  requesting a fullscreen window. */
  1149.               XSizeHints hints;
  1151.               hints.flags = USPosition | USSize;
  1152.               hints.x = 0;
  1153.               hints.y = 0;
  1154.               hints.width = window->desiredWidth;
  1155.               hints.height = window->desiredHeight;
  1156.               XSetWMNormalHints(__glutDisplay, window->win, &hints);
  1157.             }
  1158.           } else {
  1159.             XDeleteProperty(__glutDisplay, window->win, __glutMotifHints);
  1160.           }
  1161.         }
  1162.       }
  1163.       if (window->desiredConfMask & CWStackMode) {
  1164.         changes.stack_mode = window->desiredStack;
  1165.         /* Do not let glutPushWindow push window beneath the
  1166.            underlay. */
  1167.         if (window->parent && window->parent->overlay
  1168.           && window->desiredStack == Below) {
  1169.           changes.stack_mode = Above;
  1170.           changes.sibling = window->parent->overlay->win;
  1171.           window->desiredConfMask |= CWSibling;
  1172.         }
  1173.       }
  1174.       XConfigureWindow(__glutDisplay, window->win,
  1175.         window->desiredConfMask, &changes);
  1176.       window->desiredConfMask = 0;
  1177. #endif
  1178.     }
  1179. #if !defined(_WIN32)
  1180.     /* Be sure to establish the colormaps BEFORE map window is
  1181.        done. */
  1182.     if (workMask & GLUT_COLORMAP_WORK) {
  1183.       __glutEstablishColormapsProperty(window);
  1184.     }
  1185. #endif
  1186.     if (workMask & GLUT_MAP_WORK) {
  1187.       switch (window->desiredMapState) {
  1188.       case WithdrawnState:
  1189.         if (window->parent) {
  1190.           XUnmapWindow(__glutDisplay, window->win);
  1191.         } else {
  1192.           XWithdrawWindow(__glutDisplay, window->win,
  1193.             __glutScreen);
  1194.         }
  1195.         window->shownState = 0;
  1196.         break;
  1197.       case NormalState:
  1198.         XMapWindow(__glutDisplay, window->win);
  1199.         window->shownState = 1;
  1200.         break;
  1201. #ifdef _WIN32
  1202.       case GameModeState:  /* Not an Xlib value. */
  1203.         ShowWindow(window->win, SW_SHOW);
  1204.         window->shownState = 1;
  1205.         break;
  1206. #endif
  1207.       case IconicState:
  1208.         XIconifyWindow(__glutDisplay, window->win, __glutScreen);
  1209.         window->shownState = 0;
  1210.         break;
  1211.       }
  1212.     }
  1213.   }
  1214.   if (workMask & (GLUT_REDISPLAY_WORK | GLUT_OVERLAY_REDISPLAY_WORK | GLUT_REPAIR_WORK | GLUT_OVERLAY_REPAIR_WORK)) {
  1215.     if (window->forceReshape) {
  1216.       /* Guarantee that before a display callback is generated
  1217.          for a window, a reshape callback must be generated. */
  1218.       __glutSetWindow(window);
  1219.       window->reshape(window->width, window->height);
  1220.       window->forceReshape = False;
  1222.       /* Setting the redisplay bit on the first reshape is
  1223.          necessary to make the "Mesa glXSwapBuffers to repair
  1224.          damage" hack operate correctly.  Without indicating a
  1225.          redisplay is necessary, there's not an initial back
  1226.          buffer render from which to blit from when damage
  1227.          happens to the window. */
  1228.       workMask |= GLUT_REDISPLAY_WORK;
  1229.     }
  1230.     /* The code below is more involved than otherwise necessary
  1231.        because it is paranoid about the overlay or entire window
  1232.        being removed or destroyed in the course of the callbacks.
  1233.        Notice how the global __glutWindowDamaged is used to record
  1234.        the layers' damage status.  See the code in glutLayerGet for
  1235.        how __glutWindowDamaged is used. The  point is to not have to
  1236.        update the "damaged" field after  the callback since the
  1237.        window (or overlay) may be destroyed (or removed) when the
  1238.        callback returns. */
  1240.     if (window->overlay && window->overlay->display) {
  1241.       int num = window->num;
  1242.       Window xid = window->overlay ? window->overlay->win : None;
  1244.       /* If an overlay display callback is registered, we
  1245.          differentiate between a redisplay needed for the
  1246.          overlay and/or normal plane.  If there is no overlay
  1247.          display callback registered, we simply use the
  1248.          standard display callback. */
  1250.       if (workMask & (GLUT_REDISPLAY_WORK | GLUT_REPAIR_WORK)) {
  1251.         if (__glutMesaSwapHackSupport) {
  1252.           if (window->usedSwapBuffers) {
  1253.             if ((workMask & (GLUT_REPAIR_WORK | GLUT_REDISPLAY_WORK)) == GLUT_REPAIR_WORK) {
  1254.       SWAP_BUFFERS_WINDOW(window);
  1255.               goto skippedDisplayCallback1;
  1256.             }
  1257.           }
  1258.         }
  1259.         /* Render to normal plane. */
  1260. #ifdef _WIN32
  1261.         window->renderDc = window->hdc;
  1262. #endif
  1263.         window->renderWin = window->win;
  1264.         window->renderCtx = window->ctx;
  1265.         __glutWindowDamaged = (workMask & GLUT_REPAIR_WORK);
  1266.         __glutSetWindow(window);
  1267.         window->usedSwapBuffers = 0;
  1268.         window->display();
  1269.         __glutWindowDamaged = 0;
  1271.       skippedDisplayCallback1:;
  1272.       }
  1273.       if (workMask & (GLUT_OVERLAY_REDISPLAY_WORK | GLUT_OVERLAY_REPAIR_WORK)) {
  1274.         window = __glutWindowList[num];
  1275.         if (window && window->overlay &&
  1276.           window->overlay->win == xid && window->overlay->display) {
  1278.           /* Render to overlay. */
  1279. #ifdef _WIN32
  1280.           window->renderDc = window->overlay->hdc;
  1281. #endif
  1282.           window->renderWin = window->overlay->win;
  1283.           window->renderCtx = window->overlay->ctx;
  1284.           __glutWindowDamaged = (workMask & GLUT_OVERLAY_REPAIR_WORK);
  1285.           __glutSetWindow(window);
  1286.           window->overlay->display();
  1287.           __glutWindowDamaged = 0;
  1288.         } else {
  1289.           /* Overlay may have since been destroyed or the
  1290.              overlay callback may have been disabled during
  1291.              normal display callback. */
  1292.         }
  1293.       }
  1294.     } else {
  1295.       if (__glutMesaSwapHackSupport) {
  1296.         if (!window->overlay && window->usedSwapBuffers) {
  1297.           if ((workMask & (GLUT_REPAIR_WORK | GLUT_REDISPLAY_WORK)) == GLUT_REPAIR_WORK) {
  1298.     SWAP_BUFFERS_WINDOW(window);
  1299.             goto skippedDisplayCallback2;
  1300.           }
  1301.         }
  1302.       }
  1303.       /* Render to normal plane (and possibly overlay). */
  1304.       __glutWindowDamaged = (workMask & (GLUT_OVERLAY_REPAIR_WORK | GLUT_REPAIR_WORK));
  1305.       __glutSetWindow(window);
  1306.       window->usedSwapBuffers = 0;
  1307.       window->display();
  1308.       __glutWindowDamaged = 0;
  1310.     skippedDisplayCallback2:;
  1311.     }
  1312.   }
  1313.   /* Combine workMask with window->workMask to determine what
  1314.      finish and debug work there is. */
  1315.   workMask |= window->workMask;
  1317.   if (workMask & GLUT_FINISH_WORK) {
  1318.     /* Finish work makes sure a glFinish gets done to indirect
  1319.        rendering contexts.  Indirect contexts tend to have much 
  1320.        longer latency because lots of OpenGL extension requests 
  1321.        can queue up in the X protocol stream. __glutSetWindow
  1322.        is where the finish works gets queued for indirect
  1323.        contexts. */
  1324.     __glutSetWindow(window);
  1325.     glFinish();
  1326.   }
  1327.   if (workMask & GLUT_DEBUG_WORK) {
  1328.     __glutSetWindow(window);
  1329.     glutReportErrors();
  1330.   }
  1331.   /* Strip out dummy, finish, and debug work bits. */
  1332.   window->workMask &= ~(GLUT_DUMMY_WORK | GLUT_FINISH_WORK | GLUT_DEBUG_WORK);
  1333.   if (window->workMask) {
  1334.     /* Leave on work list. */
  1335.     return window;
  1336.   } else {
  1337. if (beforeEnd == &window->prevWorkWin)
  1338.   beforeEnd = 0;
  1339.     /* Remove current window from work list. */
  1340.     return window->prevWorkWin;
  1341.   }
  1342. }
  1344. /* CENTRY */
  1345. void APIENTRY
  1346. glutMainLoop(void)
  1347. {
  1348. #if !defined(_WIN32)
  1349.   if (!__glutDisplay)
  1350.     __glutFatalUsage("main loop entered with out proper initialization.");
  1351. #endif
  1352.   if (!__glutWindowListSize)
  1353.     __glutFatalUsage(
  1354.       "main loop entered with no windows created.");
  1355.   for (;;) {
  1356.     if (__glutWindowWorkList) {
  1357.       GLUTwindow *remainder, *work;
  1359.       work = __glutWindowWorkList;
  1360.       __glutWindowWorkList = NULL;
  1361.       if (work) {
  1362.         remainder = processWindowWorkList(work);
  1363.         if (remainder) {
  1364.           *beforeEnd = __glutWindowWorkList;
  1365.           __glutWindowWorkList = remainder;
  1366.         }
  1367.       }
  1368.     }
  1369.     if (__glutIdleFunc || __glutWindowWorkList) {
  1370.       idleWait();
  1371.     } else {
  1372.       if (__glutTimerList) {
  1373.         waitForSomething();
  1374.       } else {
  1375.         processEventsAndTimeouts();
  1376.       }
  1377. #if defined(_WIN32)
  1378.   // If there is no idle function, go to sleep for a millisecond (we 
  1379.   // still need to possibly service timers) or until there is some 
  1380.   // event in our queue.
  1381.       MsgWaitForMultipleObjects(0, NULL, FALSE, 1, QS_ALLEVENTS);
  1382. #endif
  1383.     }
  1384.  }
  1385. }
  1386. /* ENDCENTRY */