windows/cursor.c

   1 /*
   2  *    WINE
   3 */
   4 static char Copyright[] = "Copyright  Martin Ayotte, 1993";
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <fcntl.h>
  12 #include <unistd.h>
  13 #include <X11/cursorfont.h>
  14 #include <X11/Xlib.h>
  15 #include "prototypes.h"
  16 #include "windows.h"
  17 #include "win.h"
  18 #include "gdi.h"
  19 #include "wine.h"
  20 #include "cursor.h"
  21 #include "stddebug.h"
  22 /* #define DEBUG_CURSOR   */
  23 /* #undef  DEBUG_CURSOR   */
  24 /* #define DEBUG_RESOURCE */
  25 /* #undef  DEBUG_RESOURCE */
  26 #include "debug.h"
  27
  28 static int ShowCursCount = 0;
  29 static HCURSOR hActiveCursor;
  30 static HCURSOR hEmptyCursor = 0;
  31 RECT    ClipCursorRect;
  32 extern HINSTANCE hSysRes;
  33 extern int desktopX, desktopY;   /* misc/main.c */
  34
  35 static struct { LPSTR name; HCURSOR cursor; } system_cursor[] =
  36 {
  37     { IDC_ARROW, 0 },
  38     { IDC_IBEAM, 0 },
  39     { IDC_WAIT, 0 },
  40     { IDC_CROSS, 0 },
  41     { IDC_UPARROW, 0 },
  42     { IDC_SIZE, 0 },
  43     { IDC_ICON, 0 },
  44     { IDC_SIZENWSE, 0 },
  45     { IDC_SIZENESW, 0 },
  46     { IDC_SIZEWE, 0 },
  47     { IDC_SIZENS, 0 }
  48 };
  49
  50 #define NB_SYS_CURSORS  (sizeof(system_cursor)/sizeof(system_cursor[0]))
  51
  52
  53 /**********************************************************************
  54  *                      LoadCursor [USER.173]
  55  */
  56 HCURSOR LoadCursor(HANDLE instance, LPSTR cursor_name)
  57 {
  58     XColor      bkcolor;
  59     XColor      fgcolor;
  60     HCURSOR     hCursor;
  61     HANDLE      rsc_mem;
  62     WORD        *lp;
  63     CURSORDESCRIP *lpcurdesc;
  64     CURSORALLOC   *lpcur;
  65     HDC         hdc;
  66     int i, j, image_size;
  67
  68     dprintf_resource(stddeb,"LoadCursor: instance = %04x, name = %p\n",
  69            instance, cursor_name);
  70     if (!instance)
  71     {
  72         for (i = 0; i < NB_SYS_CURSORS; i++)
  73             if (system_cursor[i].name == cursor_name)
  74             {
  75                 hCursor = system_cursor[i].cursor;
  76                 break;
  77             }
  78         if (i == NB_SYS_CURSORS) return 0;
  79         if (hCursor) return hCursor;
  80     }
  81     hCursor = GlobalAlloc(GMEM_MOVEABLE, sizeof(CURSORALLOC) + 1024L);
  82     if (hCursor == (HCURSOR)NULL) return 0;
  83     if (!instance) system_cursor[i].cursor = hCursor;
  84
  85     dprintf_cursor(stddeb,"LoadCursor Alloc hCursor=%X\n", hCursor);
  86     lpcur = (CURSORALLOC *)GlobalLock(hCursor);
  87     memset(lpcur, 0, sizeof(CURSORALLOC));
  88     if (instance == (HANDLE)NULL) {
  89         instance = hSysRes;
  90         switch((LONG)cursor_name) {
  91             case IDC_ARROW:
  92                 lpcur->xcursor = XCreateFontCursor(display, XC_top_left_arrow);
  93                 GlobalUnlock(hCursor);
  94                 return hCursor;
  95             case IDC_CROSS:
  96                 lpcur->xcursor = XCreateFontCursor(display, XC_crosshair);
  97                 GlobalUnlock(hCursor);
  98                 return hCursor;
  99             case IDC_IBEAM:
 100                 lpcur->xcursor = XCreateFontCursor(display, XC_xterm);
 101                 GlobalUnlock(hCursor);
 102                 return hCursor;
 103             case IDC_WAIT:
 104                 lpcur->xcursor = XCreateFontCursor(display, XC_watch);
 105                 GlobalUnlock(hCursor);
 106                 return hCursor;
 107             case IDC_SIZENS:
 108                 lpcur->xcursor = XCreateFontCursor(display, XC_sb_v_double_arrow);
 109                 GlobalUnlock(hCursor);
 110                 return hCursor;
 111             case IDC_SIZEWE:
 112                 lpcur->xcursor = XCreateFontCursor(display, XC_sb_h_double_arrow);
 113                 GlobalUnlock(hCursor);
 114                 return hCursor;
 115             case IDC_SIZENWSE:
 116             case IDC_SIZENESW:
 117                 lpcur->xcursor = XCreateFontCursor(display, XC_fleur);
 118                 GlobalUnlock(hCursor);
 119                 return hCursor;
 120             default:
 121                 break;
 122             }
 123         }
 124
 125 #if 1
 126     lpcur->xcursor = XCreateFontCursor(display, XC_top_left_arrow);
 127     GlobalUnlock(hCursor);
 128     return hCursor;
 129 #endif
 130
 131     if (!(hdc = GetDC(GetDesktopWindow()))) return 0;
 132     rsc_mem = RSC_LoadResource(instance, cursor_name, NE_RSCTYPE_GROUP_CURSOR,
 133                                &image_size);
 134     if (rsc_mem == (HANDLE)NULL) {
 135     fprintf(stderr,"LoadCursor / Cursor %p not Found !\n", cursor_name);
 136         ReleaseDC(GetDesktopWindow(), hdc);
 137         return 0;
 138         }
 139     lp = (WORD *)GlobalLock(rsc_mem);
 140     if (lp == NULL) {
 141         GlobalFree(rsc_mem);
 142         ReleaseDC(GetDesktopWindow(), hdc);
 143         return 0;
 144         }
 145     lpcurdesc = (CURSORDESCRIP *)(lp + 3);
 146     dprintf_cursor(stddeb,"LoadCursor / image_size=%d\n", image_size);
 147     dprintf_cursor(stddeb,"LoadCursor / curReserved=%X\n", *lp);
 148     dprintf_cursor(stddeb,"LoadCursor / curResourceType=%X\n", *(lp + 1));
 149     dprintf_cursor(stddeb,"LoadCursor / curResourceCount=%X\n", *(lp + 2));
 150     dprintf_cursor(stddeb,"LoadCursor / cursor Width=%d\n",
 151                 (int)lpcurdesc->Width);
 152     dprintf_cursor(stddeb,"LoadCursor / cursor Height=%d\n",
 153                 (int)lpcurdesc->Height);
 154     dprintf_cursor(stddeb,"LoadCursor / cursor curXHotspot=%d\n",
 155                 (int)lpcurdesc->curXHotspot);
 156     dprintf_cursor(stddeb,"LoadCursor / cursor curYHotspot=%d\n",
 157                 (int)lpcurdesc->curYHotspot);
 158     dprintf_cursor(stddeb,"LoadCursor / cursor curDIBSize=%lX\n",
 159                 (DWORD)lpcurdesc->curDIBSize);
 160     dprintf_cursor(stddeb,"LoadCursor / cursor curDIBOffset=%lX\n",
 161                 (DWORD)lpcurdesc->curDIBOffset);
 162     lpcur->descriptor = *lpcurdesc;
 163     GlobalUnlock(rsc_mem);
 164     GlobalFree(rsc_mem);
 165     rsc_mem = RSC_LoadResource(instance,
 166         MAKEINTRESOURCE(lpcurdesc->curDIBOffset),
 167         NE_RSCTYPE_CURSOR, &image_size);
 168     if (rsc_mem == (HANDLE)NULL) {
 169         fprintf(stderr,
 170                 "LoadCursor / Cursor %p Bitmap not Found !\n", cursor_name);
 171         ReleaseDC(GetDesktopWindow(), hdc);
 172         return 0;
 173         }
 174     lp = (WORD *)GlobalLock(rsc_mem);
 175     if (lp == NULL) {
 176         GlobalFree(rsc_mem);
 177         ReleaseDC(GetDesktopWindow(), hdc);
 178         return 0;
 179         }
 180         lp++;
 181     for (j = 0; j < 16; j++)
 182         dprintf_cursor(stddeb,"%04X ", *(lp + j));
 183 /*
 184     if (*lp == sizeof(BITMAPINFOHEADER))
 185         lpcur->hBitmap = ConvertInfoBitmap(hdc, (BITMAPINFO *)lp);
 186     else
 187 */
 188         lpcur->hBitmap = 0;
 189 /*     lp += sizeof(BITMAP); */
 190     for (i = 0; i < 81; i++) {
 191         char temp = *((char *)lp + 162 + i);
 192         *((char *)lp + 162 + i) = *((char *)lp + 324 - i);
 193         *((char *)lp + 324 - i) = temp;
 194         }
 195     lpcur->pixshape = XCreatePixmapFromBitmapData(
 196         display, DefaultRootWindow(display),
 197         ((char *)lp + 211), 32, 32,
 198 /*
 199         lpcurdesc->Width / 2, lpcurdesc->Height / 4,
 200 */
 201         WhitePixel(display, DefaultScreen(display)),
 202         BlackPixel(display, DefaultScreen(display)), 1);
 203     lpcur->pixmask = XCreatePixmapFromBitmapData(
 204         display, DefaultRootWindow(display),
 205         ((char *)lp + 211), 32, 32,
 206         WhitePixel(display, DefaultScreen(display)),
 207         BlackPixel(display, DefaultScreen(display)), 1);
 208     memset(&bkcolor, 0, sizeof(XColor));
 209     memset(&fgcolor, 0, sizeof(XColor));
 210     bkcolor.pixel = WhitePixel(display, DefaultScreen(display));
 211     fgcolor.pixel = BlackPixel(display, DefaultScreen(display));
 212     dprintf_cursor(stddeb,"LoadCursor / before XCreatePixmapCursor !\n");
 213     lpcur->xcursor = XCreatePixmapCursor(display,
 214         lpcur->pixshape, lpcur->pixmask,
 215         &fgcolor, &bkcolor, lpcur->descriptor.curXHotspot,
 216         lpcur->descriptor.curYHotspot);
 217     GlobalUnlock(rsc_mem);
 218     GlobalFree(rsc_mem);
 219 /*
 220     hCursor = CreateCursor(instance, lpcur->descriptor.curXHotspot,
 221         lpcur->descriptor.curYHotspot, 32, 32,
 222         (LPSTR)lp + 211, , (LPSTR)lp + 211);
 223 */
 224     XFreePixmap(display, lpcur->pixshape);
 225     XFreePixmap(display, lpcur->pixmask);
 226     ReleaseDC(GetDesktopWindow(), hdc);
 227     GlobalUnlock(hCursor);
 228     return hCursor;
 229 }
 230
 231
 232
 233 /**********************************************************************
 234  *                      CreateCursor [USER.406]
 235  */
 236 HCURSOR CreateCursor(HANDLE instance, short nXhotspot, short nYhotspot,
 237         short nWidth, short nHeight, LPSTR lpANDbitPlane, LPSTR lpXORbitPlane)
 238 {
 239     XColor      bkcolor;
 240     XColor      fgcolor;
 241     HCURSOR     hCursor;
 242     CURSORALLOC   *lpcur;
 243     HDC         hdc;
 244
 245     dprintf_resource(stddeb,"CreateCursor: inst=%04x nXhotspot=%d  nYhotspot=%d nWidth=%d nHeight=%d\n",
 246        instance, nXhotspot, nYhotspot, nWidth, nHeight);
 247     dprintf_resource(stddeb,"CreateCursor: inst=%04x lpANDbitPlane=%p lpXORbitPlane=%p\n",
 248         instance, lpANDbitPlane, lpXORbitPlane);
 249
 250     if (!(hdc = GetDC(GetDesktopWindow()))) return 0;
 251     hCursor = GlobalAlloc(GMEM_MOVEABLE, sizeof(CURSORALLOC) + 1024L);
 252     if (hCursor == (HCURSOR)NULL) {
 253         ReleaseDC(GetDesktopWindow(), hdc);
 254         return 0;
 255         }
 256     dprintf_cursor(stddeb,"CreateCursor Alloc hCursor=%X\n", hCursor);
 257     lpcur = (CURSORALLOC *)GlobalLock(hCursor);
 258     memset(lpcur, 0, sizeof(CURSORALLOC));
 259     lpcur->descriptor.curXHotspot = nXhotspot;
 260     lpcur->descriptor.curYHotspot = nYhotspot;
 261     lpcur->pixshape = XCreatePixmapFromBitmapData(
 262         display, DefaultRootWindow(display),
 263         lpXORbitPlane, nWidth, nHeight,
 264         WhitePixel(display, DefaultScreen(display)),
 265         BlackPixel(display, DefaultScreen(display)), 1);
 266     lpcur->pixmask = XCreatePixmapFromBitmapData(
 267         display, DefaultRootWindow(display),
 268         lpANDbitPlane, nWidth, nHeight,
 269         WhitePixel(display, DefaultScreen(display)),
 270         BlackPixel(display, DefaultScreen(display)), 1);
 271     memset(&bkcolor, 0, sizeof(XColor));
 272     memset(&fgcolor, 0, sizeof(XColor));
 273     bkcolor.pixel = WhitePixel(display, DefaultScreen(display));
 274     fgcolor.pixel = BlackPixel(display, DefaultScreen(display));
 275     lpcur->xcursor = XCreatePixmapCursor(display,
 276         lpcur->pixshape, lpcur->pixmask,
 277         &fgcolor, &bkcolor, lpcur->descriptor.curXHotspot,
 278         lpcur->descriptor.curYHotspot);
 279     XFreePixmap(display, lpcur->pixshape);
 280     XFreePixmap(display, lpcur->pixmask);
 281     ReleaseDC(GetDesktopWindow(), hdc);
 282     GlobalUnlock(hCursor);
 283     return hCursor;
 284 }
 285
 286
 287
 288 /**********************************************************************
 289  *                      DestroyCursor [USER.458]
 290  */
 291 BOOL DestroyCursor(HCURSOR hCursor)
 292 {
 293     CURSORALLOC *lpcur;
 294     if (hCursor == (HCURSOR)NULL) return FALSE;
 295     lpcur = (CURSORALLOC *)GlobalLock(hCursor);
 296     if (lpcur->hBitmap != (HBITMAP)NULL) DeleteObject(lpcur->hBitmap);
 297     GlobalUnlock(hCursor);
 298     GlobalFree(hCursor);
 299     return TRUE;
 300 }
 301
 302
 303 /**********************************************************************
 304  *         CURSOR_SetCursor
 305  *
 306  * Internal helper function for SetCursor() and ShowCursor().
 307  */
 308 static void CURSOR_SetCursor( HCURSOR hCursor )
 309 {
 310     CURSORALLOC *lpcur;
 311
 312     if (!(lpcur = (CURSORALLOC *)GlobalLock(hCursor))) return FALSE;
 313     if (rootWindow != DefaultRootWindow(display))
 314     {
 315         XDefineCursor( display, rootWindow, lpcur->xcursor );
 316     }
 317     else
 318     {
 319         HWND hwnd = GetWindow( GetDesktopWindow(), GW_CHILD );
 320         while(hwnd)
 321         {
 322             Window win = WIN_GetXWindow( hwnd );
 323             if (win) XDefineCursor( display, win, lpcur->xcursor );
 324             hwnd = GetWindow( hwnd, GW_HWNDNEXT );
 325         }
 326     }
 327     GlobalUnlock( hCursor );
 328 }
 329
 330 /**********************************************************************
 331  *                      SetCursor [USER.69]
 332  */
 333 HCURSOR SetCursor(HCURSOR hCursor)
 334 {
 335     HCURSOR hOldCursor;
 336
 337     dprintf_cursor(stddeb,"SetCursor / hCursor=%04X !\n", hCursor);
 338     hOldCursor = hActiveCursor;
 339     hActiveCursor = hCursor;
 340     if ((hCursor != hOldCursor) || (ShowCursCount < 0))
 341     {
 342         CURSOR_SetCursor( hCursor );
 343     }
 344     ShowCursCount = 0;
 345     return hOldCursor;
 346 }
 347
 348
 349 /**********************************************************************
 350  *                      GetCursor [USER.247]
 351  */
 352 HCURSOR GetCursor(void)
 353 {
 354     return hActiveCursor;
 355 }
 356
 357
 358 /**********************************************************************
 359  *                        SetCursorPos [USER.70]
 360  */
 361 void SetCursorPos(short x, short y)
 362 {
 363     dprintf_cursor(stddeb,"SetCursorPos // x=%d y=%d\n", x, y);
 364     XWarpPointer( display, None, rootWindow, 0, 0, 0, 0, x, y );
 365 }
 366
 367
 368 /**********************************************************************
 369  *                        GetCursorPos [USER.17]
 370  */
 371 void GetCursorPos(LPPOINT lpRetPoint)
 372 {
 373     Window      root, child;
 374     int         rootX, rootY;
 375     int         childX, childY;
 376     unsigned int mousebut;
 377
 378     if (!lpRetPoint) return;
 379     if (!XQueryPointer( display, rootWindow, &root, &child,
 380                         &rootX, &rootY, &childX, &childY, &mousebut ))
 381         lpRetPoint->x = lpRetPoint->y = 0;
 382     else
 383     {
 384         lpRetPoint->x = rootX + desktopX;
 385         lpRetPoint->y = rootY + desktopY;
 386     }
 387     dprintf_cursor(stddeb,
 388                 "GetCursorPos // x=%d y=%d\n", lpRetPoint->x, lpRetPoint->y);
 389 }
 390
 391
 392 /**********************************************************************
 393  *                      ShowCursor [USER.71]
 394  */
 395 int ShowCursor(BOOL bShow)
 396 {
 397     dprintf_cursor(stddeb, "ShowCursor(%d), count=%d\n", bShow, ShowCursCount);
 398
 399     if (bShow)
 400     {
 401         if (++ShowCursCount == 0)  /* Time to show it */
 402             CURSOR_SetCursor( hActiveCursor );
 403     }
 404     else  /* Hide it */
 405     {
 406         if (--ShowCursCount == -1)  /* Time to hide it */
 407         {
 408             if (!hEmptyCursor)
 409                 hEmptyCursor = CreateCursor( 0, 1, 1, 1, 1,
 410                                              "\xFF\xFF", "\xFF\xFF" );
 411             CURSOR_SetCursor( hEmptyCursor );
 412         }
 413     }
 414     return 0;
 415 }
 416
 417
 418 /**********************************************************************
 419  *                        ClipCursor [USER.16]
 420  */
 421 void ClipCursor(LPRECT lpNewClipRect)
 422 {
 423     CopyRect(&ClipCursorRect, lpNewClipRect);
 424 }
 425
 426
 427 /**********************************************************************
 428  *                        GetClipCursor [USER.309]
 429  */
 430 void GetClipCursor(LPRECT lpRetClipRect)
 431 {
 432     if (lpRetClipRect != NULL)
 433         CopyRect(lpRetClipRect, &ClipCursorRect);
 434 }
 435
 436
 437
 438