win32ss/user/ntuser/clipboard.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * PURPOSE:          Clipboard routines
   5  * FILE:             win32ss/user/ntuser/clipboard.c
   6  * PROGRAMER:        Filip Navara <xnavara@volny.cz>
   7  *                   Pablo Borobia <pborobia@gmail.com>
   8  *                   Rafal Harabien <rafalh@reactos.org>
   9  */
  10
  11 #include <win32k.h>
  12 DBG_DEFAULT_CHANNEL(UserClipbrd);
  13
  14 #define DATA_DELAYED     (HANDLE)0
  15 #define DATA_SYNTH_USER  (HANDLE)1
  16 #define DATA_SYNTH_KRNL  (HANDLE)2
  17 #define IS_DATA_DELAYED(ce)     ((ce)->hData == DATA_DELAYED)
  18 #define IS_DATA_SYNTHESIZED(ce) ((ce)->hData == DATA_SYNTH_USER || (ce)->hData == DATA_SYNTH_KRNL)
  19
  20 static PWINSTATION_OBJECT FASTCALL
  21 IntGetWinStaForCbAccess(VOID)
  22 {
  23     HWINSTA hWinSta;
  24     PWINSTATION_OBJECT pWinStaObj;
  25     NTSTATUS Status;
  26
  27     hWinSta = UserGetProcessWindowStation();
  28     Status = IntValidateWindowStationHandle(hWinSta, UserMode, WINSTA_ACCESSCLIPBOARD, &pWinStaObj, 0);
  29     if (!NT_SUCCESS(Status))
  30     {
  31         ERR("Cannot open winsta\n");
  32         SetLastNtError(Status);
  33         return NULL;
  34     }
  35
  36     return pWinStaObj;
  37 }
  38
  39 /* If format exists, returns a non-null value (pointing to formated object) */
  40 static PCLIP FASTCALL
  41 IntGetFormatElement(PWINSTATION_OBJECT pWinStaObj, UINT fmt)
  42 {
  43     DWORD i;
  44
  45     for (i = 0; i < pWinStaObj->cNumClipFormats; ++i)
  46     {
  47         if (pWinStaObj->pClipBase[i].fmt == fmt)
  48             return &pWinStaObj->pClipBase[i];
  49     }
  50
  51     return NULL;
  52 }
  53
  54 static BOOL FASTCALL
  55 IntIsFormatAvailable(PWINSTATION_OBJECT pWinStaObj, UINT fmt)
  56 {
  57     return IntGetFormatElement(pWinStaObj, fmt) != NULL;
  58 }
  59
  60 static VOID FASTCALL
  61 IntFreeElementData(PCLIP pElement)
  62 {
  63     if (!IS_DATA_DELAYED(pElement) &&
  64         !IS_DATA_SYNTHESIZED(pElement))
  65     {
  66         if (pElement->fGlobalHandle)
  67             UserDeleteObject(pElement->hData, TYPE_CLIPDATA);
  68         else if (pElement->fmt == CF_BITMAP || pElement->fmt == CF_PALETTE ||
  69                  pElement->fmt == CF_DSPBITMAP)
  70         {
  71             GreSetObjectOwner(pElement->hData, GDI_OBJ_HMGR_POWNED);
  72             GreDeleteObject(pElement->hData);
  73         }
  74     }
  75 }
  76
  77 /* Adds a new format and data to the clipboard */
  78 static PCLIP NTAPI
  79 IntAddFormatedData(PWINSTATION_OBJECT pWinStaObj, UINT fmt, HANDLE hData, BOOLEAN fGlobalHandle, BOOL bEnd)
  80 {
  81     PCLIP pElement = NULL;
  82
  83     /* Use existing entry with specified format */
  84     if (!bEnd)
  85         pElement = IntGetFormatElement(pWinStaObj, fmt);
  86
  87     /* Put new entry at the end if nothing was found */
  88     if (!pElement)
  89     {
  90         /* Allocate bigger clipboard if needed. We could use lists but Windows uses array */
  91         if (pWinStaObj->cNumClipFormats % 4 == 0)
  92         {
  93             PCLIP pNewClip;
  94
  95             /* Allocate new clipboard */
  96             pNewClip = ExAllocatePoolWithTag(PagedPool,
  97                                              (pWinStaObj->cNumClipFormats + 4) * sizeof(CLIP),
  98                                              USERTAG_CLIPBOARD);
  99             if (!pNewClip)
 100             {
 101                 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
 102                 return NULL;
 103             }
 104
 105             /* Copy data */
 106             memcpy(pNewClip, pWinStaObj->pClipBase, pWinStaObj->cNumClipFormats * sizeof(CLIP));
 107
 108             /* Free old clipboard */
 109             if (pWinStaObj->pClipBase)
 110                 ExFreePoolWithTag(pWinStaObj->pClipBase, USERTAG_CLIPBOARD);
 111
 112             /* Update WinSta */
 113             pWinStaObj->pClipBase = pNewClip;
 114         }
 115
 116         /* New element is at the end */
 117         pElement = &pWinStaObj->pClipBase[pWinStaObj->cNumClipFormats];
 118         pElement->fmt = fmt;
 119         pWinStaObj->cNumClipFormats++;
 120     }
 121     else
 122         IntFreeElementData(pElement);
 123
 124     pElement->hData = hData;
 125     pElement->fGlobalHandle = fGlobalHandle;
 126
 127     return pElement;
 128 }
 129
 130 static BOOL FASTCALL
 131 IntIsClipboardOpenByMe(PWINSTATION_OBJECT pWinSta)
 132 {
 133     /* Check if the current thread has opened the clipboard */
 134     return (pWinSta->ptiClipLock &&
 135             pWinSta->ptiClipLock == PsGetCurrentThreadWin32Thread());
 136 }
 137
 138 static VOID NTAPI
 139 IntSynthesizeDib(
 140     PWINSTATION_OBJECT pWinStaObj,
 141     HBITMAP hbm)
 142 {
 143     HDC hdc;
 144     ULONG cjInfoSize, cjDataSize;
 145     PCLIPBOARDDATA pClipboardData;
 146     HANDLE hMem;
 147     INT iResult;
 148     struct
 149     {
 150         BITMAPINFOHEADER bmih;
 151         RGBQUAD rgbColors[256];
 152     } bmiBuffer;
 153     PBITMAPINFO pbmi = (PBITMAPINFO)&bmiBuffer;
 154
 155     /* Get the display DC */
 156     hdc = UserGetDCEx(NULL, NULL, DCX_USESTYLE);
 157     if (!hdc)
 158     {
 159         return;
 160     }
 161
 162     /* Get information about the bitmap format */
 163     pbmi->bmiHeader.biSize = sizeof(bmiBuffer.bmih);
 164     iResult = GreGetDIBitsInternal(hdc,
 165                                    hbm,
 166                                    0,
 167                                    0,
 168                                    NULL,
 169                                    pbmi,
 170                                    DIB_RGB_COLORS,
 171                                    0,
 172                                    sizeof(bmiBuffer));
 173     if (iResult == 0)
 174     {
 175        goto cleanup;
 176     }
 177
 178     /* Get the size for a full BITMAPINFO */
 179     cjInfoSize = DIB_BitmapInfoSize(pbmi, DIB_RGB_COLORS);
 180
 181     /* Calculate the size of the clipboard data, which is a packed DIB */
 182     cjDataSize = cjInfoSize + pbmi->bmiHeader.biSizeImage;
 183
 184     /* Create the clipboard data */
 185     pClipboardData = (PCLIPBOARDDATA)UserCreateObject(gHandleTable,
 186                                                       NULL,
 187                                                       NULL,
 188                                                       &hMem,
 189                                                       TYPE_CLIPDATA,
 190                                                       sizeof(CLIPBOARDDATA) + cjDataSize);
 191     if (!pClipboardData)
 192     {
 193         goto cleanup;
 194     }
 195
 196     /* Set the data size */
 197     pClipboardData->cbData = cjDataSize;
 198
 199     /* Copy the BITMAPINFOHEADER */
 200     memcpy(pClipboardData->Data, pbmi, sizeof(BITMAPINFOHEADER));
 201
 202     /* Get the bitmap bits and the color table */
 203     iResult = GreGetDIBitsInternal(hdc,
 204                                    hbm,
 205                                    0,
 206                                    abs(pbmi->bmiHeader.biHeight),
 207                                    (LPBYTE)pClipboardData->Data + cjInfoSize,
 208                                    (LPBITMAPINFO)pClipboardData->Data,
 209                                    DIB_RGB_COLORS,
 210                                    pbmi->bmiHeader.biSizeImage,
 211                                    cjInfoSize);
 212
 213     /* Add the clipboard data */
 214     IntAddFormatedData(pWinStaObj, CF_DIB, hMem, TRUE, TRUE);
 215
 216     /* Release the extra reference (UserCreateObject added 2 references) */
 217     UserDereferenceObject(pClipboardData);
 218
 219 cleanup:
 220     UserReleaseDC(NULL, hdc, FALSE);
 221 }
 222
 223 static VOID WINAPI
 224 IntSynthesizeBitmap(PWINSTATION_OBJECT pWinStaObj, PCLIP pBmEl)
 225 {
 226     HDC hdc = NULL;
 227     PBITMAPINFO pBmi, pConvertedBmi = NULL;
 228     HBITMAP hBm = NULL;
 229     PCLIPBOARDDATA pMemObj;
 230     PCLIP pDibEl;
 231     ULONG Offset;
 232
 233     TRACE("IntSynthesizeBitmap(%p, %p)\n", pWinStaObj, pBmEl);
 234
 235     pDibEl = IntGetFormatElement(pWinStaObj, CF_DIB);
 236     ASSERT(pDibEl && !IS_DATA_SYNTHESIZED(pDibEl));
 237     if (!pDibEl->fGlobalHandle)
 238         return;
 239
 240     pMemObj = (PCLIPBOARDDATA)UserGetObject(gHandleTable, pDibEl->hData, TYPE_CLIPDATA);
 241     if (!pMemObj)
 242         return;
 243
 244     pBmi = (BITMAPINFO*)pMemObj->Data;
 245
 246     if (pMemObj->cbData < sizeof(DWORD) && pMemObj->cbData < pBmi->bmiHeader.biSize)
 247         goto cleanup;
 248
 249     pConvertedBmi = DIB_ConvertBitmapInfo(pBmi, DIB_RGB_COLORS);
 250     if (!pConvertedBmi)
 251         goto cleanup;
 252
 253     Offset = DIB_BitmapInfoSize(pBmi, DIB_RGB_COLORS);
 254
 255     hdc = UserGetDCEx(NULL, NULL, DCX_USESTYLE);
 256     if (!hdc)
 257         goto cleanup;
 258
 259     hBm = GreCreateDIBitmapInternal(hdc,
 260                                     pConvertedBmi->bmiHeader.biWidth,
 261                                     pConvertedBmi->bmiHeader.biHeight,
 262                                     CBM_INIT,
 263                                     pMemObj->Data + Offset,
 264                                     pConvertedBmi,
 265                                     DIB_RGB_COLORS,
 266                                     0,
 267                                     pMemObj->cbData - Offset,
 268                                     0);
 269
 270     if (hBm)
 271     {
 272         GreSetObjectOwner(hBm, GDI_OBJ_HMGR_PUBLIC);
 273         pBmEl->hData = hBm;
 274     }
 275
 276 cleanup:
 277     if (hdc)
 278         UserReleaseDC(NULL, hdc, FALSE);
 279
 280     if (pConvertedBmi)
 281         DIB_FreeConvertedBitmapInfo(pConvertedBmi, pBmi, -1);
 282 }
 283
 284 static VOID NTAPI
 285 IntAddSynthesizedFormats(PWINSTATION_OBJECT pWinStaObj)
 286 {
 287     BOOL bHaveText, bHaveUniText, bHaveOemText, bHaveLocale, bHaveBm, bHaveDib;
 288
 289     bHaveText = IntIsFormatAvailable(pWinStaObj, CF_TEXT);
 290     bHaveOemText = IntIsFormatAvailable(pWinStaObj, CF_OEMTEXT);
 291     bHaveUniText = IntIsFormatAvailable(pWinStaObj, CF_UNICODETEXT);
 292     bHaveLocale = IntIsFormatAvailable(pWinStaObj, CF_LOCALE);
 293     bHaveBm = IntIsFormatAvailable(pWinStaObj, CF_BITMAP);
 294     bHaveDib = IntIsFormatAvailable(pWinStaObj, CF_DIB);
 295
 296     /* Add CF_LOCALE format if we have CF_TEXT */
 297     if (!bHaveLocale && bHaveText)
 298     {
 299         PCLIPBOARDDATA pMemObj;
 300         HANDLE hMem;
 301
 302         pMemObj = (PCLIPBOARDDATA)UserCreateObject(gHandleTable, NULL, NULL, &hMem, TYPE_CLIPDATA,
 303                                                    sizeof(CLIPBOARDDATA) + sizeof(LCID));
 304         if (pMemObj)
 305         {
 306             pMemObj->cbData = sizeof(LCID);
 307             *((LCID*)pMemObj->Data) = NtCurrentTeb()->CurrentLocale;
 308             IntAddFormatedData(pWinStaObj, CF_LOCALE, hMem, TRUE, TRUE);
 309
 310             /* Release the extra reference (UserCreateObject added 2 references) */
 311             UserDereferenceObject(pMemObj);
 312         }
 313     }
 314
 315     /* Add CF_TEXT. Note: it is synthesized in user32.dll */
 316     if (!bHaveText && (bHaveUniText || bHaveOemText))
 317         IntAddFormatedData(pWinStaObj, CF_TEXT, DATA_SYNTH_USER, FALSE, TRUE);
 318
 319     /* Add CF_OEMTEXT. Note: it is synthesized in user32.dll */
 320     if (!bHaveOemText && (bHaveUniText || bHaveText))
 321         IntAddFormatedData(pWinStaObj, CF_OEMTEXT, DATA_SYNTH_USER, FALSE, TRUE);
 322
 323     /* Add CF_UNICODETEXT. Note: it is synthesized in user32.dll */
 324     if (!bHaveUniText && (bHaveText || bHaveOemText))
 325         IntAddFormatedData(pWinStaObj, CF_UNICODETEXT, DATA_SYNTH_USER, FALSE, TRUE);
 326
 327     /* Add CF_BITMAP. Note: it is synthesized on demand */
 328     if (!bHaveBm && bHaveDib)
 329         IntAddFormatedData(pWinStaObj, CF_BITMAP, DATA_SYNTH_KRNL, FALSE, TRUE);
 330
 331     /* Note: We need to render the DIB or DIBV5 format as soon as possible
 332        because pallette information may change */
 333     if (!bHaveDib && bHaveBm)
 334         IntSynthesizeDib(pWinStaObj, IntGetFormatElement(pWinStaObj, CF_BITMAP)->hData);
 335 }
 336
 337 VOID NTAPI
 338 UserEmptyClipboardData(PWINSTATION_OBJECT pWinSta)
 339 {
 340     DWORD i;
 341     PCLIP pElement;
 342
 343     for (i = 0; i < pWinSta->cNumClipFormats; ++i)
 344     {
 345         pElement = &pWinSta->pClipBase[i];
 346         IntFreeElementData(pElement);
 347     }
 348
 349     if (pWinSta->pClipBase)
 350         ExFreePoolWithTag(pWinSta->pClipBase, USERTAG_CLIPBOARD);
 351
 352     pWinSta->pClipBase = NULL;
 353     pWinSta->cNumClipFormats = 0;
 354 }
 355
 356 /* UserClipboardRelease is called from IntSendDestroyMsg in window.c */
 357 VOID FASTCALL
 358 UserClipboardRelease(PWND pWindow)
 359 {
 360     PWINSTATION_OBJECT pWinStaObj;
 361
 362     pWinStaObj = IntGetWinStaForCbAccess();
 363     if (!pWinStaObj)
 364         return;
 365
 366     co_IntSendMessage(pWinStaObj->spwndClipOwner->head.h, WM_RENDERALLFORMATS, 0, 0);
 367
 368     /* If the window being destroyed is the current clipboard owner... */
 369     if (pWindow == pWinStaObj->spwndClipOwner)
 370     {
 371         /* ... make it release the clipboard */
 372         pWinStaObj->spwndClipOwner = NULL;
 373     }
 374
 375     if (pWinStaObj->fClipboardChanged)
 376     {
 377         /* Add synthesized formats - they are rendered later */
 378         IntAddSynthesizedFormats(pWinStaObj);
 379
 380         /* Notify viewer windows in chain */
 381         pWinStaObj->fClipboardChanged = FALSE;
 382         if (pWinStaObj->spwndClipViewer)
 383         {
 384             TRACE("Clipboard: sending WM_DRAWCLIPBOARD to %p\n", pWinStaObj->spwndClipViewer->head.h);
 385             // For 32-bit applications this message is sent as a notification
 386             co_IntSendMessageNoWait(pWinStaObj->spwndClipViewer->head.h, WM_DRAWCLIPBOARD, 0, 0);
 387         }
 388     }
 389
 390     ObDereferenceObject(pWinStaObj);
 391 }
 392
 393 /* UserClipboardFreeWindow is called from co_UserFreeWindow in window.c */
 394 VOID FASTCALL
 395 UserClipboardFreeWindow(PWND pWindow)
 396 {
 397     PWINSTATION_OBJECT pWinStaObj;
 398
 399     pWinStaObj = IntGetWinStaForCbAccess();
 400     if (!pWinStaObj)
 401         return;
 402
 403     if (pWindow == pWinStaObj->spwndClipOwner)
 404     {
 405         /* The owner window was destroyed */
 406         pWinStaObj->spwndClipOwner = NULL;
 407     }
 408
 409     /* Check if clipboard is not locked by this window, if yes, unlock it */
 410     if (pWindow == pWinStaObj->spwndClipOpen)
 411     {
 412         /* The window that opens the clipboard was destroyed */
 413         pWinStaObj->spwndClipOpen = NULL;
 414         pWinStaObj->ptiClipLock = NULL;
 415     }
 416     /* Remove window from window chain */
 417     if (pWindow == pWinStaObj->spwndClipViewer)
 418         pWinStaObj->spwndClipViewer = NULL;
 419
 420     ObDereferenceObject(pWinStaObj);
 421 }
 422
 423 UINT APIENTRY
 424 UserEnumClipboardFormats(UINT fmt)
 425 {
 426     UINT Ret = 0;
 427     PCLIP pElement;
 428     PWINSTATION_OBJECT pWinStaObj;
 429
 430     pWinStaObj = IntGetWinStaForCbAccess();
 431     if (!pWinStaObj)
 432         goto cleanup;
 433
 434     /* Check if the clipboard has been opened */
 435     if (!IntIsClipboardOpenByMe(pWinStaObj))
 436     {
 437         EngSetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 438         goto cleanup;
 439     }
 440
 441     if (fmt == 0)
 442     {
 443         /* Return first format */
 444         if (pWinStaObj->pClipBase)
 445             Ret = pWinStaObj->pClipBase[0].fmt;
 446     }
 447     else
 448     {
 449         /* Return next format */
 450         pElement = IntGetFormatElement(pWinStaObj, fmt);
 451         if (pElement != NULL)
 452         {
 453             ++pElement;
 454             if (pElement < &pWinStaObj->pClipBase[pWinStaObj->cNumClipFormats])
 455             {
 456                 Ret = pElement->fmt;
 457             }
 458         }
 459     }
 460
 461 cleanup:
 462     if (pWinStaObj)
 463         ObDereferenceObject(pWinStaObj);
 464
 465     return Ret;
 466 }
 467
 468 BOOL NTAPI
 469 UserOpenClipboard(HWND hWnd)
 470 {
 471     PWND pWindow = NULL;
 472     BOOL bRet = FALSE;
 473     PWINSTATION_OBJECT pWinStaObj = NULL;
 474
 475     if (hWnd)
 476     {
 477         pWindow = UserGetWindowObject(hWnd);
 478         if (!pWindow)
 479             goto cleanup;
 480     }
 481
 482     pWinStaObj = IntGetWinStaForCbAccess();
 483     if (!pWinStaObj)
 484         goto cleanup;
 485
 486     /* Check if we already opened the clipboard */
 487     if ((pWindow == pWinStaObj->spwndClipOpen) && IntIsClipboardOpenByMe(pWinStaObj))
 488     {
 489         bRet = TRUE;
 490         goto cleanup;
 491     }
 492
 493     /* If the clipboard was already opened by somebody else, bail out */
 494     if ((pWindow != pWinStaObj->spwndClipOpen) && pWinStaObj->ptiClipLock)
 495     {
 496         ERR("Access denied!\n");
 497         EngSetLastError(ERROR_ACCESS_DENIED);
 498         goto cleanup;
 499     }
 500
 501     /* Open the clipboard */
 502     pWinStaObj->spwndClipOpen = pWindow;
 503     pWinStaObj->ptiClipLock = PsGetCurrentThreadWin32Thread();
 504     bRet = TRUE;
 505
 506 cleanup:
 507     if (pWinStaObj)
 508         ObDereferenceObject(pWinStaObj);
 509
 510     return bRet;
 511 }
 512
 513 BOOL APIENTRY
 514 NtUserOpenClipboard(HWND hWnd, DWORD Unknown1)
 515 {
 516     BOOL bRet;
 517
 518     UserEnterExclusive();
 519     bRet = UserOpenClipboard(hWnd);
 520     UserLeave();
 521
 522     return bRet;
 523 }
 524
 525 BOOL NTAPI
 526 UserCloseClipboard(VOID)
 527 {
 528     BOOL bRet = FALSE;
 529     PWINSTATION_OBJECT pWinStaObj;
 530
 531     pWinStaObj = IntGetWinStaForCbAccess();
 532     if (!pWinStaObj)
 533         goto cleanup;
 534
 535     /* Check if the clipboard has been opened */
 536     if (!IntIsClipboardOpenByMe(pWinStaObj))
 537     {
 538         EngSetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 539         goto cleanup;
 540     }
 541
 542     /* Clipboard is no longer open */
 543     pWinStaObj->spwndClipOpen = NULL;
 544     pWinStaObj->ptiClipLock = NULL;
 545     bRet = TRUE;
 546
 547     if (pWinStaObj->fClipboardChanged)
 548     {
 549         /* Add synthesized formats - they are rendered later */
 550         IntAddSynthesizedFormats(pWinStaObj);
 551
 552         /* Notify viewer windows in chain */
 553         pWinStaObj->fClipboardChanged = FALSE;
 554         if (pWinStaObj->spwndClipViewer)
 555         {
 556             TRACE("Clipboard: sending WM_DRAWCLIPBOARD to %p\n", pWinStaObj->spwndClipViewer->head.h);
 557             // For 32-bit applications this message is sent as a notification
 558             co_IntSendMessageNoWait(pWinStaObj->spwndClipViewer->head.h, WM_DRAWCLIPBOARD, 0, 0);
 559         }
 560     }
 561
 562 cleanup:
 563     if (pWinStaObj)
 564         ObDereferenceObject(pWinStaObj);
 565
 566     return bRet;
 567 }
 568
 569 BOOL APIENTRY
 570 NtUserCloseClipboard(VOID)
 571 {
 572     BOOL bRet;
 573
 574     UserEnterExclusive();
 575     bRet = UserCloseClipboard();
 576     UserLeave();
 577
 578     return bRet;
 579 }
 580
 581 HWND APIENTRY
 582 NtUserGetOpenClipboardWindow(VOID)
 583 {
 584     HWND hWnd = NULL;
 585     PWINSTATION_OBJECT pWinStaObj;
 586
 587     UserEnterShared();
 588
 589     pWinStaObj = IntGetWinStaForCbAccess();
 590     if (!pWinStaObj)
 591         goto cleanup;
 592
 593     if (pWinStaObj->spwndClipOpen)
 594         hWnd = pWinStaObj->spwndClipOpen->head.h;
 595
 596     ObDereferenceObject(pWinStaObj);
 597
 598 cleanup:
 599     UserLeave();
 600
 601     return hWnd;
 602 }
 603
 604 BOOL APIENTRY
 605 NtUserChangeClipboardChain(HWND hWndRemove, HWND hWndNewNext)
 606 {
 607     BOOL bRet = FALSE;
 608     PWND pWindowRemove;
 609     PWINSTATION_OBJECT pWinStaObj;
 610
 611     TRACE("NtUserChangeClipboardChain(%p, %p)\n", hWndRemove, hWndNewNext);
 612
 613     UserEnterExclusive();
 614
 615     pWinStaObj = IntGetWinStaForCbAccess();
 616     if (!pWinStaObj)
 617         goto cleanup;
 618
 619     pWindowRemove = UserGetWindowObject(hWndRemove);
 620
 621     if (pWindowRemove && pWinStaObj->spwndClipViewer)
 622     {
 623         if (pWindowRemove == pWinStaObj->spwndClipViewer)
 624             pWinStaObj->spwndClipViewer = UserGetWindowObject(hWndNewNext);
 625
 626         if (pWinStaObj->spwndClipViewer)
 627             bRet = (BOOL)co_IntSendMessage(pWinStaObj->spwndClipViewer->head.h, WM_CHANGECBCHAIN, (WPARAM)hWndRemove, (LPARAM)hWndNewNext);
 628     }
 629
 630     ObDereferenceObject(pWinStaObj);
 631
 632 cleanup:
 633     UserLeave();
 634
 635     return bRet;
 636 }
 637
 638 DWORD APIENTRY
 639 NtUserCountClipboardFormats(VOID)
 640 {
 641     DWORD cFormats = 0;
 642     PWINSTATION_OBJECT pWinStaObj;
 643
 644     UserEnterShared();
 645
 646     pWinStaObj = IntGetWinStaForCbAccess();
 647     if (!pWinStaObj)
 648         goto cleanup;
 649
 650     cFormats = pWinStaObj->cNumClipFormats;
 651
 652     ObDereferenceObject(pWinStaObj);
 653
 654 cleanup:
 655     UserLeave();
 656
 657     return cFormats;
 658 }
 659
 660 BOOL NTAPI
 661 UserEmptyClipboard(VOID)
 662 {
 663     BOOL bRet = FALSE;
 664     PWINSTATION_OBJECT pWinStaObj;
 665
 666     pWinStaObj = IntGetWinStaForCbAccess();
 667     if (!pWinStaObj)
 668         return FALSE;
 669
 670     /* Check if the clipboard has been opened */
 671     if (!IntIsClipboardOpenByMe(pWinStaObj))
 672     {
 673         EngSetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 674         goto cleanup;
 675     }
 676
 677     UserEmptyClipboardData(pWinStaObj);
 678
 679     if (pWinStaObj->spwndClipOwner)
 680     {
 681         TRACE("Clipboard: WM_DESTROYCLIPBOARD to %p\n", pWinStaObj->spwndClipOwner->head.h);
 682         // For 32-bit applications this message is sent as a notification
 683         co_IntSendMessage(pWinStaObj->spwndClipOwner->head.h, WM_DESTROYCLIPBOARD, 0, 0);
 684     }
 685
 686     pWinStaObj->spwndClipOwner = pWinStaObj->spwndClipOpen;
 687
 688     pWinStaObj->iClipSerialNumber++;
 689     pWinStaObj->iClipSequenceNumber++;
 690     pWinStaObj->fClipboardChanged = TRUE;
 691     pWinStaObj->fInDelayedRendering = FALSE;
 692
 693     bRet = TRUE;
 694
 695 cleanup:
 696     if (pWinStaObj)
 697         ObDereferenceObject(pWinStaObj);
 698
 699     return bRet;
 700 }
 701
 702 BOOL APIENTRY
 703 NtUserEmptyClipboard(VOID)
 704 {
 705     BOOL bRet;
 706
 707     TRACE("NtUserEmptyClipboard()\n");
 708
 709     UserEnterExclusive();
 710     bRet = UserEmptyClipboard();
 711     UserLeave();
 712
 713     return bRet;
 714 }
 715
 716 INT APIENTRY
 717 NtUserGetClipboardFormatName(UINT fmt, LPWSTR lpszFormatName, INT cchMaxCount)
 718 {
 719     INT iRet = 0;
 720
 721     UserEnterShared();
 722
 723     /* If the format is built-in we fail */
 724     if (fmt < 0xc000 || fmt > 0xffff)
 725     {
 726         /* Registetrated formats are >= 0xc000 */
 727         goto cleanup;
 728     }
 729
 730     if (cchMaxCount < 1 || !lpszFormatName)
 731     {
 732         EngSetLastError(ERROR_INVALID_PARAMETER);
 733         goto cleanup;
 734     }
 735
 736     _SEH2_TRY
 737     {
 738         ProbeForWrite(lpszFormatName, cchMaxCount * sizeof(WCHAR), 1);
 739
 740         iRet = IntGetAtomName((RTL_ATOM)fmt,
 741                               lpszFormatName,
 742                               cchMaxCount * sizeof(WCHAR));
 743         iRet /= sizeof(WCHAR);
 744     }
 745     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 746     {
 747         SetLastNtError(_SEH2_GetExceptionCode());
 748     }
 749     _SEH2_END;
 750
 751 cleanup:
 752     UserLeave();
 753
 754     return iRet;
 755 }
 756
 757 HWND APIENTRY
 758 NtUserGetClipboardOwner(VOID)
 759 {
 760     HWND hWnd = NULL;
 761     PWINSTATION_OBJECT pWinStaObj;
 762
 763     UserEnterShared();
 764
 765     pWinStaObj = IntGetWinStaForCbAccess();
 766     if (!pWinStaObj)
 767         goto cleanup;
 768
 769     if (pWinStaObj->spwndClipOwner)
 770         hWnd = pWinStaObj->spwndClipOwner->head.h;
 771
 772     ObDereferenceObject(pWinStaObj);
 773
 774 cleanup:
 775     UserLeave();
 776
 777     return hWnd;
 778 }
 779
 780 HWND APIENTRY
 781 NtUserGetClipboardViewer(VOID)
 782 {
 783     HWND hWnd = NULL;
 784     PWINSTATION_OBJECT pWinStaObj;
 785
 786     UserEnterShared();
 787
 788     pWinStaObj = IntGetWinStaForCbAccess();
 789     if (!pWinStaObj)
 790         goto cleanup;
 791
 792     if (pWinStaObj->spwndClipViewer)
 793         hWnd = pWinStaObj->spwndClipViewer->head.h;
 794
 795     ObDereferenceObject(pWinStaObj);
 796
 797 cleanup:
 798     UserLeave();
 799
 800     return hWnd;
 801 }
 802
 803 INT APIENTRY
 804 NtUserGetPriorityClipboardFormat(UINT *paFormatPriorityList, INT cFormats)
 805 {
 806     INT i, iRet = 0;
 807     PWINSTATION_OBJECT pWinStaObj;
 808
 809     UserEnterShared();
 810
 811     pWinStaObj = IntGetWinStaForCbAccess();
 812     if (!pWinStaObj)
 813         goto cleanup;
 814
 815     if (pWinStaObj->pClipBase == NULL)
 816     {
 817         iRet = 0;
 818     }
 819     else
 820     {
 821         _SEH2_TRY
 822         {
 823             ProbeForRead(paFormatPriorityList, cFormats * sizeof(UINT), sizeof(UINT));
 824
 825             iRet = -1;
 826
 827             for (i = 0; i < cFormats; ++i)
 828             {
 829                 if (IntIsFormatAvailable(pWinStaObj, paFormatPriorityList[i]))
 830                 {
 831                     iRet = paFormatPriorityList[i];
 832                     break;
 833                 }
 834             }
 835         }
 836         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 837         {
 838             SetLastNtError(_SEH2_GetExceptionCode());
 839         }
 840         _SEH2_END;
 841     }
 842
 843     ObDereferenceObject(pWinStaObj);
 844
 845 cleanup:
 846     UserLeave();
 847
 848     return iRet;
 849
 850 }
 851
 852 BOOL APIENTRY
 853 NtUserIsClipboardFormatAvailable(UINT fmt)
 854 {
 855     BOOL bRet = FALSE;
 856     PWINSTATION_OBJECT pWinStaObj;
 857
 858     TRACE("NtUserIsClipboardFormatAvailable(%x)\n", fmt);
 859
 860     UserEnterShared();
 861
 862     pWinStaObj = IntGetWinStaForCbAccess();
 863     if (!pWinStaObj)
 864         goto cleanup;
 865
 866     if (IntIsFormatAvailable(pWinStaObj, fmt))
 867         bRet = TRUE;
 868
 869     ObDereferenceObject(pWinStaObj);
 870
 871 cleanup:
 872     UserLeave();
 873
 874     return bRet;
 875 }
 876
 877 HANDLE APIENTRY
 878 NtUserGetClipboardData(UINT fmt, PGETCLIPBDATA pgcd)
 879 {
 880     HANDLE hRet = NULL;
 881     PCLIP pElement;
 882     PWINSTATION_OBJECT pWinStaObj;
 883
 884     TRACE("NtUserGetClipboardData(%x, %p)\n", fmt, pgcd);
 885
 886     UserEnterShared();
 887
 888     pWinStaObj = IntGetWinStaForCbAccess();
 889     if (!pWinStaObj)
 890         goto cleanup;
 891
 892     /* Check if the clipboard has been opened */
 893     if (!IntIsClipboardOpenByMe(pWinStaObj))
 894     {
 895         EngSetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 896         goto cleanup;
 897     }
 898
 899     pElement = IntGetFormatElement(pWinStaObj, fmt);
 900     if (pElement && IS_DATA_DELAYED(pElement) && pWinStaObj->spwndClipOwner)
 901     {
 902         /* Send WM_RENDERFORMAT message */
 903         pWinStaObj->fInDelayedRendering = TRUE;
 904         co_IntSendMessage(pWinStaObj->spwndClipOwner->head.h, WM_RENDERFORMAT, (WPARAM)fmt, 0);
 905         pWinStaObj->fInDelayedRendering = FALSE;
 906
 907         /* Data should be in clipboard now */
 908         pElement = IntGetFormatElement(pWinStaObj, fmt);
 909     }
 910
 911     if (!pElement || IS_DATA_DELAYED(pElement))
 912         goto cleanup;
 913
 914     if (IS_DATA_SYNTHESIZED(pElement))
 915     {
 916         /* Note: Data is synthesized in usermode */
 917         /* TODO: Add more formats */
 918         switch (fmt)
 919         {
 920             case CF_UNICODETEXT:
 921             case CF_TEXT:
 922             case CF_OEMTEXT:
 923                 pElement = IntGetFormatElement(pWinStaObj, CF_UNICODETEXT);
 924                 if (IS_DATA_SYNTHESIZED(pElement))
 925                     pElement = IntGetFormatElement(pWinStaObj, CF_TEXT);
 926                 if (IS_DATA_SYNTHESIZED(pElement))
 927                     pElement = IntGetFormatElement(pWinStaObj, CF_OEMTEXT);
 928                 break;
 929             case CF_BITMAP:
 930                 IntSynthesizeBitmap(pWinStaObj, pElement);
 931                 break;
 932             default:
 933                 ASSERT(FALSE);
 934         }
 935     }
 936
 937     _SEH2_TRY
 938     {
 939         ProbeForWrite(pgcd, sizeof(*pgcd), 1);
 940         pgcd->uFmtRet = pElement->fmt;
 941         pgcd->fGlobalHandle = pElement->fGlobalHandle;
 942
 943         /* Text and bitmap needs more data */
 944         if (fmt == CF_TEXT)
 945         {
 946             PCLIP pLocaleEl;
 947
 948             pLocaleEl = IntGetFormatElement(pWinStaObj, CF_LOCALE);
 949             if (pLocaleEl && !IS_DATA_DELAYED(pLocaleEl))
 950                 pgcd->hLocale = pLocaleEl->hData;
 951         }
 952         else if (fmt == CF_BITMAP)
 953         {
 954             PCLIP pPaletteEl;
 955
 956             pPaletteEl = IntGetFormatElement(pWinStaObj, CF_PALETTE);
 957             if (pPaletteEl && !IS_DATA_DELAYED(pPaletteEl))
 958                 pgcd->hPalette = pPaletteEl->hData;
 959         }
 960
 961         hRet = pElement->hData;
 962     }
 963     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 964     {
 965         SetLastNtError(_SEH2_GetExceptionCode());
 966     }
 967     _SEH2_END;
 968
 969 cleanup:
 970     if (pWinStaObj)
 971         ObDereferenceObject(pWinStaObj);
 972
 973     UserLeave();
 974
 975     TRACE("NtUserGetClipboardData returns %p\n", hRet);
 976
 977     return hRet;
 978 }
 979
 980 HANDLE NTAPI
 981 UserSetClipboardData(UINT fmt, HANDLE hData, PSETCLIPBDATA scd)
 982 {
 983     HANDLE hRet = NULL;
 984     PWINSTATION_OBJECT pWinStaObj;
 985
 986     pWinStaObj = IntGetWinStaForCbAccess();
 987     if (!pWinStaObj)
 988         goto cleanup;
 989
 990     if (!fmt || !pWinStaObj->ptiClipLock)
 991     {
 992         ERR("Access denied!\n");
 993         EngSetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 994         goto cleanup;
 995     }
 996
 997     if (scd->fIncSerialNumber)
 998         pWinStaObj->iClipSerialNumber++;
 999
1000     /* Is it a delayed rendering? */
1001     if (hData)
1002     {
1003         /* Is it a bitmap? */
1004         if (fmt == CF_BITMAP)
1005         {
1006             /* Make bitmap public */
1007             GreSetObjectOwner(hData, GDI_OBJ_HMGR_PUBLIC);
1008         }
1009
1010         /* Save data in the clipboard */
1011         IntAddFormatedData(pWinStaObj, fmt, hData, scd->fGlobalHandle, FALSE);
1012         TRACE("hData stored\n");
1013
1014         /* If the serial number was increased, increase also the sequence number */
1015         if (scd->fIncSerialNumber)
1016             pWinStaObj->iClipSequenceNumber++;
1017
1018         pWinStaObj->fClipboardChanged = TRUE;
1019
1020         /* Note: Synthesized formats are added in NtUserCloseClipboard */
1021     }
1022     else
1023     {
1024         /* This is a delayed rendering */
1025         IntAddFormatedData(pWinStaObj, fmt, DATA_DELAYED, FALSE, FALSE);
1026         TRACE("SetClipboardData delayed format: %u\n", fmt);
1027     }
1028
1029     /* Return hData on success */
1030     hRet = hData;
1031
1032 cleanup:
1033     TRACE("NtUserSetClipboardData returns: %p\n", hRet);
1034
1035     if (pWinStaObj)
1036         ObDereferenceObject(pWinStaObj);
1037
1038     return hRet;
1039 }
1040
1041 HANDLE APIENTRY
1042 NtUserSetClipboardData(UINT fmt, HANDLE hData, PSETCLIPBDATA pUnsafeScd)
1043 {
1044     SETCLIPBDATA scd;
1045     HANDLE hRet;
1046
1047     TRACE("NtUserSetClipboardData(%x %p %p)\n", fmt, hData, pUnsafeScd);
1048
1049     _SEH2_TRY
1050     {
1051         ProbeForRead(pUnsafeScd, sizeof(*pUnsafeScd), 1);
1052         RtlCopyMemory(&scd, pUnsafeScd, sizeof(scd));
1053     }
1054     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1055     {
1056         SetLastNtError(_SEH2_GetExceptionCode());
1057         _SEH2_YIELD(return NULL;)
1058     }
1059     _SEH2_END
1060
1061     UserEnterExclusive();
1062
1063     /* Call internal function */
1064     hRet = UserSetClipboardData(fmt, hData, &scd);
1065
1066     UserLeave();
1067
1068     return hRet;
1069 }
1070
1071 HWND APIENTRY
1072 NtUserSetClipboardViewer(HWND hWndNewViewer)
1073 {
1074     HWND hWndNext = NULL;
1075     PWINSTATION_OBJECT pWinStaObj;
1076     PWND pWindow;
1077
1078     UserEnterExclusive();
1079
1080     pWinStaObj = IntGetWinStaForCbAccess();
1081     if (!pWinStaObj)
1082         goto cleanup;
1083
1084     pWindow = UserGetWindowObject(hWndNewViewer);
1085     if (!pWindow)
1086     {
1087         EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
1088         goto cleanup;
1089     }
1090
1091     /* Return previous viewer. New viever window should
1092        send messages to rest of the chain */
1093     if (pWinStaObj->spwndClipViewer)
1094         hWndNext = pWinStaObj->spwndClipViewer->head.h;
1095
1096     /* Set new viewer window */
1097     pWinStaObj->spwndClipViewer = pWindow;
1098
1099     /* Notify viewer windows in chain */
1100     pWinStaObj->fClipboardChanged = FALSE;
1101     if (pWinStaObj->spwndClipViewer)
1102     {
1103         TRACE("Clipboard: sending WM_DRAWCLIPBOARD to %p\n", pWinStaObj->spwndClipViewer->head.h);
1104         // For 32-bit applications this message is sent as a notification
1105         co_IntSendMessageNoWait(pWinStaObj->spwndClipViewer->head.h, WM_DRAWCLIPBOARD, 0, 0);
1106     }
1107
1108 cleanup:
1109     if (pWinStaObj)
1110         ObDereferenceObject(pWinStaObj);
1111
1112     UserLeave();
1113
1114     return hWndNext;
1115 }
1116
1117 // Sequence number is incremented whenever the contents of the clipboard change
1118 // or the clipboard is emptied. If clipboard rendering is delayed,
1119 // the sequence number is not incremented until the changes are rendered.
1120
1121 DWORD APIENTRY
1122 NtUserGetClipboardSequenceNumber(VOID)
1123 {
1124     DWORD dwRet = 0;
1125     PWINSTATION_OBJECT pWinStaObj;
1126
1127     UserEnterShared();
1128
1129     pWinStaObj = IntGetWinStaForCbAccess();
1130     if (!pWinStaObj)
1131         goto cleanup;
1132
1133     /* Get windowstation sequence number */
1134     dwRet = (DWORD)pWinStaObj->iClipSequenceNumber;
1135
1136     ObDereferenceObject(pWinStaObj);
1137
1138 cleanup:
1139     UserLeave();
1140
1141     return dwRet;
1142 }
1143
1144 HANDLE APIENTRY
1145 NtUserConvertMemHandle(
1146    PVOID pData,
1147    DWORD cbData)
1148 {
1149     HANDLE hMem = NULL;
1150     PCLIPBOARDDATA pMemObj;
1151
1152     UserEnterExclusive();
1153
1154     /* Create Clipboard data object */
1155     pMemObj = UserCreateObject(gHandleTable, NULL, NULL, &hMem, TYPE_CLIPDATA, sizeof(CLIPBOARDDATA) + cbData);
1156     if (!pMemObj)
1157         goto cleanup;
1158
1159     pMemObj->cbData = cbData;
1160
1161     /* Copy data */
1162     _SEH2_TRY
1163     {
1164         ProbeForRead(pData, cbData, 1);
1165         memcpy(pMemObj->Data, pData, cbData);
1166     }
1167     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1168     {
1169         pMemObj = NULL;
1170     }
1171     _SEH2_END;
1172
1173     /* Release the extra reference (UserCreateObject added 2 references) */
1174     UserDereferenceObject(pMemObj);
1175
1176     /* If we failed to copy data, remove handle */
1177     if (!pMemObj)
1178     {
1179         UserDeleteObject(hMem, TYPE_CLIPDATA);
1180         hMem = NULL;
1181     }
1182
1183 cleanup:
1184     UserLeave();
1185
1186     return hMem;
1187 }
1188
1189 NTSTATUS APIENTRY
1190 NtUserCreateLocalMemHandle(
1191    HANDLE hMem,
1192    PVOID pData,
1193    DWORD cbData,
1194    DWORD *pcbData)
1195 {
1196     PCLIPBOARDDATA pMemObj;
1197     NTSTATUS Status = STATUS_SUCCESS;
1198
1199     UserEnterShared();
1200
1201     /* Get Clipboard data object */
1202     pMemObj = (PCLIPBOARDDATA)UserGetObject(gHandleTable, hMem, TYPE_CLIPDATA);
1203     if (!pMemObj)
1204     {
1205         Status = STATUS_INVALID_HANDLE;
1206         goto cleanup;
1207     }
1208
1209     /* Don't overrun */
1210     if (cbData > pMemObj->cbData)
1211         cbData = pMemObj->cbData;
1212
1213     /* Copy data to usermode */
1214     _SEH2_TRY
1215     {
1216         if (pcbData)
1217         {
1218             ProbeForWrite(pcbData, sizeof(*pcbData), 1);
1219             *pcbData = pMemObj->cbData;
1220         }
1221
1222         ProbeForWrite(pData, cbData, 1);
1223         memcpy(pData, pMemObj->Data, cbData);
1224     }
1225     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1226     {
1227         Status = _SEH2_GetExceptionCode();
1228     }
1229     _SEH2_END;
1230
1231 cleanup:
1232     UserLeave();
1233
1234     return Status;
1235 }
1236
1237 /* EOF */