dlls/win32u/cursoricon.c

   1 /*
   2  * Cursor and icon support
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  * Copyright 1996 Martin Von Loewis
   6  * Copyright 1997 Alex Korobka
   7  * Copyright 1998 Turchanov Sergey
   8  * Copyright 2007 Henri Verbeet
   9  * Copyright 2009 Vincent Povirk for CodeWeavers
  10  * Copyright 2016 Dmitry Timoshkov
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  25  */
  26
  27 #if 0
  28 #pragma makedep unix
  29 #endif
  30
  31 #include <assert.h>
  32 #include "ntgdi_private.h"
  33 #include "ntuser_private.h"
  34 #include "wine/server.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(cursor);
  38 WINE_DECLARE_DEBUG_CHANNEL(icon);
  39
  40 struct cursoricon_object
  41 {
  42     struct user_object      obj;        /* object header */
  43     struct list             entry;      /* entry in shared icons list */
  44     ULONG_PTR               param;      /* opaque param used by 16-bit code */
  45     UNICODE_STRING          module;     /* module for icons loaded from resources */
  46     WCHAR                  *resname;    /* resource name for icons loaded from resources */
  47     HRSRC                   rsrc;       /* resource for shared icons */
  48     BOOL                    is_shared;  /* whether this object is shared */
  49     BOOL                    is_icon;    /* whether icon or cursor */
  50     BOOL                    is_ani;     /* whether this object is a static cursor or an animated cursor */
  51     UINT                    delay;      /* delay between this frame and the next (in jiffies) */
  52     union
  53     {
  54         struct cursoricon_frame  frame; /* frame-specific icon data */
  55         struct
  56         {
  57             UINT  num_frames;           /* number of frames in the icon/cursor */
  58             UINT  num_steps;            /* number of sequence steps in the icon/cursor */
  59             HICON *frames;              /* list of animated cursor frames */
  60         } ani;
  61     };
  62 };
  63
  64 static struct list icon_cache = LIST_INIT( icon_cache );
  65
  66 static struct cursoricon_object *get_icon_ptr( HICON handle )
  67 {
  68     struct cursoricon_object *obj = get_user_handle_ptr( handle, NTUSER_OBJ_ICON );
  69     if (obj == OBJ_OTHER_PROCESS)
  70     {
  71         WARN( "icon handle %p from other process\n", handle );
  72         obj = NULL;
  73     }
  74     return obj;
  75 }
  76
  77 /***********************************************************************
  78  *           NtUserShowCursor    (win32u.@)
  79  */
  80 INT WINAPI NtUserShowCursor( BOOL show )
  81 {
  82     HCURSOR cursor;
  83     int increment = show ? 1 : -1;
  84     int count;
  85
  86     SERVER_START_REQ( set_cursor )
  87     {
  88         req->flags = SET_CURSOR_COUNT;
  89         req->show_count = increment;
  90         wine_server_call( req );
  91         cursor = wine_server_ptr_handle( reply->prev_handle );
  92         count = reply->prev_count + increment;
  93     }
  94     SERVER_END_REQ;
  95
  96     TRACE("%d, count=%d\n", show, count );
  97
  98     if (show && !count) user_driver->pSetCursor( cursor );
  99     else if (!show && count == -1) user_driver->pSetCursor( 0 );
 100
 101     return count;
 102 }
 103
 104 /***********************************************************************
 105  *           NtUserSetCursor (win32u.@)
 106  */
 107 HCURSOR WINAPI NtUserSetCursor( HCURSOR cursor )
 108 {
 109     struct cursoricon_object *obj;
 110     HCURSOR old_cursor;
 111     int show_count;
 112     BOOL ret;
 113
 114     TRACE( "%p\n", cursor );
 115
 116     SERVER_START_REQ( set_cursor )
 117     {
 118         req->flags = SET_CURSOR_HANDLE;
 119         req->handle = wine_server_user_handle( cursor );
 120         if ((ret = !wine_server_call_err( req )))
 121         {
 122             old_cursor = wine_server_ptr_handle( reply->prev_handle );
 123             show_count = reply->prev_count;
 124         }
 125     }
 126     SERVER_END_REQ;
 127     if (!ret) return 0;
 128
 129     user_driver->pSetCursor( show_count >= 0 ? cursor : 0 );
 130
 131     if (!(obj = get_icon_ptr( old_cursor ))) return 0;
 132     release_user_handle_ptr( obj );
 133     return old_cursor;
 134 }
 135
 136 /***********************************************************************
 137  *           NtUserGetCursor (win32u.@)
 138  */
 139 HCURSOR WINAPI NtUserGetCursor(void)
 140 {
 141     HCURSOR ret;
 142
 143     SERVER_START_REQ( set_cursor )
 144     {
 145         req->flags = 0;
 146         wine_server_call( req );
 147         ret = wine_server_ptr_handle( reply->prev_handle );
 148     }
 149     SERVER_END_REQ;
 150     return ret;
 151 }
 152
 153 /***********************************************************************
 154  *           NtUserClipCursor (win32u.@)
 155  */
 156 BOOL WINAPI NtUserClipCursor( const RECT *rect )
 157 {
 158     UINT dpi;
 159     BOOL ret;
 160     RECT new_rect;
 161
 162     TRACE( "Clipping to %s\n", wine_dbgstr_rect(rect) );
 163
 164     if (rect)
 165     {
 166         if (rect->left > rect->right || rect->top > rect->bottom) return FALSE;
 167         if ((dpi = get_thread_dpi()))
 168         {
 169             HMONITOR monitor = monitor_from_rect( rect, MONITOR_DEFAULTTOPRIMARY, dpi );
 170             new_rect = map_dpi_rect( *rect, dpi, get_monitor_dpi( monitor ));
 171             rect = &new_rect;
 172         }
 173     }
 174
 175     SERVER_START_REQ( set_cursor )
 176     {
 177         req->clip_msg = WM_WINE_CLIPCURSOR;
 178         if (rect)
 179         {
 180             req->flags       = SET_CURSOR_CLIP;
 181             req->clip.left   = rect->left;
 182             req->clip.top    = rect->top;
 183             req->clip.right  = rect->right;
 184             req->clip.bottom = rect->bottom;
 185         }
 186         else req->flags = SET_CURSOR_NOCLIP;
 187
 188         if ((ret = !wine_server_call( req )))
 189         {
 190             new_rect.left   = reply->new_clip.left;
 191             new_rect.top    = reply->new_clip.top;
 192             new_rect.right  = reply->new_clip.right;
 193             new_rect.bottom = reply->new_clip.bottom;
 194         }
 195     }
 196     SERVER_END_REQ;
 197     if (ret) user_driver->pClipCursor( &new_rect );
 198     return ret;
 199 }
 200
 201 BOOL get_clip_cursor( RECT *rect )
 202 {
 203     UINT dpi;
 204     BOOL ret;
 205
 206     if (!rect) return FALSE;
 207
 208     SERVER_START_REQ( set_cursor )
 209     {
 210         req->flags = 0;
 211         if ((ret = !wine_server_call( req )))
 212         {
 213             rect->left   = reply->new_clip.left;
 214             rect->top    = reply->new_clip.top;
 215             rect->right  = reply->new_clip.right;
 216             rect->bottom = reply->new_clip.bottom;
 217         }
 218     }
 219     SERVER_END_REQ;
 220
 221     if (ret && (dpi = get_thread_dpi()))
 222     {
 223         HMONITOR monitor = monitor_from_rect( rect, MONITOR_DEFAULTTOPRIMARY, 0 );
 224         *rect = map_dpi_rect( *rect, get_monitor_dpi( monitor ), dpi );
 225     }
 226     return ret;
 227 }
 228
 229 HICON alloc_cursoricon_handle( BOOL is_icon )
 230 {
 231     struct cursoricon_object *obj;
 232     HICON handle;
 233
 234     if (!(obj = calloc( 1, sizeof(*obj) ))) return NULL;
 235     obj->is_icon = is_icon;
 236     if (!(handle = alloc_user_handle( &obj->obj, NTUSER_OBJ_ICON ))) free( obj );
 237     return handle;
 238 }
 239
 240 static struct cursoricon_object *get_icon_frame_ptr( HICON handle, UINT step )
 241 {
 242     struct cursoricon_object *obj, *ret;
 243
 244     if (!(obj = get_icon_ptr( handle ))) return NULL;
 245     if (!obj->is_ani) return obj;
 246     if (step >= obj->ani.num_steps)
 247     {
 248         release_user_handle_ptr( obj );
 249         return NULL;
 250     }
 251     ret = get_icon_ptr( obj->ani.frames[step] );
 252     release_user_handle_ptr( obj );
 253     return ret;
 254 }
 255
 256 static BOOL free_icon_handle( HICON handle )
 257 {
 258     struct cursoricon_object *obj = free_user_handle( handle, NTUSER_OBJ_ICON );
 259
 260     if (obj == OBJ_OTHER_PROCESS) WARN( "icon handle %p from other process\n", handle );
 261     else if (obj)
 262     {
 263         ULONG param = obj->param;
 264         void *ret_ptr;
 265         ULONG ret_len;
 266         UINT i;
 267
 268         assert( !obj->rsrc );  /* shared icons can't be freed */
 269
 270         if (!obj->is_ani)
 271         {
 272             if (obj->frame.alpha) NtGdiDeleteObjectApp( obj->frame.alpha );
 273             if (obj->frame.color) NtGdiDeleteObjectApp( obj->frame.color );
 274             if (obj->frame.mask)  NtGdiDeleteObjectApp( obj->frame.mask );
 275         }
 276         else
 277         {
 278             for (i = 0; i < obj->ani.num_steps; i++)
 279             {
 280                 HICON hFrame = obj->ani.frames[i];
 281
 282                 if (hFrame)
 283                 {
 284                     UINT j;
 285
 286                     free_icon_handle( obj->ani.frames[i] );
 287                     for (j = 0; j < obj->ani.num_steps; j++)
 288                     {
 289                         if (obj->ani.frames[j] == hFrame) obj->ani.frames[j] = 0;
 290                     }
 291                 }
 292             }
 293             free( obj->ani.frames );
 294         }
 295         if (!IS_INTRESOURCE( obj->resname )) free( obj->resname );
 296         free( obj );
 297         if (param) KeUserModeCallback( NtUserCallFreeIcon, &param, sizeof(param), &ret_ptr, &ret_len );
 298         user_driver->pDestroyCursorIcon( handle );
 299         return TRUE;
 300     }
 301     return FALSE;
 302 }
 303
 304 /***********************************************************************
 305  *           NtUserDestroyCursor (win32u.@)
 306  */
 307 BOOL WINAPI NtUserDestroyCursor( HCURSOR cursor, ULONG arg )
 308 {
 309     struct cursoricon_object *obj;
 310     BOOL shared, ret;
 311
 312     TRACE( "%p\n", cursor );
 313
 314     if (!(obj = get_icon_ptr( cursor ))) return FALSE;
 315     shared = obj->is_shared;
 316     release_user_handle_ptr( obj );
 317     ret = NtUserGetCursor() != cursor;
 318     if (!shared) free_icon_handle( cursor );
 319     return ret;
 320 }
 321
 322 /***********************************************************************
 323  *           NtUserSetCursorIconData (win32u.@)
 324  */
 325 BOOL WINAPI NtUserSetCursorIconData( HCURSOR cursor, UNICODE_STRING *module, UNICODE_STRING *res_name,
 326                                      struct cursoricon_desc *desc )
 327 {
 328     struct cursoricon_object *obj;
 329     UINT i, j;
 330
 331     if (!(obj = get_icon_ptr( cursor ))) return FALSE;
 332
 333     if (obj->is_ani || obj->frame.width)
 334     {
 335         /* already initialized */
 336         release_user_handle_ptr( obj );
 337         SetLastError( ERROR_INVALID_CURSOR_HANDLE );
 338         return FALSE;
 339     }
 340
 341     obj->delay = desc->delay;
 342
 343     if (desc->num_steps)
 344     {
 345         if (!(obj->ani.frames = calloc( desc->num_steps, sizeof(*obj->ani.frames) )))
 346         {
 347             release_user_handle_ptr( obj );
 348             return FALSE;
 349         }
 350         obj->is_ani = TRUE;
 351         obj->ani.num_steps  = desc->num_steps;
 352         obj->ani.num_frames = desc->num_frames;
 353     }
 354     else obj->frame = desc->frames[0];
 355
 356     if (!res_name)
 357         obj->resname = NULL;
 358     else if (res_name->Length)
 359     {
 360         obj->resname = malloc( res_name->Length + sizeof(WCHAR) );
 361         if (obj->resname)
 362         {
 363             memcpy( obj->resname, res_name->Buffer, res_name->Length );
 364             obj->resname[res_name->Length / sizeof(WCHAR)] = 0;
 365         }
 366     }
 367     else
 368         obj->resname = MAKEINTRESOURCEW( LOWORD(res_name->Buffer) );
 369
 370     if (module && module->Length && (obj->module.Buffer = malloc( module->Length )))
 371     {
 372         memcpy( obj->module.Buffer, module->Buffer, module->Length );
 373         obj->module.Length = module->Length;
 374     }
 375
 376     if (obj->is_ani)
 377     {
 378         /* Setup the animated frames in the correct sequence */
 379         for (i = 0; i < desc->num_steps; i++)
 380         {
 381             struct cursoricon_desc frame_desc;
 382             DWORD frame_id;
 383
 384             if (obj->ani.frames[i]) continue; /* already set */
 385
 386             frame_id = desc->frame_seq ? desc->frame_seq[i] : i;
 387             if (frame_id >= obj->ani.num_frames)
 388             {
 389                 frame_id = obj->ani.num_frames - 1;
 390                 ERR_(cursor)( "Sequence indicates frame past end of list, corrupt?\n" );
 391             }
 392             memset( &frame_desc, 0, sizeof(frame_desc) );
 393             frame_desc.delay  = desc->frame_rates ? desc->frame_rates[i] : desc->delay;
 394             frame_desc.frames = &desc->frames[frame_id];
 395             if (!(obj->ani.frames[i] = alloc_cursoricon_handle( obj->is_icon )) ||
 396                 !NtUserSetCursorIconData( obj->ani.frames[i], NULL, NULL, &frame_desc ))
 397             {
 398                 release_user_handle_ptr( obj );
 399                 return 0;
 400             }
 401
 402             if (desc->frame_seq)
 403             {
 404                 for (j = i + 1; j < obj->ani.num_steps; j++)
 405                 {
 406                     if (desc->frame_seq[j] == frame_id) obj->ani.frames[j] = obj->ani.frames[i];
 407                 }
 408             }
 409         }
 410     }
 411
 412     if (desc->flags & LR_SHARED)
 413     {
 414         obj->is_shared = TRUE;
 415         if (obj->module.Length)
 416         {
 417             obj->rsrc = desc->rsrc;
 418             list_add_head( &icon_cache, &obj->entry );
 419         }
 420     }
 421
 422     release_user_handle_ptr( obj );
 423     return TRUE;
 424 }
 425
 426 /***********************************************************************
 427  *           NtUserFindExistingCursorIcon (win32u.@)
 428  */
 429 HICON WINAPI NtUserFindExistingCursorIcon( UNICODE_STRING *module, UNICODE_STRING *res_name, void *desc )
 430 {
 431     struct cursoricon_object *ptr;
 432     HICON ret = 0;
 433
 434     user_lock();
 435     LIST_FOR_EACH_ENTRY( ptr, &icon_cache, struct cursoricon_object, entry )
 436     {
 437         if (ptr->module.Length != module->Length) continue;
 438         if (memcmp( ptr->module.Buffer, module->Buffer, module->Length )) continue;
 439         /* We pass rsrc as desc argument, this is not compatible with Windows */
 440         if (ptr->rsrc != desc) continue;
 441         ret = ptr->obj.handle;
 442         break;
 443     }
 444     user_unlock();
 445     return ret;
 446 }
 447
 448 /***********************************************************************
 449  *           NtUserGetIconSize (win32u.@)
 450  */
 451 BOOL WINAPI NtUserGetIconSize( HICON handle, UINT step, LONG *width, LONG *height )
 452 {
 453     struct cursoricon_object *obj;
 454
 455     if (!(obj = get_icon_frame_ptr( handle, step )))
 456     {
 457         SetLastError( ERROR_INVALID_CURSOR_HANDLE );
 458         return FALSE;
 459     }
 460
 461     *width  = obj->frame.width;
 462     *height = obj->frame.height * 2;
 463     release_user_handle_ptr( obj );
 464     return TRUE;
 465 }
 466
 467 /**********************************************************************
 468  *           NtUserGetCursorFrameInfo (win32u.@)
 469  */
 470 HCURSOR WINAPI NtUserGetCursorFrameInfo( HCURSOR cursor, DWORD istep, DWORD *rate_jiffies,
 471                                          DWORD *num_steps )
 472 {
 473     struct cursoricon_object *obj;
 474     HCURSOR ret = 0;
 475     UINT icon_steps;
 476
 477     if (!rate_jiffies || !num_steps) return 0;
 478
 479     if (!(obj = get_icon_ptr( cursor ))) return 0;
 480
 481     TRACE( "%p => %d %p %p\n", cursor, istep, rate_jiffies, num_steps );
 482
 483     icon_steps = obj->is_ani ? obj->ani.num_steps : 1;
 484     if (istep < icon_steps || !obj->is_ani)
 485     {
 486         UINT icon_frames = 1;
 487
 488         if (obj->is_ani)
 489             icon_frames = obj->ani.num_frames;
 490         if (obj->is_ani && icon_frames > 1)
 491             ret = obj->ani.frames[istep];
 492         else
 493             ret = cursor;
 494         if (icon_frames == 1)
 495         {
 496             *rate_jiffies = 0;
 497             *num_steps = 1;
 498         }
 499         else if (icon_steps == 1)
 500         {
 501             *num_steps = ~0;
 502             *rate_jiffies = obj->delay;
 503         }
 504         else if (istep < icon_steps)
 505         {
 506             struct cursoricon_object *frame;
 507
 508             *num_steps = icon_steps;
 509             frame = get_icon_ptr( obj->ani.frames[istep] );
 510             if (obj->ani.num_steps == 1)
 511                 *num_steps = ~0;
 512             else
 513                 *num_steps = obj->ani.num_steps;
 514             *rate_jiffies = frame->delay;
 515             release_user_handle_ptr( frame );
 516         }
 517     }
 518
 519     release_user_handle_ptr( obj );
 520     return ret;
 521 }
 522
 523 /***********************************************************************
 524  *             copy_bitmap
 525  *
 526  * Helper function to duplicate a bitmap.
 527  */
 528 static HBITMAP copy_bitmap( HBITMAP bitmap )
 529 {
 530     HDC src, dst = 0;
 531     HBITMAP new_bitmap = 0;
 532     BITMAP bmp;
 533
 534     if (!bitmap) return 0;
 535     if (!NtGdiExtGetObjectW( bitmap, sizeof(bmp), &bmp )) return 0;
 536
 537     if ((src = NtGdiCreateCompatibleDC( 0 )) && (dst = NtGdiCreateCompatibleDC( 0 )))
 538     {
 539         NtGdiSelectBitmap( src, bitmap );
 540         if ((new_bitmap = NtGdiCreateCompatibleBitmap( src, bmp.bmWidth, bmp.bmHeight )))
 541         {
 542             NtGdiSelectBitmap( dst, new_bitmap );
 543             NtGdiBitBlt( dst, 0, 0, bmp.bmWidth, bmp.bmHeight, src, 0, 0, SRCCOPY, 0, 0 );
 544         }
 545     }
 546     NtGdiDeleteObjectApp( dst );
 547     NtGdiDeleteObjectApp( src );
 548     return new_bitmap;
 549 }
 550
 551 /**********************************************************************
 552  *           NtUserGetIconInfo (win32u.@)
 553  */
 554 BOOL WINAPI NtUserGetIconInfo( HICON icon, ICONINFO *info, UNICODE_STRING *module,
 555                                UNICODE_STRING *res_name, DWORD *bpp, LONG unk )
 556 {
 557     struct cursoricon_object *obj, *frame_obj;
 558     BOOL ret = TRUE;
 559
 560     if (!(obj = get_icon_ptr( icon )))
 561     {
 562         SetLastError( ERROR_INVALID_CURSOR_HANDLE );
 563         return FALSE;
 564     }
 565     if (!(frame_obj = get_icon_frame_ptr( icon, 0 )))
 566     {
 567         release_user_handle_ptr( obj );
 568         return FALSE;
 569     }
 570
 571     TRACE( "%p => %dx%d\n", icon, frame_obj->frame.width, frame_obj->frame.height );
 572
 573     info->fIcon        = obj->is_icon;
 574     info->xHotspot     = frame_obj->frame.hotspot.x;
 575     info->yHotspot     = frame_obj->frame.hotspot.y;
 576     info->hbmColor     = copy_bitmap( frame_obj->frame.color );
 577     info->hbmMask      = copy_bitmap( frame_obj->frame.mask );
 578     if (!info->hbmMask || (!info->hbmColor && frame_obj->frame.color))
 579     {
 580         NtGdiDeleteObjectApp( info->hbmMask );
 581         NtGdiDeleteObjectApp( info->hbmColor );
 582         ret = FALSE;
 583     }
 584     else if (obj->module.Length)
 585     {
 586         if (module)
 587         {
 588             size_t size = min( module->MaximumLength, obj->module.Length );
 589             if (size) memcpy( module->Buffer, obj->module.Buffer, size );
 590             module->Length = size / sizeof(WCHAR); /* length in chars, not bytes */
 591         }
 592         if (res_name)
 593         {
 594             if (IS_INTRESOURCE( obj->resname ))
 595             {
 596                 res_name->Buffer = obj->resname;
 597                 res_name->Length = 0;
 598             }
 599             else
 600             {
 601                 size_t size = min( res_name->MaximumLength, lstrlenW( obj->resname) * sizeof(WCHAR) );
 602                 if (size) memcpy( res_name->Buffer, obj->resname, size );
 603                 module->Length = size / sizeof(WCHAR); /* length in chars, not bytes */
 604             }
 605         }
 606     }
 607     else
 608     {
 609         if (module) module->Length = 0;
 610         if (res_name)
 611         {
 612             res_name->Length = 0;
 613             res_name->Buffer = NULL;
 614         }
 615     }
 616     release_user_handle_ptr( frame_obj );
 617     release_user_handle_ptr( obj );
 618     return ret;
 619 }
 620
 621 /******************************************************************************
 622  *           NtUserDrawIconEx (win32u.@)
 623  */
 624 BOOL WINAPI NtUserDrawIconEx( HDC hdc, INT x0, INT y0, HICON icon, INT width,
 625                               INT height, UINT step, HBRUSH brush, UINT flags )
 626 {
 627     struct cursoricon_object *obj;
 628     HBITMAP offscreen_bitmap = 0;
 629     HDC hdc_dest, mem_dc;
 630     COLORREF old_fg, old_bg;
 631     INT x, y, nStretchMode;
 632     BOOL result = FALSE;
 633
 634     TRACE_(icon)( "(hdc=%p,pos=%d.%d,hicon=%p,extend=%d.%d,step=%d,br=%p,flags=0x%08x)\n",
 635                   hdc, x0, y0, icon, width, height, step, brush, flags );
 636
 637     if (!(obj = get_icon_frame_ptr( icon, step )))
 638     {
 639         FIXME_(icon)("Error retrieving icon frame %d\n", step);
 640         return FALSE;
 641     }
 642     if (!(mem_dc = NtGdiCreateCompatibleDC( hdc )))
 643     {
 644         release_user_handle_ptr( obj );
 645         return FALSE;
 646     }
 647
 648     if (flags & DI_NOMIRROR)
 649         FIXME_(icon)("Ignoring flag DI_NOMIRROR\n");
 650
 651     /* Calculate the size of the destination image.  */
 652     if (width == 0)
 653     {
 654         if (flags & DI_DEFAULTSIZE)
 655             width = get_system_metrics( SM_CXICON );
 656         else
 657             width = obj->frame.width;
 658     }
 659     if (height == 0)
 660     {
 661         if (flags & DI_DEFAULTSIZE)
 662             height = get_system_metrics( SM_CYICON );
 663         else
 664             height = obj->frame.height;
 665     }
 666
 667     if (get_gdi_object_type( brush ) == NTGDI_OBJ_BRUSH)
 668     {
 669         HBRUSH prev_brush;
 670         RECT r;
 671
 672         SetRect(&r, 0, 0, width, width);
 673
 674         if (!(hdc_dest = NtGdiCreateCompatibleDC(hdc))) goto failed;
 675         if (!(offscreen_bitmap = NtGdiCreateCompatibleBitmap(hdc, width, height)))
 676         {
 677             NtGdiDeleteObjectApp( hdc_dest );
 678             goto failed;
 679         }
 680         NtGdiSelectBitmap( hdc_dest, offscreen_bitmap );
 681
 682         prev_brush = NtGdiSelectBrush( hdc_dest, brush );
 683         NtGdiPatBlt( hdc_dest, r.left, r.top, r.right - r.left, r.bottom - r.top, PATCOPY );
 684         if (prev_brush) NtGdiSelectBrush( hdc_dest, prev_brush );
 685         x = y = 0;
 686     }
 687     else
 688     {
 689         hdc_dest = hdc;
 690         x = x0;
 691         y = y0;
 692     }
 693
 694     nStretchMode = set_stretch_blt_mode( hdc, STRETCH_DELETESCANS );
 695     NtGdiGetAndSetDCDword( hdc, NtGdiSetTextColor, RGB(0,0,0), &old_fg );
 696     NtGdiGetAndSetDCDword( hdc, NtGdiSetBkColor, RGB(255,255,255), &old_bg );
 697
 698     if (obj->frame.alpha && (flags & DI_IMAGE))
 699     {
 700         BOOL alpha_blend = TRUE;
 701
 702         if (get_gdi_object_type( hdc_dest ) == NTGDI_OBJ_MEMDC)
 703         {
 704             BITMAP bm;
 705             HBITMAP bmp = NtGdiGetDCObject( hdc_dest, NTGDI_OBJ_SURF );
 706             alpha_blend = NtGdiExtGetObjectW( bmp, sizeof(bm), &bm ) && bm.bmBitsPixel > 8;
 707         }
 708         if (alpha_blend)
 709         {
 710             BLENDFUNCTION pixelblend = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
 711             NtGdiSelectBitmap( mem_dc, obj->frame.alpha );
 712             if (NtGdiAlphaBlend( hdc_dest, x, y, width, height, mem_dc,
 713                                  0, 0, obj->frame.width, obj->frame.height,
 714                                  pixelblend, 0 )) goto done;
 715         }
 716     }
 717
 718     if (flags & DI_MASK)
 719     {
 720         DWORD rop = (flags & DI_IMAGE) ? SRCAND : SRCCOPY;
 721         NtGdiSelectBitmap( mem_dc, obj->frame.mask );
 722         NtGdiStretchBlt( hdc_dest, x, y, width, height,
 723                          mem_dc, 0, 0, obj->frame.width, obj->frame.height, rop, 0 );
 724     }
 725
 726     if (flags & DI_IMAGE)
 727     {
 728         if (obj->frame.color)
 729         {
 730             DWORD rop = (flags & DI_MASK) ? SRCINVERT : SRCCOPY;
 731             NtGdiSelectBitmap( mem_dc, obj->frame.color );
 732             NtGdiStretchBlt( hdc_dest, x, y, width, height,
 733                              mem_dc, 0, 0, obj->frame.width, obj->frame.height, rop, 0 );
 734         }
 735         else
 736         {
 737             DWORD rop = (flags & DI_MASK) ? SRCINVERT : SRCCOPY;
 738             NtGdiSelectBitmap( mem_dc, obj->frame.mask );
 739             NtGdiStretchBlt( hdc_dest, x, y, width, height,
 740                              mem_dc, 0, obj->frame.height, obj->frame.width,
 741                              obj->frame.height, rop, 0 );
 742         }
 743     }
 744
 745 done:
 746     if (offscreen_bitmap) NtGdiBitBlt( hdc, x0, y0, width, height, hdc_dest, 0, 0, SRCCOPY, 0, 0 );
 747
 748     NtGdiGetAndSetDCDword( hdc, NtGdiSetTextColor, old_fg, NULL );
 749     NtGdiGetAndSetDCDword( hdc, NtGdiSetBkColor, old_bg, NULL );
 750     nStretchMode = set_stretch_blt_mode( hdc, nStretchMode );
 751
 752     result = TRUE;
 753     if (hdc_dest != hdc) NtGdiDeleteObjectApp( hdc_dest );
 754     if (offscreen_bitmap) NtGdiDeleteObjectApp( offscreen_bitmap );
 755 failed:
 756     NtGdiDeleteObjectApp( mem_dc );
 757     release_user_handle_ptr( obj );
 758     return result;
 759 }
 760
 761 ULONG_PTR get_icon_param( HICON handle )
 762 {
 763     ULONG_PTR ret = 0;
 764     struct cursoricon_object *obj = get_user_handle_ptr( handle, NTUSER_OBJ_ICON );
 765
 766     if (obj == OBJ_OTHER_PROCESS) WARN( "icon handle %p from other process\n", handle );
 767     else if (obj)
 768     {
 769         ret = obj->param;
 770         release_user_handle_ptr( obj );
 771     }
 772     return ret;
 773 }
 774
 775 ULONG_PTR set_icon_param( HICON handle, ULONG_PTR param )
 776 {
 777     ULONG_PTR ret = 0;
 778     struct cursoricon_object *obj = get_user_handle_ptr( handle, NTUSER_OBJ_ICON );
 779
 780     if (obj == OBJ_OTHER_PROCESS) WARN( "icon handle %p from other process\n", handle );
 781     else if (obj)
 782     {
 783         ret = obj->param;
 784         obj->param = param;
 785         release_user_handle_ptr( obj );
 786     }
 787     return ret;
 788 }