src/glut/os2/WarpWin.cpp

   1 /* WarpWin.c     */
   2 /* glut for Warp */
   3 #include <stdio.h>
   4 #include <string.h>
   5
   6 #include "WarpWin.h"
   7 #include "WarpGL.h"
   8
   9 #define POKA 0
  10
  11 /* global variables that must be set for some functions to operate
  12    correctly. */
  13 HDC XHDC;
  14 HWND XHWND;
  15
  16
  17 void
  18 XStoreColor(Display* display, Colormap colormap, XColor* color)
  19 {
  20   /* KLUDGE: set XHDC to 0 if the palette should NOT be realized after
  21      setting the color.  set XHDC to the correct HDC if it should. */
  22
  23   LONG pe;
  24   ULONG cclr;
  25   int r,g,b;
  26   /* X11 stores color from 0-65535, Win32 expects them to be 0-256, so
  27      twiddle the bits ( / 256). */
  28   r = color->red / 256;
  29   g = color->green / 256;
  30   b = color->blue / 256;
  31   pe = LONGFromRGB(r,g,b);
  32   /* make sure we use this flag, otherwise the colors might get mapped
  33      to another place in the colormap, and when we glIndex() that
  34      color, it may have moved (argh!!) */
  35   pe |= (PC_NOCOLLAPSE<<24);
  36 /* This function changes the entries in a palette.  */
  37 #if POKA
  38 OS2:
  39  rc = GpiSetPaletteEntries(colormap,LCOLF_CONSECRGB, color->pixel, 1, &pe);
  40  GpiSelectPalette(hps,colormap);
  41  WinRealizePalette(hwnd,hps,&cclr);
  42 source Win:
  43   if (XHDC) {
  44     UnrealizeObject(colormap);
  45     SelectPalette(XHDC, colormap, FALSE);
  46     RealizePalette(XHDC);
  47
  48    }
  49 #endif
  50 }
  51
  52 void
  53 XSetWindowColormap(Display* display, Window window, Colormap colormap)
  54 {
  55 #if POKA
  56   HDC hdc = GetDC(window);
  57
  58   /* if the third parameter is FALSE, the logical colormap is copied
  59      into the device palette when the application is in the
  60      foreground, if it is TRUE, the colors are mapped into the current
  61      palette in the best possible way. */
  62   SelectPalette(hdc, colormap, FALSE);
  63   RealizePalette(hdc);
  64
  65   /* note that we don't have to release the DC, since our window class
  66      uses the WC_OWNDC flag! */
  67 #endif
  68 }
  69
  70
  71 /* display, root and visual - don't used at all */
  72 Colormap
  73 XCreateColormap(Display* display, Window root, Visual* visual, int alloc)
  74 {
  75   /* KLUDGE: this function needs XHDC to be set to the HDC currently
  76      being operated on before it is invoked! */
  77
  78   HPAL    palette;
  79   int n;
  80 #if POKA
  81   PIXELFORMATDESCRIPTOR pfd;
  82   LOGPALETTE *logical;
  83
  84   /* grab the pixel format */
  85   memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
  86   DescribePixelFormat(XHDC, GetPixelFormat(XHDC),
  87                      sizeof(PIXELFORMATDESCRIPTOR), &pfd);
  88
  89   if (!(pfd.dwFlags & PFD_NEED_PALETTE ||
  90       pfd.iPixelType == PFD_TYPE_COLORINDEX))
  91   {
  92     return 0;
  93   }
  94
  95   n = 1 << pfd.cColorBits;
  96
  97   /* allocate a bunch of memory for the logical palette (assume 256
  98      colors in a Win32 palette */
  99   logical = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +
 100                                sizeof(PALETTEENTRY) * n);
 101   memset(logical, 0, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * n);
 102
 103   /* set the entries in the logical palette */
 104   logical->palVersion = 0x300;
 105   logical->palNumEntries = n;
 106
 107   /* start with a copy of the current system palette */
 108   GetSystemPaletteEntries(XHDC, 0, 256, &logical->palPalEntry[0]);
 109
 110   if (pfd.iPixelType == PFD_TYPE_RGBA) {
 111     int redMask = (1 << pfd.cRedBits) - 1;
 112     int greenMask = (1 << pfd.cGreenBits) - 1;
 113     int blueMask = (1 << pfd.cBlueBits) - 1;
 114     int i;
 115
 116     /* fill in an RGBA color palette */
 117     for (i = 0; i < n; ++i) {
 118       logical->palPalEntry[i].peRed =
 119        (((i >> pfd.cRedShift)   & redMask)   * 255) / redMask;
 120       logical->palPalEntry[i].peGreen =
 121        (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
 122        logical->palPalEntry[i].peBlue =
 123        (((i >> pfd.cBlueShift)  & blueMask)  * 255) / blueMask;
 124       logical->palPalEntry[i].peFlags = 0;
 125     }
 126   }
 127
 128   palette = CreatePalette(logical);
 129   free(logical);
 130
 131   SelectPalette(XHDC, palette, FALSE);
 132   RealizePalette(XHDC);
 133 #endif /* POKA */
 134
 135   return palette;
 136 }
 137
 138
 139
 140 int  GetSystemMetrics( int mode)
 141 {  RECTL rect;
 142
 143    switch(mode)
 144    {   case   SM_CXSCREEN:
 145         WinQueryWindowRect(HWND_DESKTOP,&rect);
 146         return (rect.xRight-rect.xLeft);
 147       break;
 148        case   SM_CYSCREEN:
 149         WinQueryWindowRect(HWND_DESKTOP,&rect);
 150         return (rect.yTop-rect.yBottom);
 151       break;
 152        default: ;
 153    }
 154    return 0;
 155 }
 156 /*
 157  *    XParseGeometry parses strings of the form
 158  *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
 159  *   width, height, xoffset, and yoffset are unsigned integers.
 160  *   Example:  "=80x24+300-49"
 161  *   The equal sign is optional.
 162  *   It returns a bitmask that indicates which of the four values
 163  *   were actually found in the string.  For each value found,
 164  *   the corresponding argument is updated;  for each value
 165  *   not found, the corresponding argument is left unchanged.
 166  */
 167
 168 static int
 169 ReadInteger(char *string, char **NextString)
 170 {
 171     register int Result = 0;
 172     int Sign = 1;
 173
 174     if (*string == '+')
 175        string++;
 176     else if (*string == '-')
 177     {
 178        string++;
 179        Sign = -1;
 180     }
 181     for (; (*string >= '0') && (*string <= '9'); string++)
 182     {
 183        Result = (Result * 10) + (*string - '0');
 184     }
 185     *NextString = string;
 186     if (Sign >= 0)
 187        return (Result);
 188     else
 189        return (-Result);
 190 }
 191
 192 int XParseGeometry(char *string, int *x, int *y, unsigned int *width, unsigned int *height)
 193 {
 194        int mask = NoValue;
 195        register char *strind;
 196        unsigned int tempWidth, tempHeight;
 197        int tempX, tempY;
 198        char *nextCharacter;
 199
 200        if ( (string == NULL) || (*string == '\0')) return(mask);
 201        if (*string == '=')
 202                string++;  /* ignore possible '=' at beg of geometry spec */
 203
 204        strind = (char *)string;
 205        if (*strind != '+' && *strind != '-' && *strind != 'x') {
 206                tempWidth = ReadInteger(strind, &nextCharacter);
 207                if (strind == nextCharacter)
 208                    return (0);
 209                strind = nextCharacter;
 210                mask |= WidthValue;
 211        }
 212
 213        if (*strind == 'x' || *strind == 'X') {
 214                strind++;
 215                tempHeight = ReadInteger(strind, &nextCharacter);
 216                if (strind == nextCharacter)
 217                    return (0);
 218                strind = nextCharacter;
 219                mask |= HeightValue;
 220        }
 221
 222        if ((*strind == '+') || (*strind == '-')) {
 223                if (*strind == '-') {
 224                        strind++;
 225                        tempX = -ReadInteger(strind, &nextCharacter);
 226                        if (strind == nextCharacter)
 227                            return (0);
 228                        strind = nextCharacter;
 229                        mask |= XNegative;
 230
 231                }
 232                else
 233                {       strind++;
 234                        tempX = ReadInteger(strind, &nextCharacter);
 235                        if (strind == nextCharacter)
 236                            return(0);
 237                        strind = nextCharacter;
 238                }
 239                mask |= XValue;
 240                if ((*strind == '+') || (*strind == '-')) {
 241                        if (*strind == '-') {
 242                                strind++;
 243                                tempY = -ReadInteger(strind, &nextCharacter);
 244                                if (strind == nextCharacter)
 245                                    return(0);
 246                                strind = nextCharacter;
 247                                mask |= YNegative;
 248
 249                        }
 250                        else
 251                        {
 252                                strind++;
 253                                tempY = ReadInteger(strind, &nextCharacter);
 254                                if (strind == nextCharacter)
 255                                    return(0);
 256                                strind = nextCharacter;
 257                        }
 258                        mask |= YValue;
 259                }
 260        }
 261
 262        /* If strind isn't at the end of the string the it's an invalid
 263                geometry specification. */
 264
 265        if (*strind != '\0') return (0);
 266
 267        if (mask & XValue)
 268            *x = tempX;
 269        if (mask & YValue)
 270            *y = tempY;
 271        if (mask & WidthValue)
 272             *width = tempWidth;
 273        if (mask & HeightValue)
 274             *height = tempHeight;
 275        return (mask);
 276 }
 277
 278 int gettimeofday(struct timeval* tp, void* tzp)
 279 {
 280  DATETIME    DateTime;
 281  APIRET       ulrc;  /*  Return Code. */
 282
 283  ulrc = DosGetDateTime(&DateTime);
 284  tp->tv_sec  = 60 * (60*DateTime.hours + DateTime.minutes) + DateTime.seconds;
 285  tp->tv_usec = DateTime.hundredths * 10000;
 286  return 0;
 287 }
 288
 289
 290 int
 291 XPending(Display* display)
 292 {
 293   /* similar functionality...I don't think that it is exact, but this
 294      will have to do. */
 295   QMSG msg;
 296   extern HAB   hab;      /* PM anchor block handle         */
 297
 298 //?? WinPeekMsg(hab
 299   return WinPeekMsg(hab, &msg, NULLHANDLE, 0, 0, PM_NOREMOVE);
 300 }
 301
 302 void
 303 __glutAdjustCoords(Window parent, int* x, int* y, int* width, int* height)
 304 {
 305   RECTL rect;
 306
 307   /* adjust the window rectangle because Win32 thinks that the x, y,
 308      width & height are the WHOLE window (including decorations),
 309      whereas GLUT treats the x, y, width & height as only the CLIENT
 310      area of the window. */
 311   rect.xLeft = *x; rect.yTop = *y;
 312   rect.xRight = *x + *width; rect.yBottom = *y + *height;
 313
 314   /* must adjust the coordinates according to the correct style
 315      because depending on the style, there may or may not be
 316      borders. */
 317 //??  AdjustWindowRect(&rect, WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
 318 //??              (parent ? WS_CHILD : WS_OVERLAPPEDWINDOW),
 319 //??              FALSE);
 320   /* FALSE in the third parameter = window has no menu bar */
 321
 322   /* readjust if the x and y are offscreen */
 323   if(rect.xLeft < 0) {
 324     *x = 0;
 325   } else {
 326     *x = rect.xLeft;
 327   }
 328
 329   if(rect.yTop < 0) {
 330     *y = 0;
 331   } else {
 332     *y = rect.yTop;
 333   }
 334
 335   *width = rect.xRight - rect.xLeft;     /* adjusted width */
 336   *height = -(rect.yBottom - rect.yTop);    /* adjusted height */
 337 }
 338
 339
 340 int
 341 __glutGetTransparentPixel(Display * dpy, XVisualInfo * vinfo)
 342 {
 343   /* the transparent pixel on Win32 is always index number 0.  So if
 344      we put this routine in this file, we can avoid compiling the
 345      whole of layerutil.c which is where this routine normally comes
 346      from. */
 347   return 0;
 348 }
 349
 350 /* Translate point coordinates src_x and src_y from src to dst */
 351
 352 Bool
 353 XTranslateCoordinates(Display *display, Window src, Window dst,
 354                      int src_x, int src_y,
 355                      int* dest_x_return, int* dest_y_return,
 356                      Window* child_return)
 357 {
 358   SWP swp_src,swp_dst;
 359
 360   WinQueryWindowPos(src,&swp_src);
 361   WinQueryWindowPos(dst,&swp_dst);
 362
 363   *dest_x_return =  src_x + swp_src.x - swp_dst.x;
 364   *dest_y_return =  src_y + swp_src.y - swp_dst.y;
 365
 366   /* just to make compilers happy...we don't use the return value. */
 367   return True;
 368 }
 369
 370 Status
 371 XGetGeometry(Display* display, Window window, Window* root_return,
 372             int* x_return, int* y_return,
 373             unsigned int* width_return, unsigned int* height_return,
 374             unsigned int *border_width_return, unsigned int* depth_return)
 375 {
 376   /* KLUDGE: doesn't return the border_width or depth or root, x & y
 377      are in screen coordinates. */
 378   SWP swp_src;
 379   WinQueryWindowPos(window,&swp_src);
 380
 381   *x_return = swp_src.x;
 382   *y_return = swp_src.y;
 383   *width_return = swp_src.cx;
 384   *height_return = swp_src.cy;
 385
 386   /* just to make compilers happy...we don't use the return value. */
 387   return 1;
 388 }
 389
 390 /* Get Display Width in millimeters */
 391 int
 392 DisplayWidthMM(Display* display, int screen)
 393 {
 394   int width;
 395   LONG *pVC_Caps;
 396   pVC_Caps = GetVideoConfig(NULLHANDLE);
 397   width = (int)( 0.001 * pVC_Caps[CAPS_WIDTH]  / pVC_Caps[CAPS_HORIZONTAL_RESOLUTION]);/* mm */
 398   return width;
 399 }
 400
 401 /* Get Display Height in millimeters */
 402 int
 403 DisplayHeightMM(Display* display, int screen)
 404 {
 405   int height;
 406   LONG *pVC_Caps;
 407   pVC_Caps = GetVideoConfig(NULLHANDLE);
 408   height = (int)( 0.001 * pVC_Caps[CAPS_HEIGHT] / pVC_Caps[CAPS_VERTICAL_RESOLUTION]); /* mm */
 409   return height;
 410 }
 411
 412 void ScreenToClient( HWND hwnd,   POINTL *point)
 413 {
 414   SWP swp_src;
 415   WinQueryWindowPos(hwnd,&swp_src);
 416   point->x -= swp_src.x;
 417   point->y -= swp_src.y;
 418 }
 419