src/glut/glx/win32_x11.c

   1
   2 /* Copyright (c) Nate Robins, 1997. */
   3 /* portions Copyright (c) Mark Kilgard, 1998. */
   4
   5 /* This program is freely distributable without licensing fees
   6    and is provided without guarantee or warrantee expressed or
   7    implied. This program is -not- in the public domain. */
   8
   9 #include "glutint.h"
  10
  11 /* global variable that must be set for some functions to operate
  12    correctly. */
  13 HDC XHDC;
  14
  15 XVisualInfo*
  16 XGetVisualInfo(Display* display, long mask, XVisualInfo* template, int* nitems)
  17 {
  18   /* KLUDGE: this function needs XHDC to be set to the HDC currently
  19      being operated on before it is invoked! */
  20
  21   PIXELFORMATDESCRIPTOR* pfds;
  22   int i, n;
  23
  24   n = DescribePixelFormat(XHDC, 0, 0, NULL);
  25   pfds = (PIXELFORMATDESCRIPTOR*)malloc(sizeof(PIXELFORMATDESCRIPTOR) * n);
  26   memset(pfds, 0, sizeof(PIXELFORMATDESCRIPTOR) * n);
  27
  28   for (i = 0; i < n; i++) {
  29     DescribePixelFormat(XHDC, i + 1, sizeof(PIXELFORMATDESCRIPTOR), &pfds[i]);
  30   }
  31
  32   *nitems = n;
  33   return pfds;
  34 }
  35
  36 Colormap
  37 XCreateColormap(Display* display, Window root, Visual* visual, int alloc)
  38 {
  39   /* KLUDGE: this function needs XHDC to be set to the HDC currently
  40      being operated on before it is invoked! */
  41
  42   PIXELFORMATDESCRIPTOR pfd;
  43   LOGPALETTE *logical;
  44   HPALETTE    palette;
  45   int n;
  46
  47   /* grab the pixel format */
  48   memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
  49   DescribePixelFormat(XHDC, GetPixelFormat(XHDC),
  50                       sizeof(PIXELFORMATDESCRIPTOR), &pfd);
  51
  52   if (!(pfd.dwFlags & PFD_NEED_PALETTE ||
  53       pfd.iPixelType == PFD_TYPE_COLORINDEX))
  54   {
  55     return 0;
  56   }
  57
  58   n = 1 << pfd.cColorBits;
  59
  60   /* allocate a bunch of memory for the logical palette (assume 256
  61      colors in a Win32 palette */
  62   logical = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +
  63                                 sizeof(PALETTEENTRY) * n);
  64   memset(logical, 0, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * n);
  65
  66   /* set the entries in the logical palette */
  67   logical->palVersion = 0x300;
  68   logical->palNumEntries = n;
  69
  70   /* start with a copy of the current system palette */
  71   GetSystemPaletteEntries(XHDC, 0, 256, &logical->palPalEntry[0]);
  72
  73   if (pfd.iPixelType == PFD_TYPE_RGBA) {
  74     int redMask = (1 << pfd.cRedBits) - 1;
  75     int greenMask = (1 << pfd.cGreenBits) - 1;
  76     int blueMask = (1 << pfd.cBlueBits) - 1;
  77     int i;
  78
  79     /* fill in an RGBA color palette */
  80     for (i = 0; i < n; ++i) {
  81       logical->palPalEntry[i].peRed =
  82         (((i >> pfd.cRedShift)   & redMask)   * 255) / redMask;
  83       logical->palPalEntry[i].peGreen =
  84         (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
  85         logical->palPalEntry[i].peBlue =
  86         (((i >> pfd.cBlueShift)  & blueMask)  * 255) / blueMask;
  87       logical->palPalEntry[i].peFlags = 0;
  88     }
  89   }
  90
  91   palette = CreatePalette(logical);
  92   free(logical);
  93
  94   SelectPalette(XHDC, palette, FALSE);
  95   RealizePalette(XHDC);
  96
  97   return palette;
  98 }
  99
 100 void
 101 XAllocColorCells(Display* display, Colormap colormap, Bool contig,
 102                  unsigned long plane_masks_return[], unsigned int nplanes,
 103                  unsigned long pixels_return[], unsigned int npixels)
 104 {
 105   /* NOP -- we did all the allocating in XCreateColormap! */
 106 }
 107
 108 void
 109 XStoreColor(Display* display, Colormap colormap, XColor* color)
 110 {
 111   /* KLUDGE: set XHDC to 0 if the palette should NOT be realized after
 112      setting the color.  set XHDC to the correct HDC if it should. */
 113
 114   PALETTEENTRY pe;
 115
 116   /* X11 stores color from 0-65535, Win32 expects them to be 0-256, so
 117      twiddle the bits ( / 256). */
 118   pe.peRed = color->red / 256;
 119   pe.peGreen = color->green / 256;
 120   pe.peBlue = color->blue / 256;
 121
 122   /* make sure we use this flag, otherwise the colors might get mapped
 123      to another place in the colormap, and when we glIndex() that
 124      color, it may have moved (argh!!) */
 125   pe.peFlags = PC_NOCOLLAPSE;
 126
 127   /* the pixel field of the XColor structure is the index into the
 128      colormap */
 129   SetPaletteEntries(colormap, color->pixel, 1, &pe);
 130
 131   if (XHDC) {
 132     UnrealizeObject(colormap);
 133     SelectPalette(XHDC, colormap, FALSE);
 134     RealizePalette(XHDC);
 135   }
 136 }
 137
 138 void
 139 XSetWindowColormap(Display* display, Window window, Colormap colormap)
 140 {
 141   HDC hdc = GetDC(window);
 142
 143   /* if the third parameter is FALSE, the logical colormap is copied
 144      into the device palette when the application is in the
 145      foreground, if it is TRUE, the colors are mapped into the current
 146      palette in the best possible way. */
 147   SelectPalette(hdc, colormap, FALSE);
 148   RealizePalette(hdc);
 149
 150   /* note that we don't have to release the DC, since our window class
 151      uses the WC_OWNDC flag! */
 152 }
 153
 154 Bool
 155 XTranslateCoordinates(Display *display, Window src, Window dst,
 156                       int src_x, int src_y,
 157                       int* dest_x_return, int* dest_y_return,
 158                       Window* child_return)
 159 {
 160   /* KLUDGE: this isn't really a translate coordinates into some other
 161   windows coordinate system...it only translates coordinates into the
 162   root window (screen) coordinate system. */
 163
 164   POINT point;
 165
 166   point.x = src_x;
 167   point.y = src_y;
 168
 169   ClientToScreen(src, &point);
 170
 171   *dest_x_return = point.x;
 172   *dest_y_return = point.y;
 173
 174   /* just to make compilers happy...we don't use the return value. */
 175   return True;
 176 }
 177
 178 Status
 179 XGetGeometry(Display* display, Window window, Window* root_return,
 180              int* x_return, int* y_return,
 181              unsigned int* width_return, unsigned int* height_return,
 182              unsigned int *border_width_return, unsigned int* depth_return)
 183 {
 184   /* KLUDGE: doesn't return the border_width or depth or root, x & y
 185      are in screen coordinates. */
 186
 187   RECT rect;
 188   POINT point;
 189
 190   GetClientRect(window, &rect);
 191
 192   point.x = 0;
 193   point.y = 0;
 194   ClientToScreen(window, &point);
 195
 196   *x_return = point.x;
 197   *y_return = point.y;
 198   *width_return = rect.right;
 199   *height_return = rect.bottom;
 200
 201   /* just to make compilers happy...we don't use the return value. */
 202   return 1;
 203 }
 204
 205 int
 206 DisplayWidthMM(Display* display, int screen)
 207 {
 208   int width;
 209   HWND hwnd = GetDesktopWindow();
 210   HDC hdc = GetDC(hwnd);
 211
 212   width = GetDeviceCaps(hdc, HORZSIZE);
 213
 214   /* make sure to release this DC (it's the desktops, not ours) */
 215   ReleaseDC(hwnd, hdc);
 216
 217   return width;
 218 }
 219
 220 int
 221 DisplayHeightMM(Display* display, int screen)
 222 {
 223   int height;
 224   HWND hwnd = GetDesktopWindow();
 225   HDC hdc = GetDC(hwnd);
 226
 227   height = GetDeviceCaps(hdc, VERTSIZE);
 228
 229   /* make sure to release this DC (it's the desktops, not ours) */
 230   ReleaseDC(hwnd, hdc);
 231
 232   return height;
 233 }
 234
 235 void
 236 XWarpPointer(Display* display, Window src, Window dst,
 237              int src_x, int src_y, int src_width, int src_height,
 238              int dst_x, int dst_y)
 239 {
 240   /* KLUDGE: this isn't really a warp pointer into some other windows
 241   coordinate system...it only warps the pointer into the root window
 242   (screen) coordinate system. */
 243
 244   POINT point;
 245
 246   point.x = dst_x;
 247   point.y = dst_y;
 248   ClientToScreen(dst, &point);
 249
 250   SetCursorPos(point.x, point.y);
 251 }
 252
 253 int
 254 XPending(Display* display)
 255 {
 256   /* similar functionality...I don't think that it is exact, but this
 257      will have to do. */
 258   MSG msg;
 259
 260   return PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
 261 }
 262
 263 /* the following function was stolen from the X sources as indicated. */
 264
 265 /* Copyright    Massachusetts Institute of Technology  1985, 1986, 1987 */
 266 /* $XConsortium: XParseGeom.c,v 11.18 91/02/21 17:23:05 rws Exp $ */
 267
 268 /*
 269 Permission to use, copy, modify, distribute, and sell this software and its
 270 documentation for any purpose is hereby granted without fee, provided that
 271 the above copyright notice appear in all copies and that both that
 272 copyright notice and this permission notice appear in supporting
 273 documentation, and that the name of M.I.T. not be used in advertising or
 274 publicity pertaining to distribution of the software without specific,
 275 written prior permission.  M.I.T. makes no representations about the
 276 suitability of this software for any purpose.  It is provided "as is"
 277 without express or implied warranty.
 278 */
 279
 280 /*
 281  *    XParseGeometry parses strings of the form
 282  *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
 283  *   width, height, xoffset, and yoffset are unsigned integers.
 284  *   Example:  "=80x24+300-49"
 285  *   The equal sign is optional.
 286  *   It returns a bitmask that indicates which of the four values
 287  *   were actually found in the string.  For each value found,
 288  *   the corresponding argument is updated;  for each value
 289  *   not found, the corresponding argument is left unchanged.
 290  */
 291
 292 static int
 293 ReadInteger(char *string, char **NextString)
 294 {
 295     register int Result = 0;
 296     int Sign = 1;
 297
 298     if (*string == '+')
 299         string++;
 300     else if (*string == '-')
 301     {
 302         string++;
 303         Sign = -1;
 304     }
 305     for (; (*string >= '0') && (*string <= '9'); string++)
 306     {
 307         Result = (Result * 10) + (*string - '0');
 308     }
 309     *NextString = string;
 310     if (Sign >= 0)
 311         return (Result);
 312     else
 313         return (-Result);
 314 }
 315
 316 int XParseGeometry(char *string, int *x, int *y, unsigned int *width, unsigned int *height)
 317 {
 318         int mask = NoValue;
 319         register char *strind;
 320         unsigned int tempWidth, tempHeight;
 321         int tempX, tempY;
 322         char *nextCharacter;
 323
 324         if ( (string == NULL) || (*string == '\0')) return(mask);
 325         if (*string == '=')
 326                 string++;  /* ignore possible '=' at beg of geometry spec */
 327
 328         strind = (char *)string;
 329         if (*strind != '+' && *strind != '-' && *strind != 'x') {
 330                 tempWidth = ReadInteger(strind, &nextCharacter);
 331                 if (strind == nextCharacter)
 332                     return (0);
 333                 strind = nextCharacter;
 334                 mask |= WidthValue;
 335         }
 336
 337         if (*strind == 'x' || *strind == 'X') {
 338                 strind++;
 339                 tempHeight = ReadInteger(strind, &nextCharacter);
 340                 if (strind == nextCharacter)
 341                     return (0);
 342                 strind = nextCharacter;
 343                 mask |= HeightValue;
 344         }
 345
 346         if ((*strind == '+') || (*strind == '-')) {
 347                 if (*strind == '-') {
 348                         strind++;
 349                         tempX = -ReadInteger(strind, &nextCharacter);
 350                         if (strind == nextCharacter)
 351                             return (0);
 352                         strind = nextCharacter;
 353                         mask |= XNegative;
 354
 355                 }
 356                 else
 357                 {       strind++;
 358                         tempX = ReadInteger(strind, &nextCharacter);
 359                         if (strind == nextCharacter)
 360                             return(0);
 361                         strind = nextCharacter;
 362                 }
 363                 mask |= XValue;
 364                 if ((*strind == '+') || (*strind == '-')) {
 365                         if (*strind == '-') {
 366                                 strind++;
 367                                 tempY = -ReadInteger(strind, &nextCharacter);
 368                                 if (strind == nextCharacter)
 369                                     return(0);
 370                                 strind = nextCharacter;
 371                                 mask |= YNegative;
 372
 373                         }
 374                         else
 375                         {
 376                                 strind++;
 377                                 tempY = ReadInteger(strind, &nextCharacter);
 378                                 if (strind == nextCharacter)
 379                                     return(0);
 380                                 strind = nextCharacter;
 381                         }
 382                         mask |= YValue;
 383                 }
 384         }
 385
 386         /* If strind isn't at the end of the string the it's an invalid
 387                 geometry specification. */
 388
 389         if (*strind != '\0') return (0);
 390
 391         if (mask & XValue)
 392             *x = tempX;
 393         if (mask & YValue)
 394             *y = tempY;
 395         if (mask & WidthValue)
 396             *width = tempWidth;
 397         if (mask & HeightValue)
 398             *height = tempHeight;
 399         return (mask);
 400 }