dlls/win32u/clipboard.c

   1 /*
   2  * WIN32 clipboard implementation
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  * Copyright 1996 Alex Korobka
   6  * Copyright 1999 Noel Borthwick
   7  * Copyright 2003 Ulrich Czekalla for CodeWeavers
   8  * Copyright 2016 Alexandre Julliard
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  *
  24  */
  25
  26 #if 0
  27 #pragma makedep unix
  28 #endif
  29
  30 #include <pthread.h>
  31 #include "ntstatus.h"
  32 #define WIN32_NO_STATUS
  33 #include "win32u_private.h"
  34 #include "ntgdi_private.h"
  35 #include "ntuser_private.h"
  36 #include "wine/server.h"
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(clipboard);
  40
  41 static pthread_mutex_t clipboard_mutex = PTHREAD_MUTEX_INITIALIZER;
  42
  43 struct cached_format
  44 {
  45     struct list entry;       /* entry in cache list */
  46     UINT        format;      /* format id */
  47     UINT        seqno;       /* sequence number when the data was set */
  48     HANDLE      handle;      /* original data handle */
  49 };
  50
  51 static struct list cached_formats = LIST_INIT( cached_formats );
  52 static struct list formats_to_free = LIST_INIT( formats_to_free );
  53
  54
  55 /* get a debug string for a format id */
  56 static const char *debugstr_format( UINT id )
  57 {
  58     WCHAR buffer[256];
  59     DWORD le = RtlGetLastWin32Error();
  60     BOOL r = NtUserGetClipboardFormatName( id, buffer, ARRAYSIZE(buffer) );
  61     RtlSetLastWin32Error(le);
  62
  63     if (r)
  64         return wine_dbg_sprintf( "%04x %s", id, debugstr_w(buffer) );
  65
  66     switch (id)
  67     {
  68 #define BUILTIN(id) case id: return #id;
  69     BUILTIN(CF_TEXT)
  70     BUILTIN(CF_BITMAP)
  71     BUILTIN(CF_METAFILEPICT)
  72     BUILTIN(CF_SYLK)
  73     BUILTIN(CF_DIF)
  74     BUILTIN(CF_TIFF)
  75     BUILTIN(CF_OEMTEXT)
  76     BUILTIN(CF_DIB)
  77     BUILTIN(CF_PALETTE)
  78     BUILTIN(CF_PENDATA)
  79     BUILTIN(CF_RIFF)
  80     BUILTIN(CF_WAVE)
  81     BUILTIN(CF_UNICODETEXT)
  82     BUILTIN(CF_ENHMETAFILE)
  83     BUILTIN(CF_HDROP)
  84     BUILTIN(CF_LOCALE)
  85     BUILTIN(CF_DIBV5)
  86     BUILTIN(CF_OWNERDISPLAY)
  87     BUILTIN(CF_DSPTEXT)
  88     BUILTIN(CF_DSPBITMAP)
  89     BUILTIN(CF_DSPMETAFILEPICT)
  90     BUILTIN(CF_DSPENHMETAFILE)
  91 #undef BUILTIN
  92     default: return wine_dbg_sprintf( "%04x", id );
  93     }
  94 }
  95
  96 /* retrieve a data format from the cache */
  97 static struct cached_format *get_cached_format( UINT format )
  98 {
  99     struct cached_format *cache;
 100
 101     LIST_FOR_EACH_ENTRY( cache, &cached_formats, struct cached_format, entry )
 102         if (cache->format == format) return cache;
 103     return NULL;
 104 }
 105
 106 /* free a single cached format */
 107 static void free_cached_data( struct cached_format *cache )
 108 {
 109     struct free_cached_data_params params;
 110     void *ret_ptr;
 111     ULONG ret_len;
 112
 113     switch (cache->format)
 114     {
 115     case CF_BITMAP:
 116     case CF_PALETTE:
 117         make_gdi_object_system( cache->handle, FALSE );
 118     case CF_DSPBITMAP:
 119         NtGdiDeleteObjectApp( cache->handle );
 120         break;
 121
 122     default:
 123         params.format = cache->format;
 124         params.handle = cache->handle;
 125         KeUserModeCallback( NtUserFreeCachedClipboardData, &params, sizeof(params),
 126                             &ret_ptr, &ret_len );
 127         break;
 128     }
 129     free( cache );
 130 }
 131
 132 /* free all the data in the cache */
 133 static void free_cached_formats( struct list *list )
 134 {
 135     struct list *ptr;
 136
 137     while ((ptr = list_head( list )))
 138     {
 139         list_remove( ptr );
 140         free_cached_data( LIST_ENTRY( ptr, struct cached_format, entry ));
 141     }
 142 }
 143
 144 /* clear global memory formats; special types are freed on EmptyClipboard */
 145 static void invalidate_memory_formats( struct list *free_list )
 146 {
 147     struct cached_format *cache, *next;
 148
 149     LIST_FOR_EACH_ENTRY_SAFE( cache, next, &cached_formats, struct cached_format, entry )
 150     {
 151         switch (cache->format)
 152         {
 153         case CF_BITMAP:
 154         case CF_DSPBITMAP:
 155         case CF_PALETTE:
 156         case CF_ENHMETAFILE:
 157         case CF_DSPENHMETAFILE:
 158         case CF_METAFILEPICT:
 159         case CF_DSPMETAFILEPICT:
 160             continue;
 161         default:
 162             list_remove( &cache->entry );
 163             list_add_tail( free_list, &cache->entry );
 164             break;
 165         }
 166     }
 167 }
 168
 169 /**************************************************************************
 170  *           NtUserOpenClipboard    (win32u.@)
 171  */
 172 BOOL WINAPI NtUserOpenClipboard( HWND hwnd, ULONG unk )
 173 {
 174     struct list free_list = LIST_INIT( free_list );
 175     BOOL ret;
 176     HWND owner;
 177
 178     TRACE( "%p\n", hwnd );
 179
 180     user_driver->pUpdateClipboard();
 181
 182     pthread_mutex_lock( &clipboard_mutex );
 183
 184     SERVER_START_REQ( open_clipboard )
 185     {
 186         req->window = wine_server_user_handle( hwnd );
 187         ret = !wine_server_call_err( req );
 188         owner = wine_server_ptr_handle( reply->owner );
 189     }
 190     SERVER_END_REQ;
 191
 192     if (ret && !is_current_process_window( owner )) invalidate_memory_formats( &free_list );
 193
 194     pthread_mutex_unlock( &clipboard_mutex );
 195     free_cached_formats( &free_list );
 196     return ret;
 197 }
 198
 199 /**************************************************************************
 200  *           NtUserCloseClipboard    (win32u.@)
 201  */
 202 BOOL WINAPI NtUserCloseClipboard(void)
 203 {
 204     HWND viewer = 0, owner = 0;
 205     BOOL ret;
 206
 207     TRACE( "\n" );
 208
 209     SERVER_START_REQ( close_clipboard )
 210     {
 211         if ((ret = !wine_server_call_err( req )))
 212         {
 213             viewer = wine_server_ptr_handle( reply->viewer );
 214             owner = wine_server_ptr_handle( reply->owner );
 215         }
 216     }
 217     SERVER_END_REQ;
 218
 219     if (viewer) NtUserMessageCall( viewer, WM_DRAWCLIPBOARD, (WPARAM)owner, 0,
 220                                    0, NtUserSendNotifyMessage, FALSE );
 221     return ret;
 222 }
 223
 224 /**************************************************************************
 225  *           NtUserEmptyClipboard    (win32u.@)
 226  */
 227 BOOL WINAPI NtUserEmptyClipboard(void)
 228 {
 229     BOOL ret;
 230     HWND owner = NtUserGetClipboardOwner();
 231     struct list free_list = LIST_INIT( free_list );
 232
 233     TRACE( "owner %p\n", owner );
 234
 235     if (owner)
 236         send_message_timeout( owner, WM_DESTROYCLIPBOARD, 0, 0, SMTO_ABORTIFHUNG, 5000, FALSE );
 237
 238     pthread_mutex_lock( &clipboard_mutex );
 239
 240     SERVER_START_REQ( empty_clipboard )
 241     {
 242         ret = !wine_server_call_err( req );
 243     }
 244     SERVER_END_REQ;
 245
 246     if (ret)
 247     {
 248         list_move_tail( &free_list, &formats_to_free );
 249         list_move_tail( &free_list, &cached_formats );
 250     }
 251
 252     pthread_mutex_unlock( &clipboard_mutex );
 253     free_cached_formats( &free_list );
 254     return ret;
 255 }
 256
 257 /**************************************************************************
 258  *           NtUserCountClipboardFormats    (win32u.@)
 259  */
 260 INT WINAPI NtUserCountClipboardFormats(void)
 261 {
 262     INT count = 0;
 263
 264     user_driver->pUpdateClipboard();
 265
 266     SERVER_START_REQ( get_clipboard_formats )
 267     {
 268         wine_server_call( req );
 269         count = reply->count;
 270     }
 271     SERVER_END_REQ;
 272
 273     TRACE( "returning %d\n", count );
 274     return count;
 275 }
 276
 277 /**************************************************************************
 278  *           NtUserIsClipboardFormatAvailable    (win32u.@)
 279  */
 280 BOOL WINAPI NtUserIsClipboardFormatAvailable( UINT format )
 281 {
 282     BOOL ret = FALSE;
 283
 284     if (!format) return FALSE;
 285
 286     user_driver->pUpdateClipboard();
 287
 288     SERVER_START_REQ( get_clipboard_formats )
 289     {
 290         req->format = format;
 291         if (!wine_server_call_err( req )) ret = (reply->count > 0);
 292     }
 293     SERVER_END_REQ;
 294     TRACE( "%s -> %u\n", debugstr_format( format ), ret );
 295     return ret;
 296 }
 297
 298 /**************************************************************************
 299  *           NtUserGetUpdatedClipboardFormats    (win32u.@)
 300  */
 301 BOOL WINAPI NtUserGetUpdatedClipboardFormats( UINT *formats, UINT size, UINT *out_size )
 302 {
 303     BOOL ret;
 304
 305     if (!out_size)
 306     {
 307         RtlSetLastWin32Error( ERROR_NOACCESS );
 308         return FALSE;
 309     }
 310
 311     user_driver->pUpdateClipboard();
 312
 313     SERVER_START_REQ( get_clipboard_formats )
 314     {
 315         if (formats) wine_server_set_reply( req, formats, size * sizeof(*formats) );
 316         ret = !wine_server_call_err( req );
 317         *out_size = reply->count;
 318     }
 319     SERVER_END_REQ;
 320
 321     TRACE( "%p %u returning %u formats, ret %u\n", formats, size, *out_size, ret );
 322     if (!ret && !formats && *out_size) RtlSetLastWin32Error( ERROR_NOACCESS );
 323     return ret;
 324 }
 325
 326 /**************************************************************************
 327  *           NtUserGetPriorityClipboardFormat    (win32u.@)
 328  */
 329 INT WINAPI NtUserGetPriorityClipboardFormat( UINT *list, INT count )
 330 {
 331     int i;
 332
 333     TRACE( "%p %u\n", list, count );
 334
 335     if (NtUserCountClipboardFormats() == 0)
 336         return 0;
 337
 338     for (i = 0; i < count; i++)
 339         if (NtUserIsClipboardFormatAvailable( list[i] ))
 340             return list[i];
 341
 342     return -1;
 343 }
 344
 345 /**************************************************************************
 346  *           NtUserGetClipboardFormatName    (win32u.@)
 347  */
 348 INT WINAPI NtUserGetClipboardFormatName( UINT format, WCHAR *buffer, INT maxlen )
 349 {
 350     char buf[sizeof(ATOM_BASIC_INFORMATION) + MAX_ATOM_LEN * sizeof(WCHAR)];
 351     ATOM_BASIC_INFORMATION *abi = (ATOM_BASIC_INFORMATION *)buf;
 352     UINT length = 0;
 353
 354     if (format < MAXINTATOM || format > 0xffff) return 0;
 355     if (maxlen <= 0)
 356     {
 357         RtlSetLastWin32Error( ERROR_MORE_DATA );
 358         return 0;
 359     }
 360     if (!set_ntstatus( NtQueryInformationAtom( format, AtomBasicInformation,
 361                                                buf, sizeof(buf), NULL )))
 362         return 0;
 363
 364     length = min( abi->NameLength / sizeof(WCHAR), maxlen - 1 );
 365     if (length) memcpy( buffer, abi->Name, length * sizeof(WCHAR) );
 366     buffer[length] = 0;
 367     return length;
 368 }
 369
 370 /**************************************************************************
 371  *           NtUserGetClipboardOwner    (win32u.@)
 372  */
 373 HWND WINAPI NtUserGetClipboardOwner(void)
 374 {
 375     HWND owner = 0;
 376
 377     SERVER_START_REQ( get_clipboard_info )
 378     {
 379         if (!wine_server_call_err( req )) owner = wine_server_ptr_handle( reply->owner );
 380     }
 381     SERVER_END_REQ;
 382
 383     TRACE( "returning %p\n", owner );
 384     return owner;
 385 }
 386
 387 /**************************************************************************
 388  *           NtUserSetClipboardViewer    (win32u.@)
 389  */
 390 HWND WINAPI NtUserSetClipboardViewer( HWND hwnd )
 391 {
 392     HWND prev = 0, owner = 0;
 393
 394     SERVER_START_REQ( set_clipboard_viewer )
 395     {
 396         req->viewer = wine_server_user_handle( hwnd );
 397         if (!wine_server_call_err( req ))
 398         {
 399             prev = wine_server_ptr_handle( reply->old_viewer );
 400             owner = wine_server_ptr_handle( reply->owner );
 401         }
 402     }
 403     SERVER_END_REQ;
 404
 405     if (hwnd)
 406         NtUserMessageCall( hwnd, WM_DRAWCLIPBOARD, (WPARAM)owner, 0,
 407                            NULL, NtUserSendNotifyMessage, FALSE );
 408
 409     TRACE( "%p returning %p\n", hwnd, prev );
 410     return prev;
 411 }
 412
 413 /**************************************************************************
 414  *           NtUserGetClipboardViewer    (win32u.@)
 415  */
 416 HWND WINAPI NtUserGetClipboardViewer(void)
 417 {
 418     HWND viewer = 0;
 419
 420     SERVER_START_REQ( get_clipboard_info )
 421     {
 422         if (!wine_server_call_err( req )) viewer = wine_server_ptr_handle( reply->viewer );
 423     }
 424     SERVER_END_REQ;
 425
 426     TRACE( "returning %p\n", viewer );
 427     return viewer;
 428 }
 429
 430 /**************************************************************************
 431  *           NtUserChangeClipboardChain    (win32u.@)
 432  */
 433 BOOL WINAPI NtUserChangeClipboardChain( HWND hwnd, HWND next )
 434 {
 435     NTSTATUS status;
 436     HWND viewer;
 437
 438     if (!hwnd) return FALSE;
 439
 440     SERVER_START_REQ( set_clipboard_viewer )
 441     {
 442         req->viewer = wine_server_user_handle( next );
 443         req->previous = wine_server_user_handle( hwnd );
 444         status = wine_server_call( req );
 445         viewer = wine_server_ptr_handle( reply->old_viewer );
 446     }
 447     SERVER_END_REQ;
 448
 449     if (status == STATUS_PENDING)
 450         return !send_message( viewer, WM_CHANGECBCHAIN, (WPARAM)hwnd, (LPARAM)next );
 451
 452     if (status) RtlSetLastWin32Error( RtlNtStatusToDosError( status ));
 453     return !status;
 454 }
 455
 456 /**************************************************************************
 457  *           NtUserGetOpenClipboardWindow    (win32u.@)
 458  */
 459 HWND WINAPI NtUserGetOpenClipboardWindow(void)
 460 {
 461     HWND window = 0;
 462
 463     SERVER_START_REQ( get_clipboard_info )
 464     {
 465         if (!wine_server_call_err( req )) window = wine_server_ptr_handle( reply->window );
 466     }
 467     SERVER_END_REQ;
 468
 469     TRACE( "returning %p\n", window );
 470     return window;
 471 }
 472
 473 /**************************************************************************
 474  *           NtUserGetClipboardSequenceNumber    (win32u.@)
 475  */
 476 DWORD WINAPI NtUserGetClipboardSequenceNumber(void)
 477 {
 478     unsigned int seqno = 0;
 479
 480     SERVER_START_REQ( get_clipboard_info )
 481     {
 482         if (!wine_server_call_err( req )) seqno = reply->seqno;
 483     }
 484     SERVER_END_REQ;
 485
 486     TRACE( "returning %u\n", seqno );
 487     return seqno;
 488 }
 489
 490 /* see EnumClipboardFormats */
 491 UINT enum_clipboard_formats( UINT format )
 492 {
 493     UINT ret = 0;
 494
 495     SERVER_START_REQ( enum_clipboard_formats )
 496     {
 497         req->previous = format;
 498         if (!wine_server_call_err( req ))
 499         {
 500             ret = reply->format;
 501             RtlSetLastWin32Error( ERROR_SUCCESS );
 502         }
 503     }
 504     SERVER_END_REQ;
 505
 506     TRACE( "%s -> %s\n", debugstr_format( format ), debugstr_format( ret ));
 507     return ret;
 508 }
 509
 510 /**************************************************************************
 511  *           NtUserAddClipboardFormatListener    (win32u.@)
 512  */
 513 BOOL WINAPI NtUserAddClipboardFormatListener( HWND hwnd )
 514 {
 515     BOOL ret;
 516
 517     SERVER_START_REQ( add_clipboard_listener )
 518     {
 519         req->window = wine_server_user_handle( hwnd );
 520         ret = !wine_server_call_err( req );
 521     }
 522     SERVER_END_REQ;
 523     return ret;
 524 }
 525
 526 /**************************************************************************
 527  *           NtUserRemoveClipboardFormatListener    (win32u.@)
 528  */
 529 BOOL WINAPI NtUserRemoveClipboardFormatListener( HWND hwnd )
 530 {
 531     BOOL ret;
 532
 533     SERVER_START_REQ( remove_clipboard_listener )
 534     {
 535         req->window = wine_server_user_handle( hwnd );
 536         ret = !wine_server_call_err( req );
 537     }
 538     SERVER_END_REQ;
 539     return ret;
 540 }
 541
 542 /**************************************************************************
 543  *           release_clipboard_owner
 544  */
 545 void release_clipboard_owner( HWND hwnd )
 546 {
 547     HWND viewer = 0, owner = 0;
 548
 549     send_message( hwnd, WM_RENDERALLFORMATS, 0, 0 );
 550
 551     SERVER_START_REQ( release_clipboard )
 552     {
 553         req->owner = wine_server_user_handle( hwnd );
 554         if (!wine_server_call( req ))
 555         {
 556             viewer = wine_server_ptr_handle( reply->viewer );
 557             owner = wine_server_ptr_handle( reply->owner );
 558         }
 559     }
 560     SERVER_END_REQ;
 561
 562     if (viewer)
 563         NtUserMessageCall( viewer, WM_DRAWCLIPBOARD, (WPARAM)owner, 0,
 564                            0, NtUserSendNotifyMessage, FALSE );
 565 }
 566
 567 /**************************************************************************
 568  *           NtUserSetClipboardData    (win32u.@)
 569  */
 570 NTSTATUS WINAPI NtUserSetClipboardData( UINT format, HANDLE data, struct set_clipboard_params *params )
 571 {
 572     struct cached_format *cache = NULL, *prev = NULL;
 573     LCID lcid;
 574     void *ptr = NULL;
 575     data_size_t size = 0;
 576     NTSTATUS status = STATUS_SUCCESS;
 577
 578     TRACE( "%s %p\n", debugstr_format( format ), data );
 579
 580     if (params->cache_only)
 581     {
 582         pthread_mutex_lock( &clipboard_mutex );
 583         if ((cache = get_cached_format( format )) && cache->seqno == params->seqno)
 584             cache->handle = data;
 585         else
 586             status = STATUS_UNSUCCESSFUL;
 587         pthread_mutex_unlock( &clipboard_mutex );
 588         return status;
 589     }
 590
 591     if (params->data)
 592     {
 593         ptr = params->data;
 594         size = params->size;
 595         if (data)
 596         {
 597             if (!(cache = malloc( sizeof(*cache) ))) goto done;
 598             cache->format = format;
 599             cache->handle = data;
 600         }
 601
 602         if (format == CF_BITMAP || format == CF_PALETTE)
 603         {
 604             make_gdi_object_system( cache->handle, TRUE );
 605         }
 606     }
 607     NtQueryDefaultLocale( TRUE, &lcid );
 608
 609     pthread_mutex_lock( &clipboard_mutex );
 610
 611     SERVER_START_REQ( set_clipboard_data )
 612     {
 613         req->format = format;
 614         req->lcid = lcid;
 615         wine_server_add_data( req, ptr, size );
 616         if (!(status = wine_server_call( req )))
 617         {
 618             if (cache) cache->seqno = reply->seqno;
 619         }
 620     }
 621     SERVER_END_REQ;
 622
 623     if (!status)
 624     {
 625         /* free the previous entry if any */
 626         if ((prev = get_cached_format( format ))) list_remove( &prev->entry );
 627         if (cache) list_add_tail( &cached_formats, &cache->entry );
 628     }
 629     else free( cache );
 630
 631     pthread_mutex_unlock( &clipboard_mutex );
 632     if (prev) free_cached_data( prev );
 633
 634 done:
 635     return status;
 636 }
 637
 638 /**************************************************************************
 639  *           NtUserGetClipboardData    (win32u.@)
 640  */
 641 HANDLE WINAPI NtUserGetClipboardData( UINT format, struct get_clipboard_params *params )
 642 {
 643     struct cached_format *cache = NULL;
 644     unsigned int status;
 645     UINT from, data_seqno;
 646     size_t size;
 647     HWND owner;
 648     BOOL render = TRUE;
 649
 650     for (;;)
 651     {
 652         pthread_mutex_lock( &clipboard_mutex );
 653
 654         if (!params->data_only) cache = get_cached_format( format );
 655
 656         SERVER_START_REQ( get_clipboard_data )
 657         {
 658             req->format = format;
 659             req->render = render;
 660             if (cache && cache->handle)
 661             {
 662                 req->cached = 1;
 663                 req->seqno = cache->seqno;
 664             }
 665             wine_server_set_reply( req, params->data, params->size );
 666             status = wine_server_call( req );
 667             from = reply->from;
 668             size = reply->total;
 669             data_seqno = reply->seqno;
 670             owner = wine_server_ptr_handle( reply->owner );
 671         }
 672         SERVER_END_REQ;
 673
 674         params->size = size;
 675
 676         if (!status && size)
 677         {
 678             if (cache)
 679             {
 680                 if (cache->handle && data_seqno == cache->seqno)  /* we can reuse the cached data */
 681                 {
 682                     HANDLE ret = cache->handle;
 683                     pthread_mutex_unlock( &clipboard_mutex );
 684                     TRACE( "%s returning %p\n", debugstr_format( format ), ret );
 685                     return ret;
 686                 }
 687
 688                 /* cache entry is stale, remove it */
 689                 list_remove( &cache->entry );
 690                 list_add_tail( &formats_to_free, &cache->entry );
 691             }
 692
 693             if (params->data_only)
 694             {
 695                 pthread_mutex_unlock( &clipboard_mutex );
 696                 return params->data;
 697             }
 698
 699             /* allocate new cache entry */
 700             if (!(cache = malloc( sizeof(*cache) )))
 701             {
 702                 pthread_mutex_unlock( &clipboard_mutex );
 703                 return 0;
 704             }
 705
 706             cache->format = format;
 707             cache->seqno  = data_seqno;
 708             cache->handle = NULL;
 709             params->seqno = cache->seqno;
 710             list_add_tail( &cached_formats, &cache->entry );
 711             pthread_mutex_unlock( &clipboard_mutex );
 712             TRACE( "%s needs unmarshaling\n", debugstr_format( format ) );
 713             params->data_size = ~0;
 714             return 0;
 715         }
 716         pthread_mutex_unlock( &clipboard_mutex );
 717
 718         if (status == STATUS_BUFFER_OVERFLOW)
 719         {
 720             params->data_size = size;
 721             return 0;
 722         }
 723         if (status == STATUS_OBJECT_NAME_NOT_FOUND)
 724         {
 725             RtlSetLastWin32Error( ERROR_NOT_FOUND ); /* no such format */
 726             return 0;
 727         }
 728         if (status)
 729         {
 730             RtlSetLastWin32Error( RtlNtStatusToDosError( status ));
 731             TRACE( "%s error %08x\n", debugstr_format( format ), status );
 732             return 0;
 733         }
 734         if (render)  /* try rendering it */
 735         {
 736             render = FALSE;
 737             if (from)
 738             {
 739                 struct render_synthesized_format_params params = { .format = format, .from = from };
 740                 ULONG ret_len;
 741                 void *ret_ptr;
 742                 KeUserModeCallback( NtUserRenderSynthesizedFormat, &params, sizeof(params),
 743                                     &ret_ptr, &ret_len );
 744                 continue;
 745             }
 746             if (owner)
 747             {
 748                 TRACE( "%s sending WM_RENDERFORMAT to %p\n", debugstr_format( format ), owner );
 749                 send_message( owner, WM_RENDERFORMAT, format, 0 );
 750                 continue;
 751             }
 752         }
 753         TRACE( "%s returning 0\n", debugstr_format( format ));
 754         return 0;
 755     }
 756 }