dlls/winemac.drv/mouse.c

   1 /*
   2  * MACDRV mouse driver
   3  *
   4  * Copyright 1998 Ulrich Weigand
   5  * Copyright 2007 Henri Verbeet
   6  * Copyright 2011, 2012, 2013 Ken Thomases for CodeWeavers Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include "macdrv.h"
  26 #define OEMRESOURCE
  27 #include "winuser.h"
  28 #include "winreg.h"
  29 #include "wine/server.h"
  30 #include "wine/unicode.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(cursor);
  33
  34
  35 static CRITICAL_SECTION cursor_cache_section;
  36 static CRITICAL_SECTION_DEBUG critsect_debug =
  37 {
  38     0, 0, &cursor_cache_section,
  39     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  40       0, 0, { (DWORD_PTR)(__FILE__ ": cursor_cache_section") }
  41 };
  42 static CRITICAL_SECTION cursor_cache_section = { &critsect_debug, -1, 0, 0, 0, 0 };
  43
  44 static CFMutableDictionaryRef cursor_cache;
  45
  46
  47 struct system_cursors
  48 {
  49     WORD id;
  50     CFStringRef name;
  51 };
  52
  53 static const struct system_cursors user32_cursors[] =
  54 {
  55     { OCR_NORMAL,      CFSTR("arrowCursor") },
  56     { OCR_IBEAM,       CFSTR("IBeamCursor") },
  57     { OCR_CROSS,       CFSTR("crosshairCursor") },
  58     { OCR_SIZEWE,      CFSTR("resizeLeftRightCursor") },
  59     { OCR_SIZENS,      CFSTR("resizeUpDownCursor") },
  60     { OCR_NO,          CFSTR("operationNotAllowedCursor") },
  61     { OCR_HAND,        CFSTR("pointingHandCursor") },
  62     { 0 }
  63 };
  64
  65 static const struct system_cursors comctl32_cursors[] =
  66 {
  67     { 102, CFSTR("closedHandCursor") },
  68     { 104, CFSTR("dragCopyCursor") },
  69     { 105, CFSTR("arrowCursor") },
  70     { 106, CFSTR("resizeLeftRightCursor") },
  71     { 107, CFSTR("resizeLeftRightCursor") },
  72     { 108, CFSTR("pointingHandCursor") },
  73     { 135, CFSTR("resizeUpDownCursor") },
  74     { 0 }
  75 };
  76
  77 static const struct system_cursors ole32_cursors[] =
  78 {
  79     { 1, CFSTR("operationNotAllowedCursor") },
  80     { 2, CFSTR("closedHandCursor") },
  81     { 3, CFSTR("dragCopyCursor") },
  82     { 4, CFSTR("dragLinkCursor") },
  83     { 0 }
  84 };
  85
  86 static const struct system_cursors riched20_cursors[] =
  87 {
  88     { 105, CFSTR("pointingHandCursor") },
  89     { 109, CFSTR("dragCopyCursor") },
  90     { 110, CFSTR("closedHandCursor") },
  91     { 111, CFSTR("operationNotAllowedCursor") },
  92     { 0 }
  93 };
  94
  95 static const struct
  96 {
  97     const struct system_cursors *cursors;
  98     WCHAR name[16];
  99 } module_cursors[] =
 100 {
 101     { user32_cursors, {'u','s','e','r','3','2','.','d','l','l',0} },
 102     { comctl32_cursors, {'c','o','m','c','t','l','3','2','.','d','l','l',0} },
 103     { ole32_cursors, {'o','l','e','3','2','.','d','l','l',0} },
 104     { riched20_cursors, {'r','i','c','h','e','d','2','0','.','d','l','l',0} }
 105 };
 106
 107 /* The names of NSCursor class methods which return cursor objects. */
 108 static const CFStringRef cocoa_cursor_names[] =
 109 {
 110     CFSTR("arrowCursor"),
 111     CFSTR("closedHandCursor"),
 112     CFSTR("contextualMenuCursor"),
 113     CFSTR("crosshairCursor"),
 114     CFSTR("disappearingItemCursor"),
 115     CFSTR("dragCopyCursor"),
 116     CFSTR("dragLinkCursor"),
 117     CFSTR("IBeamCursor"),
 118     CFSTR("IBeamCursorForVerticalLayout"),
 119     CFSTR("openHandCursor"),
 120     CFSTR("operationNotAllowedCursor"),
 121     CFSTR("pointingHandCursor"),
 122     CFSTR("resizeDownCursor"),
 123     CFSTR("resizeLeftCursor"),
 124     CFSTR("resizeLeftRightCursor"),
 125     CFSTR("resizeRightCursor"),
 126     CFSTR("resizeUpCursor"),
 127     CFSTR("resizeUpDownCursor"),
 128 };
 129
 130
 131 /***********************************************************************
 132  *              send_mouse_input
 133  *
 134  * Update the various window states on a mouse event.
 135  */
 136 static void send_mouse_input(HWND hwnd, macdrv_window cocoa_window, UINT flags, int x, int y,
 137                              DWORD mouse_data, BOOL drag, unsigned long time)
 138 {
 139     INPUT input;
 140     HWND top_level_hwnd;
 141
 142     top_level_hwnd = GetAncestor(hwnd, GA_ROOT);
 143
 144     if ((flags & MOUSEEVENTF_MOVE) && (flags & MOUSEEVENTF_ABSOLUTE) && !drag &&
 145         cocoa_window != macdrv_thread_data()->capture_window)
 146     {
 147         RECT rect;
 148
 149         /* update the wine server Z-order */
 150         SetRect(&rect, x, y, x + 1, y + 1);
 151         MapWindowPoints(0, top_level_hwnd, (POINT *)&rect, 2);
 152
 153         SERVER_START_REQ(update_window_zorder)
 154         {
 155             req->window      = wine_server_user_handle(top_level_hwnd);
 156             req->rect.left   = rect.left;
 157             req->rect.top    = rect.top;
 158             req->rect.right  = rect.right;
 159             req->rect.bottom = rect.bottom;
 160             wine_server_call(req);
 161         }
 162         SERVER_END_REQ;
 163     }
 164
 165     input.type              = INPUT_MOUSE;
 166     input.mi.dx             = x;
 167     input.mi.dy             = y;
 168     input.mi.mouseData      = mouse_data;
 169     input.mi.dwFlags        = flags;
 170     input.mi.time           = time;
 171     input.mi.dwExtraInfo    = 0;
 172
 173     __wine_send_input(top_level_hwnd, &input);
 174 }
 175
 176
 177 /***********************************************************************
 178  *              copy_system_cursor_name
 179  */
 180 CFStringRef copy_system_cursor_name(ICONINFOEXW *info)
 181 {
 182     static const WCHAR idW[] = {'%','h','u',0};
 183     const struct system_cursors *cursors;
 184     unsigned int i;
 185     CFStringRef cursor_name = NULL;
 186     HMODULE module;
 187     HKEY key;
 188     WCHAR *p, name[MAX_PATH * 2];
 189
 190     TRACE("info->szModName %s info->szResName %s info->wResID %hu\n", debugstr_w(info->szModName),
 191           debugstr_w(info->szResName), info->wResID);
 192
 193     if (!info->szModName[0]) return NULL;
 194
 195     p = strrchrW(info->szModName, '\\');
 196     strcpyW(name, p ? p + 1 : info->szModName);
 197     p = name + strlenW(name);
 198     *p++ = ',';
 199     if (info->szResName[0]) strcpyW(p, info->szResName);
 200     else sprintfW(p, idW, info->wResID);
 201
 202     /* @@ Wine registry key: HKCU\Software\Wine\Mac Driver\Cursors */
 203     if (!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Mac Driver\\Cursors", &key))
 204     {
 205         WCHAR value[64];
 206         DWORD size, ret;
 207
 208         value[0] = 0;
 209         size = sizeof(value) / sizeof(WCHAR);
 210         ret = RegQueryValueExW(key, name, NULL, NULL, (BYTE *)value, &size);
 211         RegCloseKey(key);
 212         if (!ret)
 213         {
 214             if (!value[0])
 215             {
 216                 TRACE("registry forces standard cursor for %s\n", debugstr_w(name));
 217                 return NULL; /* force standard cursor */
 218             }
 219
 220             cursor_name = CFStringCreateWithCharacters(NULL, value, strlenW(value));
 221             if (!cursor_name)
 222             {
 223                 WARN("CFStringCreateWithCharacters failed for %s\n", debugstr_w(value));
 224                 return NULL;
 225             }
 226
 227             /* Make sure it's one of the appropriate NSCursor class methods. */
 228             for (i = 0; i < sizeof(cocoa_cursor_names) / sizeof(cocoa_cursor_names[0]); i++)
 229                 if (CFEqual(cursor_name, cocoa_cursor_names[i]))
 230                     goto done;
 231
 232             WARN("%s mapped to invalid Cocoa cursor name %s\n", debugstr_w(name), debugstr_w(value));
 233             CFRelease(cursor_name);
 234             return NULL;
 235         }
 236     }
 237
 238     if (info->szResName[0]) goto done;  /* only integer resources are supported here */
 239     if (!(module = GetModuleHandleW(info->szModName))) goto done;
 240
 241     for (i = 0; i < sizeof(module_cursors)/sizeof(module_cursors[0]); i++)
 242         if (GetModuleHandleW(module_cursors[i].name) == module) break;
 243     if (i == sizeof(module_cursors)/sizeof(module_cursors[0])) goto done;
 244
 245     cursors = module_cursors[i].cursors;
 246     for (i = 0; cursors[i].id; i++)
 247         if (cursors[i].id == info->wResID)
 248         {
 249             cursor_name = CFRetain(cursors[i].name);
 250             break;
 251         }
 252
 253 done:
 254     if (cursor_name)
 255         TRACE("%s -> %s\n", debugstr_w(name), debugstr_cf(cursor_name));
 256     else
 257         WARN("no system cursor found for %s\n", debugstr_w(name));
 258     return cursor_name;
 259 }
 260
 261 /***********************************************************************
 262  *              create_monochrome_cursor
 263  */
 264 CFArrayRef create_monochrome_cursor(HDC hdc, const ICONINFOEXW *icon, int width, int height)
 265 {
 266     char buffer[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
 267     BITMAPINFO *info = (BITMAPINFO *)buffer;
 268     unsigned int width_bytes = (width + 31) / 32 * 4;
 269     unsigned long *and_bits = NULL, *xor_bits;
 270     unsigned long *data_bits;
 271     int count, i;
 272     CGColorSpaceRef colorspace;
 273     CFMutableDataRef data;
 274     CGDataProviderRef provider;
 275     CGImageRef cgimage, cgmask, cgmasked;
 276     CGPoint hot_spot;
 277     CFDictionaryRef hot_spot_dict;
 278     const CFStringRef keys[] = { CFSTR("image"), CFSTR("hotSpot") };
 279     CFTypeRef values[sizeof(keys) / sizeof(keys[0])];
 280     CFDictionaryRef frame;
 281     CFArrayRef frames;
 282
 283     TRACE("hdc %p icon->hbmMask %p icon->xHotspot %d icon->yHotspot %d width %d height %d\n",
 284           hdc, icon->hbmMask, icon->xHotspot, icon->yHotspot, width, height);
 285
 286     info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 287     info->bmiHeader.biWidth = width;
 288     info->bmiHeader.biHeight = -height * 2;
 289     info->bmiHeader.biPlanes = 1;
 290     info->bmiHeader.biBitCount = 1;
 291     info->bmiHeader.biCompression = BI_RGB;
 292     info->bmiHeader.biSizeImage = width_bytes * height * 2;
 293     info->bmiHeader.biXPelsPerMeter = 0;
 294     info->bmiHeader.biYPelsPerMeter = 0;
 295     info->bmiHeader.biClrUsed = 0;
 296     info->bmiHeader.biClrImportant = 0;
 297
 298     and_bits = HeapAlloc(GetProcessHeap(), 0, info->bmiHeader.biSizeImage);
 299     if (!and_bits)
 300     {
 301         WARN("failed to allocate and_bits\n");
 302         return NULL;
 303     }
 304     xor_bits = (unsigned long*)((char*)and_bits + info->bmiHeader.biSizeImage / 2);
 305
 306     if (!GetDIBits(hdc, icon->hbmMask, 0, height * 2, and_bits, info, DIB_RGB_COLORS))
 307     {
 308         WARN("GetDIBits failed\n");
 309         HeapFree(GetProcessHeap(), 0, and_bits);
 310         return NULL;
 311     }
 312
 313     /* On Windows, the pixels of a monochrome cursor can have four effects:
 314        draw black, draw white, leave unchanged (transparent), or invert.  The Mac
 315        only supports the first three.  It can't do pixels which invert the
 316        background.  Since the background is usually white, I am arbitrarily
 317        mapping "invert" to "draw black".  This entails bitwise math between the
 318        cursor's AND mask and XOR mask:
 319
 320             AND | XOR | Windows cursor pixel
 321             --------------------------------
 322              0  |  0  | black
 323              0  |  1  | white
 324              1  |  0  | transparent
 325              1  |  1  | invert
 326
 327             AND | XOR | Mac image
 328             ---------------------
 329              0  |  0  | black (0)
 330              0  |  1  | white (1)
 331              1  |  0  | don't care
 332              1  |  1  | black (0)
 333
 334             AND | XOR | Mac mask
 335             ---------------------------
 336              0  |  0  | paint (0)
 337              0  |  1  | paint (0)
 338              1  |  0  | don't paint (1)
 339              1  |  1  | paint (0)
 340
 341        So, Mac image = AND ^ XOR and Mac mask = AND & ~XOR.
 342       */
 343     /* Create data for Mac image. */
 344     data = CFDataCreateMutable(NULL, info->bmiHeader.biSizeImage / 2);
 345     if (!data)
 346     {
 347         WARN("failed to create data\n");
 348         HeapFree(GetProcessHeap(), 0, and_bits);
 349         return NULL;
 350     }
 351
 352     /* image data = AND mask */
 353     CFDataAppendBytes(data, (UInt8*)and_bits, info->bmiHeader.biSizeImage / 2);
 354     /* image data ^= XOR mask */
 355     data_bits = (unsigned long*)CFDataGetMutableBytePtr(data);
 356     count = (info->bmiHeader.biSizeImage / 2) / sizeof(*data_bits);
 357     for (i = 0; i < count; i++)
 358         data_bits[i] ^= xor_bits[i];
 359
 360     colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
 361     if (!colorspace)
 362     {
 363         WARN("failed to create colorspace\n");
 364         CFRelease(data);
 365         HeapFree(GetProcessHeap(), 0, and_bits);
 366         return NULL;
 367     }
 368
 369     provider = CGDataProviderCreateWithCFData(data);
 370     CFRelease(data);
 371     if (!provider)
 372     {
 373         WARN("failed to create data provider\n");
 374         CGColorSpaceRelease(colorspace);
 375         HeapFree(GetProcessHeap(), 0, and_bits);
 376         return NULL;
 377     }
 378
 379     cgimage = CGImageCreate(width, height, 1, 1, width_bytes, colorspace,
 380                             kCGImageAlphaNone | kCGBitmapByteOrderDefault,
 381                             provider, NULL, FALSE, kCGRenderingIntentDefault);
 382     CGDataProviderRelease(provider);
 383     CGColorSpaceRelease(colorspace);
 384     if (!cgimage)
 385     {
 386         WARN("failed to create image\n");
 387         HeapFree(GetProcessHeap(), 0, and_bits);
 388         return NULL;
 389     }
 390
 391     /* Create data for mask. */
 392     data = CFDataCreateMutable(NULL, info->bmiHeader.biSizeImage / 2);
 393     if (!data)
 394     {
 395         WARN("failed to create data\n");
 396         CGImageRelease(cgimage);
 397         HeapFree(GetProcessHeap(), 0, and_bits);
 398         return NULL;
 399     }
 400
 401     /* mask data = AND mask */
 402     CFDataAppendBytes(data, (UInt8*)and_bits, info->bmiHeader.biSizeImage / 2);
 403     /* mask data &= ~XOR mask */
 404     data_bits = (unsigned long*)CFDataGetMutableBytePtr(data);
 405     for (i = 0; i < count; i++)
 406         data_bits[i] &= ~xor_bits[i];
 407     HeapFree(GetProcessHeap(), 0, and_bits);
 408
 409     provider = CGDataProviderCreateWithCFData(data);
 410     CFRelease(data);
 411     if (!provider)
 412     {
 413         WARN("failed to create data provider\n");
 414         CGImageRelease(cgimage);
 415         return NULL;
 416     }
 417
 418     cgmask = CGImageMaskCreate(width, height, 1, 1, width_bytes, provider, NULL, FALSE);
 419     CGDataProviderRelease(provider);
 420     if (!cgmask)
 421     {
 422         WARN("failed to create mask image\n");
 423         CGImageRelease(cgimage);
 424         return NULL;
 425     }
 426
 427     cgmasked = CGImageCreateWithMask(cgimage, cgmask);
 428     CGImageRelease(cgimage);
 429     CGImageRelease(cgmask);
 430     if (!cgmasked)
 431     {
 432         WARN("failed to create masked image\n");
 433         return NULL;
 434     }
 435
 436     hot_spot = CGPointMake(icon->xHotspot, icon->yHotspot);
 437     hot_spot_dict = CGPointCreateDictionaryRepresentation(hot_spot);
 438     if (!hot_spot_dict)
 439     {
 440         WARN("failed to create hot spot dictionary\n");
 441         CGImageRelease(cgmasked);
 442         return NULL;
 443     }
 444
 445     values[0] = cgmasked;
 446     values[1] = hot_spot_dict;
 447     frame = CFDictionaryCreate(NULL, (const void**)keys, values, sizeof(keys) / sizeof(keys[0]),
 448                                &kCFCopyStringDictionaryKeyCallBacks,
 449                                &kCFTypeDictionaryValueCallBacks);
 450     CFRelease(hot_spot_dict);
 451     CGImageRelease(cgmasked);
 452     if (!frame)
 453     {
 454         WARN("failed to create frame dictionary\n");
 455         return NULL;
 456     }
 457
 458     frames = CFArrayCreate(NULL, (const void**)&frame, 1, &kCFTypeArrayCallBacks);
 459     CFRelease(frame);
 460     if (!frames)
 461     {
 462         WARN("failed to create frames array\n");
 463         return NULL;
 464     }
 465
 466     return frames;
 467 }
 468
 469
 470 /***********************************************************************
 471  *              create_cursor_frame
 472  *
 473  * Create a frame dictionary for a cursor from a Windows icon.
 474  * Keys:
 475  *      "image"     a CGImage for the frame
 476  *      "duration"  a CFNumber for the frame duration in seconds
 477  *      "hotSpot"   a CFDictionary encoding a CGPoint for the hot spot
 478  */
 479 static CFDictionaryRef create_cursor_frame(HDC hdc, const ICONINFOEXW *iinfo, HANDLE icon,
 480                                            HBITMAP hbmColor, unsigned char *color_bits, int color_size,
 481                                            HBITMAP hbmMask, unsigned char *mask_bits, int mask_size,
 482                                            int width, int height, int istep)
 483 {
 484     DWORD delay_jiffies, num_steps;
 485     CFMutableDictionaryRef frame;
 486     CGPoint hot_spot;
 487     CFDictionaryRef hot_spot_dict;
 488     double duration;
 489     CFNumberRef duration_number;
 490     CGImageRef cgimage;
 491
 492     TRACE("hdc %p iinfo->xHotspot %d iinfo->yHotspot %d icon %p hbmColor %p color_bits %p color_size %d"
 493           " hbmMask %p mask_bits %p mask_size %d width %d height %d istep %d\n",
 494           hdc, iinfo->xHotspot, iinfo->yHotspot, icon, hbmColor, color_bits, color_size,
 495           hbmMask, mask_bits, mask_size, width, height, istep);
 496
 497     frame = CFDictionaryCreateMutable(NULL, 0, &kCFCopyStringDictionaryKeyCallBacks,
 498                                       &kCFTypeDictionaryValueCallBacks);
 499     if (!frame)
 500     {
 501         WARN("failed to allocate dictionary for frame\n");
 502         return NULL;
 503     }
 504
 505     hot_spot = CGPointMake(iinfo->xHotspot, iinfo->yHotspot);
 506     hot_spot_dict = CGPointCreateDictionaryRepresentation(hot_spot);
 507     if (!hot_spot_dict)
 508     {
 509         WARN("failed to create hot spot dictionary\n");
 510         CFRelease(frame);
 511         return NULL;
 512     }
 513     CFDictionarySetValue(frame, CFSTR("hotSpot"), hot_spot_dict);
 514     CFRelease(hot_spot_dict);
 515
 516     if (GetCursorFrameInfo(icon, 0x0 /* unknown parameter */, istep, &delay_jiffies, &num_steps) != 0)
 517         duration = delay_jiffies / 60.0; /* convert jiffies (1/60s) to seconds */
 518     else
 519     {
 520         WARN("Failed to retrieve animated cursor frame-rate for frame %d.\n", istep);
 521         duration = 0.1; /* fallback delay, 100 ms */
 522     }
 523     duration_number = CFNumberCreate(NULL, kCFNumberDoubleType, &duration);
 524     if (!duration_number)
 525     {
 526         WARN("failed to create duration number\n");
 527         CFRelease(frame);
 528         return NULL;
 529     }
 530     CFDictionarySetValue(frame, CFSTR("duration"), duration_number);
 531     CFRelease(duration_number);
 532
 533     cgimage = create_cgimage_from_icon_bitmaps(hdc, icon, hbmColor, color_bits, color_size,
 534                                                hbmMask, mask_bits, mask_size, width, height, istep);
 535     if (!cgimage)
 536     {
 537         CFRelease(frame);
 538         return NULL;
 539     }
 540
 541     CFDictionarySetValue(frame, CFSTR("image"), cgimage);
 542     CGImageRelease(cgimage);
 543
 544     return frame;
 545 }
 546
 547
 548 /***********************************************************************
 549  *              create_color_cursor
 550  *
 551  * Create an array of color cursor frames from a Windows cursor.  Each
 552  * frame is represented in the array by a dictionary.
 553  * Frame dictionary keys:
 554  *      "image"     a CGImage for the frame
 555  *      "duration"  a CFNumber for the frame duration in seconds
 556  *      "hotSpot"   a CFDictionary encoding a CGPoint for the hot spot
 557  */
 558 static CFArrayRef create_color_cursor(HDC hdc, const ICONINFOEXW *iinfo, HANDLE icon, int width, int height)
 559 {
 560     unsigned char *color_bits, *mask_bits;
 561     HBITMAP hbmColor = 0, hbmMask = 0;
 562     DWORD nFrames, delay_jiffies, i;
 563     int color_size, mask_size;
 564     BITMAPINFO *info = NULL;
 565     CFMutableArrayRef frames;
 566
 567     TRACE("hdc %p iinfo %p icon %p width %d height %d\n", hdc, iinfo, icon, width, height);
 568
 569     /* Retrieve the number of frames to render */
 570     if (!GetCursorFrameInfo(icon, 0x0 /* unknown parameter */, 0, &delay_jiffies, &nFrames))
 571     {
 572         WARN("GetCursorFrameInfo failed\n");
 573         return NULL;
 574     }
 575     if (!(frames = CFArrayCreateMutable(NULL, nFrames, &kCFTypeArrayCallBacks)))
 576     {
 577         WARN("failed to allocate frames array\n");
 578         return NULL;
 579     }
 580
 581     /* Allocate all of the resources necessary to obtain a cursor frame */
 582     if (!(info = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(BITMAPINFO, bmiColors[256])))) goto cleanup;
 583     info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 584     info->bmiHeader.biWidth = width;
 585     info->bmiHeader.biHeight = -height;
 586     info->bmiHeader.biPlanes = 1;
 587     info->bmiHeader.biCompression = BI_RGB;
 588     info->bmiHeader.biXPelsPerMeter = 0;
 589     info->bmiHeader.biYPelsPerMeter = 0;
 590     info->bmiHeader.biClrUsed = 0;
 591     info->bmiHeader.biClrImportant = 0;
 592     info->bmiHeader.biBitCount = 32;
 593     color_size = width * height * 4;
 594     info->bmiHeader.biSizeImage = color_size;
 595     hbmColor = CreateDIBSection(hdc, info, DIB_RGB_COLORS, (VOID **) &color_bits, NULL, 0);
 596     if (!hbmColor)
 597     {
 598         WARN("failed to create DIB section for cursor color data\n");
 599         goto cleanup;
 600     }
 601     info->bmiHeader.biBitCount = 1;
 602     info->bmiColors[0].rgbRed      = 0;
 603     info->bmiColors[0].rgbGreen    = 0;
 604     info->bmiColors[0].rgbBlue     = 0;
 605     info->bmiColors[0].rgbReserved = 0;
 606     info->bmiColors[1].rgbRed      = 0xff;
 607     info->bmiColors[1].rgbGreen    = 0xff;
 608     info->bmiColors[1].rgbBlue     = 0xff;
 609     info->bmiColors[1].rgbReserved = 0;
 610
 611     mask_size = ((width + 31) / 32 * 4) * height; /* width_bytes * height */
 612     info->bmiHeader.biSizeImage = mask_size;
 613     hbmMask = CreateDIBSection(hdc, info, DIB_RGB_COLORS, (VOID **) &mask_bits, NULL, 0);
 614     if (!hbmMask)
 615     {
 616         WARN("failed to create DIB section for cursor mask data\n");
 617         goto cleanup;
 618     }
 619
 620     /* Create a CFDictionary for each frame of the cursor */
 621     for (i = 0; i < nFrames; i++)
 622     {
 623         CFDictionaryRef frame = create_cursor_frame(hdc, iinfo, icon,
 624                                                     hbmColor, color_bits, color_size,
 625                                                     hbmMask, mask_bits, mask_size,
 626                                                     width, height, i);
 627         if (!frame) goto cleanup;
 628         CFArrayAppendValue(frames, frame);
 629         CFRelease(frame);
 630     }
 631
 632 cleanup:
 633     if (CFArrayGetCount(frames) < nFrames)
 634     {
 635         CFRelease(frames);
 636         frames = NULL;
 637     }
 638     else
 639         TRACE("returning cursor with %d frames\n", nFrames);
 640     /* Cleanup all of the resources used to obtain the frame data */
 641     if (hbmColor) DeleteObject(hbmColor);
 642     if (hbmMask) DeleteObject(hbmMask);
 643     HeapFree(GetProcessHeap(), 0, info);
 644     return frames;
 645 }
 646
 647
 648 /***********************************************************************
 649  *              DestroyCursorIcon (MACDRV.@)
 650  */
 651 void CDECL macdrv_DestroyCursorIcon(HCURSOR cursor)
 652 {
 653     TRACE("cursor %p\n", cursor);
 654
 655     EnterCriticalSection(&cursor_cache_section);
 656     if (cursor_cache)
 657         CFDictionaryRemoveValue(cursor_cache, cursor);
 658     LeaveCriticalSection(&cursor_cache_section);
 659 }
 660
 661
 662 /***********************************************************************
 663  *              ClipCursor (MACDRV.@)
 664  *
 665  * Set the cursor clipping rectangle.
 666  */
 667 BOOL CDECL macdrv_ClipCursor(LPCRECT clip)
 668 {
 669     CGRect rect;
 670
 671     TRACE("%s\n", wine_dbgstr_rect(clip));
 672
 673     if (clip)
 674     {
 675         rect = CGRectMake(clip->left, clip->top, max(1, clip->right - clip->left),
 676                           max(1, clip->bottom - clip->top));
 677     }
 678     else
 679         rect = CGRectInfinite;
 680
 681     /* FIXME: This needs to be done not just in this process but in all of the
 682        ones for this WINEPREFIX.  Broadcast a message to do that. */
 683
 684     return macdrv_clip_cursor(rect);
 685 }
 686
 687
 688 /***********************************************************************
 689  *              GetCursorPos (MACDRV.@)
 690  */
 691 BOOL CDECL macdrv_GetCursorPos(LPPOINT pos)
 692 {
 693     CGPoint pt;
 694     BOOL ret;
 695
 696     ret = macdrv_get_cursor_position(&pt);
 697     if (ret)
 698     {
 699         TRACE("pointer at (%g,%g) server pos %d,%d\n", pt.x, pt.y, pos->x, pos->y);
 700         pos->x = floor(pt.x);
 701         pos->y = floor(pt.y);
 702     }
 703     return ret;
 704 }
 705
 706
 707 /***********************************************************************
 708  *              SetCapture (MACDRV.@)
 709  */
 710  void CDECL macdrv_SetCapture(HWND hwnd, UINT flags)
 711 {
 712     struct macdrv_thread_data *thread_data = macdrv_thread_data();
 713     HWND top = GetAncestor(hwnd, GA_ROOT);
 714     macdrv_window cocoa_window = macdrv_get_cocoa_window(top, FALSE);
 715
 716     TRACE("hwnd %p top %p/%p flags 0x%08x\n", hwnd, top, cocoa_window, flags);
 717
 718     if (!thread_data) return;
 719
 720     thread_data->capture_window = cocoa_window;
 721     macdrv_set_mouse_capture_window(cocoa_window);
 722 }
 723
 724
 725 /***********************************************************************
 726  *              SetCursor (MACDRV.@)
 727  */
 728 void CDECL macdrv_SetCursor(HCURSOR cursor)
 729 {
 730     CFStringRef cursor_name = NULL;
 731     CFArrayRef cursor_frames = NULL;
 732
 733     TRACE("%p\n", cursor);
 734
 735     if (cursor)
 736     {
 737         ICONINFOEXW info;
 738
 739         EnterCriticalSection(&cursor_cache_section);
 740         if (cursor_cache)
 741         {
 742             CFTypeRef cached_cursor = CFDictionaryGetValue(cursor_cache, cursor);
 743             if (cached_cursor)
 744             {
 745                 if (CFGetTypeID(cached_cursor) == CFStringGetTypeID())
 746                     cursor_name = CFRetain(cached_cursor);
 747                 else
 748                     cursor_frames = CFRetain(cached_cursor);
 749             }
 750         }
 751         LeaveCriticalSection(&cursor_cache_section);
 752         if (cursor_name || cursor_frames)
 753             goto done;
 754
 755         info.cbSize = sizeof(info);
 756         if (!GetIconInfoExW(cursor, &info))
 757         {
 758             WARN("GetIconInfoExW failed\n");
 759             return;
 760         }
 761
 762         if ((cursor_name = copy_system_cursor_name(&info)))
 763         {
 764             DeleteObject(info.hbmColor);
 765             DeleteObject(info.hbmMask);
 766         }
 767         else
 768         {
 769             BITMAP bm;
 770             HDC hdc;
 771
 772             GetObjectW(info.hbmMask, sizeof(bm), &bm);
 773             if (!info.hbmColor) bm.bmHeight = max(1, bm.bmHeight / 2);
 774
 775             /* make sure hotspot is valid */
 776             if (info.xHotspot >= bm.bmWidth || info.yHotspot >= bm.bmHeight)
 777             {
 778                 info.xHotspot = bm.bmWidth / 2;
 779                 info.yHotspot = bm.bmHeight / 2;
 780             }
 781
 782             hdc = CreateCompatibleDC(0);
 783
 784             if (info.hbmColor)
 785             {
 786                 cursor_frames = create_color_cursor(hdc, &info, cursor, bm.bmWidth, bm.bmHeight);
 787                 DeleteObject(info.hbmColor);
 788             }
 789             else
 790                 cursor_frames = create_monochrome_cursor(hdc, &info, bm.bmWidth, bm.bmHeight);
 791
 792             DeleteObject(info.hbmMask);
 793             DeleteDC(hdc);
 794         }
 795
 796         if (cursor_name || cursor_frames)
 797         {
 798             EnterCriticalSection(&cursor_cache_section);
 799             if (!cursor_cache)
 800                 cursor_cache = CFDictionaryCreateMutable(NULL, 0, NULL,
 801                                                          &kCFTypeDictionaryValueCallBacks);
 802             CFDictionarySetValue(cursor_cache, cursor,
 803                                  cursor_name ? (CFTypeRef)cursor_name : (CFTypeRef)cursor_frames);
 804             LeaveCriticalSection(&cursor_cache_section);
 805         }
 806         else
 807             cursor_name = CFRetain(CFSTR("arrowCursor"));
 808     }
 809
 810 done:
 811     TRACE("setting cursor with cursor_name %s cursor_frames %p\n", debugstr_cf(cursor_name), cursor_frames);
 812     macdrv_set_cursor(cursor_name, cursor_frames);
 813     if (cursor_name) CFRelease(cursor_name);
 814     if (cursor_frames) CFRelease(cursor_frames);
 815 }
 816
 817
 818 /***********************************************************************
 819  *              SetCursorPos (MACDRV.@)
 820  */
 821 BOOL CDECL macdrv_SetCursorPos(INT x, INT y)
 822 {
 823     BOOL ret = macdrv_set_cursor_position(CGPointMake(x, y));
 824     if (ret)
 825         TRACE("warped to %d,%d\n", x, y);
 826     else
 827         ERR("failed to warp to %d,%d\n", x, y);
 828     return ret;
 829 }
 830
 831
 832 /***********************************************************************
 833  *              macdrv_mouse_button
 834  *
 835  * Handler for MOUSE_BUTTON events.
 836  */
 837 void macdrv_mouse_button(HWND hwnd, const macdrv_event *event)
 838 {
 839     UINT flags = 0;
 840     WORD data = 0;
 841
 842     TRACE("win %p button %d %s at (%d,%d) time %lu (%lu ticks ago)\n", hwnd, event->mouse_button.button,
 843           (event->mouse_button.pressed ? "pressed" : "released"),
 844           event->mouse_button.x, event->mouse_button.y,
 845           event->mouse_button.time_ms, (GetTickCount() - event->mouse_button.time_ms));
 846
 847     if (event->mouse_button.pressed)
 848     {
 849         switch (event->mouse_button.button)
 850         {
 851         case 0: flags |= MOUSEEVENTF_LEFTDOWN; break;
 852         case 1: flags |= MOUSEEVENTF_RIGHTDOWN; break;
 853         case 2: flags |= MOUSEEVENTF_MIDDLEDOWN; break;
 854         default:
 855             flags |= MOUSEEVENTF_XDOWN;
 856             data = 1 << (event->mouse_button.button - 3);
 857             break;
 858         }
 859     }
 860     else
 861     {
 862         switch (event->mouse_button.button)
 863         {
 864         case 0: flags |= MOUSEEVENTF_LEFTUP; break;
 865         case 1: flags |= MOUSEEVENTF_RIGHTUP; break;
 866         case 2: flags |= MOUSEEVENTF_MIDDLEUP; break;
 867         default:
 868             flags |= MOUSEEVENTF_XUP;
 869             data = 1 << (event->mouse_button.button - 3);
 870             break;
 871         }
 872     }
 873
 874     send_mouse_input(hwnd, event->window, flags | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE,
 875                      event->mouse_button.x, event->mouse_button.y,
 876                      data, FALSE, event->mouse_button.time_ms);
 877 }
 878
 879
 880 /***********************************************************************
 881  *              macdrv_mouse_moved
 882  *
 883  * Handler for MOUSE_MOVED and MOUSE_MOVED_ABSOLUTE events.
 884  */
 885 void macdrv_mouse_moved(HWND hwnd, const macdrv_event *event)
 886 {
 887     UINT flags = MOUSEEVENTF_MOVE;
 888
 889     TRACE("win %p/%p %s (%d,%d) drag %d time %lu (%lu ticks ago)\n", hwnd, event->window,
 890           (event->type == MOUSE_MOVED) ? "relative" : "absolute",
 891           event->mouse_moved.x, event->mouse_moved.y, event->mouse_moved.drag,
 892           event->mouse_moved.time_ms, (GetTickCount() - event->mouse_moved.time_ms));
 893
 894     if (event->type == MOUSE_MOVED_ABSOLUTE)
 895         flags |= MOUSEEVENTF_ABSOLUTE;
 896
 897     send_mouse_input(hwnd, event->window, flags, event->mouse_moved.x, event->mouse_moved.y,
 898                      0, event->mouse_moved.drag, event->mouse_moved.time_ms);
 899 }
 900
 901
 902 /***********************************************************************
 903  *              macdrv_mouse_scroll
 904  *
 905  * Handler for MOUSE_SCROLL events.
 906  */
 907 void macdrv_mouse_scroll(HWND hwnd, const macdrv_event *event)
 908 {
 909     TRACE("win %p/%p scroll (%d,%d) at (%d,%d) time %lu (%lu ticks ago)\n", hwnd,
 910           event->window, event->mouse_scroll.x_scroll, event->mouse_scroll.y_scroll,
 911           event->mouse_scroll.x, event->mouse_scroll.y,
 912           event->mouse_scroll.time_ms, (GetTickCount() - event->mouse_scroll.time_ms));
 913
 914     if (event->mouse_scroll.y_scroll)
 915         send_mouse_input(hwnd, event->window, MOUSEEVENTF_WHEEL | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE,
 916                          event->mouse_scroll.x, event->mouse_scroll.y,
 917                          event->mouse_scroll.y_scroll, FALSE, event->mouse_scroll.time_ms);
 918     if (event->mouse_scroll.x_scroll)
 919         send_mouse_input(hwnd, event->window, MOUSEEVENTF_HWHEEL | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE,
 920                          event->mouse_scroll.x, event->mouse_scroll.y,
 921                          event->mouse_scroll.x_scroll, FALSE, event->mouse_scroll.time_ms);
 922 }
 923
 924
 925 /***********************************************************************
 926  *              macdrv_release_capture
 927  *
 928  * Handler for RELEASE_CAPTURE events.
 929  */
 930 void macdrv_release_capture(HWND hwnd, const macdrv_event *event)
 931 {
 932     struct macdrv_thread_data *thread_data = macdrv_thread_data();
 933     HWND capture = GetCapture();
 934     HWND capture_top = GetAncestor(capture, GA_ROOT);
 935
 936     TRACE("win %p/%p thread_data->capture_window %p GetCapture() %p in %p\n", hwnd,
 937           event->window, thread_data->capture_window, capture, capture_top);
 938
 939     if (event->window == thread_data->capture_window && hwnd == capture_top)
 940     {
 941         ReleaseCapture();
 942         if (!PostMessageW(capture, WM_CANCELMODE, 0, 0))
 943             WARN("failed to post WM_CANCELMODE; error 0x%08x\n", GetLastError());
 944     }
 945 }