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