home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 5 / MA_Cover_5.iso / ppc / mesa / src-glut / win32_util.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-31  |  23.5 KB  |  772 lines
  1.  
  2. /* Copyright (c) Nate Robins, 1997. */
  3.  
  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. */
  7.  
  8.  
  9. #include "glutint.h"
  10. #include "glutstroke.h"
  11. #include "glutbitmap.h"
  12.  
  13. #if defined(__CYGWIN32__)
  14. typedef MINMAXINFO* LPMINMAXINFO;
  15. #else
  16. #include <sys/timeb.h>
  17. #endif
  18.  
  19. extern StrokeFontRec glutStrokeRoman, glutStrokeMonoRoman;
  20. extern BitmapFontRec glutBitmap8By13, glutBitmap9By15, glutBitmapTimesRoman10, glutBitmapTimesRoman24, glutBitmapHelvetica10, glutBitmapHelvetica12, glutBitmapHelvetica18;
  21.  
  22. int
  23. gettimeofday(struct timeval* tp, void* tzp)
  24. {
  25. #if defined(__CYGWIN32__)
  26.   /* gettimeofday() is not to be implemented in cygwin.dll beta 18 (cf. _syslist.h) */
  27.   /* we use GetTickCount() = number of milliseconds since windoze was started       */
  28.   /* /Stephane Rehel, Nov.16.1997                                                   */
  29.   long tc= GetTickCount();
  30.   tp->tv_sec= tc / 1000L;
  31.   tp->tv_sec= (tc % 1000L) * 1000L;
  32. #else
  33.   struct timeb tb;
  34.  
  35.   ftime(&tb);
  36.   tp->tv_sec = tb.time;
  37.   tp->tv_usec = tb.millitm * 1000;
  38. #endif
  39.  
  40.   /* 0 indicates that the call succeeded. */
  41.   return 0;
  42. }
  43.  
  44. void*
  45. __glutFont(void *font)
  46. {
  47.   switch((int)font) {
  48.   case (int)GLUT_STROKE_ROMAN:
  49.     return &glutStrokeRoman;
  50.   case (int)GLUT_STROKE_MONO_ROMAN:
  51.     return &glutStrokeMonoRoman;
  52.   case (int)GLUT_BITMAP_9_BY_15:
  53.     return &glutBitmap9By15;
  54.   case (int)GLUT_BITMAP_8_BY_13:
  55.     return &glutBitmap8By13;
  56.   case (int)GLUT_BITMAP_TIMES_ROMAN_10:
  57.     return &glutBitmapTimesRoman10;
  58.   case (int)GLUT_BITMAP_TIMES_ROMAN_24:
  59.     return &glutBitmapTimesRoman24;
  60.   case (int)GLUT_BITMAP_HELVETICA_10:
  61.     return &glutBitmapHelvetica10;
  62.   case (int)GLUT_BITMAP_HELVETICA_12:
  63.     return &glutBitmapHelvetica12;
  64.   case (int)GLUT_BITMAP_HELVETICA_18:
  65.     return &glutBitmapHelvetica18;
  66.   }
  67. }
  68.  
  69. int
  70. __glutGetTransparentPixel(Display * dpy, XVisualInfo * vinfo)
  71. {
  72.   /* the transparent pixel on Win32 is always index number 0.  So if
  73.      we put this routine in this file, we can avoid compiling the
  74.      whole of layerutil.c which is where this routine normally comes
  75.      from. */
  76.   return 0;
  77. }
  78.  
  79. void
  80. __glutAdjustCoords(Window parent, int* x, int* y, int* width, int* height)
  81. {
  82.   RECT rect;
  83.  
  84.   /* adjust the window rectangle because Win32 thinks that the x, y,
  85.      width & height are the WHOLE window (including decorations),
  86.      whereas GLUT treats the x, y, width & height as only the CLIENT
  87.      area of the window. */
  88.   rect.left = *x; rect.top = *y;
  89.   rect.right = *x + *width; rect.bottom = *y + *height;
  90.  
  91.   /* must adjust the coordinates according to the correct style
  92.      because depending on the style, there may or may not be
  93.      borders. */
  94.   AdjustWindowRect(&rect, WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
  95.            (parent ? WS_CHILD : WS_OVERLAPPEDWINDOW),
  96.            FALSE);
  97.   /* FALSE in the third parameter = window has no menu bar */
  98.  
  99.   /* readjust if the x and y are offscreen */
  100.   if(rect.left < 0) 
  101.     *x = 0;
  102.   else
  103.     *x = rect.left;
  104.   
  105.   if(rect.top < 0)  
  106.     *y = 0;
  107.   else
  108.     *y = rect.top;
  109.  
  110.   *width = rect.right - rect.left;    /* adjusted width */
  111.   *height = rect.bottom - rect.top;    /* adjusted height */
  112. }
  113.  
  114. extern unsigned __glutMenuButton;
  115. extern GLUTidleCB __glutIdleFunc;
  116. extern GLUTtimer *__glutTimerList;
  117. extern void handleTimeouts(void);
  118. extern GLUTmenuItem *__glutGetUniqueMenuItem(GLUTmenu * menu, int unique);
  119. static HMENU __glutHMenu;
  120.  
  121. LONG WINAPI __glutWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  122. { 
  123.   POINT         point;            // point structure
  124.   PAINTSTRUCT   ps;            // paint structure
  125.   LPMINMAXINFO  minmax;            // minimum/maximum info structure
  126.   GLUTwindow*   window;            // glut window associated with message
  127.   GLUTmenu*     menu;            // glut menu associated with message
  128.   int x, y, width, height, key;
  129.   int button = -1;
  130.  
  131.   //  printf("__glutWindowProc(0x%x, 0x%x, 0x%x, 0x%x)\n", hwnd, msg, wParam, lParam);
  132.  
  133.   switch(msg) {
  134.   case WM_CREATE:
  135.     return 0;
  136.  
  137.   case WM_CLOSE:
  138.     PostQuitMessage(0);
  139.     return 0;
  140.  
  141.   case WM_DESTROY:
  142.     // TODO: need to add this.
  143.     //    purgeStaleWindow(hwnd);
  144.     return 0;
  145.  
  146.   case WM_PAINT:
  147. //    printf("WM_PAINT\n");
  148.     window = __glutGetWindow(hwnd);
  149.     if (window) {
  150.       BeginPaint(hwnd, &ps);        // must have this for some Win32 reason
  151. #if TAKE_THIS_OUT
  152.       if (window->colormap) {
  153.     SelectPalette(window->hdc, window->colormap->cmap, FORCE_FOREGROUND);
  154.     RealizePalette(window->hdc);           // remap the custom palette
  155.       }
  156. #endif
  157.       EndPaint(hwnd, &ps);
  158.       if (window->win == hwnd) {
  159.     __glutPostRedisplay(window, GLUT_REPAIR_WORK);
  160.       } else if (window->overlay && window->overlay->win == hwnd) {
  161.     __glutPostRedisplay(window, GLUT_OVERLAY_REPAIR_WORK);
  162.       }
  163.     }
  164.     return 0;
  165.  
  166.   case WM_SYSCHAR:
  167.   case WM_CHAR:
  168.     window = __glutGetWindow(hwnd);
  169.     if (!window) {
  170.       break;
  171.     }
  172.     /* Win32 is dumb and sends these messages only to the parent
  173.        window.  Therefore, find out if we're in a child window and
  174.        call the child windows keyboard callback if we are. */
  175.     if (window->parent) {
  176.     GetCursorPos(&point);
  177.     ScreenToClient(hwnd, &point);
  178.     hwnd = ChildWindowFromPoint(hwnd, point);
  179.     window = __glutGetWindow(hwnd);
  180.     }
  181.     if (window->keyboard) {
  182.       GetCursorPos(&point);
  183.       ScreenToClient(window->win, &point);
  184.       __glutSetWindow(window);
  185.       __glutModifierMask = 0;
  186.       if (GetKeyState(VK_SHIFT) < 0)    /* < 0 = high order bit is on */
  187.     __glutModifierMask |= ShiftMask;
  188.       if (GetKeyState(VK_CONTROL) < 0)
  189.     __glutModifierMask |= ControlMask;
  190.       if (GetKeyState(VK_MENU) < 0)
  191.     __glutModifierMask |= Mod1Mask;
  192.       window->keyboard((char)wParam, point.x, point.y);
  193.       __glutModifierMask = (unsigned int) ~0;
  194.     }
  195.     return 0;
  196.  
  197.   case WM_SYSKEYDOWN:
  198.   case WM_KEYDOWN:
  199.     window = __glutGetWindow(hwnd);
  200.     if (!window) {
  201.       break;
  202.     }
  203.     /* Win32 is dumb and sends these messages only to the parent
  204.        window.  Therefore, find out if we're in a child window and
  205.        call the child windows keyboard callback if we are. */
  206.     if (window->parent) {
  207.     GetCursorPos(&point);
  208.     ScreenToClient(hwnd, &point);
  209.     hwnd = ChildWindowFromPoint(hwnd, point);
  210.     window = __glutGetWindow(hwnd);
  211.     }
  212.     if (window->special) {
  213.       switch (wParam) {
  214.     /* *INDENT-OFF* */
  215.     /* function keys */
  216.     case VK_F1:     key = GLUT_KEY_F1; break;
  217.     case VK_F2:     key = GLUT_KEY_F2; break;
  218.     case VK_F3:     key = GLUT_KEY_F3; break;
  219.     case VK_F4:     key = GLUT_KEY_F4; break;
  220.     case VK_F5:     key = GLUT_KEY_F5; break;
  221.     case VK_F6:     key = GLUT_KEY_F6; break;
  222.     case VK_F7:     key = GLUT_KEY_F7; break;
  223.     case VK_F8:     key = GLUT_KEY_F8; break;
  224.     case VK_F9:     key = GLUT_KEY_F9; break;
  225.     case VK_F10:    key = GLUT_KEY_F10; break;
  226.     case VK_F11:    key = GLUT_KEY_F11; break;
  227.     case VK_F12:    key = GLUT_KEY_F12; break;
  228.     /* directional keys */
  229.     case VK_LEFT:   key = GLUT_KEY_LEFT; break;
  230.     case VK_UP:     key = GLUT_KEY_UP; break;
  231.     case VK_RIGHT:  key = GLUT_KEY_RIGHT; break;
  232.     case VK_DOWN:   key = GLUT_KEY_DOWN; break;
  233.     /* *INDENT-ON* */
  234.  
  235.     case VK_PRIOR:
  236.       /* VK_PRIOR is Win32's Page Up */
  237.       key = GLUT_KEY_PAGE_UP;
  238.       break;
  239.     case VK_NEXT:
  240.       /* VK_NEXT is Win32's Page Down */
  241.       key = GLUT_KEY_PAGE_DOWN;
  242.       break;
  243.     case VK_HOME:
  244.       key = GLUT_KEY_HOME;
  245.       break;
  246.     case VK_END:
  247.       key = GLUT_KEY_END;
  248.       break;
  249.     case VK_INSERT:
  250.       key = GLUT_KEY_INSERT;
  251.       break;
  252.     default:
  253.       goto defproc;
  254.       }
  255.       GetCursorPos(&point);
  256.       ScreenToClient(window->win, &point);
  257.       __glutSetWindow(window);
  258.       __glutModifierMask = 0;
  259.       if (GetKeyState(VK_SHIFT) < 0)    // < 0 = high order bit is on
  260.     __glutModifierMask |= ShiftMask;
  261.       if (GetKeyState(VK_CONTROL) < 0)
  262.     __glutModifierMask |= ControlMask;
  263.       if (GetKeyState(VK_MENU) < 0)
  264.     __glutModifierMask |= Mod1Mask;
  265.       window->special(key, point.x, point.y);
  266.       __glutModifierMask = (unsigned int) ~0;
  267.     }
  268.     return 0;
  269.  
  270.   case WM_LBUTTONDOWN:
  271.     button = GLUT_LEFT_BUTTON;
  272.   case WM_MBUTTONDOWN:
  273.     if (button < 0)
  274.       button = GLUT_MIDDLE_BUTTON;
  275.   case WM_RBUTTONDOWN:
  276.     if (button < 0)
  277.       button = GLUT_RIGHT_BUTTON;
  278.     
  279.     /* finish the menu if we get a button down message (user must have
  280.        cancelled the menu). */
  281.     if (__glutMappedMenu) {
  282.       /* TODO: take this out once the menu on middle mouse stuff works
  283.      properly. */
  284.       if (button == GLUT_MIDDLE_BUTTON)
  285.     return 0;
  286.       GetCursorPos(&point);
  287.       ScreenToClient(hwnd, &point);
  288.       __glutItemSelected = NULL;
  289.       __glutFinishMenu(hwnd, point.x, point.y);
  290.       return 0;
  291.     }
  292.  
  293.     /* set the capture so we can get mouse events outside the window */
  294.     SetCapture(hwnd);
  295.  
  296.     /* Win32 doesn't return the same numbers as X does when the mouse
  297.        goes beyond the upper or left side of the window.  roll the
  298.        Win32's 0..2^16 pointer co-ord range to 0 +/- 2^15. */
  299.     x = LOWORD(lParam);
  300.     y = HIWORD(lParam);
  301.     if(x & 1 << 15) x -= (1 << 16);
  302.     if(y & 1 << 15) y -= (1 << 16);
  303.     
  304.     window = __glutGetWindow(hwnd);
  305.     if (window) {
  306.       menu = __glutGetMenuByNum(window->menu[button]);
  307.       if (menu) {
  308.     point.x = LOWORD(lParam); point.y = HIWORD(lParam);
  309.     ClientToScreen(window->win, &point);
  310.     __glutMenuButton = button == GLUT_RIGHT_BUTTON ? TPM_RIGHTBUTTON :
  311.                            button == GLUT_LEFT_BUTTON  ? TPM_LEFTBUTTON :
  312.                            0x0001;
  313.     __glutStartMenu(menu, window, point.x, point.y, x, y);
  314.       } else if (window->mouse) {
  315.     
  316.         __glutSetWindow(window);
  317.     __glutModifierMask = 0;
  318.     if (GetKeyState(VK_SHIFT) < 0)    // < 0 = high order bit is on
  319.       __glutModifierMask |= ShiftMask;
  320.     if (GetKeyState(VK_CONTROL) < 0)
  321.       __glutModifierMask |= ControlMask;
  322.     if (GetKeyState(VK_MENU) < 0)
  323.       __glutModifierMask |= Mod1Mask;
  324.     window->mouse(button, GLUT_DOWN, x, y);
  325.     __glutModifierMask = (unsigned int)~0;
  326.       } else {
  327.     /* Stray mouse events.  Ignore. */
  328.       }
  329.     }
  330.     return 0;
  331.  
  332.   case WM_LBUTTONUP:
  333.     button = GLUT_LEFT_BUTTON;
  334.   case WM_MBUTTONUP:
  335.     if (button < 0)
  336.       button = GLUT_MIDDLE_BUTTON;
  337.   case WM_RBUTTONUP:
  338.     if (button < 0)
  339.       button = GLUT_RIGHT_BUTTON;
  340.  
  341.     /* bail out if we're processing a menu */
  342.     if (__glutMappedMenu) {
  343.       GetCursorPos(&point);
  344.       ScreenToClient(hwnd, &point);
  345.       /* if we're getting the middle button up signal, then something
  346.      on the menu was selected. */
  347.       if (button == GLUT_MIDDLE_BUTTON) {
  348.     return 0;
  349.     /* For some reason, the code below always returns -1 even
  350.      though the point IS IN THE ITEM!  Therefore, just bail out if
  351.      we get a middle mouse up.  The user must select using the
  352.      left mouse button.  Stupid Win32. */
  353. #if 0
  354.      int item = MenuItemFromPoint(hwnd, __glutHMenu, point);
  355.      printf("item = %d %d %d\n", item, point.x, point.y);
  356.      if (item != -1)
  357.        __glutItemSelected = (GLUTmenuItem*)GetMenuItemID(__glutHMenu, item);
  358.      else
  359.        __glutItemSelected = NULL;
  360.      __glutFinishMenu(hwnd, point.x, point.y);
  361. #endif
  362.       } else {
  363.     __glutItemSelected = NULL;
  364.     __glutFinishMenu(hwnd, point.x, point.y);
  365.       }
  366.       return 0;
  367.     }
  368.  
  369.     /* release the mouse capture */
  370.     ReleaseCapture();
  371.  
  372.     window = __glutGetWindow(hwnd);
  373.     if (window && window->mouse) {
  374.       /* Win32 doesn't return the same numbers as X does when the
  375.      mouse goes beyond the upper or left side of the window.  roll
  376.      the Win32's 0..2^16 pointer co-ord range to 0 +/- 2^15. */
  377.       x = LOWORD(lParam);
  378.       y = HIWORD(lParam);
  379.       if(x & 1 << 15) x -= (1 << 16);
  380.       if(y & 1 << 15) y -= (1 << 16);
  381.       
  382.       __glutSetWindow(window);
  383.       __glutModifierMask = 0;
  384.       if (GetKeyState(VK_SHIFT) < 0)    /* < 0 = high order bit is on */
  385.     __glutModifierMask |= ShiftMask;
  386.       if (GetKeyState(VK_CONTROL) < 0)
  387.     __glutModifierMask |= ControlMask;
  388.       if (GetKeyState(VK_MENU) < 0)
  389.     __glutModifierMask |= Mod1Mask;
  390.       window->mouse(button, GLUT_UP, x, y);
  391.       __glutModifierMask = (unsigned int)~0;
  392.     } else {
  393.       /* Window might have been destroyed and all the 
  394.      events for the window may not yet be received. */
  395.     }
  396.     return 0;
  397.  
  398.   case WM_ENTERMENULOOP:
  399.     /* KLUDGE: create a timer that fires every 100 ms when we start a
  400.        menu so that we can still process the idle & timer events (that
  401.        way, the timers will fire during a menu pick and so will the
  402.        idle func. */
  403.     SetTimer(hwnd, 1, 1, NULL);
  404.     return 0;
  405.  
  406.   case WM_TIMER:
  407. //     /* if the timer id is 2, then this is the timer that is set up in
  408. //        the main glut message processing loop, and we don't want to do
  409. //        anything but acknowledge that we got it.  It is used to prevent
  410. //        CPU spiking when an idle function is installed. */
  411. //     if (wParam == 2)
  412. //       return 0;
  413.  
  414.     /* only worry about the idle function and the timeouts, since
  415.        these are the only events we expect to process during
  416.        processing of a menu. */
  417.     /* we no longer process the idle functions (as outlined in the
  418.        README), since drawing can't be done until the menu has
  419.        finished...it's pretty lame when the animation goes on, but
  420.        doesn't update, so you get this weird jerkiness. */
  421. #if 0    
  422.      if (__glutIdleFunc)
  423.        __glutIdleFunc();
  424. #endif
  425.     if (__glutTimerList)
  426.       handleTimeouts();
  427.     return 0;
  428.  
  429.   case WM_EXITMENULOOP:
  430.     /* nuke the above created timer...we don't need it anymore, since
  431.        the menu is gone now. */
  432.     KillTimer(hwnd, 1);
  433.     return 0;
  434.  
  435.   case WM_MENUSELECT:
  436.     if (lParam != 0)
  437.       __glutHMenu = (HMENU)lParam;
  438.     return 0;
  439.  
  440.   case WM_COMMAND:
  441.     if (__glutMappedMenu) {
  442.       if (GetSubMenu(__glutHMenu, LOWORD(wParam)))
  443.     __glutItemSelected = NULL;
  444.       else
  445.     __glutItemSelected = 
  446.       __glutGetUniqueMenuItem(__glutMappedMenu, LOWORD(wParam));
  447.       GetCursorPos(&point);
  448.       ScreenToClient(hwnd, &point);
  449.       __glutFinishMenu(hwnd, point.x, point.y);
  450.     } 
  451.     return 0;
  452.  
  453.   case WM_MOUSEMOVE:
  454.     //    printf("WM_MOUSEMOVE\n");
  455.     if (!__glutMappedMenu) {
  456.       window = __glutGetWindow(hwnd);
  457.       if (window) {
  458.           /* If motion function registered _and_ buttons held *
  459.              down, call motion function...  */
  460.     x = LOWORD(lParam);
  461.     y = HIWORD(lParam);
  462.  
  463.     /* Win32 doesn't return the same numbers as X does when the
  464.        mouse goes beyond the upper or left side of the window.
  465.        roll the Win32's 0..2^16 pointer co-ord range to 0..+/-2^15. */
  466.     if(x & 1 << 15) x -= (1 << 16);
  467.     if(y & 1 << 15) y -= (1 << 16);
  468.  
  469.     if (window->motion && wParam &
  470.             (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
  471.       __glutSetWindow(window);
  472.       window->motion(x, 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.          ((wParam &
  479.            (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) ==
  480.           0)) {
  481.       __glutSetWindow(window);
  482.       window->passive(x, y);
  483.     }
  484.       }
  485.     } else {
  486.       /* Motion events are thrown away when a pop up menu is
  487.      active. */
  488.     }
  489.     return 0;
  490.  
  491.   case WM_GETMINMAXINFO:
  492.     /* this voodoo is brought to you by Win32 (again).  It allows the
  493.        window to be bigger than the screen, and smaller than 100x100
  494.        (although it doesn't seem to help the y minimum). */
  495.     minmax = (LPMINMAXINFO)lParam;
  496.     minmax->ptMaxSize.x = __glutScreenWidth;
  497.     minmax->ptMaxSize.y = __glutScreenHeight;
  498.     minmax->ptMinTrackSize.x = 0;
  499.     minmax->ptMinTrackSize.y = 0;
  500.     minmax->ptMaxTrackSize.x = __glutScreenWidth + 
  501.       GetSystemMetrics(SM_CXSIZE) * 2;
  502.     minmax->ptMaxTrackSize.y = __glutScreenHeight + 
  503.       GetSystemMetrics(SM_CXSIZE) * 2 + GetSystemMetrics(SM_CYCAPTION);
  504.     return 0;
  505.  
  506.   case WM_SIZE:
  507.     window = __glutGetWindow(hwnd);
  508.     if (window) {
  509.       if (window->win != hwnd) {
  510.     /* Ignore ConfigureNotify sent to the overlay planes.
  511.        GLUT could get here because overlays select for
  512.        StructureNotify events to receive DestroyNotify. */
  513.     break;
  514.       }
  515.       width = LOWORD(lParam);
  516.       height = HIWORD(lParam);
  517.       if (width != window->width || height != window->height) {
  518. #if 0
  519.      if (window->overlay) {
  520.        XResizeWindow(__glutDisplay, window->overlay->win, width, height);
  521.      }
  522. #endif
  523.     window->width = width;
  524.     window->height = height;
  525.     __glutSetWindow(window);
  526.     /* Do not execute OpenGL out of sequence with respect
  527.        to the SetWindowPos request! */
  528.     GdiFlush();
  529.     window->reshape(width, height);
  530.     window->forceReshape = FALSE;
  531.     /* A reshape should be considered like posting a
  532.        redisplay; this is necessary for the "Mesa
  533.        glXSwapBuffers to repair damage" hack to operate
  534.        correctly.  Without it, there's not an initial
  535.        back buffer render from which to blit from when
  536.        damage happens to the window. */
  537.     __glutPostRedisplay(window, GLUT_REDISPLAY_WORK);
  538.       }
  539.     }
  540.     return 0;
  541.  
  542.   case WM_SETCURSOR:
  543.     /* if the cursor is not in the client area, then we want to send
  544.        this message to the default window procedure ('cause its
  545.        probably in the border or title, and we don't handle that
  546.        cursor.  otherwise, set our cursor.  Win32 makes us set the
  547.        cursor every time the mouse moves (DUMB!). */
  548.     if(LOWORD(lParam) != HTCLIENT)
  549.       goto defproc;
  550.     window = __glutGetWindow(hwnd);
  551.     if (window) {
  552.       /* since Win32 allows the parent to control a child windows
  553.      cursor, if the cursor is in a child of this window, bail
  554.      out. */
  555.       GetCursorPos(&point);
  556.       ScreenToClient(hwnd, &point);
  557.       if (hwnd != ChildWindowFromPoint(hwnd, point))
  558.     break;
  559.       /* KLUDGE: should actually call __glutSetWindow here, but since
  560.          it does a glXMakeCurrent(), I'm going to avoid doing that and
  561.          simply set the current window instead. */
  562.       /* __glutSetWindow(window); */
  563.       __glutCurrentWindow = window;
  564.       glutSetCursor(window->cursor);
  565.     }
  566.     /* TODO: check out the info in DevStudio on WM_SETCURSOR in the
  567.        DefaultAction section. */
  568.     return 1;
  569.  
  570.   case WM_SETFOCUS:
  571.     window = __glutGetWindow(hwnd);
  572.     if (window) {
  573.       if (window->entry) {
  574.     window->entryState = WM_SETFOCUS;
  575.     __glutSetWindow(window);
  576.     window->entry(GLUT_ENTERED);
  577. //           if (event.type == EnterNotify) {
  578.  
  579. //             /* With overlays established, X can report two
  580. //                enter events for both the overlay and normal
  581. //                plane window. Do not generate a second enter
  582. //                callback if we reported one without an
  583. //                intervening leave. */
  584.  
  585. //             if (window->entryState != EnterNotify) {
  586. //               int num = window->num;
  587. //               Window xid = window->win;
  588.  
  589. //               window->entryState = EnterNotify;
  590. //               __glutSetWindow(window);
  591. //               window->entry(GLUT_ENTERED);
  592.  
  593. //               if (__glutMappedMenu) {
  594.  
  595. //                 /* Do not generate any passive motion events
  596. //                    when menus are in use. */
  597.  
  598. //               } else {
  599.  
  600. //                 /* An EnterNotify event can result in a
  601. //                    "compound" callback if a passive motion
  602. //                    callback is also registered. In this case,
  603. //                    be a little paranoid about the possibility
  604. //                    the window could have been destroyed in the
  605. //                    entry callback. */
  606.  
  607. //                 window = __glutWindowList[num];
  608. //                 if (window && window->passive && window->win == xid) {
  609. //                   __glutSetWindow(window);
  610. //                   window->passive(event.xcrossing.x, event.xcrossing.y);
  611. //                 }
  612. //               }
  613. //             }
  614. //           } else {
  615. //             if (window->entryState != LeaveNotify) {
  616.  
  617. //               /* When an overlay is established for a window
  618. //                  already mapped and with the pointer in it, the
  619. //                  X server will generate a leave/enter event pair
  620. //                  as the pointer leaves (without moving) from the
  621. //                  normal plane X window to the newly mapped
  622. //                  overlay  X window (or vice versa). This
  623. //                  enter/leave pair should not be reported to the
  624. //                  GLUT program since the pair is a consequence of
  625. //                  creating (or destroying) the overlay, not an
  626. //                  actual leave from the GLUT window. */
  627.  
  628. //               if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {
  629. //                 XPeekEvent(__glutDisplay, &ahead);
  630. //                 if (ahead.type == EnterNotify &&
  631. //                   __glutGetWindow(ahead.xcrossing.window) == window) {
  632. //                   XNextEvent(__glutDisplay, &event);
  633. //                   break;
  634. //                 }
  635. //               }
  636. //               window->entryState = LeaveNotify;
  637. //               __glutSetWindow(window);
  638. //               window->entry(GLUT_LEFT);
  639. //             }
  640. //           }
  641. //         } else if (window->passive) {
  642. //           __glutSetWindow(window);
  643. //           window->passive(event.xcrossing.x, event.xcrossing.y);
  644.       }
  645.     }
  646.     return 0;
  647.  
  648.   case WM_KILLFOCUS:
  649.     window = __glutGetWindow(hwnd);
  650.     if (window) {
  651.       if (window->entry) {
  652.     window->entryState = WM_KILLFOCUS;
  653.     __glutSetWindow(window);
  654.     window->entry(GLUT_LEFT);
  655.       }
  656.     }
  657.     return 0;
  658.  
  659.   case WM_ACTIVATE:
  660.     window = __glutGetWindow(hwnd);
  661.     /* make sure we re-select the correct palette if needed */
  662.     if (LOWORD(wParam)) {
  663.       PostMessage(hwnd, WM_PALETTECHANGED, 0, 0);
  664.     }
  665.     if (window) {
  666.       GLUTwindow* child;
  667.       int visState;
  668.       visState = !IsIconic(window->win);
  669.       if (visState) {            // not iconic
  670.     visState = IsWindowVisible(window->win);
  671.       }
  672.       if (visState != window->visState) {
  673.     if (window->windowStatus) {
  674.       window->visState = visState;
  675.       __glutSetWindow(window);
  676.       window->windowStatus(visState);
  677.       //      window->visibility(visState ? GLUT_VISIBLE : GLUT_NOT_VISIBLE);
  678.     }
  679.     // since Win32 only sends an activate for the toplevel window,
  680.     // update the visibility for all the child windows
  681.     child = window->children;
  682.     while (child) {
  683.       child->visState = visState;
  684.       if (child->windowStatus) {
  685.         child->visState = visState;
  686.         __glutSetWindow(child);
  687.         child->windowStatus(visState);
  688.         //        child->visibility(visState ? GLUT_VISIBLE : GLUT_NOT_VISIBLE);
  689.       }
  690.       child = child->siblings;
  691.     }
  692.       }
  693.     }
  694.     return 0;
  695.  
  696.   /* Colour Palette Management */
  697.   case WM_PALETTECHANGED:
  698.     if (hwnd == (HWND)wParam)  /* don't respond to the message that we sent! */
  699.       break;
  700.     /* fall through to WM_QUERYNEWPALETTE */
  701.  
  702.   case WM_QUERYNEWPALETTE:
  703.     window = __glutGetWindow(hwnd);
  704.     if (window && window->colormap) {
  705.       UnrealizeObject(window->colormap->cmap);
  706.       SelectPalette(window->hdc, window->colormap->cmap, FALSE);
  707.       RealizePalette(window->hdc);
  708.       return TRUE;
  709.     }
  710.     return FALSE;
  711.  
  712.   /* miscellaneous messages (don't really need to enumerate them,
  713.      but it's good to know what you're not getting sometimes.) */
  714.   case WM_NCHITTEST:
  715.     /* this event is generated by every mouse move event. */
  716.     goto defproc;
  717.   case WM_NCMOUSEMOVE:
  718.     goto defproc;
  719.   case WM_NCACTIVATE:
  720.     goto defproc;
  721.   case WM_NCPAINT:
  722.     goto defproc;
  723.   case WM_NCCALCSIZE:
  724.     goto defproc;
  725.   case WM_NCCREATE:
  726.     goto defproc;
  727.   case WM_NCDESTROY:
  728.     goto defproc;
  729.   case WM_NCLBUTTONDOWN:
  730.     goto defproc;
  731.   case WM_SETTEXT:
  732.     goto defproc;
  733.   case WM_GETTEXT:
  734.     goto defproc;
  735.   case WM_ACTIVATEAPP:
  736.     goto defproc;
  737.   case WM_GETICON:
  738.     goto defproc;
  739.   case WM_ERASEBKGND:
  740.     goto defproc;
  741.   case WM_WINDOWPOSCHANGING:
  742.     goto defproc;
  743.   case WM_WINDOWPOSCHANGED:
  744.     goto defproc;
  745.   case WM_MOUSEACTIVATE:
  746.     goto defproc;
  747.   case WM_SHOWWINDOW:
  748.     goto defproc;
  749.   case WM_MOVING:
  750.     goto defproc;
  751.   case WM_MOVE:
  752.     goto defproc;
  753.   case WM_KEYUP:
  754.     goto defproc;
  755.   case WM_CAPTURECHANGED:
  756.     goto defproc;
  757.   case WM_SYSCOMMAND:
  758.     goto defproc;
  759.   case WM_ENTERSIZEMOVE:
  760.     goto defproc;
  761.   case WM_ENTERIDLE:
  762.     goto defproc;
  763.  
  764.   default: 
  765. //    printf("default: 0x%04x\n", msg);
  766.     goto defproc;
  767.   }
  768.  
  769. defproc:    
  770.   return DefWindowProc(hwnd, msg, wParam, lParam); 
  771. } 
  772.