src/glut/os2/glut_get.cpp

   1
   2 /* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
   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 #include <assert.h>
   9 #include <stdlib.h>  /* SunOS 4 needs NULL defined for GETTIMEOFDAY macro. */
  10 #include "glutint.h"
  11
  12 /* CENTRY */
  13 int GLUTAPIENTRY
  14 glutGet(GLenum param)
  15 {
  16   Window win, root;
  17   int x, y, value;
  18   unsigned int width, height, border, depth;
  19
  20   switch (param) {
  21   case GLUT_INIT_WINDOW_X:
  22     return __glutInitX;
  23   case GLUT_INIT_WINDOW_Y:
  24     return __glutInitY;
  25   case GLUT_INIT_WINDOW_WIDTH:
  26     return __glutInitWidth;
  27   case GLUT_INIT_WINDOW_HEIGHT:
  28     return __glutInitHeight;
  29   case GLUT_INIT_DISPLAY_MODE:
  30     return __glutDisplayMode;
  31   case GLUT_WINDOW_X:
  32     XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win,
  33       __glutRoot, 0, 0, &x, &y, &win);
  34     return x;
  35   case GLUT_WINDOW_Y:
  36     XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win,
  37       __glutRoot, 0, 0, &x, &y, &win);
  38     return y;
  39   case GLUT_WINDOW_WIDTH:
  40     if (!__glutCurrentWindow->reshape) {
  41       XGetGeometry(__glutDisplay, __glutCurrentWindow->win,
  42         &root, &x, &y,
  43         &width, &height, &border, &depth);
  44       return width;
  45     }
  46     return __glutCurrentWindow->width;
  47   case GLUT_WINDOW_HEIGHT:
  48     if (!__glutCurrentWindow->reshape) {
  49       XGetGeometry(__glutDisplay, __glutCurrentWindow->win,
  50         &root, &x, &y,
  51         &width, &height, &border, &depth);
  52       return height;
  53     }
  54     return __glutCurrentWindow->height;
  55 #ifdef __OS2__
  56  #define GET_CONFIG(attrib) \
  57   { if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win)  \
  58        glXGetConfig( __glutCurrentWindow->vis, attrib, &value); \
  59     else  \
  60     glXGetConfig(__glutCurrentWindow->overlay->vis, attrib, &value); \
  61   } \
  62
  63 #else
  64
  65 #define GET_CONFIG(attrib) { \
  66   if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { \
  67     glXGetConfig(__glutDisplay, __glutCurrentWindow->vis, \
  68       attrib, &value); \
  69   } else { \
  70     glXGetConfig(__glutDisplay, __glutCurrentWindow->overlay->vis, \
  71       attrib, &value); \
  72   } \
  73 }
  74 #endif
  75
  76   case GLUT_WINDOW_BUFFER_SIZE:
  77     GET_CONFIG(GLX_BUFFER_SIZE);
  78     return value;
  79   case GLUT_WINDOW_STENCIL_SIZE:
  80     GET_CONFIG(GLX_STENCIL_SIZE);
  81     return value;
  82   case GLUT_WINDOW_DEPTH_SIZE:
  83     GET_CONFIG(GLX_DEPTH_SIZE);
  84     return value;
  85   case GLUT_WINDOW_RED_SIZE:
  86     GET_CONFIG(GLX_RED_SIZE);
  87     return value;
  88   case GLUT_WINDOW_GREEN_SIZE:
  89     GET_CONFIG(GLX_GREEN_SIZE);
  90     return value;
  91   case GLUT_WINDOW_BLUE_SIZE:
  92     GET_CONFIG(GLX_BLUE_SIZE);
  93     return value;
  94   case GLUT_WINDOW_ALPHA_SIZE:
  95     GET_CONFIG(GLX_ALPHA_SIZE);
  96     return value;
  97   case GLUT_WINDOW_ACCUM_RED_SIZE:
  98     GET_CONFIG(GLX_ACCUM_RED_SIZE);
  99     return value;
 100   case GLUT_WINDOW_ACCUM_GREEN_SIZE:
 101     GET_CONFIG(GLX_ACCUM_GREEN_SIZE);
 102     return value;
 103   case GLUT_WINDOW_ACCUM_BLUE_SIZE:
 104     GET_CONFIG(GLX_ACCUM_BLUE_SIZE);
 105     return value;
 106   case GLUT_WINDOW_ACCUM_ALPHA_SIZE:
 107     GET_CONFIG(GLX_ACCUM_ALPHA_SIZE);
 108     return value;
 109   case GLUT_WINDOW_DOUBLEBUFFER:
 110     GET_CONFIG(GLX_DOUBLEBUFFER);
 111     return value;
 112   case GLUT_WINDOW_RGBA:
 113     GET_CONFIG(GLX_RGBA);
 114     return value;
 115   case GLUT_WINDOW_COLORMAP_SIZE:
 116     GET_CONFIG(GLX_RGBA);
 117     if (value) {
 118       return 0;
 119     } else {
 120 #if defined(_WIN32) || defined(__OS2__)
 121       /* KLUDGE: we always assume 256 colors in CI mode on
 122          Win32 */
 123       return 256;
 124 #else
 125       if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
 126         return __glutCurrentWindow->vis->visual->map_entries;
 127       } else {
 128         return __glutCurrentWindow->overlay->vis->visual->map_entries;
 129       }
 130 #endif /* _WIN32 */
 131     }
 132   case GLUT_WINDOW_PARENT:
 133     return __glutCurrentWindow->parent ?
 134       __glutCurrentWindow->parent->num + 1 : 0;
 135   case GLUT_WINDOW_NUM_CHILDREN:
 136     {
 137       int num = 0;
 138       GLUTwindow *children = __glutCurrentWindow->children;
 139
 140       while (children) {
 141         num++;
 142         children = children->siblings;
 143       }
 144       return num;
 145     }
 146   case GLUT_WINDOW_NUM_SAMPLES:
 147 #if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
 148     if (__glutIsSupportedByGLX("GLX_SGIS_multisample")) {
 149       GET_CONFIG(GLX_SAMPLES_SGIS);
 150       return value;
 151     } else {
 152       return 0;
 153     }
 154 #else
 155     /* Independent of GLX server support, multisampling not
 156        supported by GLX client-side. */
 157     return 0;
 158 #endif
 159   case GLUT_WINDOW_STEREO:
 160     GET_CONFIG(GLX_STEREO);
 161     return value;
 162   case GLUT_WINDOW_CURSOR:
 163     return __glutCurrentWindow->cursor;
 164   case GLUT_SCREEN_WIDTH:
 165     return DisplayWidth(__glutDisplay, __glutScreen);
 166   case GLUT_SCREEN_HEIGHT:
 167     return DisplayHeight(__glutDisplay, __glutScreen);
 168   case GLUT_SCREEN_WIDTH_MM:
 169     return DisplayWidthMM(__glutDisplay, __glutScreen);
 170   case GLUT_SCREEN_HEIGHT_MM:
 171     return DisplayHeightMM(__glutDisplay, __glutScreen);
 172   case GLUT_MENU_NUM_ITEMS:
 173     return __glutCurrentMenu->num;
 174   case GLUT_DISPLAY_MODE_POSSIBLE:
 175     {
 176       XVisualInfo *vi;
 177       Bool dummy, visAlloced;
 178       void *fbc;
 179
 180 #if defined(_WIN32)
 181       /* Our fake glXChooseVisual (which is called by
 182          __glutDetermineVisual) needs an HDC to work with, so grab one
 183          from the "root" window. */
 184       XHDC = GetDC(GetDesktopWindow());
 185 #endif
 186       vi = __glutDetermineWindowVisual(&dummy, &visAlloced, &fbc);
 187 #if defined(_WIN32)
 188       ReleaseDC(GetDesktopWindow(), XHDC);
 189 #endif
 190       if (vi) {
 191         if (visAlloced)
 192           XFree(vi);
 193         return 1;
 194       }
 195       return 0;
 196     }
 197   case GLUT_ELAPSED_TIME:
 198     {
 199 #ifdef OLD_VMS
 200        struct timeval6 elapsed, beginning, now;
 201 #else
 202        struct timeval elapsed, beginning, now;
 203 #endif
 204
 205        __glutInitTime(&beginning);
 206       GETTIMEOFDAY(&now);
 207       TIMEDELTA(elapsed, now, beginning);
 208       /* Return elapsed milliseconds. */
 209 #if defined(__vms) && ( __VMS_VER < 70000000 )
 210       return (int) (elapsed.val / TICKS_PER_MILLISECOND);
 211 #else
 212       return (int) ((elapsed.tv_sec * 1000) + (elapsed.tv_usec / 1000));
 213 #endif
 214     }
 215   case GLUT_WINDOW_FORMAT_ID:
 216 #if defined(__OS2__)
 217     return wglGetPixelFormat(__glutCurrentWindow->hdc);
 218 #elif defined(_WIN32)
 219     return GetPixelFormat(__glutCurrentWindow->hdc);
 220 #else
 221     if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
 222       return (int) __glutCurrentWindow->vis->visualid;
 223     } else {
 224       return (int) __glutCurrentWindow->overlay->vis->visualid;
 225     }
 226 #endif
 227   default:
 228     __glutWarning("invalid glutGet parameter: %d", param);
 229     return -1;
 230   }
 231 }
 232 /* ENDCENTRY */