Converted to the new debug interface, using script written by Patrik
[wine] / windows / clipboard.c
1 /*
2  * WINE clipboard function handling
3  *
4  * Copyright 1994 Martin Ayotte
5  *           1996 Alex Korobka
6  *
7  */
8
9 #include <stdlib.h>
10 #include <sys/types.h>
11 #include <sys/stat.h>
12 #include <fcntl.h>
13 #include <unistd.h>
14 #include <string.h>
15 #include "winuser.h"
16 #include "wine/winuser16.h"
17 #include "heap.h"
18 #include "task.h"
19 #include "message.h"
20 #include "clipboard.h"
21 #include "xmalloc.h"
22 #include "debug.h"
23
24 DEFAULT_DEBUG_CHANNEL(clipboard)
25
26 #define  CF_REGFORMATBASE       0xC000
27
28 /**************************************************************************
29  *                      internal variables
30  */
31
32 CLIPBOARD_DRIVER *CLIPBOARD_Driver = NULL;
33
34 static HQUEUE16 hqClipLock   = 0;
35 static BOOL bCBHasChanged  = FALSE;
36
37 HWND hWndClipOwner  = 0;   /* current clipboard owner */
38 HWND hWndClipWindow = 0;   /* window that opened clipboard */
39 static HWND hWndViewer     = 0;   /* start of viewers chain */
40
41 static WORD LastRegFormat = CF_REGFORMATBASE;
42
43 WINE_CLIPFORMAT ClipFormats[16]  = {
44     { CF_TEXT, 1, 0, "Text", (HANDLE)NULL, 0, NULL, &ClipFormats[1] , (HANDLE16)NULL},
45     { CF_BITMAP, 1, 0, "Bitmap", (HANDLE)NULL, 0, &ClipFormats[0], &ClipFormats[2] , (HANDLE16)NULL},
46     { CF_METAFILEPICT, 1, 0, "MetaFile Picture", (HANDLE)NULL, 0, &ClipFormats[1], &ClipFormats[3] , (HANDLE16)NULL},
47     { CF_SYLK, 1, 0, "Sylk", (HANDLE)NULL, 0, &ClipFormats[2], &ClipFormats[4] , (HANDLE16)NULL},
48     { CF_DIF, 1, 0, "DIF", (HANDLE)NULL, 0, &ClipFormats[3], &ClipFormats[5] , (HANDLE16)NULL},
49     { CF_TIFF, 1, 0, "TIFF", (HANDLE)NULL, 0, &ClipFormats[4], &ClipFormats[6] , (HANDLE16)NULL},
50     { CF_OEMTEXT, 1, 0, "OEM Text", (HANDLE)NULL, 0, &ClipFormats[5], &ClipFormats[7] , (HANDLE16)NULL},
51     { CF_DIB, 1, 0, "DIB", (HANDLE)NULL, 0, &ClipFormats[6], &ClipFormats[8] , (HANDLE16)NULL},
52     { CF_PALETTE, 1, 0, "Palette", (HANDLE)NULL, 0, &ClipFormats[7], &ClipFormats[9] , (HANDLE16)NULL},
53     { CF_PENDATA, 1, 0, "PenData", (HANDLE)NULL, 0, &ClipFormats[8], &ClipFormats[10] , (HANDLE16)NULL},
54     { CF_RIFF, 1, 0, "RIFF", (HANDLE)NULL, 0, &ClipFormats[9], &ClipFormats[11] , (HANDLE16)NULL},
55     { CF_WAVE, 1, 0, "Wave", (HANDLE)NULL, 0, &ClipFormats[10], &ClipFormats[12] , (HANDLE16)NULL},
56     { CF_OWNERDISPLAY, 1, 0, "Owner Display", (HANDLE)NULL, 0, &ClipFormats[11], &ClipFormats[13] , (HANDLE16)NULL},
57     { CF_DSPTEXT, 1, 0, "DSPText", (HANDLE)NULL, 0, &ClipFormats[12], &ClipFormats[14] , (HANDLE16)NULL},
58     { CF_DSPMETAFILEPICT, 1, 0, "DSPMetaFile Picture", (HANDLE)NULL, 0, &ClipFormats[13], &ClipFormats[15] , (HANDLE16)NULL},
59     { CF_DSPBITMAP, 1, 0, "DSPBitmap", (HANDLE)NULL, 0, &ClipFormats[14], NULL , (HANDLE16)NULL}
60     };
61
62 static LPWINE_CLIPFORMAT __lookup_format( LPWINE_CLIPFORMAT lpFormat, WORD wID )
63 {
64     while(TRUE)
65     {
66         if (lpFormat == NULL ||
67             lpFormat->wFormatID == wID) break;
68         lpFormat = lpFormat->NextFormat;
69     }
70     return lpFormat;
71 }
72
73 /**************************************************************************
74  *                      CLIPBOARD_ResetLock
75  */
76 void CLIPBOARD_ResetLock( HQUEUE16 hqCurrent, HQUEUE16 hqNew )
77 {
78     if( hqClipLock == hqCurrent )
79     {
80         if( hqNew )
81             hqClipLock = hqNew;
82         else
83         {
84             hWndClipOwner = 0;
85             hWndClipWindow = 0;
86             EmptyClipboard();
87             hqClipLock = 0;
88         }
89     }
90 }
91
92
93 /**************************************************************************
94  *                      CLIPBOARD_DeleteRecord
95  */
96 void CLIPBOARD_DeleteRecord(LPWINE_CLIPFORMAT lpFormat, BOOL bChange)
97 {
98     if( (lpFormat->wFormatID >= CF_GDIOBJFIRST &&
99          lpFormat->wFormatID <= CF_GDIOBJLAST) || lpFormat->wFormatID == CF_BITMAP )
100     {
101       if (lpFormat->hData32)
102         DeleteObject(lpFormat->hData32);
103       if (lpFormat->hData16)
104         DeleteObject16(lpFormat->hData16);
105     }
106     else if( lpFormat->wFormatID == CF_METAFILEPICT )
107     {
108       if (lpFormat->hData32)
109       {
110         DeleteMetaFile( ((METAFILEPICT *)GlobalLock( lpFormat->hData32 ))->hMF );
111         GlobalFree(lpFormat->hData32);
112         if (lpFormat->hData16)
113           /* HMETAFILE16 and HMETAFILE32 are apparently the same thing, 
114              and a shallow copy is enough to share a METAFILEPICT
115              structure between 16bit and 32bit clipboards.  The MetaFile
116              should of course only be deleted once. */
117           GlobalFree16(lpFormat->hData16);
118       }
119       else if (lpFormat->hData16)
120       {
121         DeleteMetaFile16( ((METAFILEPICT16 *)GlobalLock16( lpFormat->hData16 ))->hMF );
122         GlobalFree16(lpFormat->hData16);
123       }
124     }
125     else 
126     {
127       if (lpFormat->hData32)
128         GlobalFree(lpFormat->hData32);
129       if (lpFormat->hData16)
130         GlobalFree16(lpFormat->hData16);
131     }
132
133     lpFormat->wDataPresent = 0; 
134     lpFormat->hData16 = 0;
135     lpFormat->hData32 = 0;
136
137     if( bChange ) bCBHasChanged = TRUE;
138 }
139
140 /**************************************************************************
141  *                      CLIPBOARD_IsPresent
142  */
143 BOOL CLIPBOARD_IsPresent(WORD wFormat)
144 {
145     /* special case */
146
147     if( wFormat == CF_TEXT || wFormat == CF_OEMTEXT )
148         return ClipFormats[CF_TEXT-1].wDataPresent ||
149                ClipFormats[CF_OEMTEXT-1].wDataPresent;
150     else
151     {
152         LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
153         if( lpFormat ) return (lpFormat->wDataPresent);
154     }
155     return FALSE;
156 }
157
158 /**************************************************************************
159  *            OpenClipboard16   (USER.137)
160  */
161 BOOL16 WINAPI OpenClipboard16( HWND16 hWnd )
162 {
163     return OpenClipboard( hWnd );
164 }
165
166
167 /**************************************************************************
168  *            OpenClipboard32   (USER32.407)
169  *
170  * Note: Netscape uses NULL hWnd to open the clipboard.
171  */
172 BOOL WINAPI OpenClipboard( HWND hWnd )
173 {
174     BOOL bRet;
175
176     TRACE(clipboard,"(%04x)...\n", hWnd);
177
178     if (!hqClipLock)
179     {
180          hqClipLock = GetFastQueue16();
181          hWndClipWindow = hWnd;
182          bCBHasChanged = FALSE;
183          bRet = TRUE;
184     }
185     else bRet = FALSE;
186
187     TRACE(clipboard,"   returning %i\n", bRet);
188     return bRet;
189 }
190
191
192 /**************************************************************************
193  *            CloseClipboard16   (USER.138)
194  */
195 BOOL16 WINAPI CloseClipboard16(void)
196 {
197     return CloseClipboard();
198 }
199
200
201 /**************************************************************************
202  *            CloseClipboard32   (USER32.54)
203  */
204 BOOL WINAPI CloseClipboard(void)
205 {
206     TRACE(clipboard,"!\n");
207
208     if (hqClipLock == GetFastQueue16())
209     {
210         hWndClipWindow = 0;
211
212         if (bCBHasChanged && hWndViewer) 
213             SendMessage16(hWndViewer, WM_DRAWCLIPBOARD, 0, 0L);
214         hqClipLock = 0;
215     }
216     return TRUE;
217 }
218
219
220 /**************************************************************************
221  *            EmptyClipboard16   (USER.139)
222  */
223 BOOL16 WINAPI EmptyClipboard16(void)
224 {
225     return EmptyClipboard();
226 }
227
228
229 /**************************************************************************
230  *            EmptyClipboard32   (USER32.169)
231  */
232 BOOL WINAPI EmptyClipboard(void)
233 {
234     LPWINE_CLIPFORMAT lpFormat = ClipFormats; 
235
236     TRACE(clipboard,"(void)\n");
237
238     if (hqClipLock != GetFastQueue16()) return FALSE;
239
240     /* destroy private objects */
241
242     if (hWndClipOwner)
243         SendMessage16(hWndClipOwner, WM_DESTROYCLIPBOARD, 0, 0L);
244   
245     while(lpFormat) 
246     {
247         if ( lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32 )
248              CLIPBOARD_DeleteRecord( lpFormat, TRUE );
249
250         lpFormat = lpFormat->NextFormat;
251     }
252
253     hWndClipOwner = hWndClipWindow;
254
255     CLIPBOARD_Driver->pEmpty();
256
257     return TRUE;
258 }
259
260
261 /**************************************************************************
262  *            GetClipboardOwner16   (USER.140)
263  */
264 HWND16 WINAPI GetClipboardOwner16(void)
265 {
266     return hWndClipOwner;
267 }
268
269
270 /**************************************************************************
271  *            GetClipboardOwner32   (USER32.225)
272  */
273 HWND WINAPI GetClipboardOwner(void)
274 {
275     return hWndClipOwner;
276 }
277
278
279 /**************************************************************************
280  *            SetClipboardData16   (USER.141)
281  */
282 HANDLE16 WINAPI SetClipboardData16( UINT16 wFormat, HANDLE16 hData )
283 {
284     LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
285
286     TRACE(clipboard, "(%04X, %04x) !\n", wFormat, hData);
287
288     /* NOTE: If the hData is zero and current owner doesn't match
289      * the window that opened the clipboard then this application
290      * is screwed because WM_RENDERFORMAT will go to the owner
291      * (to become the owner it must call EmptyClipboard() before
292      *  adding new data).
293      */
294
295     if( (hqClipLock != GetFastQueue16()) || !lpFormat ||
296         (!hData && (!hWndClipOwner || (hWndClipOwner != hWndClipWindow))) ) return 0; 
297
298     CLIPBOARD_Driver->pSetData(wFormat);
299
300     if ( lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32 ) 
301     {
302         CLIPBOARD_DeleteRecord(lpFormat, TRUE);
303
304         /* delete existing CF_TEXT/CF_OEMTEXT aliases */
305
306         if( wFormat == CF_TEXT 
307             && ( ClipFormats[CF_OEMTEXT-1].hData16 
308                  ||  ClipFormats[CF_OEMTEXT-1].hData32 )
309             && !ClipFormats[CF_OEMTEXT-1].wDataPresent )
310             CLIPBOARD_DeleteRecord(&ClipFormats[CF_OEMTEXT-1], TRUE);
311         if( wFormat == CF_OEMTEXT 
312             && ( ClipFormats[CF_OEMTEXT-1].hData16 
313                  ||  ClipFormats[CF_OEMTEXT-1].hData32 )
314             && !ClipFormats[CF_TEXT-1].wDataPresent )
315             CLIPBOARD_DeleteRecord(&ClipFormats[CF_TEXT-1], TRUE);
316     }
317
318     bCBHasChanged = TRUE;
319     lpFormat->wDataPresent = 1;
320     lpFormat->hData16 = hData;          /* 0 is legal, see WM_RENDERFORMAT */
321     lpFormat->hData32 = 0;
322
323     return lpFormat->hData16;
324 }
325
326
327 /**************************************************************************
328  *            SetClipboardData   (USER32.470)
329  */
330 HANDLE WINAPI SetClipboardData( UINT wFormat, HANDLE hData )
331 {
332     LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
333
334     TRACE(clipboard, "(%08X, %08x) !\n", wFormat, hData);
335
336     /* NOTE: If the hData is zero and current owner doesn't match
337      * the window that opened the clipboard then this application
338      * is screwed because WM_RENDERFORMAT will go to the owner
339      * (to become the owner it must call EmptyClipboard() before
340      *  adding new data).
341      */
342
343     if( (hqClipLock != GetFastQueue16()) || !lpFormat ||
344         (!hData && (!hWndClipOwner || (hWndClipOwner != hWndClipWindow))) ) return 0; 
345
346     CLIPBOARD_Driver->pSetData(wFormat);
347
348     if ( lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32 ) 
349     {
350         CLIPBOARD_DeleteRecord(lpFormat, TRUE);
351
352         /* delete existing CF_TEXT/CF_OEMTEXT aliases */
353
354         if( wFormat == CF_TEXT 
355             && ( ClipFormats[CF_OEMTEXT-1].hData16 
356                  ||  ClipFormats[CF_OEMTEXT-1].hData32 )
357             && !ClipFormats[CF_OEMTEXT-1].wDataPresent )
358             CLIPBOARD_DeleteRecord(&ClipFormats[CF_OEMTEXT-1], TRUE);
359         if( wFormat == CF_OEMTEXT 
360             && ( ClipFormats[CF_OEMTEXT-1].hData16 
361                  ||  ClipFormats[CF_OEMTEXT-1].hData32 )
362             && !ClipFormats[CF_TEXT-1].wDataPresent )
363             CLIPBOARD_DeleteRecord(&ClipFormats[CF_TEXT-1], TRUE);
364     }
365
366     bCBHasChanged = TRUE;
367     lpFormat->wDataPresent = 1;
368     lpFormat->hData32 = hData;          /* 0 is legal, see WM_RENDERFORMAT */
369     lpFormat->hData16 = 0;
370
371     return lpFormat->hData32;
372 }
373
374
375 /**************************************************************************
376  *                      CLIPBOARD_RenderFormat
377  */
378 static BOOL CLIPBOARD_RenderFormat(LPWINE_CLIPFORMAT lpFormat)
379 {
380   if( lpFormat->wDataPresent && !lpFormat->hData16 && !lpFormat->hData32 )
381   {
382     if( IsWindow(hWndClipOwner) )
383       SendMessage16(hWndClipOwner,WM_RENDERFORMAT,
384                     (WPARAM16)lpFormat->wFormatID,0L);
385     else
386     {
387       WARN(clipboard, "\thWndClipOwner (%04x) is lost!\n", 
388            hWndClipOwner);
389       hWndClipOwner = 0; lpFormat->wDataPresent = 0;
390       return FALSE;
391     }
392   }
393   return (lpFormat->hData16 || lpFormat->hData32) ? TRUE : FALSE;
394 }
395
396 /**************************************************************************
397  *                      CLIPBOARD_RenderText
398  *
399  * Convert text between UNIX and DOS formats.
400  *
401  * FIXME: Should be a pair of driver functions that convert between OEM text and Windows.
402  *
403  */
404 static BOOL CLIPBOARD_RenderText(LPWINE_CLIPFORMAT lpTarget, LPWINE_CLIPFORMAT lpSource)
405 {
406     UINT16 size;
407     LPCSTR lpstrS; 
408     LPSTR  lpstrT;
409
410     if (lpSource->hData32)
411     {
412       size = GlobalSize( lpSource->hData32 );
413       lpstrS = (LPSTR)GlobalLock(lpSource->hData32);
414     }
415     else
416     {
417       size = GlobalSize16( lpSource->hData16 );
418       lpstrS = (LPSTR)GlobalLock16(lpSource->hData16);
419     }
420
421     if( !lpstrS ) return FALSE;
422     TRACE(clipboard,"\tconverting from '%s' to '%s', %i chars\n",
423                                       lpSource->Name, lpTarget->Name, size);
424
425     lpTarget->hData32 = GlobalAlloc(GMEM_ZEROINIT, size); 
426     lpstrT = (LPSTR)GlobalLock(lpTarget->hData32);
427
428     if( lpstrT )
429     {
430         if( lpSource->wFormatID == CF_TEXT )
431             CharToOemBuffA(lpstrS, lpstrT, size);
432         else
433             OemToCharBuffA(lpstrS, lpstrT, size);
434         TRACE(clipboard,"\tgot %s\n", lpstrT);
435         GlobalUnlock(lpTarget->hData32);
436         if (lpSource->hData32)
437           GlobalUnlock(lpSource->hData32);
438         else
439           GlobalUnlock16(lpSource->hData16);
440         return TRUE;
441     }
442
443     lpTarget->hData32 = 0;
444     if (lpSource->hData32)
445       GlobalUnlock(lpSource->hData32);
446     else
447       GlobalUnlock16(lpSource->hData16);
448     return FALSE;
449 }
450
451 /**************************************************************************
452  *             GetClipboardData16   (USER.142)
453  */
454 HANDLE16 WINAPI GetClipboardData16( UINT16 wFormat )
455 {
456     LPWINE_CLIPFORMAT lpRender = ClipFormats; 
457     LPWINE_CLIPFORMAT lpUpdate = NULL;
458
459     if (hqClipLock != GetFastQueue16()) return 0;
460
461     TRACE(clipboard,"(%04X)\n", wFormat);
462
463     if( wFormat == CF_TEXT && !lpRender[CF_TEXT-1].wDataPresent 
464                            &&  lpRender[CF_OEMTEXT-1].wDataPresent )
465     {
466         lpRender = &ClipFormats[CF_OEMTEXT-1];
467         lpUpdate = &ClipFormats[CF_TEXT-1];
468
469         TRACE(clipboard,"\tOEMTEXT -> TEXT\n");
470     }
471     else if( wFormat == CF_OEMTEXT && !lpRender[CF_OEMTEXT-1].wDataPresent
472                                    &&  lpRender[CF_TEXT-1].wDataPresent )
473     {
474         lpRender = &ClipFormats[CF_TEXT-1];
475         lpUpdate = &ClipFormats[CF_OEMTEXT-1];
476         
477         TRACE(clipboard,"\tTEXT -> OEMTEXT\n");
478     }
479     else
480     {
481         lpRender = __lookup_format( ClipFormats, wFormat );
482         lpUpdate = lpRender;
483     }
484    
485     if( !lpRender || !CLIPBOARD_RenderFormat(lpRender) ) return 0; 
486     if( lpUpdate != lpRender && !lpUpdate->hData16 && !lpUpdate->hData32 ) 
487         CLIPBOARD_RenderText(lpUpdate, lpRender);
488
489     if( lpUpdate->hData32 && !lpUpdate->hData16 )
490     {
491       int size;
492       if( lpUpdate->wFormatID == CF_METAFILEPICT )
493         size = sizeof( METAFILEPICT16 );
494       else
495         size = GlobalSize(lpUpdate->hData32);
496       lpUpdate->hData16 = GlobalAlloc16(GMEM_ZEROINIT, size);
497       if( !lpUpdate->hData16 )
498         ERR(clipboard, "(%04X) -- not enough memory in 16b heap\n", wFormat);
499       else
500       {
501       if( lpUpdate->wFormatID == CF_METAFILEPICT )
502       {
503         FIXME(clipboard,"\timplement function CopyMetaFilePict32to16\n");
504         FIXME(clipboard,"\tin the appropriate file.\n");
505 #ifdef SOMEONE_IMPLEMENTED_ME
506         CopyMetaFilePict32to16( GlobalLock16(lpUpdate->hData16), 
507                                 GlobalLock(lpUpdate->hData32) );
508 #endif
509       }
510       else
511       {
512         memcpy( GlobalLock16(lpUpdate->hData16), 
513                 GlobalLock(lpUpdate->hData32), 
514                 size );
515       }
516         GlobalUnlock16(lpUpdate->hData16);
517         GlobalUnlock(lpUpdate->hData32);
518       }
519     }
520
521     TRACE(clipboard,"\treturning %04x (type %i)\n", 
522                               lpUpdate->hData16, lpUpdate->wFormatID);
523     return lpUpdate->hData16;
524 }
525
526
527 /**************************************************************************
528  *             GetClipboardData32   (USER32.222)
529  */
530 HANDLE WINAPI GetClipboardData( UINT wFormat )
531 {
532     LPWINE_CLIPFORMAT lpRender = ClipFormats; 
533     LPWINE_CLIPFORMAT lpUpdate = NULL;
534
535     if (hqClipLock != GetFastQueue16()) return 0;
536
537     TRACE(clipboard,"(%08X)\n", wFormat);
538
539     if( wFormat == CF_TEXT && !lpRender[CF_TEXT-1].wDataPresent 
540                            &&  lpRender[CF_OEMTEXT-1].wDataPresent )
541     {
542         lpRender = &ClipFormats[CF_OEMTEXT-1];
543         lpUpdate = &ClipFormats[CF_TEXT-1];
544
545         TRACE(clipboard,"\tOEMTEXT -> TEXT\n");
546     }
547     else if( wFormat == CF_OEMTEXT && !lpRender[CF_OEMTEXT-1].wDataPresent
548                                    &&  lpRender[CF_TEXT-1].wDataPresent )
549     {
550         lpRender = &ClipFormats[CF_TEXT-1];
551         lpUpdate = &ClipFormats[CF_OEMTEXT-1];
552         
553         TRACE(clipboard,"\tTEXT -> OEMTEXT\n");
554     }
555     else
556     {
557         lpRender = __lookup_format( ClipFormats, wFormat );
558         lpUpdate = lpRender;
559     }
560    
561     if( !lpRender || !CLIPBOARD_RenderFormat(lpRender) ) return 0; 
562     if( lpUpdate != lpRender && !lpUpdate->hData16 && !lpUpdate->hData32 ) 
563         CLIPBOARD_RenderText(lpUpdate, lpRender);
564
565     if( lpUpdate->hData16 && !lpUpdate->hData32 )
566     {
567       int size;
568       if( lpUpdate->wFormatID == CF_METAFILEPICT )
569         size = sizeof( METAFILEPICT );
570       else
571         size = GlobalSize16(lpUpdate->hData16);
572       lpUpdate->hData32 = GlobalAlloc(GMEM_ZEROINIT, size); 
573       if( lpUpdate->wFormatID == CF_METAFILEPICT )
574       {
575         FIXME(clipboard,"\timplement function CopyMetaFilePict16to32\n");
576         FIXME(clipboard,"\tin the appropriate file.\n");
577 #ifdef SOMEONE_IMPLEMENTED_ME
578         CopyMetaFilePict16to32( GlobalLock16(lpUpdate->hData32), 
579                                 GlobalLock(lpUpdate->hData16) );
580 #endif
581       }
582       else
583       {
584         memcpy( GlobalLock(lpUpdate->hData32), 
585                 GlobalLock16(lpUpdate->hData16), 
586                 size );
587       }
588       GlobalUnlock(lpUpdate->hData32);
589       GlobalUnlock16(lpUpdate->hData16);
590     }
591
592     TRACE(clipboard,"\treturning %04x (type %i)\n", 
593                               lpUpdate->hData32, lpUpdate->wFormatID);
594     return lpUpdate->hData32;
595 }
596
597 /**************************************************************************
598  *           CountClipboardFormats16   (USER.143)
599  */
600 INT16 WINAPI CountClipboardFormats16(void)
601 {
602     return CountClipboardFormats();
603 }
604
605
606 /**************************************************************************
607  *           CountClipboardFormats32   (USER32.63)
608  */
609 INT WINAPI CountClipboardFormats(void)
610 {
611     INT FormatCount = 0;
612     LPWINE_CLIPFORMAT lpFormat = ClipFormats; 
613
614     TRACE(clipboard,"(void)\n");
615
616     while(TRUE) 
617     {
618         if (lpFormat == NULL) break;
619
620         if( lpFormat->wFormatID != CF_TEXT )
621             CLIPBOARD_Driver->pGetData( lpFormat->wFormatID );
622  
623         if (lpFormat->wDataPresent) 
624         {
625             TRACE(clipboard, "\tdata found for format %i\n", lpFormat->wFormatID);
626             FormatCount++;
627         }
628         lpFormat = lpFormat->NextFormat;
629     }
630
631     /* these two are equivalent, adjust the total */
632
633     FormatCount += abs(ClipFormats[CF_TEXT-1].wDataPresent -
634                        ClipFormats[CF_OEMTEXT-1].wDataPresent);
635
636     TRACE(clipboard,"\ttotal %d\n", FormatCount);
637     return FormatCount;
638 }
639
640
641 /**************************************************************************
642  *            EnumClipboardFormats16   (USER.144)
643  */
644 UINT16 WINAPI EnumClipboardFormats16( UINT16 wFormat )
645 {
646     return EnumClipboardFormats( wFormat );
647 }
648
649
650 /**************************************************************************
651  *            EnumClipboardFormats32   (USER32.179)
652  */
653 UINT WINAPI EnumClipboardFormats( UINT wFormat )
654 {
655     LPWINE_CLIPFORMAT lpFormat = ClipFormats; 
656
657     TRACE(clipboard,"(%04X)\n", wFormat);
658
659     if( hqClipLock != GetFastQueue16() ) return 0;
660
661     if( wFormat < CF_OEMTEXT )
662         CLIPBOARD_Driver->pGetData( CF_OEMTEXT );
663
664     if (wFormat == 0) /* start from the beginning */
665         lpFormat = ClipFormats;
666     else
667     {
668         /* walk up to the specified format record */
669
670         if( !(lpFormat = __lookup_format( lpFormat, wFormat )) ) 
671             return 0;
672         lpFormat = lpFormat->NextFormat; /* right */
673     }
674
675     while(TRUE) 
676     {
677         if (lpFormat == NULL) return 0;
678
679         if( lpFormat->wFormatID != CF_OEMTEXT && lpFormat->wFormatID != CF_TEXT )
680             CLIPBOARD_Driver->pGetData( lpFormat->wFormatID );
681
682         if (lpFormat->wDataPresent || 
683            (lpFormat->wFormatID == CF_OEMTEXT && ClipFormats[CF_TEXT-1].wDataPresent) ||
684            (lpFormat->wFormatID == CF_TEXT && ClipFormats[CF_OEMTEXT-1].wDataPresent) )
685             break;
686         lpFormat = lpFormat->NextFormat;
687     }
688
689     return lpFormat->wFormatID;
690 }
691
692
693 /**************************************************************************
694  *            RegisterClipboardFormat16  (USER.145)
695  */
696 UINT16 WINAPI RegisterClipboardFormat16( LPCSTR FormatName )
697 {
698     LPWINE_CLIPFORMAT lpNewFormat; 
699     LPWINE_CLIPFORMAT lpFormat = ClipFormats; 
700
701     if (FormatName == NULL) return 0;
702
703     TRACE(clipboard,"('%s') !\n", FormatName);
704
705     /* walk format chain to see if it's already registered */
706
707     while(TRUE) 
708     {
709         if ( !strcmp(lpFormat->Name,FormatName) )
710         {
711              lpFormat->wRefCount++;
712              return lpFormat->wFormatID;
713         }
714  
715         if ( lpFormat->NextFormat == NULL ) break;
716
717         lpFormat = lpFormat->NextFormat;
718     }
719
720     /* allocate storage for new format entry */
721
722     lpNewFormat = (LPWINE_CLIPFORMAT)xmalloc(sizeof(WINE_CLIPFORMAT));
723     lpFormat->NextFormat = lpNewFormat;
724     lpNewFormat->wFormatID = LastRegFormat;
725     lpNewFormat->wRefCount = 1;
726
727     lpNewFormat->Name = (LPSTR)xmalloc(strlen(FormatName) + 1);
728     strcpy(lpNewFormat->Name, FormatName);
729
730     lpNewFormat->wDataPresent = 0;
731     lpNewFormat->hData16 = 0;
732     lpNewFormat->hData32 = 0;
733     lpNewFormat->BufSize = 0;
734     lpNewFormat->PrevFormat = lpFormat;
735     lpNewFormat->NextFormat = NULL;
736
737     return LastRegFormat++;
738 }
739
740
741 /**************************************************************************
742  *            RegisterClipboardFormat32A   (USER32.431)
743  */
744 UINT WINAPI RegisterClipboardFormatA( LPCSTR formatName )
745 {
746     return RegisterClipboardFormat16( formatName );
747 }
748
749
750 /**************************************************************************
751  *            RegisterClipboardFormat32W   (USER32.432)
752  */
753 UINT WINAPI RegisterClipboardFormatW( LPCWSTR formatName )
754 {
755     LPSTR aFormat = HEAP_strdupWtoA( GetProcessHeap(), 0, formatName );
756     UINT ret = RegisterClipboardFormatA( aFormat );
757     HeapFree( GetProcessHeap(), 0, aFormat );
758     return ret;
759 }
760
761 /**************************************************************************
762  *            GetClipboardFormatName16   (USER.146)
763  */
764 INT16 WINAPI GetClipboardFormatName16( UINT16 wFormat, LPSTR retStr, INT16 maxlen )
765 {
766     return GetClipboardFormatNameA( wFormat, retStr, maxlen );
767 }
768
769
770 /**************************************************************************
771  *            GetClipboardFormatName32A   (USER32.223)
772  */
773 INT WINAPI GetClipboardFormatNameA( UINT wFormat, LPSTR retStr, INT maxlen )
774 {
775     LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
776
777     TRACE(clipboard, "(%04X, %p, %d) !\n", wFormat, retStr, maxlen);
778
779     if (lpFormat == NULL || lpFormat->Name == NULL || 
780         lpFormat->wFormatID < CF_REGFORMATBASE) return 0;
781
782     TRACE(clipboard, "Name='%s' !\n", lpFormat->Name);
783
784     lstrcpynA( retStr, lpFormat->Name, maxlen );
785     return strlen(retStr);
786 }
787
788
789 /**************************************************************************
790  *            GetClipboardFormatName32W   (USER32.224)
791  */
792 INT WINAPI GetClipboardFormatNameW( UINT wFormat, LPWSTR retStr, INT maxlen )
793 {
794     LPSTR p = HEAP_xalloc( GetProcessHeap(), 0, maxlen );
795     INT ret = GetClipboardFormatNameA( wFormat, p, maxlen );
796     lstrcpynAtoW( retStr, p, maxlen );
797     HeapFree( GetProcessHeap(), 0, p );
798     return ret;
799 }
800
801
802 /**************************************************************************
803  *            SetClipboardViewer16   (USER.147)
804  */
805 HWND16 WINAPI SetClipboardViewer16( HWND16 hWnd )
806 {
807     return SetClipboardViewer( hWnd );
808 }
809
810
811 /**************************************************************************
812  *            SetClipboardViewer32   (USER32.471)
813  */
814 HWND WINAPI SetClipboardViewer( HWND hWnd )
815 {
816     HWND hwndPrev = hWndViewer;
817
818     TRACE(clipboard,"(%04x): returning %04x\n", hWnd, hwndPrev);
819
820     hWndViewer = hWnd;
821     return hwndPrev;
822 }
823
824
825 /**************************************************************************
826  *           GetClipboardViewer16   (USER.148)
827  */
828 HWND16 WINAPI GetClipboardViewer16(void)
829 {
830     return hWndViewer;
831 }
832
833
834 /**************************************************************************
835  *           GetClipboardViewer32   (USER32.226)
836  */
837 HWND WINAPI GetClipboardViewer(void)
838 {
839     return hWndViewer;
840 }
841
842
843 /**************************************************************************
844  *           ChangeClipboardChain16   (USER.149)
845  */
846 BOOL16 WINAPI ChangeClipboardChain16(HWND16 hWnd, HWND16 hWndNext)
847 {
848     return ChangeClipboardChain(hWnd, hWndNext);
849 }
850
851 /**************************************************************************
852  *           ChangeClipboardChain32   (USER32.22)
853  */
854 BOOL WINAPI ChangeClipboardChain(HWND hWnd, HWND hWndNext)
855 {
856     BOOL bRet = 0;
857
858     FIXME(clipboard, "(0x%04x, 0x%04x): stub?\n", hWnd, hWndNext);
859
860     if( hWndViewer )
861         bRet = !SendMessage16( hWndViewer, WM_CHANGECBCHAIN,
862                              (WPARAM16)hWnd, (LPARAM)hWndNext);   
863     else
864         WARN(clipboard, "hWndViewer is lost\n");
865
866     if( hWnd == hWndViewer ) hWndViewer = hWndNext;
867
868     return bRet;
869 }
870
871
872
873 /**************************************************************************
874  *           IsClipboardFormatAvailable16   (USER.193)
875  */
876 BOOL16 WINAPI IsClipboardFormatAvailable16( UINT16 wFormat )
877 {
878     return IsClipboardFormatAvailable( wFormat );
879 }
880
881
882 /**************************************************************************
883  *           IsClipboardFormatAvailable32   (USER32.340)
884  */
885 BOOL WINAPI IsClipboardFormatAvailable( UINT wFormat )
886 {
887     TRACE(clipboard,"(%04X) !\n", wFormat);
888
889     CLIPBOARD_Driver->pGetData( (wFormat == CF_TEXT) ? CF_OEMTEXT : wFormat );
890
891     return CLIPBOARD_IsPresent(wFormat);
892 }
893
894
895 /**************************************************************************
896  *             GetOpenClipboardWindow16   (USER.248)
897  */
898 HWND16 WINAPI GetOpenClipboardWindow16(void)
899 {
900     return hWndClipWindow;
901 }
902
903
904 /**************************************************************************
905  *             GetOpenClipboardWindow32   (USER32.277)
906  */
907 HWND WINAPI GetOpenClipboardWindow(void)
908 {
909     return hWndClipWindow;
910 }
911
912
913 /**************************************************************************
914  *             GetPriorityClipboardFormat16   (USER.402)
915  */
916 INT16 WINAPI GetPriorityClipboardFormat16( UINT16 *lpPriorityList, INT16 nCount)
917 {
918     FIXME(clipboard, "(%p,%d): stub\n", lpPriorityList, nCount );
919     return 0;
920 }
921
922
923 /**************************************************************************
924  *             GetPriorityClipboardFormat32   (USER32.279)
925  */
926 INT WINAPI GetPriorityClipboardFormat( UINT *lpPriorityList, INT nCount )
927 {
928     int Counter;
929
930     if(CountClipboardFormats() == 0) 
931     { 
932         return 0;
933     }
934
935     for(Counter = 0; Counter <= nCount; Counter++)
936     {
937         if(IsClipboardFormatAvailable(*(lpPriorityList+sizeof(INT)*Counter)))
938             return *(lpPriorityList+sizeof(INT)*Counter);
939     }
940
941     return -1;
942 }
943
944
945