source: trunk/src/user32/clipboard.cpp@ 8650

Last change on this file since 8650 was 7736, checked in by sandervl, 24 years ago

fixed SetClipboardData for CF_UNICODETEXT
File size: 12.1 KB
Line 
1/* $Id: clipboard.cpp,v 1.14 2002-01-07 14:32:21 sandervl Exp $ */
2
3/*
4 * Win32 Clipboard API functions for OS/2
5 *
6 * Copyright 1998 Sander van Leeuwen
7 * Copyright 1998 Patrick Haller
8 * Copyright 1998 Peter Fitzsimmons
9 *
10 *
11 * NOTE: Use OS/2 frame handles for Open32 functions
12 *
13 * Project Odin Software License can be found in LICENSE.TXT
14 *
15 */
16
17#include <os2win.h>
18#include <string.h>
19#include "win32wbase.h"
20#include <unicode.h>
21
22#define DBG_LOCALLOG DBG_clipboard
23#include "dbglocal.h"
24
25#ifdef USING_OPEN32CLIPBOARD
26
27#define FLAG_TO_OPEN32 0
28#define FLAG_FROM_OPEN32 1
29
30//******************************************************************************
31//******************************************************************************
32HGLOBAL GlobalCopy(HGLOBAL hDest, HGLOBAL hSource, BOOL fToOpen32)
33{
34 LPVOID src;
35 LPVOID dest;
36 ULONG size;
37
38 if(fToOpen32 == FLAG_TO_OPEN32) {
39 src = GlobalLock(hSource);
40 if(src) {
41 size = GlobalSize(hSource);
42 if(hDest == NULL) {
43 hDest = O32_GlobalAlloc(GHND, size);
44 }
45 dest = O32_GlobalLock(hDest);
46 memcpy(dest, src, size);
47 O32_GlobalUnlock(hDest);
48 }
49 GlobalUnlock(hSource);
50 }
51 else {
52 src = O32_GlobalLock(hSource);
53 if(src) {
54 size = O32_GlobalSize(hSource);
55 if(hDest == NULL) {
56 hDest = GlobalAlloc(GHND, size);
57 }
58 dest = GlobalLock(hDest);
59 memcpy(dest, src, size);
60 GlobalUnlock(hDest);
61 }
62 O32_GlobalUnlock(hSource);
63 }
64 return hDest;
65}
66#endif
67
68//******************************************************************************
69//******************************************************************************
70BOOL WIN32API ChangeClipboardChain( HWND hwndRemove, HWND hwndNext)
71{
72 Win32BaseWindow *wndRemove, *wndNext;
73 HWND hwndOS2Remove, hwndOS2Next;
74
75 wndRemove = Win32BaseWindow::GetWindowFromHandle(hwndRemove);
76 if(!wndRemove) {
77 dprintf(("ChangeClipboardChain, window %x not found", hwndRemove));
78 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
79 return 0;
80 }
81 hwndOS2Remove = wndRemove->getOS2WindowHandle();
82 RELEASE_WNDOBJ(wndRemove);
83
84 wndNext = Win32BaseWindow::GetWindowFromHandle(hwndNext);
85 if(!wndNext) {
86 dprintf(("ChangeClipboardChain, window %x not found", hwndNext));
87 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
88 return 0;
89 }
90 hwndOS2Next = wndNext->getOS2WindowHandle();
91 RELEASE_WNDOBJ(wndNext);
92
93 dprintf(("USER32: ChangeClipboardChain\n"));
94 return O32_ChangeClipboardChain(hwndOS2Remove, hwndOS2Next);
95}
96//******************************************************************************
97//******************************************************************************
98BOOL WIN32API CloseClipboard(void)
99{
100 dprintf(("USER32: CloseClipboard\n"));
101 return O32_CloseClipboard();
102}
103//******************************************************************************
104//******************************************************************************
105int WIN32API CountClipboardFormats(void)
106{
107 dprintf(("USER32: CountClipboardFormats\n"));
108 return O32_CountClipboardFormats();
109}
110//******************************************************************************
111//******************************************************************************
112BOOL WIN32API EmptyClipboard(void)
113{
114 dprintf(("USER32: EmptyClipboard\n"));
115 return O32_EmptyClipboard();
116}
117//******************************************************************************
118//******************************************************************************
119UINT WIN32API EnumClipboardFormats(UINT arg1)
120{
121 dprintf(("USER32: EnumClipboardFormats\n"));
122 return O32_EnumClipboardFormats(arg1);
123}
124//******************************************************************************
125//******************************************************************************
126HANDLE WIN32API GetClipboardData( UINT uFormat)
127{
128#ifdef USING_OPEN32CLIPBOARD
129 HANDLE hClipObj = 0, hClipObjOpen32 = 0;
130
131 dprintf(("USER32: GetClipboardData %x", uFormat));
132 hClipObjOpen32 = O32_GetClipboardData(uFormat);
133 //memory leak
134 if(hClipObjOpen32) {
135 hClipObj = GlobalCopy(NULL, hClipObjOpen32, FLAG_FROM_OPEN32);
136 }
137 return hClipObj;
138#else
139 dprintf(("USER32: GetClipboardData %x", uFormat));
140 return O32_GetClipboardData(uFormat);
141#endif
142}
143//******************************************************************************
144//******************************************************************************
145int WIN32API GetClipboardFormatNameA(UINT format,LPSTR lpszFormatName,int cchMaxCount)
146{
147 dprintf(("USER32: GetClipboardFormatNameA %d\n",format));
148 return O32_GetClipboardFormatName(format,lpszFormatName,cchMaxCount);
149}
150//******************************************************************************
151//******************************************************************************
152int WIN32API GetClipboardFormatNameW(UINT format,LPWSTR lpszFormatName,int cchMaxCount)
153{
154 int rc;
155 char *astring = (CHAR*)malloc(cchMaxCount);
156
157 dprintf(("USER32: GetClipboardFormatNameW %d\n",format));
158 rc = O32_GetClipboardFormatName(format,astring,cchMaxCount);
159 if (rc) AsciiToUnicode(astring,lpszFormatName);
160 free(astring);
161 return(rc);
162}
163//******************************************************************************
164//******************************************************************************
165HWND WIN32API GetClipboardOwner(void)
166{
167 HWND hwndOwner;
168 Win32BaseWindow *window;
169
170 dprintf(("USER32: GetClipboardOwner\n"));
171 hwndOwner = O32_GetClipboardOwner();
172
173 window = Win32BaseWindow::GetWindowFromOS2Handle(hwndOwner);
174 if(!window) {
175 //an OS/2 window probably owns the clipboard, we pretend nobody owns it
176 return NULL;
177 }
178 hwndOwner = window->getWindowHandle();
179 RELEASE_WNDOBJ(window);
180 return hwndOwner;
181}
182//******************************************************************************
183//******************************************************************************
184HWND WIN32API GetClipboardViewer(void)
185{
186 Win32BaseWindow *window;
187 HWND hwndViewer;
188
189 dprintf(("USER32: GetClipboardViewer\n"));
190 hwndViewer = O32_GetClipboardViewer();
191
192 window = Win32BaseWindow::GetWindowFromOS2Handle(hwndViewer);
193 if(!window) {
194 //probably an OS/2 window, we pretend it's nobody
195 return NULL;
196 }
197 hwndViewer = window->getWindowHandle();
198 RELEASE_WNDOBJ(window);
199 return hwndViewer;
200}
201//******************************************************************************
202//******************************************************************************
203HWND WIN32API GetOpenClipboardWindow(void)
204{
205 Win32BaseWindow *window;
206 HWND hwnd;
207
208 dprintf(("USER32: GetOpenClipboardWindow\n"));
209 hwnd = O32_GetOpenClipboardWindow();
210
211 window = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
212 if(!window) {
213 //probably an OS/2 window, we pretend it's nobody
214 return NULL;
215 }
216 hwnd = window->getWindowHandle();
217 RELEASE_WNDOBJ(window);
218 return hwnd;
219}
220//******************************************************************************
221//******************************************************************************
222int WIN32API GetPriorityClipboardFormat( PUINT arg1, int arg2)
223{
224 dprintf(("USER32: GetPriorityClipboardFormat\n"));
225 return O32_GetPriorityClipboardFormat(arg1, arg2);
226}
227//******************************************************************************
228//******************************************************************************
229BOOL WIN32API IsClipboardFormatAvailable( UINT arg1)
230{
231 dprintf(("USER32: IsClipboardFormatAvailable %x", arg1));
232 return O32_IsClipboardFormatAvailable(arg1);
233}
234//******************************************************************************
235//******************************************************************************
236BOOL WIN32API OpenClipboard( HWND hwnd)
237{
238 Win32BaseWindow *window;
239
240 if (hwnd) {
241 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
242 if(!window) {
243 dprintf(("OpenClipboard, window %x not found", hwnd));
244 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
245 return 0;
246 }
247 hwnd = window->getOS2WindowHandle();
248 RELEASE_WNDOBJ(window);
249 }
250 dprintf(("USER32: OpenClipboard %x", hwnd));
251 return O32_OpenClipboard(hwnd);
252}
253//******************************************************************************
254//******************************************************************************
255UINT WIN32API RegisterClipboardFormatA( LPCSTR arg1)
256{
257 dprintf(("USER32: RegisterClipboardFormatA %s", arg1));
258 return O32_RegisterClipboardFormat(arg1);
259}
260//******************************************************************************
261//******************************************************************************
262UINT WIN32API RegisterClipboardFormatW(LPCWSTR arg1)
263{
264 UINT rc;
265 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
266
267 dprintf(("USER32: RegisterClipboardFormatW %s\n", astring));
268 rc = O32_RegisterClipboardFormat(astring);
269 FreeAsciiString(astring);
270 dprintf(("USER32: RegisterClipboardFormatW returned %d\n", rc));
271 return(rc);
272}
273//******************************************************************************
274//******************************************************************************
275HANDLE WIN32API SetClipboardData( UINT uFormat, HANDLE hClipObj)
276{
277#ifdef USING_OPEN32CLIPBOARD
278 HANDLE hClipObjOpen32 = 0;
279
280 dprintf(("USER32: SetClipboardData %x %x", uFormat, hClipObj));
281 //memory leak
282 if(hClipObj) {
283 hClipObjOpen32 = GlobalCopy(NULL, hClipObj, FLAG_TO_OPEN32);
284 }
285 O32_SetClipboardData(uFormat, hClipObjOpen32);
286
287 return hClipObj;
288#else
289 dprintf(("USER32: SetClipboardData %x %x", uFormat, hClipObj));
290
291 if(uFormat == CF_UNICODETEXT)
292 {
293 //have to translate to CF_TEXT, because WGSS doesn't understand
294 //unicode text
295 LPWSTR lpTextUnicode;
296 LPSTR lpTextAscii;
297 DWORD length;
298 HANDLE hClipObjAscii;
299
300 lpTextUnicode = (LPWSTR)GlobalLock(hClipObj);
301 if(lpTextUnicode == NULL) {
302 dprintf(("!ERROR!: Invalid handle!!"));
303 SetLastError(ERROR_INVALID_HANDLE);
304 return 0;
305 }
306 length = GlobalSize(hClipObj)/sizeof(WCHAR);
307 hClipObjAscii = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, length);
308 lpTextAscii = (LPSTR)GlobalLock(hClipObjAscii);
309 if(!hClipObjAscii || lpTextAscii == NULL || length == 0) {
310 dprintf(("!ERROR!: GlobalAlloc %d failed!!", length));
311 SetLastError(ERROR_INVALID_HANDLE);
312 return 0;
313 }
314 WideCharToMultiByte(CP_ACP, 0, lpTextUnicode, -1, lpTextAscii, length, 0, NULL);
315
316 GlobalUnlock(hClipObjAscii);
317 GlobalUnlock(hClipObj);
318 HANDLE ret = O32_SetClipboardData(CF_TEXT, hClipObjAscii);
319 //hClipObjAscii will be freed when the clipboard is closed
320 return ret;
321 }
322 return O32_SetClipboardData(uFormat, hClipObj);
323#endif
324}
325//******************************************************************************
326//******************************************************************************
327HWND WIN32API SetClipboardViewer( HWND hwndNew)
328{
329 Win32BaseWindow *wndnew, *wndold;
330 HWND hwndOld;
331 HWND hwndOS2New;
332
333 wndnew = Win32BaseWindow::GetWindowFromHandle(hwndNew);
334 if(!wndnew) {
335 dprintf(("SetClipboardViewer, window %x not found", hwndNew));
336 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
337 return 0;
338 }
339 dprintf(("USER32: SetClipboardViewer %x", hwndNew));
340 hwndOS2New = wndnew->getOS2WindowHandle();
341 RELEASE_WNDOBJ(wndnew);
342
343 hwndOld = O32_SetClipboardViewer(hwndOS2New);
344
345 wndold = Win32BaseWindow::GetWindowFromOS2Handle(hwndOld);
346 if(!wndold) {
347 //probably an OS/2 window, so pretend it's nobody
348 return 0;
349 }
350 hwndOld = wndold->getWindowHandle();
351 RELEASE_WNDOBJ(wndold);
352 return hwndOld;
353}
354//******************************************************************************
355//******************************************************************************
Note: See TracBrowser for help on using the repository browser.