Context Navigation

source: trunk/src/user32/user32.cpp@ 289

Visit:

Last change on this file since 289 was 289, checked in by sandervl, 26 years ago
* empty log message *
File size: 231.6 KB

Line
1	/* $Id: user32.cpp,v 1.19 1999-07-11 21:11:57 sandervl Exp $ */
2
3	/*
4	* Win32 misc user32 API functions for OS/2
5	*
6	* Copyright 1998 Sander van Leeuwen
7	* Copyright 1998 Patrick Haller
8	* Copyright 1998 Peter Fitzsimmons
9	* Copyright 1999 Christoph Bratschi
10	*
11	*
12	* Project Odin Software License can be found in LICENSE.TXT
13	*
14	*/
15	/*****************************************************************************
16	* Name : USER32.CPP
17	* Purpose : This module maps all Win32 functions contained in USER32.DLL
18	* to their OS/2-specific counterparts as far as possible.
19	*****************************************************************************/
20
21	#include <os2win.h>
22	#include "misc.h"
23
24	#include "user32.h"
25	#include "wndproc.h"
26	#include "wndclass.h"
27	#include "icon.h"
28	#include "usrcall.h"
29	#include "syscolor.h"
30
31	#include <wchar.h>
32	#include <stdlib.h>
33	#include <string.h>
34
35	//undocumented stuff
36	// WIN32API CalcChildScroll
37	// WIN32API CascadeChildWindows
38	// WIN32API ClientThreadConnect
39	// WIN32API DragObject
40	// WIN32API DrawFrame
41	// WIN32API EditWndProc
42	// WIN32API EndTask
43	// WIN32API GetInputDesktop
44	// WIN32API GetNextQueueWindow
45	// WIN32API GetShellWindow
46	// WIN32API InitSharedTable
47	// WIN32API InitTask
48	// WIN32API IsHungThread
49	// WIN32API LockWindowStation
50	// WIN32API ModifyAccess
51	// WIN32API PlaySoundEvent
52	// WIN32API RegisterLogonProcess
53	// WIN32API RegisterNetworkCapabilities
54	// WIN32API RegisterSystemThread
55	// WIN32API SetDeskWallpaper
56	// WIN32API SetDesktopBitmap
57	// WIN32API SetInternalWindowPos
58	// WIN32API SetLogonNotifyWindow
59	// WIN32API SetShellWindow
60	// WIN32API SetSysColorsTemp
61	// WIN32API SetWindowFullScreenState
62	// WIN32API SwitchToThisWindow
63	// WIN32API SysErrorBox
64	// WIN32API TileChildWindows
65	// WIN32API UnlockWindowStation
66	// WIN32API UserClientDllInitialize
67	// WIN32API UserSignalProc
68	// WIN32API WinOldAppHackoMatic
69	// WIN32API WNDPROC_CALLBACK
70	// WIN32API YieldTask
71
72
73
74
75	//******************************************************************************
76	//******************************************************************************
77	HWND WIN32API GetActiveWindow()
78	{
79	return(O32_GetActiveWindow());
80	}
81	//******************************************************************************
82	//******************************************************************************
83	int __cdecl wsprintfA(char *lpOut, LPCSTR lpFmt, ...)
84	{
85	int rc;
86	va_list argptr;
87
88	#ifdef DEBUG
89	WriteLog("USER32: wsprintfA\n");
90	WriteLog("USER32: %s\n", lpFmt);
91	#endif
92	va_start(argptr, lpFmt);
93	rc = O32_wvsprintf(lpOut, (char *)lpFmt, argptr);
94	va_end(argptr);
95	#ifdef DEBUG
96	WriteLog("USER32: %s\n", lpOut);
97	#endif
98	return(rc);
99	}
100	//******************************************************************************
101	//******************************************************************************
102	int __cdecl wsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, ...)
103	{
104	int rc;
105	char *lpFmtA;
106	char szOut[512];
107	va_list argptr;
108
109	dprintf(("USER32: wsprintfW(%08xh,%08xh).\n",
110	lpOut,
111	lpFmt));
112
113	lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
114
115	/* @@@PH 98/07/13 transform "%s" to "%ls" does the unicode magic */
116	{
117	PSZ pszTemp;
118	PSZ pszTemp1;
119	ULONG ulStrings;
120	ULONG ulIndex; /* temporary string counter */
121
122	for (ulStrings = 0, /* determine number of placeholders */
123	pszTemp = lpFmtA;
124
125	(pszTemp != NULL) &&
126	(*pszTemp != 0);
127
128	ulStrings++)
129	{
130	pszTemp = strstr(pszTemp,
131	"%s");
132	if (pszTemp != NULL) /* skip 2 characters */
133	{
134	pszTemp++;
135	pszTemp++;
136	}
137	else
138	break; /* leave loop immediately */
139	}
140
141	if (ulStrings != 0) /* transformation required ? */
142	{
143	/* now reallocate lpFmt */
144	ulStrings += strlen(lpFmtA); /* calculate total string length */
145	pszTemp = lpFmtA; /* save string pointer */
146	pszTemp1 = lpFmtA; /* save string pointer */
147
148	/* @@@PH allocation has to be compatible to FreeAsciiString !!! */
149	lpFmtA = (char *)malloc(ulStrings + 1);
150	if (lpFmtA == NULL) /* check proper allocation */
151	return (0); /* raise error condition */
152
153	for (ulIndex = 0;
154	ulIndex <= ulStrings;
155	ulIndex++,
156	pszTemp++)
157	{
158	if ((pszTemp[0] == '%') &&
159	(pszTemp[1] == 's') )
160	{
161	/* replace %s by %ls */
162	lpFmtA[ulIndex++] = '%';
163	lpFmtA[ulIndex ] = 'l';
164	lpFmtA[ulIndex+1] = 's';
165	}
166	else
167	lpFmtA[ulIndex] = pszTemp; / just copy over the character */
168	}
169
170	lpFmtA[ulStrings] = 0; /* string termination */
171
172	FreeAsciiString(pszTemp1); /* the original string is obsolete */
173	}
174	}
175
176	dprintf(("USER32: wsprintfW (%s).\n",
177	lpFmt));
178
179	va_start(argptr,
180	lpFmt);
181
182	rc = O32_wvsprintf(szOut,
183	lpFmtA,
184	argptr);
185
186	AsciiToUnicode(szOut,
187	lpOut);
188
189	FreeAsciiString(lpFmtA);
190	return(rc);
191	}
192	//******************************************************************************
193	//******************************************************************************
194	int WIN32API MessageBoxA(HWND hwndOwner, LPCTSTR lpszText, LPCTSTR lpszTitle, UINT fuStyle)
195	{
196	dprintf(("USER32: MessageBoxA %s %s\n", lpszText, lpszTitle));
197	return(O32_MessageBox(hwndOwner, lpszText, lpszTitle, fuStyle));
198	}
199	//******************************************************************************
200	//******************************************************************************
201	BOOL WIN32API MessageBeep( UINT arg1)
202	{
203	#ifdef DEBUG
204	WriteLog("USER32: MessageBeep\n");
205	#endif
206	return O32_MessageBeep(arg1);
207	}
208	//******************************************************************************
209	//******************************************************************************
210	LONG WIN32API SendDlgItemMessageA( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
211	{
212	#ifdef DEBUG
213	WriteLog("USER32: SendDlgItemMessageA\n");
214	#endif
215	return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
216	}
217	//******************************************************************************
218	//******************************************************************************
219	VOID WIN32API PostQuitMessage( int arg1)
220	{
221	dprintf(("USER32: PostQuitMessage\n"));
222	O32_PostQuitMessage(arg1);
223	}
224	//******************************************************************************
225	// Not implemented by Open32 (31-5-99 Christoph Bratschi)
226	//******************************************************************************
227	BOOL WIN32API IsDlgButtonChecked( HWND arg1, UINT arg2)
228	{
229	#ifdef DEBUG
230	WriteLog("USER32: IsDlgButtonChecked\n");
231	#endif
232	// return O32_IsDlgButtonChecked(arg1, arg2);
233	return (BOOL)SendDlgItemMessageA(arg1,arg2,BM_GETCHECK,0,0);
234	}
235	//******************************************************************************
236	//******************************************************************************
237	int WIN32API GetWindowTextLengthA( HWND arg1)
238	{
239	dprintf(("USER32: GetWindowTextLength\n"));
240	return O32_GetWindowTextLength(arg1);
241	}
242	//******************************************************************************
243	//******************************************************************************
244	int WIN32API GetWindowTextA( HWND arg1, LPSTR arg2, int arg3)
245	{
246	dprintf(("USER32: GetWindowTextA\n"));
247	return O32_GetWindowText(arg1, arg2, arg3);
248	}
249	//******************************************************************************
250
251	/*******************************************************************
252	* InternalGetWindowText (USER32.326)
253	*/
254	int WIN32API InternalGetWindowText(HWND hwnd,
255	LPWSTR lpString,
256	INT nMaxCount )
257	{
258	dprintf(("USER32: InternalGetWindowText(%08xh,%08xh,%08xh) not properly implemented.\n",
259	hwnd,
260	lpString,
261	nMaxCount));
262
263	return GetWindowTextW(hwnd,lpString,nMaxCount);
264	}
265
266
267	//******************************************************************************
268	BOOL WIN32API GetWindowRect( HWND arg1, PRECT arg2)
269	{
270	BOOL rc;
271
272	rc = O32_GetWindowRect(arg1, arg2);
273	dprintf(("USER32: GetWindowRect %X returned %d\n", arg1, rc));
274	return(rc);
275	}
276	//******************************************************************************
277	//******************************************************************************
278	HWND WIN32API GetNextDlgTabItem( HWND arg1, HWND arg2, BOOL arg3)
279	{
280	dprintf(("USER32: GetNextDlgTabItem\n"));
281	return O32_GetNextDlgTabItem(arg1, arg2, arg3);
282	}
283	//******************************************************************************
284	//******************************************************************************
285	BOOL WIN32API GetMessageA( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
286	{
287	//// dprintf(("USER32: GetMessage\n"));
288	return O32_GetMessage(arg1, arg2, arg3, arg4);
289	}
290	//******************************************************************************
291	//******************************************************************************
292	HWND WIN32API GetFocus(void)
293	{
294	// dprintf(("USER32: GetFocus\n"));
295	return O32_GetFocus();
296	}
297	//******************************************************************************
298	//******************************************************************************
299	HWND WIN32API GetDlgItem(HWND arg1, int arg2)
300	{
301	HWND rc;
302
303	rc = O32_GetDlgItem(arg1, arg2);
304	dprintf(("USER32: GetDlgItem %d returned %d\n", arg2, rc));
305	return(rc);
306	}
307	//******************************************************************************
308	//******************************************************************************
309	int WIN32API GetDlgCtrlID( HWND arg1)
310	{
311	dprintf(("USER32: GetDlgCtrlID\n"));
312	return O32_GetDlgCtrlID(arg1);
313	}
314	//******************************************************************************
315	//******************************************************************************
316	HWND WIN32API GetDesktopWindow(void)
317	{
318	dprintf(("USER32: GetDesktopWindow\n"));
319	return O32_GetDesktopWindow();
320	}
321	//******************************************************************************
322	//******************************************************************************
323	BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
324	{
325	BOOL rc;
326	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
327
328	dprintf(("USER32: EnumThreadWindows\n"));
329	rc = O32_EnumThreadWindows(dwThreadId, callback->GetOS2Callback(), (LPARAM)callback);
330	if(callback)
331	delete callback;
332	return(rc);
333	}
334	//******************************************************************************
335	//******************************************************************************
336	BOOL WIN32API EndDialog( HWND arg1, int arg2)
337	{
338	BOOL rc;
339
340	dprintf(("USER32: EndDialog\n"));
341	rc = O32_EndDialog(arg1, arg2);
342	return(rc);
343	}
344	//******************************************************************************
345	//******************************************************************************
346	LONG WIN32API DispatchMessageA( const MSG * arg1)
347	{
348	//// dprintf(("USER32: DispatchMessage\n"));
349	return O32_DispatchMessage(arg1);
350	}
351	//******************************************************************************
352	//******************************************************************************
353	BOOL WIN32API OffsetRect( PRECT arg1, int arg2, int arg3)
354	{
355	#ifdef DEBUG
356	//// WriteLog("USER32: OffsetRect\n");
357	#endif
358	return O32_OffsetRect(arg1, arg2, arg3);
359	}
360	//******************************************************************************
361	//******************************************************************************
362	BOOL WIN32API CopyRect( PRECT arg1, const RECT * arg2)
363	{
364	// ddprintf(("USER32: CopyRect\n"));
365	return O32_CopyRect(arg1, arg2);
366	}
367	//******************************************************************************
368	// Not implemented by Open32 (5-31-99 Christoph Bratschi)
369	//******************************************************************************
370	BOOL WIN32API CheckDlgButton( HWND arg1, int arg2, UINT arg3)
371	{
372	#ifdef DEBUG
373	WriteLog("USER32: CheckDlgButton\n");
374	#endif
375	// return O32_CheckDlgButton(arg1, arg2, arg3);
376	return (BOOL)SendDlgItemMessageA(arg1,arg2,BM_SETCHECK,arg3,0);
377	}
378	//******************************************************************************
379	//******************************************************************************
380	HWND WIN32API SetFocus( HWND arg1)
381	{
382	dprintf(("USER32: SetFocus\n"));
383	return O32_SetFocus(arg1);
384	}
385	//******************************************************************************
386	//******************************************************************************
387	BOOL WIN32API TranslateMessage( const MSG * arg1)
388	{
389	#ifdef DEBUG
390	//// WriteLog("USER32: TranslateMessage\n");
391	#endif
392	return O32_TranslateMessage(arg1);
393	}
394	//******************************************************************************
395	//******************************************************************************
396	BOOL WIN32API SetWindowPos( HWND arg1, HWND arg2, int arg3, int arg4, int arg5, int arg6, UINT arg7)
397	{
398	#ifdef DEBUG
399	WriteLog("USER32: SetWindowPos\n");
400	#endif
401	return O32_SetWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
402	}
403	//******************************************************************************
404	//******************************************************************************
405	BOOL WIN32API ShowWindow(HWND arg1, int arg2)
406	{
407	#ifdef DEBUG
408	WriteLog("USER32: ShowWindow %X %d\n", arg1, arg2);
409	#endif
410	return O32_ShowWindow(arg1, arg2);
411	}
412	//******************************************************************************
413	//******************************************************************************
414	BOOL WIN32API SetWindowTextA(HWND arg1, LPCSTR arg2)
415	{
416	#ifdef DEBUG
417	WriteLog("USER32: SetWindowText %s\n", arg2);
418	#endif
419	return O32_SetWindowText(arg1, arg2);
420	}
421	//******************************************************************************
422	//******************************************************************************
423	BOOL WIN32API SetForegroundWindow(HWND arg1)
424	{
425	#ifdef DEBUG
426	WriteLog("USER32: SetForegroundWindow\n");
427	#endif
428	return O32_SetForegroundWindow(arg1);
429	}
430	//******************************************************************************
431	//******************************************************************************
432	int WIN32API ReleaseDC( HWND arg1, HDC arg2)
433	{
434	#ifdef DEBUG
435	WriteLog("USER32: ReleaseDC\n");
436	#endif
437	return O32_ReleaseDC(arg1, arg2);
438	}
439	//******************************************************************************
440	//******************************************************************************
441	BOOL WIN32API InvalidateRect(HWND arg1, const RECT *arg2, BOOL arg3)
442	{
443	#ifdef DEBUG
444	if(arg2)
445	WriteLog("USER32: InvalidateRect for window %X (%d,%d)(%d,%d) %d\n", arg1, arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
446	else WriteLog("USER32: InvalidateRect for window %X NULL, %d\n", arg1, arg3);
447	#endif
448	return O32_InvalidateRect(arg1, arg2, arg3);
449	}
450	//******************************************************************************
451	//******************************************************************************
452	BOOL WIN32API GetUpdateRect( HWND arg1, PRECT arg2, BOOL arg3)
453	{
454	#ifdef DEBUG
455	WriteLog("USER32: GetUpdateRect\n");
456	#endif
457	return O32_GetUpdateRect(arg1, arg2, arg3);
458	}
459	//******************************************************************************
460	//******************************************************************************
461	HDC WIN32API GetDC( HWND arg1)
462	{
463	HDC hdc;
464
465	hdc = O32_GetDC(arg1);
466	#ifdef DEBUG
467	WriteLog("USER32: GetDC of %X returns %X\n", arg1, hdc);
468	#endif
469	return(hdc);
470	}
471	//******************************************************************************
472	//******************************************************************************
473	HDC WIN32API GetDCEx(HWND arg1, HRGN arg2, DWORD arg3)
474	{
475	#ifdef DEBUG
476	WriteLog("USER32: GetDCEx\n");
477	#endif
478	return O32_GetDCEx(arg1, arg2, arg3);
479	}
480	//******************************************************************************
481	//******************************************************************************
482	BOOL WIN32API GetClientRect( HWND arg1, PRECT arg2)
483	{
484	#ifdef DEBUG
485	WriteLog("USER32: GetClientRect of %X\n", arg1);
486	#endif
487
488	return O32_GetClientRect(arg1, arg2);
489	}
490	//******************************************************************************
491	//******************************************************************************
492	HWND WIN32API FindWindowA(LPCSTR arg1, LPCSTR arg2)
493	{
494	#ifdef DEBUG
495	WriteLog("USER32: FindWindow\n");
496	#endif
497	return O32_FindWindow(arg1, arg2);
498	}
499	//******************************************************************************
500	//******************************************************************************
501	HWND WIN32API FindWindowExA(HWND arg1, HWND arg2, LPCSTR arg3, LPCSTR arg4)
502	{
503	#ifdef DEBUG
504	WriteLog("USER32: FindWindowExA, not completely implemented\n");
505	#endif
506	return O32_FindWindow(arg3, arg4);
507	}
508	//******************************************************************************
509	//******************************************************************************
510	BOOL WIN32API FlashWindow( HWND arg1, BOOL arg2)
511	{
512	#ifdef DEBUG
513	WriteLog("USER32: FlashWindow\n");
514	#endif
515	return O32_FlashWindow(arg1, arg2);
516	}
517	//******************************************************************************
518	//******************************************************************************
519	BOOL WIN32API EndPaint( HWND arg1, const PAINTSTRUCT * arg2)
520	{
521	#ifdef DEBUG
522	WriteLog("USER32: EndPaint\n");
523	#endif
524	return O32_EndPaint(arg1, arg2);
525	}
526	//******************************************************************************
527	//******************************************************************************
528	BOOL WIN32API MoveWindow(HWND arg1, int arg2, int arg3, int arg4, int arg5, BOOL arg6)
529	{
530	BOOL rc;
531
532	rc = O32_MoveWindow(arg1, arg2, arg3, arg4, arg5, arg6);
533	dprintf(("USER32: MoveWindow %X to (%d,%d) size (%d,%d), repaint = %d returned %d\n", arg1, arg2, arg3, arg4, arg5, arg6, rc));
534	return(rc);
535	}
536	//******************************************************************************
537	//******************************************************************************
538	HWND WIN32API CreateWindowExA(DWORD dwExStyle,
539	LPCSTR arg2,
540	LPCSTR arg3,
541	DWORD dwStyle,
542	int x,
543	int y,
544	int nWidth,
545	int nHeight,
546	HWND parent,
547	HMENU arg10,
548	HINSTANCE arg11,
549	PVOID arg12)
550	{
551	HWND hwnd;
552	Win32WindowProc *window = NULL;
553
554	/* @@@PH 98/06/12 CreateWindow crashes somewhere in Open32 */
555	if(arg3 == NULL)
556	arg3 = (LPCSTR)"CRASH, CRASH";
557
558	// 6-12-99 CB: WS_CLIPCHILDREN not set -> controls not redrawn
559	// Problems with group boxes
560	//SvL: Not necessary anymore (EB's fixes)
561	// dwStyle \|= WS_CLIPCHILDREN;
562
563	//SvL: Correct window style (like Wine does)
564	if(dwStyle & WS_CHILD) {
565	dwStyle \|= WS_CLIPSIBLINGS;
566	if(!(dwStyle & WS_POPUP)) {
567	dwStyle \|= WS_CAPTION;
568	}
569	}
570	if(dwExStyle & WS_EX_DLGMODALFRAME)
571	{
572	dwStyle &= ~WS_THICKFRAME;
573	}
574
575	#ifdef DEBUG
576	WriteLog("USER32: CreateWindow: dwExStyle = %X\n", dwExStyle);
577	if((int)arg2 >> 16 != 0)
578	WriteLog("USER32: CreateWindow: classname = %s\n", arg2);
579	else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
580	WriteLog("USER32: CreateWindow: windowname= %s\n", arg3);
581	WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
582	WriteLog("USER32: CreateWindow: x = %d\n", x);
583	WriteLog("USER32: CreateWindow: y = %d\n", y);
584	WriteLog("USER32: CreateWindow: nWidth = %d\n", nWidth);
585	WriteLog("USER32: CreateWindow: nHeight = %d\n", nHeight);
586	WriteLog("USER32: CreateWindow: parent = %X\n", parent);
587	WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
588	WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
589	WriteLog("USER32: CreateWindow: param = %X\n", arg12);
590	#endif
591
592	if((int) arg2 >> 16 != 0 && strcmp(arg2, "COMBOBOX") == 0)
593	{
594	dprintf(("COMBOBOX creation"));
595	//TODO: #%@#%$ Open32 doesn't support this
596	dwStyle &= ~(CBS_OWNERDRAWFIXED \| CBS_OWNERDRAWVARIABLE);
597
598	/* @@@PH 98/06/12 drop down combos are problematic too */
599	/* so we translate the styles to OS/2 style */
600	dwStyle \|= CBS_DROPDOWN \| CBS_DROPDOWNLIST;
601	}
602
603	//Classname might be name of system class, in which case we don't
604	//need to use our own callback
605	// if(Win32WindowClass::FindClass((LPSTR)arg2) != NULL) {
606	window = new Win32WindowProc(arg11, arg2);
607	// }
608
609	hwnd = O32_CreateWindowEx(dwExStyle,
610	arg2,
611	arg3,
612	dwStyle,
613	x,
614	y,
615	nWidth,
616	nHeight,
617	parent,
618	arg10,
619	arg11,
620	arg12);
621
622	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
623	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
624	delete(window);
625	window = 0;
626	}
627	if(window) {
628	window->SetWindowHandle(hwnd);
629	}
630
631	dprintf(("USER32: ************CreateWindowExA %s (%d,%d,%d,%d), hwnd = %X\n", arg2, x, y, nWidth, nHeight, hwnd));
632	return(hwnd);
633	}
634	//******************************************************************************
635	//******************************************************************************
636	LRESULT WIN32API SendMessageA(HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
637	{
638	LRESULT rc;
639
640	#ifdef DEBUG1
641	WriteLog("USER32: SendMessage....\n");
642	#endif
643	rc = O32_SendMessage(arg1, arg2, arg3, arg4);
644	#ifdef DEBUG1
645	WriteLog("USER32: *****SendMessage %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
646	#endif
647	return(rc);
648	}
649	//******************************************************************************
650	//******************************************************************************
651	HWND WIN32API SetActiveWindow( HWND arg1)
652	{
653	#ifdef DEBUG
654	WriteLog("USER32: SetActiveWindow\n");
655	#endif
656	return O32_SetActiveWindow(arg1);
657	}
658	//******************************************************************************
659	//******************************************************************************
660	HDC WIN32API BeginPaint(HWND arg1, PPAINTSTRUCT arg2)
661	{
662	dprintf(("USER32: BeginPaint %X\n", arg2));
663	return O32_BeginPaint(arg1, arg2);
664	}
665	//******************************************************************************
666	//******************************************************************************
667	BOOL WIN32API IsDialogMessageA( HWND arg1, LPMSG arg2)
668	{
669	#ifdef DEBUG
670	//// WriteLog("USER32: IsDialogMessage\n");
671	#endif
672	return O32_IsDialogMessage(arg1, arg2);
673	}
674	//******************************************************************************
675	//******************************************************************************
676	int WIN32API DrawTextA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5)
677	{
678	#ifdef DEBUG
679	WriteLog("USER32: DrawTextA %s", arg2);
680	#endif
681	return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
682	}
683	//******************************************************************************
684	//******************************************************************************
685	int WIN32API DrawTextExA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
686	{
687	#ifdef DEBUG
688	WriteLog("USER32: DrawTextExA (not completely implemented) %s", arg2);
689	#endif
690	return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
691	}
692	//******************************************************************************
693	//******************************************************************************
694	int WIN32API GetSystemMetrics(int arg1)
695	{
696	int rc;
697
698	switch(arg1) {
699	case SM_CXICONSPACING: //TODO: size of grid cell for large icons
700	rc = O32_GetSystemMetrics(SM_CXICON);
701	break;
702	case SM_CYICONSPACING:
703	rc = O32_GetSystemMetrics(SM_CYICON);
704	break;
705	case SM_PENWINDOWS:
706	rc = FALSE;
707	break;
708	case SM_DBCSENABLED:
709	rc = FALSE;
710	break;
711	case SM_CXEDGE: //size of 3D window edge (not supported)
712	rc = 1;
713	break;
714	case SM_CYEDGE:
715	rc = 1;
716	break;
717	case SM_CXMINSPACING: //can be SM_CXMINIMIZED or larger
718	rc = O32_GetSystemMetrics(SM_CXMINIMIZED);
719	break;
720	case SM_CYMINSPACING:
721	rc = GetSystemMetrics(SM_CYMINIMIZED);
722	break;
723	case SM_CXSMICON: //recommended size of small icons (TODO: adjust to screen res.)
724	rc = 16;
725	break;
726	case SM_CYSMICON:
727	rc = 16;
728	break;
729	case SM_CYSMCAPTION: //size in pixels of a small caption (TODO: ????)
730	rc = 8;
731	break;
732	case SM_CXSMSIZE: //size of small caption buttons (pixels) (TODO: implement properly)
733	rc = 16;
734	break;
735	case SM_CYSMSIZE:
736	rc = 16;
737	break;
738	case SM_CXMENUSIZE: //TODO: size of menu bar buttons (such as MDI window close)
739	rc = 16;
740	break;
741	case SM_CYMENUSIZE:
742	rc = 16;
743	break;
744	case SM_ARRANGE:
745	rc = ARW_BOTTOMLEFT \| ARW_LEFT;
746	break;
747	case SM_CXMINIMIZED:
748	break;
749	case SM_CYMINIMIZED:
750	break;
751	case SM_CXMAXTRACK: //max window size
752	case SM_CXMAXIMIZED: //max toplevel window size
753	rc = O32_GetSystemMetrics(SM_CXSCREEN);
754	break;
755	case SM_CYMAXTRACK:
756	case SM_CYMAXIMIZED:
757	rc = O32_GetSystemMetrics(SM_CYSCREEN);
758	break;
759	case SM_NETWORK:
760	rc = 0x01; //TODO: default = yes
761	break;
762	case SM_CLEANBOOT:
763	rc = 0; //normal boot
764	break;
765	case SM_CXDRAG: //nr of pixels before drag becomes a real one
766	rc = 2;
767	break;
768	case SM_CYDRAG:
769	rc = 2;
770	break;
771	case SM_SHOWSOUNDS: //show instead of play sound
772	rc = FALSE;
773	break;
774	case SM_CXMENUCHECK:
775	rc = 4; //TODO
776	break;
777	case SM_CYMENUCHECK:
778	rc = O32_GetSystemMetrics(SM_CYMENU);
779	break;
780	case SM_SLOWMACHINE:
781	rc = FALSE; //even a slow machine is fast with OS/2 :)
782	break;
783	case SM_MIDEASTENABLED:
784	rc = FALSE;
785	break;
786	case SM_CMETRICS:
787	rc = O32_GetSystemMetrics(44); //Open32 changed this one
788	break;
789	default:
790	rc = O32_GetSystemMetrics(arg1);
791	break;
792	}
793	#ifdef DEBUG
794	WriteLog("USER32: GetSystemMetrics %d returned %d\n", arg1, rc);
795	#endif
796	return(rc);
797	}
798	//******************************************************************************
799	//******************************************************************************
800	UINT WIN32API SetTimer( HWND arg1, UINT arg2, UINT arg3, TIMERPROC arg4)
801	{
802	#ifdef DEBUG
803	WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
804	#endif
805	//SvL: Write callback handler class for this one
806	return O32_SetTimer(arg1, arg2, arg3, (TIMERPROC_O32)arg4);
807	}
808	//******************************************************************************
809	//******************************************************************************
810	BOOL WIN32API KillTimer(HWND arg1, UINT arg2)
811	{
812	#ifdef DEBUG
813	WriteLog("USER32: KillTimer\n");
814	#endif
815	return O32_KillTimer(arg1, arg2);
816	}
817	//******************************************************************************
818	//******************************************************************************
819	BOOL WIN32API DestroyWindow(HWND arg1)
820	{
821	#ifdef DEBUG
822	WriteLog("USER32: DestroyWindow\n");
823	#endif
824	return O32_DestroyWindow(arg1);
825	}
826	//******************************************************************************
827	//******************************************************************************
828	BOOL WIN32API PostMessageA( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
829	{
830	#ifdef DEBUG
831	WriteLog("USER32: PostMessageA %X %X %X %X\n", arg1, arg2, arg3, arg4);
832	#endif
833	return O32_PostMessage(arg1, arg2, arg3, arg4);
834	}
835	//******************************************************************************
836	//******************************************************************************
837	BOOL WIN32API InflateRect( PRECT arg1, int arg2, int arg3)
838	{
839	#ifdef DEBUG
840	WriteLog("USER32: InflateRect\n");
841	#endif
842	return O32_InflateRect(arg1, arg2, arg3);
843	}
844	//******************************************************************************
845	//TODO:How can we emulate this one in OS/2???
846	//******************************************************************************
847	DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
848	{
849	#ifdef DEBUG
850	WriteLog("USER32: WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
851	#endif
852
853	if(dwTimeOut == INFINITE) return(0);
854
855	// DosSleep(dwTimeOut/16);
856	return(0);
857	}
858	//******************************************************************************
859	//******************************************************************************
860	UINT WIN32API GetDlgItemTextA(HWND arg1, int arg2, LPSTR arg3, UINT arg4)
861	{
862	UINT rc;
863
864	rc = O32_GetDlgItemText(arg1, arg2, arg3, arg4);
865	#ifdef DEBUG
866	if(rc)
867	WriteLog("USER32: GetDlgItemTextA returned %s\n", arg3);
868	else WriteLog("USER32: GetDlgItemTextA returned 0 (%d)\n", GetLastError());
869	#endif
870	return(rc);
871	}
872	//******************************************************************************
873	//******************************************************************************
874	BOOL WIN32API PeekMessageA(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
875	{
876	#ifdef DEBUG
877	// WriteLog("USER32: PeekMessage\n");
878	#endif
879	return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
880	}
881	//******************************************************************************
882	//******************************************************************************
883	int WIN32API ShowCursor( BOOL arg1)
884	{
885	#ifdef DEBUG
886	WriteLog("USER32: ShowCursor\n");
887	#endif
888	return O32_ShowCursor(arg1);
889	}
890	//******************************************************************************
891	//BUGBUG: UpdateWindow sends a WM_ERASEBKGRND when it shouldn't!
892	// So we just do it manually
893	//******************************************************************************
894	BOOL WIN32API UpdateWindow(HWND hwnd)
895	{
896	RECT rect;
897
898	#ifdef DEBUG
899	WriteLog("USER32: UpdateWindow\n");
900	#endif
901
902	#if 0 // EB: ->>> doesn't work. No correct update of Winhlp32 scrolling area.
903	if(O32_GetUpdateRect(hwnd, &rect, FALSE) != FALSE) {//update region empty?
904	WndCallback(hwnd, WM_PAINT, 0, 0);
905	// O32_PostMessage(hwnd, WM_PAINT, 0, 0);
906	}
907	#ifdef DEBUG
908	else WriteLog("USER32: Update region empty!\n");
909	#endif
910	return(TRUE);
911	#endif
912
913	return O32_UpdateWindow(hwnd);
914	}
915	//******************************************************************************
916	//******************************************************************************
917	BOOL WIN32API AdjustWindowRect( PRECT arg1, DWORD arg2, BOOL arg3)
918	{
919	#ifdef DEBUG
920	WriteLog("USER32: AdjustWindowRect\n");
921	#endif
922	return O32_AdjustWindowRect(arg1, arg2, arg3);
923	}
924	//******************************************************************************
925	//******************************************************************************
926	BOOL WIN32API AdjustWindowRectEx( PRECT arg1, DWORD arg2, BOOL arg3, DWORD arg4)
927	{
928	#ifdef DEBUG
929	WriteLog("USER32: AdjustWindowRectEx\n");
930	#endif
931	return O32_AdjustWindowRectEx(arg1, arg2, arg3, arg4);
932	}
933	//******************************************************************************
934	//******************************************************************************
935	BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
936	{
937	#ifdef DEBUG
938	//// WriteLog("USER32: ClientToScreen\n");
939	#endif
940	return O32_ClientToScreen(arg1, arg2);
941	}
942	//******************************************************************************
943	//******************************************************************************
944	BOOL WIN32API SetRect( PRECT arg1, int arg2, int arg3, int arg4, int arg5)
945	{
946	#ifdef DEBUG
947	WriteLog("USER32: SetRect\n");
948	#endif
949	return O32_SetRect(arg1, arg2, arg3, arg4, arg5);
950	}
951	//******************************************************************************
952	//******************************************************************************
953	BOOL WIN32API SetDlgItemInt( HWND arg1, int arg2, UINT arg3, BOOL arg4)
954	{
955	#ifdef DEBUG
956	WriteLog("USER32: SetDlgItemInt\n");
957	#endif
958	return O32_SetDlgItemInt(arg1, arg2, arg3, arg4);
959	}
960	//******************************************************************************
961	//******************************************************************************
962	BOOL WIN32API SetDlgItemTextA( HWND arg1, int arg2, LPCSTR arg3)
963	{
964	#ifdef DEBUG
965	WriteLog("USER32: SetDlgItemText to %s\n", arg3);
966	#endif
967	return O32_SetDlgItemText(arg1, arg2, arg3);
968	}
969	//******************************************************************************
970	//******************************************************************************
971	BOOL WIN32API WinHelpA( HWND arg1, LPCSTR arg2, UINT arg3, DWORD arg4)
972	{
973	#ifdef DEBUG
974	WriteLog("USER32: WinHelp not implemented %s\n", arg2);
975	#endif
976	// return O32_WinHelp(arg1, arg2, arg3, arg4);
977	return(TRUE);
978	}
979	//******************************************************************************
980	//******************************************************************************
981	BOOL WIN32API IsIconic( HWND arg1)
982	{
983	#ifdef DEBUG
984	WriteLog("USER32: IsIconic\n");
985	#endif
986	return O32_IsIconic(arg1);
987	}
988	//******************************************************************************
989	//******************************************************************************
990	int WIN32API TranslateAcceleratorA(HWND arg1, HACCEL arg2, LPMSG arg3)
991	{
992	#ifdef DEBUG
993	//// WriteLog("USER32: TranslateAccelerator\n");
994	#endif
995	return O32_TranslateAccelerator(arg1, arg2, arg3);
996	}
997	//******************************************************************************
998	//******************************************************************************
999	HWND WIN32API GetWindow(HWND arg1, UINT arg2)
1000	{
1001	HWND rc;
1002
1003	rc = O32_GetWindow(arg1, arg2);
1004	#ifdef DEBUG
1005	WriteLog("USER32: GetWindow %X %d returned %d\n", arg1, arg2, rc);
1006	#endif
1007	return(rc);
1008	}
1009	//******************************************************************************
1010	//******************************************************************************
1011	HDC WIN32API GetWindowDC(HWND arg1)
1012	{
1013	#ifdef DEBUG
1014	WriteLog("USER32: GetWindowDC\n");
1015	#endif
1016	return O32_GetWindowDC(arg1);
1017	}
1018	//******************************************************************************
1019	//******************************************************************************
1020	BOOL WIN32API SubtractRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
1021	{
1022	#ifdef DEBUG
1023	WriteLog("USER32: SubtractRect");
1024	#endif
1025	return O32_SubtractRect(arg1, arg2, arg3);
1026	}
1027	//******************************************************************************
1028	//SvL: 24-6-'97 - Added
1029	//******************************************************************************
1030	BOOL WIN32API ClipCursor(const RECT * arg1)
1031	{
1032	#ifdef DEBUG
1033	WriteLog("USER32: ClipCursor\n");
1034	#endif
1035	return O32_ClipCursor(arg1);
1036	}
1037	//******************************************************************************
1038	//SvL: 24-6-'97 - Added
1039	//TODO: Not implemented
1040	//******************************************************************************
1041	WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1042	{
1043	#ifdef DEBUG
1044	//// WriteLog("USER32: GetAsyncKeyState Not implemented\n");
1045	#endif
1046	return 0;
1047	}
1048	//******************************************************************************
1049	//SvL: 24-6-'97 - Added
1050	//******************************************************************************
1051	HCURSOR WIN32API GetCursor(void)
1052	{
1053	#ifdef DEBUG
1054	//// WriteLog("USER32: GetCursor\n");
1055	#endif
1056	return O32_GetCursor();
1057	}
1058	//******************************************************************************
1059	//SvL: 24-6-'97 - Added
1060	//******************************************************************************
1061	BOOL WIN32API GetCursorPos( PPOINT arg1)
1062	{
1063	#ifdef DEBUG
1064	//// WriteLog("USER32: GetCursorPos\n");
1065	#endif
1066	return O32_GetCursorPos(arg1);
1067	}
1068	//******************************************************************************
1069	//SvL: 24-6-'97 - Added
1070	//******************************************************************************
1071	UINT WIN32API RegisterWindowMessageA(LPCSTR arg1)
1072	{
1073	UINT rc;
1074
1075	rc = O32_RegisterWindowMessage(arg1);
1076	#ifdef DEBUG
1077	WriteLog("USER32: RegisterWindowMessageA %s returned %X\n", arg1, rc);
1078	#endif
1079	return(rc);
1080	}
1081	//******************************************************************************
1082	//SvL: 24-6-'97 - Added
1083	//******************************************************************************
1084	WORD WIN32API VkKeyScanA( char arg1)
1085	{
1086	#ifdef DEBUG
1087	WriteLog("USER32: VkKeyScanA\n");
1088	#endif
1089	return O32_VkKeyScan(arg1);
1090	}
1091	//******************************************************************************
1092	//SvL: 24-6-'97 - Added
1093	//******************************************************************************
1094	SHORT WIN32API GetKeyState( int arg1)
1095	{
1096	#ifdef DEBUG
1097	WriteLog("USER32: GetKeyState %d\n", arg1);
1098	#endif
1099	return O32_GetKeyState(arg1);
1100	}
1101	//******************************************************************************
1102	//******************************************************************************
1103	HCURSOR WIN32API SetCursor( HCURSOR arg1)
1104	{
1105	#ifdef DEBUG
1106	WriteLog("USER32: SetCursor\n");
1107	#endif
1108	return O32_SetCursor(arg1);
1109	}
1110	//******************************************************************************
1111	//******************************************************************************
1112	BOOL WIN32API SetCursorPos( int arg1, int arg2)
1113	{
1114	#ifdef DEBUG
1115	WriteLog("USER32: SetCursorPos\n");
1116	#endif
1117	return O32_SetCursorPos(arg1, arg2);
1118	}
1119	//******************************************************************************
1120	//******************************************************************************
1121	BOOL WIN32API EnableScrollBar( HWND arg1, INT arg2, UINT arg3)
1122	{
1123	#ifdef DEBUG
1124	WriteLog("USER32: EnableScrollBar\n");
1125	#endif
1126	return O32_EnableScrollBar(arg1, arg2, arg3);
1127	}
1128	//******************************************************************************
1129	//******************************************************************************
1130	BOOL WIN32API EnableWindow( HWND arg1, BOOL arg2)
1131	{
1132	#ifdef DEBUG
1133	WriteLog("USER32: EnableWindow\n");
1134	#endif
1135	return O32_EnableWindow(arg1, arg2);
1136	}
1137	//******************************************************************************
1138	//******************************************************************************
1139	HWND WIN32API SetCapture( HWND arg1)
1140	{
1141	#ifdef DEBUG
1142	WriteLog("USER32: SetCapture\n");
1143	#endif
1144	return O32_SetCapture(arg1);
1145	}
1146	//******************************************************************************
1147	//******************************************************************************
1148	BOOL WIN32API ReleaseCapture(void)
1149	{
1150	#ifdef DEBUG
1151	WriteLog("USER32: ReleaseCapture\n");
1152	#endif
1153	return O32_ReleaseCapture();
1154	}
1155	//******************************************************************************
1156	//******************************************************************************
1157	DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD arg5)
1158	{
1159	#ifdef DEBUG
1160	WriteLog("USER32: MsgWaitForMultipleObjects\n");
1161	#endif
1162	return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
1163	}
1164	//******************************************************************************
1165	//******************************************************************************
1166	HDWP WIN32API BeginDeferWindowPos( int arg1)
1167	{
1168	#ifdef DEBUG
1169	WriteLog("USER32: BeginDeferWindowPos\n");
1170	#endif
1171	return O32_BeginDeferWindowPos(arg1);
1172	}
1173	//******************************************************************************
1174	//******************************************************************************
1175	BOOL WIN32API BringWindowToTop( HWND arg1)
1176	{
1177	#ifdef DEBUG
1178	WriteLog("USER32: BringWindowToTop\n");
1179	#endif
1180	return O32_BringWindowToTop(arg1);
1181	}
1182	//******************************************************************************
1183	//******************************************************************************
1184	BOOL WIN32API CallMsgFilterA( LPMSG arg1, int arg2)
1185	{
1186	#ifdef DEBUG
1187	WriteLog("USER32: CallMsgFilterA\n");
1188	#endif
1189	return O32_CallMsgFilter(arg1, arg2);
1190	}
1191	//******************************************************************************
1192	//******************************************************************************
1193	BOOL WIN32API CallMsgFilterW( LPMSG arg1, int arg2)
1194	{
1195	#ifdef DEBUG
1196	WriteLog("USER32: CallMsgFilterW\n");
1197	#endif
1198	// NOTE: This will not work as is (needs UNICODE support)
1199	return O32_CallMsgFilter(arg1, arg2);
1200	}
1201	//******************************************************************************
1202	//******************************************************************************
1203	LRESULT WIN32API CallWindowProcA(WNDPROC wndprcPrev,
1204	HWND arg2,
1205	UINT arg3,
1206	WPARAM arg4,
1207	LPARAM arg5)
1208	{
1209	#ifdef DEBUG
1210	//// WriteLog("USER32: CallWindowProcA %X hwnd=%X, msg = %X\n", wndprcPrev, arg2, arg3);
1211	#endif
1212
1213	return wndprcPrev(arg2, arg3, arg4, arg5); //win32 callback (__stdcall)
1214	}
1215	//******************************************************************************
1216	//******************************************************************************
1217	LRESULT WIN32API CallWindowProcW(WNDPROC arg1,
1218	HWND arg2,
1219	UINT arg3,
1220	WPARAM arg4,
1221	LPARAM arg5)
1222	{
1223	dprintf(("USER32: CallWindowProcW(%08xh,%08xh,%08xh,%08xh,%08xh) not properly implemented.\n",
1224	arg1,
1225	arg2,
1226	arg3,
1227	arg4,
1228	arg5));
1229
1230	return CallWindowProcA(arg1,
1231	arg2,
1232	arg3,
1233	arg4,
1234	arg5);
1235	}
1236	//******************************************************************************
1237	//******************************************************************************
1238	BOOL WIN32API ChangeClipboardChain( HWND arg1, HWND arg2)
1239	{
1240	#ifdef DEBUG
1241	WriteLog("USER32: ChangeClipboardChain\n");
1242	#endif
1243	return O32_ChangeClipboardChain(arg1, arg2);
1244	}
1245	//******************************************************************************
1246	//******************************************************************************
1247	UINT WIN32API ArrangeIconicWindows( HWND arg1)
1248	{
1249	#ifdef DEBUG
1250	WriteLog("USER32: ArrangeIconicWindows\n");
1251	#endif
1252	return O32_ArrangeIconicWindows(arg1);
1253	}
1254	//******************************************************************************
1255	// Not implemented by Open32 (5-31-99 Christoph Bratschi)
1256	//******************************************************************************
1257	BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT arg4)
1258	{
1259	#ifdef DEBUG
1260	WriteLog("USER32: CheckRadioButton\n");
1261	#endif
1262	// return O32_CheckRadioButton(arg1, arg2, arg3, arg4);
1263	if (arg2 > arg3) return (FALSE);
1264	for (UINT x=arg2;x <= arg3;x++)
1265	{
1266	SendDlgItemMessageA(arg1,x,BM_SETCHECK,(x == arg4) ? BST_CHECKED : BST_UNCHECKED,0);
1267	}
1268	return (TRUE);
1269	}
1270	//******************************************************************************
1271	//******************************************************************************
1272	HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
1273	{
1274	#ifdef DEBUG
1275	WriteLog("USER32: ChildWindowFromPoint\n");
1276	#endif
1277	return O32_ChildWindowFromPoint(arg1, arg2);
1278	}
1279	//******************************************************************************
1280	//******************************************************************************
1281	HWND WIN32API ChildWindowFromPointEx(HWND arg1, POINT arg2, UINT uFlags)
1282	{
1283	#ifdef DEBUG
1284	WriteLog("USER32: ChildWindowFromPointEx, not completely supported!\n");
1285	#endif
1286	return O32_ChildWindowFromPoint(arg1, arg2);
1287	}
1288	//******************************************************************************
1289	//******************************************************************************
1290	BOOL WIN32API CloseClipboard(void)
1291	{
1292	#ifdef DEBUG
1293	WriteLog("USER32: CloseClipboard\n");
1294	#endif
1295	return O32_CloseClipboard();
1296	}
1297	//******************************************************************************
1298	//******************************************************************************
1299	BOOL WIN32API CloseWindow( HWND arg1)
1300	{
1301	#ifdef DEBUG
1302	WriteLog("USER32: CloseWindow\n");
1303	#endif
1304	return O32_CloseWindow(arg1);
1305	}
1306	//******************************************************************************
1307	//******************************************************************************
1308	HICON WIN32API CopyIcon( HICON arg1)
1309	{
1310	#ifdef DEBUG
1311	WriteLog("USER32: CopyIcon\n");
1312	#endif
1313	return O32_CopyIcon(arg1);
1314	}
1315	//******************************************************************************
1316	//******************************************************************************
1317	int WIN32API CountClipboardFormats(void)
1318	{
1319	#ifdef DEBUG
1320	WriteLog("USER32: CountClipboardFormats\n");
1321	#endif
1322	return O32_CountClipboardFormats();
1323	}
1324	//******************************************************************************
1325	//******************************************************************************
1326	HACCEL WIN32API CreateAcceleratorTableA( LPACCEL arg1, int arg2)
1327	{
1328	#ifdef DEBUG
1329	WriteLog("USER32: CreateAcceleratorTableA\n");
1330	#endif
1331	return O32_CreateAcceleratorTable(arg1, arg2);
1332	}
1333	//******************************************************************************
1334	//******************************************************************************
1335	HACCEL WIN32API CreateAcceleratorTableW( LPACCEL arg1, int arg2)
1336	{
1337	#ifdef DEBUG
1338	WriteLog("USER32: CreateAcceleratorTableW\n");
1339	#endif
1340	// NOTE: This will not work as is (needs UNICODE support)
1341	return O32_CreateAcceleratorTable(arg1, arg2);
1342	}
1343	//******************************************************************************
1344	//******************************************************************************
1345	BOOL WIN32API CreateCaret( HWND arg1, HBITMAP arg2, int arg3, int arg4)
1346	{
1347	#ifdef DEBUG
1348	WriteLog("USER32: CreateCaret\n");
1349	#endif
1350	return O32_CreateCaret(arg1, arg2, arg3, arg4);
1351	}
1352	//******************************************************************************
1353	//******************************************************************************
1354	HCURSOR WIN32API CreateCursor( HINSTANCE arg1, int arg2, int arg3, int arg4, int arg5, const VOID * arg6, const VOID * arg7)
1355	{
1356	#ifdef DEBUG
1357	WriteLog("USER32: CreateCursor\n");
1358	#endif
1359	return O32_CreateCursor(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1360	}
1361	//******************************************************************************
1362	//******************************************************************************
1363	HICON WIN32API CreateIcon( HINSTANCE arg1, INT arg2, INT arg3, BYTE arg4, BYTE arg5, LPCVOID arg6, LPCVOID arg7)
1364	{
1365	#ifdef DEBUG
1366	WriteLog("USER32: CreateIcon\n");
1367	#endif
1368	return O32_CreateIcon(arg1, arg2, arg3, arg4, arg5, (const BYTE )arg6, (const BYTE )arg7);
1369	}
1370	//******************************************************************************
1371	//ASSERT dwVer == win31 (ok according to SDK docs)
1372	//******************************************************************************
1373	HICON WIN32API CreateIconFromResource(PBYTE presbits, UINT dwResSize,
1374	BOOL fIcon, DWORD dwVer)
1375	{
1376	HICON hicon;
1377	DWORD OS2ResSize = 0;
1378	PBYTE OS2Icon = ConvertWin32Icon(presbits, dwResSize, &OS2ResSize);
1379
1380	hicon = O32_CreateIconFromResource(OS2Icon, OS2ResSize, fIcon, dwVer);
1381	#ifdef DEBUG
1382	WriteLog("USER32: CreateIconFromResource returned %X (%X)\n", hicon, GetLastError());
1383	#endif
1384	if(OS2Icon)
1385	FreeIcon(OS2Icon);
1386
1387	return(hicon);
1388	}
1389	//******************************************************************************
1390	//******************************************************************************
1391	HICON WIN32API CreateIconFromResourceEx(PBYTE presbits, UINT dwResSize,
1392	BOOL fIcon, DWORD dwVer,
1393	int cxDesired, int cyDesired,
1394	UINT Flags)
1395	{
1396	#ifdef DEBUG
1397	WriteLog("USER32: CreateIconFromResourceEx %X %d %d %X %d %d %X, not completely supported!\n", presbits, dwResSize, fIcon, dwVer, cxDesired, cyDesired, Flags);
1398	#endif
1399	return CreateIconFromResource(presbits, dwResSize, fIcon, dwVer);
1400	}
1401	//******************************************************************************
1402	//******************************************************************************
1403	HICON WIN32API CreateIconIndirect(LPICONINFO arg1)
1404	{
1405	#ifdef DEBUG
1406	WriteLog("USER32: CreateIconIndirect\n");
1407	#endif
1408	return O32_CreateIconIndirect(arg1);
1409	}
1410	//******************************************************************************
1411	//******************************************************************************
1412	HWND WIN32API CreateMDIWindowA(LPCSTR arg1, LPCSTR arg2, DWORD arg3,
1413	int arg4, int arg5, int arg6, int arg7,
1414	HWND arg8, HINSTANCE arg9, LPARAM arg10)
1415	{
1416	HWND hwnd;
1417
1418	#ifdef DEBUG
1419	WriteLog("USER32: CreateMDIWindowA\n");
1420	#endif
1421	Win32WindowProc *window = new Win32WindowProc(arg9, arg1);
1422	hwnd = O32_CreateMDIWindow((LPSTR)arg1, (LPSTR)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1423	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1424	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1425	delete(window);
1426	window = 0;
1427	}
1428
1429	#ifdef DEBUG
1430	WriteLog("USER32: CreateMDIWindowA returned %X\n", hwnd);
1431	#endif
1432	return hwnd;
1433	}
1434	//******************************************************************************
1435	//******************************************************************************
1436	HWND WIN32API CreateMDIWindowW(LPCWSTR arg1, LPCWSTR arg2, DWORD arg3, int arg4,
1437	int arg5, int arg6, int arg7, HWND arg8, HINSTANCE arg9,
1438	LPARAM arg10)
1439	{
1440	HWND hwnd;
1441	char astring1 = NULL, astring2 = NULL;
1442	Win32WindowProc *window = NULL;
1443
1444	if((int)arg1 >> 16 != 0) {
1445	astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1446	}
1447	else astring1 = (char *)arg2;
1448
1449	astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1450
1451	//Classname might be name of system class, in which case we don't
1452	//need to use our own callback
1453	// if(Win32WindowClass::FindClass((LPSTR)astring1) != NULL) {
1454	window = new Win32WindowProc(arg9, astring1);
1455	// }
1456	hwnd = O32_CreateMDIWindow(astring1, astring2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1457	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1458	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1459	delete(window);
1460	window = 0;
1461	}
1462	if(window) {
1463	window->SetWindowHandle(hwnd);
1464	}
1465
1466	if(astring1) FreeAsciiString(astring1);
1467	FreeAsciiString(astring2);
1468	#ifdef DEBUG
1469	WriteLog("USER32: CreateMDIWindowW hwnd = %X\n", hwnd);
1470	#endif
1471	return(hwnd);
1472	}
1473	//******************************************************************************
1474	//******************************************************************************
1475	HWND WIN32API CreateWindowExW(DWORD arg1,
1476	LPCWSTR arg2,
1477	LPCWSTR arg3,
1478	DWORD dwStyle,
1479	int arg5,
1480	int arg6,
1481	int arg7,
1482	int arg8,
1483	HWND arg9,
1484	HMENU arg10,
1485	HINSTANCE arg11,
1486	PVOID arg12)
1487	{
1488	HWND hwnd;
1489	char *astring1 = NULL,
1490	*astring2 = NULL;
1491	Win32WindowProc *window = NULL;
1492
1493	/* @@@PH 98/06/21 changed to call OS2CreateWindowExA */
1494	if(HIWORD(arg2) != 0)
1495	astring1 = UnicodeToAsciiString((LPWSTR)arg2);
1496	else
1497	astring1 = (char *)arg2;
1498
1499	astring2 = UnicodeToAsciiString((LPWSTR)arg3);
1500
1501	#ifdef DEBUG
1502	WriteLog("USER32: CreateWindowExW: dwExStyle = %X\n", arg1);
1503	if((int)arg2 >> 16 != 0)
1504	WriteLog("USER32: CreateWindow: classname = %s\n", astring1);
1505	else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
1506	WriteLog("USER32: CreateWindow: windowname= %s\n", astring2);
1507	WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
1508	WriteLog("USER32: CreateWindow: x = %d\n", arg5);
1509	WriteLog("USER32: CreateWindow: y = %d\n", arg6);
1510	WriteLog("USER32: CreateWindow: nWidth = %d\n", arg7);
1511	WriteLog("USER32: CreateWindow: nHeight = %d\n", arg8);
1512	WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
1513	WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
1514	WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
1515	WriteLog("USER32: CreateWindow: param = %X\n", arg12);
1516	#endif
1517
1518	hwnd = CreateWindowExA(arg1,
1519	astring1,
1520	astring2,
1521	dwStyle,
1522	arg5,
1523	arg6,
1524	arg7,
1525	arg8,
1526	arg9,
1527	arg10,
1528	arg11,
1529	arg12);
1530
1531	if(HIWORD(arg1) != 0)
1532	FreeAsciiString(astring1);
1533
1534	FreeAsciiString(astring2);
1535
1536	#ifdef DEBUG
1537	WriteLog("USER32: ************CreateWindowExW hwnd = %X (%X)\n", hwnd, GetLastError());
1538	#endif
1539	return(hwnd);
1540	}
1541	//******************************************************************************
1542	//******************************************************************************
1543	HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
1544	{
1545	#ifdef DEBUG
1546	WriteLog("USER32: DeferWindowPos\n");
1547	#endif
1548	return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1549	}
1550	//******************************************************************************
1551	//******************************************************************************
1552	BOOL WIN32API DestroyAcceleratorTable( HACCEL arg1)
1553	{
1554	#ifdef DEBUG
1555	WriteLog("USER32: DestroyAcceleratorTable\n");
1556	#endif
1557	return O32_DestroyAcceleratorTable(arg1);
1558	}
1559	//******************************************************************************
1560	//******************************************************************************
1561	BOOL WIN32API DestroyCaret(void)
1562	{
1563	#ifdef DEBUG
1564	WriteLog("USER32: DestroyCaret\n");
1565	#endif
1566	return O32_DestroyCaret();
1567	}
1568	//******************************************************************************
1569	//******************************************************************************
1570	BOOL WIN32API DestroyCursor( HCURSOR arg1)
1571	{
1572	#ifdef DEBUG
1573	WriteLog("USER32: DestroyCursor\n");
1574	#endif
1575	return O32_DestroyCursor(arg1);
1576	}
1577	//******************************************************************************
1578	//******************************************************************************
1579	BOOL WIN32API DestroyIcon( HICON arg1)
1580	{
1581	#ifdef DEBUG
1582	WriteLog("USER32: DestroyIcon\n");
1583	#endif
1584	return O32_DestroyIcon(arg1);
1585	}
1586	//******************************************************************************
1587	//******************************************************************************
1588	LONG WIN32API DispatchMessageW( const MSG * arg1)
1589	{
1590	#ifdef DEBUG
1591	WriteLog("USER32: DispatchMessageW\n");
1592	#endif
1593	// NOTE: This will not work as is (needs UNICODE support)
1594	return O32_DispatchMessage(arg1);
1595	}
1596	//******************************************************************************
1597	//******************************************************************************
1598	int WIN32API DlgDirListA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1599	{
1600	#ifdef DEBUG
1601	WriteLog("USER32: DlgDirListA\n");
1602	#endif
1603	return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1604	}
1605	//******************************************************************************
1606	//******************************************************************************
1607	int WIN32API DlgDirListComboBoxA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1608	{
1609	#ifdef DEBUG
1610	WriteLog("USER32: DlgDirListComboBoxA\n");
1611	#endif
1612	return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1613	}
1614	//******************************************************************************
1615	//******************************************************************************
1616	int WIN32API DlgDirListComboBoxW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1617	{
1618	#ifdef DEBUG
1619	WriteLog("USER32: DlgDirListComboBoxW NOT WORKING\n");
1620	#endif
1621	// NOTE: This will not work as is (needs UNICODE support)
1622	return 0;
1623	// return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1624	}
1625	//******************************************************************************
1626	//******************************************************************************
1627	int WIN32API DlgDirListW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1628	{
1629	#ifdef DEBUG
1630	WriteLog("USER32: DlgDirListW NOT WORKING\n");
1631	#endif
1632	// NOTE: This will not work as is (needs UNICODE support)
1633	return 0;
1634	// return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1635	}
1636	//******************************************************************************
1637	//******************************************************************************
1638	BOOL WIN32API DlgDirSelectComboBoxExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1639	{
1640	#ifdef DEBUG
1641	WriteLog("USER32: DlgDirSelectComboBoxExA\n");
1642	#endif
1643	return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1644	}
1645	//******************************************************************************
1646	//******************************************************************************
1647	BOOL WIN32API DlgDirSelectComboBoxExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1648	{
1649	#ifdef DEBUG
1650	WriteLog("USER32: DlgDirSelectComboBoxExW NOT WORKING\n");
1651	#endif
1652	// NOTE: This will not work as is (needs UNICODE support)
1653	return 0;
1654	// return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1655	}
1656	//******************************************************************************
1657	//******************************************************************************
1658	BOOL WIN32API DlgDirSelectExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1659	{
1660	#ifdef DEBUG
1661	WriteLog("USER32: DlgDirSelectExA\n");
1662	#endif
1663	return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1664	}
1665	//******************************************************************************
1666	//******************************************************************************
1667	BOOL WIN32API DlgDirSelectExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1668	{
1669	#ifdef DEBUG
1670	WriteLog("USER32: DlgDirSelectExW NOT WORKING\n");
1671	#endif
1672	// NOTE: This will not work as is (needs UNICODE support)
1673	return 0;
1674	// return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1675	}
1676	//******************************************************************************
1677	//******************************************************************************
1678	BOOL WIN32API DrawFocusRect( HDC arg1, const RECT * arg2)
1679	{
1680	#ifdef DEBUG
1681	WriteLog("USER32: DrawFocusRect\n");
1682	#endif
1683	return O32_DrawFocusRect(arg1, arg2);
1684	}
1685	//******************************************************************************
1686	//******************************************************************************
1687	BOOL WIN32API DrawIcon( HDC arg1, int arg2, int arg3, HICON arg4)
1688	{
1689	#ifdef DEBUG
1690	WriteLog("USER32: DrawIcon\n");
1691	#endif
1692	return O32_DrawIcon(arg1, arg2, arg3, arg4);
1693	}
1694	//******************************************************************************
1695	//******************************************************************************
1696	BOOL WIN32API DrawIconEx(HDC hdc, int xLeft, int xRight, HICON hIcon,
1697	int cxWidth, int cyWidth, UINT istepIfAniCur,
1698	HBRUSH hbrFlickerFreeDraw, UINT diFlags)
1699	{
1700	#ifdef DEBUG
1701	WriteLog("USER32: DrawIcon, partially implemented\n");
1702	#endif
1703	return O32_DrawIcon(hdc, xLeft, xRight, hIcon);
1704	}
1705	//******************************************************************************
1706	//******************************************************************************
1707	BOOL WIN32API DrawMenuBar( HWND arg1)
1708	{
1709	#ifdef DEBUG
1710	WriteLog("USER32: DrawMenuBar\n");
1711	#endif
1712	return O32_DrawMenuBar(arg1);
1713	}
1714	//******************************************************************************
1715	//******************************************************************************
1716	int WIN32API DrawTextW( HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5)
1717	{
1718	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1719	int rc;
1720
1721	#ifdef DEBUG
1722	WriteLog("USER32: DrawTextW %s\n", astring);
1723	#endif
1724	rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1725	FreeAsciiString(astring);
1726	return(rc);
1727	}
1728	//******************************************************************************
1729	//******************************************************************************
1730	int WIN32API DrawTextExW(HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
1731	{
1732	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1733	int rc;
1734
1735	#ifdef DEBUG
1736	WriteLog("USER32: DrawTextExW (not completely supported) %s\n", astring);
1737	#endif
1738	rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1739	FreeAsciiString(astring);
1740	return(rc);
1741	}
1742	//******************************************************************************
1743	//******************************************************************************
1744	BOOL WIN32API EmptyClipboard(void)
1745	{
1746	#ifdef DEBUG
1747	WriteLog("USER32: EmptyClipboard\n");
1748	#endif
1749	return O32_EmptyClipboard();
1750	}
1751	//******************************************************************************
1752	//******************************************************************************
1753	BOOL WIN32API EndDeferWindowPos( HDWP arg1)
1754	{
1755	#ifdef DEBUG
1756	WriteLog("USER32: EndDeferWindowPos\n");
1757	#endif
1758	return O32_EndDeferWindowPos(arg1);
1759	}
1760	//******************************************************************************
1761	//******************************************************************************
1762	BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1763	{
1764	BOOL rc;
1765	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1766
1767	#ifdef DEBUG
1768	WriteLog("USER32: EnumChildWindows\n");
1769	#endif
1770	rc = O32_EnumChildWindows(hwnd, callback->GetOS2Callback(), (LPARAM)callback);
1771	if(callback)
1772	delete callback;
1773	return(rc);
1774	}
1775	//******************************************************************************
1776	//******************************************************************************
1777	UINT WIN32API EnumClipboardFormats(UINT arg1)
1778	{
1779	#ifdef DEBUG
1780	WriteLog("USER32: EnumClipboardFormats\n");
1781	#endif
1782	return O32_EnumClipboardFormats(arg1);
1783	}
1784	//******************************************************************************
1785	//******************************************************************************
1786	int WIN32API EnumPropsA(HWND arg1, PROPENUMPROCA arg2)
1787	{
1788	#ifdef DEBUG
1789	WriteLog("USER32: EnumPropsA DOES NOT WORK\n");
1790	#endif
1791	//calling convention problems
1792	return 0;
1793	// return O32_EnumProps(arg1, (PROPENUMPROC_O32)arg2);
1794	}
1795	//******************************************************************************
1796	//******************************************************************************
1797	int WIN32API EnumPropsExA( HWND arg1, PROPENUMPROCEXA arg2, LPARAM arg3)
1798	{
1799	#ifdef DEBUG
1800	WriteLog("USER32: EnumPropsExA DOES NOT WORK\n");
1801	#endif
1802	//calling convention problems
1803	return 0;
1804	// return O32_EnumPropsEx(arg1, arg2, (PROPENUMPROCEX_O32)arg3);
1805	}
1806	//******************************************************************************
1807	//******************************************************************************
1808	int WIN32API EnumPropsExW( HWND arg1, PROPENUMPROCEXW arg2, LPARAM arg3)
1809	{
1810	#ifdef DEBUG
1811	WriteLog("USER32: EnumPropsExW\n");
1812	#endif
1813	// NOTE: This will not work as is (needs UNICODE support)
1814	//calling convention problems
1815	return 0;
1816	// return O32_EnumPropsEx(arg1, arg2, arg3);
1817	}
1818	//******************************************************************************
1819	//******************************************************************************
1820	int WIN32API EnumPropsW( HWND arg1, PROPENUMPROCW arg2)
1821	{
1822	#ifdef DEBUG
1823	WriteLog("USER32: EnumPropsW\n");
1824	#endif
1825	// NOTE: This will not work as is (needs UNICODE support)
1826	//calling convention problems
1827	return 0;
1828	// return O32_EnumProps(arg1, arg2);
1829	}
1830	//******************************************************************************
1831	//******************************************************************************
1832	BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1833	{
1834	BOOL rc;
1835	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1836
1837	#ifdef DEBUG
1838	WriteLog("USER32: EnumWindows\n");
1839	#endif
1840	rc = O32_EnumWindows(callback->GetOS2Callback(), (LPARAM)callback);
1841	if(callback)
1842	delete callback;
1843	return(rc);
1844	}
1845	//******************************************************************************
1846	//******************************************************************************
1847	BOOL WIN32API EqualRect( const RECT * arg1, const RECT * arg2)
1848	{
1849	#ifdef DEBUG
1850	WriteLog("USER32: EqualRect\n");
1851	#endif
1852	return O32_EqualRect(arg1, arg2);
1853	}
1854	//******************************************************************************
1855	//******************************************************************************
1856	BOOL WIN32API ExcludeUpdateRgn( HDC arg1, HWND arg2)
1857	{
1858	#ifdef DEBUG
1859	WriteLog("USER32: ExcludeUpdateRgn\n");
1860	#endif
1861	return O32_ExcludeUpdateRgn(arg1, arg2);
1862	}
1863	//******************************************************************************
1864	//******************************************************************************
1865	BOOL WIN32API ExitWindowsEx( UINT arg1, DWORD arg2)
1866	{
1867	#ifdef DEBUG
1868	WriteLog("USER32: ExitWindowsEx\n");
1869	#endif
1870	return O32_ExitWindowsEx(arg1, arg2);
1871	}
1872	//******************************************************************************
1873	//******************************************************************************
1874	int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
1875	{
1876	#ifdef DEBUG
1877	WriteLog("USER32: FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
1878	#endif
1879	return O32_FillRect(arg1, arg2, arg3);
1880	}
1881	//******************************************************************************
1882	//******************************************************************************
1883	HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
1884	{
1885	char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1886	char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1887	HWND rc;
1888
1889	#ifdef DEBUG
1890	WriteLog("USER32: FindWindowW\n");
1891	#endif
1892	rc = O32_FindWindow(astring1, astring2);
1893	FreeAsciiString(astring1);
1894	FreeAsciiString(astring2);
1895	return rc;
1896	}
1897	//******************************************************************************
1898	//******************************************************************************
1899	int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH arg3)
1900	{
1901	#ifdef DEBUG
1902	WriteLog("USER32: FrameRect\n");
1903	#endif
1904	return O32_FrameRect(arg1, arg2, arg3);
1905	}
1906	//******************************************************************************
1907	//******************************************************************************
1908	HWND WIN32API GetCapture(void)
1909	{
1910	#ifdef DEBUG
1911	WriteLog("USER32: GetCapture\n");
1912	#endif
1913	return O32_GetCapture();
1914	}
1915	//******************************************************************************
1916	//******************************************************************************
1917	UINT WIN32API GetCaretBlinkTime(void)
1918	{
1919	#ifdef DEBUG
1920	WriteLog("USER32: GetCaretBlinkTime\n");
1921	#endif
1922	return O32_GetCaretBlinkTime();
1923	}
1924	//******************************************************************************
1925	//******************************************************************************
1926	BOOL WIN32API GetCaretPos( PPOINT arg1)
1927	{
1928	#ifdef DEBUG
1929	WriteLog("USER32: GetCaretPos\n");
1930	#endif
1931	return O32_GetCaretPos(arg1);
1932	}
1933	//******************************************************************************
1934	//******************************************************************************
1935	BOOL WIN32API GetClipCursor( PRECT arg1)
1936	{
1937	#ifdef DEBUG
1938	WriteLog("USER32: GetClipCursor\n");
1939	#endif
1940	return O32_GetClipCursor(arg1);
1941	}
1942	//******************************************************************************
1943	//******************************************************************************
1944	HANDLE WIN32API GetClipboardData( UINT arg1)
1945	{
1946	#ifdef DEBUG
1947	WriteLog("USER32: GetClipboardData\n");
1948	#endif
1949	return O32_GetClipboardData(arg1);
1950	}
1951	//******************************************************************************
1952	//******************************************************************************
1953	int WIN32API GetClipboardFormatNameA( UINT arg1, LPSTR arg2, int arg3)
1954	{
1955	#ifdef DEBUG
1956	WriteLog("USER32: GetClipboardFormatNameA %s\n", arg2);
1957	#endif
1958	return O32_GetClipboardFormatName(arg1, arg2, arg3);
1959	}
1960	//******************************************************************************
1961	//******************************************************************************
1962	int WIN32API GetClipboardFormatNameW(UINT arg1, LPWSTR arg2, int arg3)
1963	{
1964	int rc;
1965	char *astring = UnicodeToAsciiString(arg2);
1966
1967	#ifdef DEBUG
1968	WriteLog("USER32: GetClipboardFormatNameW %s\n", astring);
1969	#endif
1970	rc = O32_GetClipboardFormatName(arg1, astring, arg3);
1971	FreeAsciiString(astring);
1972	return(rc);
1973	}
1974	//******************************************************************************
1975	//******************************************************************************
1976	HWND WIN32API GetClipboardOwner(void)
1977	{
1978	#ifdef DEBUG
1979	WriteLog("USER32: GetClipboardOwner\n");
1980	#endif
1981	return O32_GetClipboardOwner();
1982	}
1983	//******************************************************************************
1984	//******************************************************************************
1985	HWND WIN32API GetClipboardViewer(void)
1986	{
1987	#ifdef DEBUG
1988	WriteLog("USER32: GetClipboardViewer\n");
1989	#endif
1990	return O32_GetClipboardViewer();
1991	}
1992	//******************************************************************************
1993	//******************************************************************************
1994	DWORD WIN32API GetDialogBaseUnits(void)
1995	{
1996	#ifdef DEBUG
1997	WriteLog("USER32: GetDialogBaseUnits\n");
1998	#endif
1999	return O32_GetDialogBaseUnits();
2000	}
2001	//******************************************************************************
2002	//******************************************************************************
2003	UINT WIN32API GetDlgItemInt( HWND arg1, int arg2, PBOOL arg3, BOOL arg4)
2004	{
2005	#ifdef DEBUG
2006	WriteLog("USER32: GetDlgItemInt\n");
2007	#endif
2008	return O32_GetDlgItemInt(arg1, arg2, arg3, arg4);
2009	}
2010
2011
2012	/*****************************************************************************
2013	* Name : UINT WIN32API GetDlgItemTextW
2014	* Purpose : Determine the text of a window control
2015	* Parameters: HWND arg1
2016	* int arg2
2017	* LPWSTR arg3
2018	* UINT arg4
2019	* Variables :
2020	* Result :
2021	* Remark :
2022	* Status : UNTESTED UNKNOWN STUB
2023	*
2024	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2025	*****************************************************************************/
2026
2027	UINT WIN32API GetDlgItemTextW(HWND arg1,
2028	int arg2,
2029	LPWSTR arg3,
2030	UINT arg4)
2031	{
2032	LPSTR lpBuffer; /* temporary buffer for the ascii result */
2033	UINT uiResult; /* return value of the ascii variant */
2034
2035	dprintf(("USER32: GetDlgItemTextW(%08xh,%08xh,%08xh,%08xh)\n",
2036	arg1,
2037	arg2,
2038	arg3,
2039	arg4));
2040
2041
2042	lpBuffer = (LPSTR)malloc(arg4); /* allocate temporary buffer */
2043	uiResult = GetDlgItemTextA(arg1, /* call ascii variant */
2044	arg2,
2045	lpBuffer,
2046	arg4);
2047
2048	AsciiToUnicodeN(lpBuffer, /* now convert result to unicode */
2049	arg3,
2050	arg4);
2051
2052	free(lpBuffer); /* free the temporary buffer */
2053
2054	return (uiResult); /* OK, that's it */
2055	}
2056
2057
2058	//******************************************************************************
2059	//******************************************************************************
2060	UINT WIN32API GetDoubleClickTime(void)
2061	{
2062	#ifdef DEBUG
2063	WriteLog("USER32: GetDoubleClickTime\n");
2064	#endif
2065	return O32_GetDoubleClickTime();
2066	}
2067	//******************************************************************************
2068	//******************************************************************************
2069	HWND WIN32API GetForegroundWindow(void)
2070	{
2071	#ifdef DEBUG
2072	WriteLog("USER32: GetForegroundWindow\n");
2073	#endif
2074	return O32_GetForegroundWindow();
2075	}
2076	//******************************************************************************
2077	//******************************************************************************
2078	BOOL WIN32API GetIconInfo( HICON arg1, LPICONINFO arg2)
2079	{
2080	#ifdef DEBUG
2081	WriteLog("USER32: GetIconInfo\n");
2082	#endif
2083	return O32_GetIconInfo(arg1, arg2);
2084	}
2085	//******************************************************************************
2086	//******************************************************************************
2087	int WIN32API GetKeyNameTextA( LPARAM arg1, LPSTR arg2, int arg3)
2088	{
2089	#ifdef DEBUG
2090	WriteLog("USER32: GetKeyNameTextA\n");
2091	#endif
2092	return O32_GetKeyNameText(arg1, arg2, arg3);
2093	}
2094	//******************************************************************************
2095	//******************************************************************************
2096	int WIN32API GetKeyNameTextW( LPARAM arg1, LPWSTR arg2, int arg3)
2097	{
2098	#ifdef DEBUG
2099	WriteLog("USER32: GetKeyNameTextW DOES NOT WORK\n");
2100	#endif
2101	// NOTE: This will not work as is (needs UNICODE support)
2102	return 0;
2103	// return O32_GetKeyNameText(arg1, arg2, arg3);
2104	}
2105	//******************************************************************************
2106	//******************************************************************************
2107	int WIN32API GetKeyboardType( int arg1)
2108	{
2109	#ifdef DEBUG
2110	WriteLog("USER32: GetKeyboardType\n");
2111	#endif
2112	return O32_GetKeyboardType(arg1);
2113	}
2114	//******************************************************************************
2115	//******************************************************************************
2116	HWND WIN32API GetLastActivePopup( HWND arg1)
2117	{
2118	#ifdef DEBUG
2119	WriteLog("USER32: GetLastActivePopup\n");
2120	#endif
2121	return O32_GetLastActivePopup(arg1);
2122	}
2123	//******************************************************************************
2124	//******************************************************************************
2125	LONG WIN32API GetMessageExtraInfo(void)
2126	{
2127	dprintf(("USER32: GetMessageExtraInfo\n"));
2128	return O32_GetMessageExtraInfo();
2129	}
2130	//******************************************************************************
2131	//******************************************************************************
2132	DWORD WIN32API GetMessagePos(void)
2133	{
2134	dprintf(("USER32: GetMessagePos\n"));
2135	return O32_GetMessagePos();
2136	}
2137	//******************************************************************************
2138	//******************************************************************************
2139	LONG WIN32API GetMessageTime(void)
2140	{
2141	dprintf(("USER32: GetMessageTime\n"));
2142	return O32_GetMessageTime();
2143	}
2144	//******************************************************************************
2145	//******************************************************************************
2146	BOOL WIN32API GetMessageW(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
2147	{
2148	BOOL rc;
2149
2150	// NOTE: This will not work as is (needs UNICODE support)
2151	rc = O32_GetMessage(arg1, arg2, arg3, arg4);
2152	dprintf(("USER32: GetMessageW %X returned %d\n", arg2, rc));
2153	return(rc);
2154	}
2155	//******************************************************************************
2156	//******************************************************************************
2157	HWND WIN32API GetNextDlgGroupItem( HWND arg1, HWND arg2, BOOL arg3)
2158	{
2159	#ifdef DEBUG
2160	WriteLog("USER32: GetNextDlgGroupItem\n");
2161	#endif
2162	return O32_GetNextDlgGroupItem(arg1, arg2, arg3);
2163	}
2164	//******************************************************************************
2165	//******************************************************************************
2166	HWND WIN32API GetOpenClipboardWindow(void)
2167	{
2168	#ifdef DEBUG
2169	WriteLog("USER32: GetOpenClipboardWindow\n");
2170	#endif
2171	return O32_GetOpenClipboardWindow();
2172	}
2173	//******************************************************************************
2174	//******************************************************************************
2175	HWND WIN32API GetParent( HWND arg1)
2176	{
2177	#ifdef DEBUG
2178	//// WriteLog("USER32: GetParent\n");
2179	#endif
2180	return O32_GetParent(arg1);
2181	}
2182	//******************************************************************************
2183	//******************************************************************************
2184	int WIN32API GetPriorityClipboardFormat( PUINT arg1, int arg2)
2185	{
2186	#ifdef DEBUG
2187	WriteLog("USER32: GetPriorityClipboardFormat\n");
2188	#endif
2189	return O32_GetPriorityClipboardFormat(arg1, arg2);
2190	}
2191	//******************************************************************************
2192	//******************************************************************************
2193	HANDLE WIN32API GetPropA( HWND arg1, LPCSTR arg2)
2194	{
2195	#ifdef DEBUG
2196	if((int)arg2 >> 16 != 0)
2197	WriteLog("USER32: GetPropA %s\n", arg2);
2198	else WriteLog("USER32: GetPropA %X\n", arg2);
2199	#endif
2200	return O32_GetProp(arg1, arg2);
2201	}
2202	//******************************************************************************
2203	//******************************************************************************
2204	HANDLE WIN32API GetPropW(HWND arg1, LPCWSTR arg2)
2205	{
2206	BOOL handle;
2207	char *astring;
2208
2209	if((int)arg2 >> 16 != 0)
2210	astring = UnicodeToAsciiString((LPWSTR)arg2);
2211	else astring = (char *)arg2;
2212	#ifdef DEBUG
2213	if((int)arg2 >> 16 != 0)
2214	WriteLog("USER32: GetPropW %s\n", astring);
2215	else WriteLog("USER32: GetPropW %X\n", astring);
2216	#endif
2217	handle = GetPropA(arg1, (LPCSTR)astring);
2218	if((int)arg2 >> 16 != 0)
2219	FreeAsciiString(astring);
2220
2221	return(handle);
2222	}
2223	//******************************************************************************
2224	//******************************************************************************
2225	DWORD WIN32API GetQueueStatus( UINT arg1)
2226	{
2227	#ifdef DEBUG
2228	WriteLog("USER32: GetQueueStatus\n");
2229	#endif
2230	return O32_GetQueueStatus(arg1);
2231	}
2232	//******************************************************************************
2233	//******************************************************************************
2234	int WIN32API GetScrollPos(HWND hwnd, int fnBar)
2235	{
2236	int pos;
2237
2238	pos = O32_GetScrollPos(hwnd, fnBar);
2239	#ifdef DEBUG
2240	WriteLog("USER32: GetScrollPos of %X type %d returned %d\n", hwnd, fnBar, pos);
2241	#endif
2242	return(pos);
2243	}
2244	//******************************************************************************
2245	//******************************************************************************
2246	BOOL WIN32API GetScrollRange( HWND arg1, int arg2, int * arg3, int * arg4)
2247	{
2248	#ifdef DEBUG
2249	WriteLog("USER32: GetScrollRange\n");
2250	#endif
2251	return O32_GetScrollRange(arg1, arg2, arg3, arg4);
2252	}
2253	//******************************************************************************
2254	//******************************************************************************
2255	DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
2256	{
2257	#ifdef DEBUG
2258	WriteLog("USER32: GetTabbedTextExtentA\n");
2259	#endif
2260	return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
2261	}
2262	//******************************************************************************
2263	//******************************************************************************
2264	DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
2265	{
2266	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2267	DWORD rc;
2268
2269	#ifdef DEBUG
2270	WriteLog("USER32: GetTabbedTextExtentW\n");
2271	#endif
2272	rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
2273	FreeAsciiString(astring);
2274	return rc;
2275	}
2276	//******************************************************************************
2277	//******************************************************************************
2278	HWND WIN32API GetTopWindow( HWND arg1)
2279	{
2280	#ifdef DEBUG
2281	//// WriteLog("USER32: GetTopWindow\n");
2282	#endif
2283	return O32_GetTopWindow(arg1);
2284	}
2285	//******************************************************************************
2286	//******************************************************************************
2287	int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2288	{
2289	#ifdef DEBUG
2290	WriteLog("USER32: GetUpdateRgn\n");
2291	#endif
2292	return O32_GetUpdateRgn(arg1, arg2, arg3);
2293	}
2294	//******************************************************************************
2295	//******************************************************************************
2296	BOOL WIN32API GetWindowPlacement( HWND arg1, LPWINDOWPLACEMENT arg2)
2297	{
2298	#ifdef DEBUG
2299	WriteLog("USER32: GetWindowPlacement\n");
2300	#endif
2301	return O32_GetWindowPlacement(arg1, arg2);
2302	}
2303	//******************************************************************************
2304
2305	/***********************************************************************
2306	* GetInternalWindowPos (USER32.245)
2307	*/
2308	UINT WIN32API GetInternalWindowPos(HWND hwnd,
2309	LPRECT rectWnd,
2310	LPPOINT ptIcon )
2311	{
2312	WINDOWPLACEMENT wndpl;
2313
2314	dprintf(("USER32: GetInternalWindowPos(%08xh,%08xh,%08xh)\n",
2315	hwnd,
2316	rectWnd,
2317	ptIcon));
2318
2319	if (O32_GetWindowPlacement( hwnd, &wndpl ))
2320	{
2321	if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
2322	if (ptIcon) *ptIcon = wndpl.ptMinPosition;
2323	return wndpl.showCmd;
2324	}
2325	return 0;
2326	}
2327
2328
2329	//******************************************************************************
2330	int WIN32API GetWindowTextLengthW( HWND arg1)
2331	{
2332	#ifdef DEBUG
2333	WriteLog("USER32: GetWindowTextLengthW\n");
2334	#endif
2335	return O32_GetWindowTextLength(arg1);
2336	}
2337	//******************************************************************************
2338	//******************************************************************************
2339	int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
2340	{
2341	char title[128];
2342	int rc;
2343
2344	rc = O32_GetWindowText(hwnd, title, sizeof(title));
2345	#ifdef DEBUG
2346	WriteLog("USER32: GetWindowTextW returned %s\n", title);
2347	#endif
2348	if(rc > cch) {
2349	title[cch-1] = 0;
2350	rc = cch;
2351	}
2352	AsciiToUnicode(title, lpsz);
2353	return(rc);
2354	}
2355	//******************************************************************************
2356	//******************************************************************************
2357	DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD arg2)
2358	{
2359	#ifdef DEBUG
2360	WriteLog("USER32: GetWindowThreadProcessId\n");
2361	#endif
2362	return O32_GetWindowThreadProcessId(arg1, arg2);
2363	}
2364	//******************************************************************************
2365	//******************************************************************************
2366	BOOL WIN32API HideCaret( HWND arg1)
2367	{
2368	#ifdef DEBUG
2369	WriteLog("USER32: HideCaret\n");
2370	#endif
2371	return O32_HideCaret(arg1);
2372	}
2373	//******************************************************************************
2374	//******************************************************************************
2375	BOOL WIN32API InSendMessage(void)
2376	{
2377	#ifdef DEBUG
2378	WriteLog("USER32: InSendMessage\n");
2379	#endif
2380	return O32_InSendMessage();
2381	}
2382	//******************************************************************************
2383	//******************************************************************************
2384	BOOL WIN32API IntersectRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
2385	{
2386	#ifdef DEBUG
2387	//// WriteLog("USER32: IntersectRect\n");
2388	#endif
2389	return O32_IntersectRect(arg1, arg2, arg3);
2390	}
2391	//******************************************************************************
2392	//******************************************************************************
2393	BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2394	{
2395	#ifdef DEBUG
2396	WriteLog("USER32: InvalidateRgn\n");
2397	#endif
2398	return O32_InvalidateRgn(arg1, arg2, arg3);
2399	}
2400	//******************************************************************************
2401	//******************************************************************************
2402	BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
2403	{
2404	#ifdef DEBUG
2405	WriteLog("USER32: InvertRect\n");
2406	#endif
2407	return O32_InvertRect(arg1, arg2);
2408	}
2409	//******************************************************************************
2410	//******************************************************************************
2411	BOOL WIN32API IsChild( HWND arg1, HWND arg2)
2412	{
2413	#ifdef DEBUG
2414	WriteLog("USER32: IsChild\n");
2415	#endif
2416	return O32_IsChild(arg1, arg2);
2417	}
2418	//******************************************************************************
2419	//******************************************************************************
2420	BOOL WIN32API IsClipboardFormatAvailable( UINT arg1)
2421	{
2422	#ifdef DEBUG
2423	WriteLog("USER32: IsClipboardFormatAvailable\n");
2424	#endif
2425	return O32_IsClipboardFormatAvailable(arg1);
2426	}
2427	//******************************************************************************
2428	//******************************************************************************
2429	BOOL WIN32API IsDialogMessageW( HWND arg1, LPMSG arg2)
2430	{
2431	#ifdef DEBUG
2432	WriteLog("USER32: IsDialogMessageW\n");
2433	#endif
2434	// NOTE: This will not work as is (needs UNICODE support)
2435	return O32_IsDialogMessage(arg1, arg2);
2436	}
2437
2438	//******************************************************************************
2439	//******************************************************************************
2440	BOOL WIN32API IsRectEmpty( const RECT * arg1)
2441	{
2442	#ifdef DEBUG
2443	WriteLog("USER32: IsRectEmpty\n");
2444	#endif
2445	return O32_IsRectEmpty(arg1);
2446	}
2447	//******************************************************************************
2448	//******************************************************************************
2449	BOOL WIN32API IsWindow( HWND arg1)
2450	{
2451	#ifdef DEBUG
2452	WriteLog("USER32: IsWindow\n");
2453	#endif
2454	return O32_IsWindow(arg1);
2455	}
2456	//******************************************************************************
2457	//******************************************************************************
2458	BOOL WIN32API IsWindowEnabled( HWND arg1)
2459	{
2460	#ifdef DEBUG
2461	WriteLog("USER32: IsWindowEnabled\n");
2462	#endif
2463	return O32_IsWindowEnabled(arg1);
2464	}
2465	//******************************************************************************
2466	//******************************************************************************
2467	BOOL WIN32API IsWindowVisible( HWND arg1)
2468	{
2469	#ifdef DEBUG
2470	WriteLog("USER32: IsWindowVisible\n");
2471	#endif
2472	return O32_IsWindowVisible(arg1);
2473	}
2474	//******************************************************************************
2475	//******************************************************************************
2476	BOOL WIN32API IsZoomed( HWND arg1)
2477	{
2478	#ifdef DEBUG
2479	WriteLog("USER32: IsZoomed\n");
2480	#endif
2481	return O32_IsZoomed(arg1);
2482	}
2483	//******************************************************************************
2484	//******************************************************************************
2485	BOOL WIN32API LockWindowUpdate( HWND arg1)
2486	{
2487	#ifdef DEBUG
2488	WriteLog("USER32: LockWindowUpdate\n");
2489	#endif
2490	return O32_LockWindowUpdate(arg1);
2491	}
2492	//******************************************************************************
2493	//******************************************************************************
2494	BOOL WIN32API MapDialogRect( HWND arg1, PRECT arg2)
2495	{
2496	#ifdef DEBUG
2497	WriteLog("USER32: MapDialogRect\n");
2498	#endif
2499	return O32_MapDialogRect(arg1, arg2);
2500	}
2501	//******************************************************************************
2502	//******************************************************************************
2503	UINT WIN32API MapVirtualKeyA( UINT arg1, UINT arg2)
2504	{
2505	#ifdef DEBUG
2506	WriteLog("USER32: MapVirtualKeyA\n");
2507	#endif
2508	return O32_MapVirtualKey(arg1, arg2);
2509	}
2510	//******************************************************************************
2511	//******************************************************************************
2512	UINT WIN32API MapVirtualKeyW( UINT arg1, UINT arg2)
2513	{
2514	#ifdef DEBUG
2515	WriteLog("USER32: MapVirtualKeyW\n");
2516	#endif
2517	// NOTE: This will not work as is (needs UNICODE support)
2518	return O32_MapVirtualKey(arg1, arg2);
2519	}
2520	//******************************************************************************
2521	//******************************************************************************
2522	int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
2523	{
2524	#ifdef DEBUG
2525	WriteLog("USER32: MapWindowPoints\n");
2526	#endif
2527	return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
2528	}
2529	//******************************************************************************
2530	//******************************************************************************
2531	int WIN32API MessageBoxW(HWND arg1, LPCWSTR arg2, LPCWSTR arg3, UINT arg4)
2532	{
2533	char astring1, astring2;
2534	int rc;
2535
2536	astring1 = UnicodeToAsciiString((LPWSTR)arg2);
2537	astring2 = UnicodeToAsciiString((LPWSTR)arg3);
2538	#ifdef DEBUG
2539	WriteLog("USER32: MessageBoxW %s %s\n", astring1, astring2);
2540	#endif
2541	rc = O32_MessageBox(arg1, astring1, astring2, arg4);
2542	FreeAsciiString(astring1);
2543	FreeAsciiString(astring2);
2544	return(rc);
2545	}
2546	//******************************************************************************
2547	//******************************************************************************
2548	BOOL WIN32API OpenClipboard( HWND arg1)
2549	{
2550	#ifdef DEBUG
2551	WriteLog("USER32: OpenClipboard\n");
2552	#endif
2553	return O32_OpenClipboard(arg1);
2554	}
2555	//******************************************************************************
2556	//******************************************************************************
2557	BOOL WIN32API PeekMessageW( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
2558	{
2559	#ifdef DEBUG
2560	WriteLog("USER32: PeekMessageW\n");
2561	#endif
2562	// NOTE: This will not work as is (needs UNICODE support)
2563	return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
2564	}
2565	//******************************************************************************
2566	//******************************************************************************
2567	// NOTE: Open32 function doesn't have the 'W'.
2568	BOOL WIN32API PostMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2569	{
2570	#ifdef DEBUG
2571	WriteLog("USER32: PostMessageW\n");
2572	#endif
2573	// NOTE: This will not work as is (needs UNICODE support)
2574	return O32_PostMessage(arg1, arg2, arg3, arg4);
2575	}
2576	//******************************************************************************
2577	//******************************************************************************
2578	BOOL WIN32API PostThreadMessageA( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2579	{
2580	#ifdef DEBUG
2581	WriteLog("USER32: PostThreadMessageA\n");
2582	#endif
2583	return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2584	}
2585	//******************************************************************************
2586	//******************************************************************************
2587	BOOL WIN32API PostThreadMessageW( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2588	{
2589	#ifdef DEBUG
2590	WriteLog("USER32: PostThreadMessageW\n");
2591	#endif
2592	// NOTE: This will not work as is (needs UNICODE support)
2593	return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2594	}
2595	//******************************************************************************
2596	//******************************************************************************
2597	BOOL WIN32API PtInRect( const RECT * arg1, POINT arg2)
2598	{
2599	#ifdef DEBUG1
2600	WriteLog("USER32: PtInRect\n");
2601	#endif
2602	return O32_PtInRect(arg1, arg2);
2603	}
2604	//******************************************************************************
2605	//******************************************************************************
2606	BOOL WIN32API RedrawWindow( HWND arg1, const RECT * arg2, HRGN arg3, UINT arg4)
2607	{
2608	BOOL rc;
2609
2610	rc = O32_RedrawWindow(arg1, arg2, arg3, arg4);
2611	#ifdef DEBUG
2612	WriteLog("USER32: RedrawWindow %X , %X, %X, %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2613	#endif
2614	InvalidateRect(arg1, arg2, TRUE);
2615	UpdateWindow(arg1);
2616	SendMessageA(arg1, WM_PAINT, 0, 0);
2617	return(rc);
2618	}
2619	//******************************************************************************
2620	//******************************************************************************
2621	UINT WIN32API RegisterClipboardFormatA( LPCSTR arg1)
2622	{
2623	#ifdef DEBUG
2624	WriteLog("USER32: RegisterClipboardFormatA\n");
2625	#endif
2626	return O32_RegisterClipboardFormat(arg1);
2627	}
2628	//******************************************************************************
2629	//******************************************************************************
2630	UINT WIN32API RegisterClipboardFormatW(LPCWSTR arg1)
2631	{
2632	UINT rc;
2633	char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2634
2635	#ifdef DEBUG
2636	WriteLog("USER32: RegisterClipboardFormatW %s\n", astring);
2637	#endif
2638	rc = O32_RegisterClipboardFormat(astring);
2639	FreeAsciiString(astring);
2640	#ifdef DEBUG
2641	WriteLog("USER32: RegisterClipboardFormatW returned %d\n", rc);
2642	#endif
2643	return(rc);
2644	}
2645	//******************************************************************************
2646	//******************************************************************************
2647	UINT WIN32API RegisterWindowMessageW( LPCWSTR arg1)
2648	{
2649	char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2650	UINT rc;
2651
2652	#ifdef DEBUG
2653	WriteLog("USER32: RegisterWindowMessageW\n");
2654	#endif
2655	rc = O32_RegisterWindowMessage(astring);
2656	FreeAsciiString(astring);
2657	return rc;
2658	}
2659	//******************************************************************************
2660	//******************************************************************************
2661	HANDLE WIN32API RemovePropA( HWND arg1, LPCSTR arg2)
2662	{
2663	#ifdef DEBUG
2664	WriteLog("USER32: RemovePropA\n");
2665	#endif
2666	return O32_RemoveProp(arg1, arg2);
2667	}
2668	//******************************************************************************
2669	//******************************************************************************
2670	HANDLE WIN32API RemovePropW( HWND arg1, LPCWSTR arg2)
2671	{
2672	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2673	HANDLE rc;
2674
2675	#ifdef DEBUG
2676	WriteLog("USER32: RemovePropW\n");
2677	#endif
2678	rc = O32_RemoveProp(arg1, astring);
2679	FreeAsciiString(astring);
2680	return rc;
2681	}
2682	//******************************************************************************
2683	//******************************************************************************
2684	BOOL WIN32API ReplyMessage( LRESULT arg1)
2685	{
2686	#ifdef DEBUG
2687	WriteLog("USER32: ReplyMessage\n");
2688	#endif
2689	return O32_ReplyMessage(arg1);
2690	}
2691	//******************************************************************************
2692	//******************************************************************************
2693	BOOL WIN32API ScreenToClient( HWND arg1, LPPOINT arg2)
2694	{
2695	#ifdef DEBUG
2696	WriteLog("USER32: ScreenToClient\n");
2697	#endif
2698	return O32_ScreenToClient(arg1, arg2);
2699	}
2700	//******************************************************************************
2701	//******************************************************************************
2702	BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7)
2703	{
2704	#ifdef DEBUG
2705	WriteLog("USER32: ScrollDC\n");
2706	#endif
2707	return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2708	}
2709	//******************************************************************************
2710	//******************************************************************************
2711	BOOL WIN32API ScrollWindow( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5)
2712	{
2713	#ifdef DEBUG
2714	WriteLog("USER32: ScrollWindow\n");
2715	#endif
2716	return O32_ScrollWindow(arg1, arg2, arg3, arg4, arg5);
2717	}
2718	//******************************************************************************
2719	//******************************************************************************
2720	BOOL WIN32API ScrollWindowEx( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7, UINT arg8)
2721	{
2722	#ifdef DEBUG
2723	WriteLog("USER32: ScrollWindowEx\n");
2724	#endif
2725	return O32_ScrollWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2726	}
2727	//******************************************************************************
2728	//******************************************************************************
2729	LONG WIN32API SendDlgItemMessageW( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
2730	{
2731	#ifdef DEBUG
2732	WriteLog("USER32: SendDlgItemMessageW\n");
2733	#endif
2734	return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
2735	}
2736	//******************************************************************************
2737	//******************************************************************************
2738	LRESULT WIN32API SendMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2739	{
2740	LRESULT rc;
2741
2742	#ifdef DEBUG
2743	WriteLog("USER32: SendMessageW....\n");
2744	#endif
2745	rc = O32_SendMessage(arg1, arg2, arg3, arg4);
2746	#ifdef DEBUG
2747	WriteLog("USER32: SendMessageW %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2748	#endif
2749	return(rc);
2750	}
2751	//******************************************************************************
2752	//******************************************************************************
2753	BOOL WIN32API SetCaretBlinkTime( UINT arg1)
2754	{
2755	#ifdef DEBUG
2756	WriteLog("USER32: SetCaretBlinkTime\n");
2757	#endif
2758	return O32_SetCaretBlinkTime(arg1);
2759	}
2760	//******************************************************************************
2761	//******************************************************************************
2762	BOOL WIN32API SetCaretPos( int arg1, int arg2)
2763	{
2764	dprintf(("USER32: SetCaretPos\n"));
2765	return O32_SetCaretPos(arg1, arg2);
2766	}
2767	//******************************************************************************
2768	//******************************************************************************
2769	HANDLE WIN32API SetClipboardData( UINT arg1, HANDLE arg2)
2770	{
2771	dprintf(("USER32: SetClipboardData\n"));
2772	return O32_SetClipboardData(arg1, arg2);
2773	}
2774	//******************************************************************************
2775	//******************************************************************************
2776	HWND WIN32API SetClipboardViewer( HWND arg1)
2777	{
2778	dprintf(("USER32: SetClipboardViewer\n"));
2779	return O32_SetClipboardViewer(arg1);
2780	}
2781	//******************************************************************************
2782	//******************************************************************************
2783	BOOL WIN32API SetDlgItemTextW( HWND arg1, int arg2, LPCWSTR arg3)
2784	{
2785	char *astring = UnicodeToAsciiString((LPWSTR)arg3);
2786	BOOL rc;
2787
2788	#ifdef DEBUG
2789	WriteLog("USER32: SetDlgItemTextW\n");
2790	#endif
2791	// NOTE: This will not work as is (needs UNICODE support)
2792	rc = O32_SetDlgItemText(arg1, arg2, astring);
2793	FreeAsciiString(astring);
2794	return rc;
2795	}
2796	//******************************************************************************
2797	//******************************************************************************
2798	BOOL WIN32API SetDoubleClickTime( UINT arg1)
2799	{
2800	#ifdef DEBUG
2801	WriteLog("USER32: SetDoubleClickTime\n");
2802	#endif
2803	return O32_SetDoubleClickTime(arg1);
2804	}
2805	//******************************************************************************
2806	//******************************************************************************
2807	HWND WIN32API SetParent( HWND arg1, HWND arg2)
2808	{
2809	#ifdef DEBUG
2810	WriteLog("USER32: SetParent\n");
2811	#endif
2812	return O32_SetParent(arg1, arg2);
2813	}
2814	//******************************************************************************
2815	//******************************************************************************
2816	BOOL WIN32API SetPropA( HWND arg1, LPCSTR arg2, HANDLE arg3)
2817	{
2818	#ifdef DEBUG
2819	if((int)arg2 >> 16 != 0)
2820	WriteLog("USER32: SetPropA %S\n", arg2);
2821	else WriteLog("USER32: SetPropA %X\n", arg2);
2822	#endif
2823	return O32_SetProp(arg1, arg2, arg3);
2824	}
2825	//******************************************************************************
2826	//******************************************************************************
2827	BOOL WIN32API SetPropW(HWND arg1, LPCWSTR arg2, HANDLE arg3)
2828	{
2829	BOOL rc;
2830	char *astring;
2831
2832	if((int)arg2 >> 16 != 0)
2833	astring = UnicodeToAsciiString((LPWSTR)arg2);
2834	else astring = (char *)arg2;
2835
2836	#ifdef DEBUG
2837	if((int)arg2 >> 16 != 0)
2838	WriteLog("USER32: SetPropW %S\n", astring);
2839	else WriteLog("USER32: SetPropW %X\n", astring);
2840	#endif
2841	rc = O32_SetProp(arg1, astring, arg3);
2842	if((int)astring >> 16 != 0)
2843	FreeAsciiString(astring);
2844	return(rc);
2845	}
2846	//******************************************************************************
2847	//******************************************************************************
2848	BOOL WIN32API SetRectEmpty( PRECT arg1)
2849	{
2850	#ifdef DEBUG
2851	WriteLog("USER32: SetRectEmpty\n");
2852	#endif
2853	return O32_SetRectEmpty(arg1);
2854	}
2855	//******************************************************************************
2856	//******************************************************************************
2857	int WIN32API SetScrollPos( HWND arg1, int arg2, int arg3, BOOL arg4)
2858	{
2859	#ifdef DEBUG
2860	WriteLog("USER32: SetScrollPos\n");
2861	#endif
2862	return O32_SetScrollPos(arg1, arg2, arg3, arg4);
2863	}
2864	//******************************************************************************
2865	//******************************************************************************
2866	BOOL WIN32API SetScrollRange( HWND arg1, int arg2, int arg3, int arg4, BOOL arg5)
2867	{
2868	#ifdef DEBUG
2869	WriteLog("USER32: SetScrollRange\n");
2870	#endif
2871	return O32_SetScrollRange(arg1, arg2, arg3, arg4, arg5);
2872	}
2873	//******************************************************************************
2874	//******************************************************************************
2875	BOOL WIN32API SetWindowPlacement( HWND arg1, const WINDOWPLACEMENT * arg2)
2876	{
2877	dprintf(("USER32: SetWindowPlacement\n"));
2878	return O32_SetWindowPlacement(arg1, arg2);
2879	}
2880	//******************************************************************************
2881	//******************************************************************************
2882	BOOL WIN32API SetWindowTextW( HWND arg1, LPCWSTR arg2)
2883	{
2884	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2885	BOOL rc;
2886
2887	rc = SetWindowTextA(arg1, (LPCSTR)astring);
2888	dprintf(("USER32: SetWindowTextW %X %s returned %d\n", arg1, astring, rc));
2889	FreeAsciiString(astring);
2890	return(rc);
2891	}
2892	//******************************************************************************
2893	//******************************************************************************
2894	BOOL WIN32API ShowCaret( HWND arg1)
2895	{
2896	dprintf(("USER32: ShowCaret\n"));
2897	return O32_ShowCaret(arg1);
2898	}
2899	//******************************************************************************
2900	//******************************************************************************
2901	BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
2902	{
2903	dprintf(("USER32: ShowOwnedPopups\n"));
2904	return O32_ShowOwnedPopups(arg1, arg2);
2905	}
2906	//******************************************************************************
2907	//******************************************************************************
2908	BOOL WIN32API ShowScrollBar( HWND arg1, int arg2, BOOL arg3)
2909	{
2910	#ifdef DEBUG
2911	WriteLog("USER32: ShowScrollBar\n");
2912	#endif
2913	return O32_ShowScrollBar(arg1, arg2, arg3);
2914	}
2915	//******************************************************************************
2916	//******************************************************************************
2917	BOOL WIN32API SwapMouseButton( BOOL arg1)
2918	{
2919	#ifdef DEBUG
2920	WriteLog("USER32: SwapMouseButton\n");
2921	#endif
2922	return O32_SwapMouseButton(arg1);
2923	}
2924	//******************************************************************************
2925	//******************************************************************************
2926	BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
2927	{
2928	BOOL rc;
2929	NONCLIENTMETRICSA cmetric = (NONCLIENTMETRICSA )pvParam;
2930
2931	switch(uiAction) {
2932	case SPI_SCREENSAVERRUNNING:
2933	(BOOL )pvParam = FALSE;
2934	rc = TRUE;
2935	break;
2936	case SPI_GETDRAGFULLWINDOWS:
2937	(BOOL )pvParam = FALSE;
2938	rc = TRUE;
2939	break;
2940	case SPI_GETNONCLIENTMETRICS:
2941	memset(cmetric, 0, sizeof(NONCLIENTMETRICSA));
2942	cmetric->cbSize = sizeof(NONCLIENTMETRICSA);
2943	//CB: font info not valid, needs improvements
2944	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfCaptionFont),0);
2945	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMenuFont),0);
2946	//CB: experimental change for statusbar (and tooltips)
2947
2948	//O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfStatusFont),0);
2949	lstrcpyA(cmetric->lfStatusFont.lfFaceName,"WarpSans");
2950	cmetric->lfStatusFont.lfHeight = 9;
2951
2952	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMessageFont),0);
2953	cmetric->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
2954	cmetric->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
2955	cmetric->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
2956	cmetric->iCaptionWidth = 32; //TODO
2957	cmetric->iCaptionHeight = 16; //TODO
2958	cmetric->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
2959	cmetric->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
2960	cmetric->iMenuWidth = 32; //TODO
2961	cmetric->iMenuHeight = GetSystemMetrics(SM_CYMENU);
2962	rc = TRUE;
2963	break;
2964	case 104: //TODO: Undocumented
2965	rc = 16;
2966	break;
2967	default:
2968	rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
2969	break;
2970	}
2971	#ifdef DEBUG
2972	WriteLog("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc);
2973	#endif
2974	return(rc);
2975	}
2976	//******************************************************************************
2977	//TODO: Check for more options that have different structs for Unicode!!!!
2978	//******************************************************************************
2979	BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
2980	{
2981	BOOL rc;
2982	NONCLIENTMETRICSW clientMetricsW = (NONCLIENTMETRICSW )pvParam;
2983	NONCLIENTMETRICSA clientMetricsA = {0};
2984	PVOID pvParamA;
2985	UINT uiParamA;
2986
2987	switch(uiAction) {
2988	case SPI_SETNONCLIENTMETRICS:
2989	clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
2990	clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
2991	clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
2992	clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
2993	clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
2994	clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
2995	ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
2996	clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
2997	clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
2998	ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
2999	clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
3000	clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
3001	ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
3002	ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
3003	ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
3004	//no break
3005	case SPI_GETNONCLIENTMETRICS:
3006	uiParamA = sizeof(NONCLIENTMETRICSA);
3007	pvParamA = &clientMetricsA;
3008	break;
3009	default:
3010	pvParamA = pvParam;
3011	uiParamA = uiParam;
3012	break;
3013	}
3014	rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
3015
3016	switch(uiAction) {
3017	case SPI_GETNONCLIENTMETRICS:
3018	clientMetricsW->cbSize = sizeof(*clientMetricsW);
3019	clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
3020	clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
3021	clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
3022	clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
3023	clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
3024	ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
3025
3026	clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
3027	clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
3028	ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
3029
3030	clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
3031	clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
3032	ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
3033	ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
3034	ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
3035	break;
3036	}
3037	#ifdef DEBUG
3038	WriteLog("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc);
3039	#endif
3040	return(rc);
3041	}
3042	//******************************************************************************
3043	//******************************************************************************
3044	LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3045	{
3046	#ifdef DEBUG
3047	WriteLog("USER32: TabbedTextOutA\n");
3048	#endif
3049	return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
3050	}
3051	//******************************************************************************
3052	//******************************************************************************
3053	LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3054	{
3055	char *astring = UnicodeToAsciiString((LPWSTR)arg4);
3056	LONG rc;
3057
3058	#ifdef DEBUG
3059	WriteLog("USER32: TabbedTextOutW\n");
3060	#endif
3061	rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
3062	FreeAsciiString(astring);
3063	return rc;
3064	}
3065	//******************************************************************************
3066	//******************************************************************************
3067	int WIN32API TranslateAccelerator( HWND arg1, HACCEL arg2, LPMSG arg3)
3068	{
3069	#ifdef DEBUG
3070	WriteLog("USER32: TranslateAccelerator\n");
3071	#endif
3072	return O32_TranslateAccelerator(arg1, arg2, arg3);
3073	}
3074	//******************************************************************************
3075	//******************************************************************************
3076	int WIN32API TranslateAcceleratorW( HWND arg1, HACCEL arg2, LPMSG arg3)
3077	{
3078	#ifdef DEBUG
3079	WriteLog("USER32: TranslateAcceleratorW\n");
3080	#endif
3081	// NOTE: This will not work as is (needs UNICODE support)
3082	return O32_TranslateAccelerator(arg1, arg2, arg3);
3083	}
3084	//******************************************************************************
3085	//******************************************************************************
3086	BOOL WIN32API TranslateMDISysAccel( HWND arg1, LPMSG arg2)
3087	{
3088	#ifdef DEBUG
3089	//// WriteLog("USER32: TranslateMDISysAccel\n");
3090	#endif
3091	return O32_TranslateMDISysAccel(arg1, arg2);
3092	}
3093	//******************************************************************************
3094	//******************************************************************************
3095	BOOL WIN32API UnionRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
3096	{
3097	#ifdef DEBUG
3098	WriteLog("USER32: UnionRect\n");
3099	#endif
3100	return O32_UnionRect(arg1, arg2, arg3);
3101	}
3102	//******************************************************************************
3103	//******************************************************************************
3104	BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
3105	{
3106	#ifdef DEBUG
3107	WriteLog("USER32: ValidateRect\n");
3108	#endif
3109	return O32_ValidateRect(arg1, arg2);
3110	}
3111	//******************************************************************************
3112	//******************************************************************************
3113	BOOL WIN32API ValidateRgn( HWND arg1, HRGN arg2)
3114	{
3115	#ifdef DEBUG
3116	WriteLog("USER32: ValidateRgn\n");
3117	#endif
3118	return O32_ValidateRgn(arg1, arg2);
3119	}
3120	//******************************************************************************
3121	//******************************************************************************
3122	WORD WIN32API VkKeyScanW( WCHAR arg1)
3123	{
3124	#ifdef DEBUG
3125	WriteLog("USER32: VkKeyScanW\n");
3126	#endif
3127	// NOTE: This will not work as is (needs UNICODE support)
3128	return O32_VkKeyScan((char)arg1);
3129	}
3130	//******************************************************************************
3131	//******************************************************************************
3132	BOOL WIN32API WaitMessage(void)
3133	{
3134	#ifdef DEBUG
3135	WriteLog("USER32: WaitMessage\n");
3136	#endif
3137	return O32_WaitMessage();
3138	}
3139	//******************************************************************************
3140	//******************************************************************************
3141	BOOL WIN32API WinHelpW( HWND arg1, LPCWSTR arg2, UINT arg3, DWORD arg4)
3142	{
3143	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
3144	BOOL rc;
3145
3146	#ifdef DEBUG
3147	WriteLog("USER32: WinHelpW\n");
3148	#endif
3149	rc = WinHelpA(arg1, astring, arg3, arg4);
3150	FreeAsciiString(astring);
3151	return rc;
3152	}
3153	//******************************************************************************
3154	//******************************************************************************
3155	HWND WIN32API WindowFromDC( HDC arg1)
3156	{
3157	#ifdef DEBUG
3158	WriteLog("USER32: WindowFromDC\n");
3159	#endif
3160	return O32_WindowFromDC(arg1);
3161	}
3162	//******************************************************************************
3163	//******************************************************************************
3164	HWND WIN32API WindowFromPoint( POINT arg1)
3165	{
3166	#ifdef DEBUG
3167	WriteLog("USER32: WindowFromPoint\n");
3168	#endif
3169	return O32_WindowFromPoint(arg1);
3170	}
3171	//******************************************************************************
3172	//******************************************************************************
3173	int WIN32API wvsprintfA( LPSTR arg1, LPCSTR arg2, va_list arg3)
3174	{
3175	#ifdef DEBUG
3176	WriteLog("USER32: wvsprintfA\n");
3177	#endif
3178	return O32_wvsprintf(arg1, arg2, (LPCVOID *)arg3);
3179	}
3180	//******************************************************************************
3181	//******************************************************************************
3182	int WIN32API wvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, va_list argptr)
3183	{
3184	int rc;
3185	char szOut[256];
3186	char *lpFmtA;
3187
3188	lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
3189	#ifdef DEBUG
3190	WriteLog("USER32: wvsprintfW, DOES NOT HANDLE UNICODE STRINGS!\n");
3191	WriteLog("USER32: %s\n", lpFmt);
3192	#endif
3193	rc = O32_wvsprintf(szOut, lpFmtA, (LPCVOID)argptr);
3194
3195	AsciiToUnicode(szOut, lpOut);
3196	#ifdef DEBUG
3197	WriteLog("USER32: %s\n", lpOut);
3198	#endif
3199	FreeAsciiString(lpFmtA);
3200	return(rc);
3201	}
3202	//******************************************************************************
3203	//No need to support this
3204	//******************************************************************************
3205	BOOL WIN32API SetMessageQueue(int cMessagesMax)
3206	{
3207	#ifdef DEBUG
3208	WriteLog("USER32: SetMessageQueue\n");
3209	#endif
3210	return(TRUE);
3211	}
3212	//******************************************************************************
3213	//TODO: Not complete
3214	//******************************************************************************
3215	BOOL WIN32API GetScrollInfo(HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
3216	{
3217	#ifdef DEBUG
3218	WriteLog("USER32: GetScrollInfo\n");
3219	#endif
3220	if(lpsi == NULL)
3221	return(FALSE);
3222
3223	if(lpsi->fMask & SIF_POS)
3224	lpsi->nPos = GetScrollPos(hwnd, fnBar);
3225	if(lpsi->fMask & SIF_RANGE)
3226	GetScrollRange(hwnd, fnBar, &lpsi->nMin, &lpsi->nMax);
3227	if(lpsi->fMask & SIF_PAGE) {
3228	#ifdef DEBUG
3229	WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3230	#endif
3231	lpsi->nPage = 25;
3232	}
3233	return(TRUE);
3234	}
3235	//******************************************************************************
3236	//TODO: Not complete
3237	//******************************************************************************
3238	INT WIN32API SetScrollInfo(HWND hwnd, INT fnBar, const SCROLLINFO *lpsi, BOOL fRedraw)
3239	{
3240	int smin, smax;
3241
3242	#ifdef DEBUG
3243	WriteLog("USER32: SetScrollInfo\n");
3244	#endif
3245	if(lpsi == NULL)
3246	return(FALSE);
3247
3248	if(lpsi->fMask & SIF_POS)
3249	SetScrollPos(hwnd, fnBar, lpsi->nPos, fRedraw);
3250	if(lpsi->fMask & SIF_RANGE)
3251	SetScrollRange(hwnd, fnBar, lpsi->nMin, lpsi->nMax, fRedraw);
3252	if(lpsi->fMask & SIF_PAGE) {
3253	#ifdef DEBUG
3254	WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3255	#endif
3256	}
3257	if(lpsi->fMask & SIF_DISABLENOSCROLL) {
3258	#ifdef DEBUG
3259	WriteLog("USER32: GetScrollInfo, disable scrollbar not yet implemented\n");
3260	#endif
3261	}
3262	return(TRUE);
3263	}
3264	//******************************************************************************
3265	//******************************************************************************
3266	BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3267	LPARAM lpData, int nCount, int X, int Y, int nWidth,
3268	int nHeight)
3269	{
3270	BOOL rc;
3271	COLORREF curclr;
3272
3273	#ifdef DEBUG
3274	WriteLog("USER32: GrayStringA, not completely implemented\n");
3275	#endif
3276	if(lpOutputFunc == NULL && lpData == NULL) {
3277	#ifdef DEBUG
3278	WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3279	#endif
3280	return(FALSE);
3281	}
3282	if(lpOutputFunc) {
3283	return(lpOutputFunc(hdc, lpData, nCount));
3284	}
3285	curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3286	rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
3287	SetTextColor(hdc, curclr);
3288
3289	return(rc);
3290	}
3291	//******************************************************************************
3292	//******************************************************************************
3293	BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3294	LPARAM lpData, int nCount, int X, int Y, int nWidth,
3295	int nHeight)
3296	{
3297	BOOL rc;
3298	char *astring;
3299	COLORREF curclr;
3300
3301	#ifdef DEBUG
3302	WriteLog("USER32: GrayStringW, not completely implemented\n");
3303	#endif
3304
3305	if(lpOutputFunc == NULL && lpData == NULL) {
3306	#ifdef DEBUG
3307	WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3308	#endif
3309	return(FALSE);
3310	}
3311	if(nCount == 0)
3312	nCount = UniStrlen((UniChar*)lpData);
3313
3314	if(lpOutputFunc) {
3315	return(lpOutputFunc(hdc, lpData, nCount));
3316	}
3317	astring = UnicodeToAsciiString((LPWSTR)lpData);
3318
3319	curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3320	rc = TextOutA(hdc, X, Y, astring, nCount);
3321	SetTextColor(hdc, curclr);
3322
3323	FreeAsciiString(astring);
3324	return(rc);
3325	}
3326	//******************************************************************************
3327	//TODO:
3328	//******************************************************************************
3329	int WIN32API CopyAcceleratorTableA(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3330	int cAccelEntries)
3331	{
3332	#ifdef DEBUG
3333	WriteLog("USER32: CopyAcceleratorTableA, not implemented\n");
3334	#endif
3335	return(0);
3336	}
3337	//******************************************************************************
3338	//TODO:
3339	//******************************************************************************
3340	int WIN32API CopyAcceleratorTableW(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3341	int cAccelEntries)
3342	{
3343	#ifdef DEBUG
3344	WriteLog("USER32: CopyAcceleratorTableW, not implemented\n");
3345	#endif
3346	return(0);
3347	}
3348	//******************************************************************************
3349	//******************************************************************************
3350	LRESULT WIN32API SendMessageTimeoutA(HWND hwnd, UINT Msg, WPARAM wParam,
3351	LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3352	LPDWORD lpdwResult)
3353	{
3354	#ifdef DEBUG
3355	WriteLog("USER32: SendMessageTimeoutA, partially implemented\n");
3356	#endif
3357	//ignore fuFlags & wTimeOut
3358	*lpdwResult = SendMessageA(hwnd, Msg, wParam, lParam);
3359	return(TRUE);
3360	}
3361	//******************************************************************************
3362	//******************************************************************************
3363	LRESULT WIN32API SendMessageTimeoutW(HWND hwnd, UINT Msg, WPARAM wParam,
3364	LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3365	LPDWORD lpdwResult)
3366	{
3367	#ifdef DEBUG
3368	WriteLog("USER32: SendMessageTimeoutW, partially implemented\n");
3369	#endif
3370	return(SendMessageTimeoutA(hwnd, Msg, wParam, lParam, fuFlags, uTimeOut, lpdwResult));
3371	}
3372	//******************************************************************************
3373	//******************************************************************************
3374	HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
3375	{
3376	#ifdef DEBUG
3377	WriteLog("USER32: CopyImage, not implemented\n");
3378	#endif
3379	switch(uType) {
3380	case IMAGE_BITMAP:
3381	case IMAGE_CURSOR:
3382	case IMAGE_ICON:
3383	default:
3384	#ifdef DEBUG
3385	WriteLog("USER32: CopyImage, unknown type\n");
3386	#endif
3387	return(NULL);
3388	}
3389	return(NULL);
3390	}
3391	//******************************************************************************
3392	//******************************************************************************
3393	BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
3394	{
3395	#ifdef DEBUG
3396	WriteLog("USER32: GetKeyboardState, not properly implemented\n");
3397	#endif
3398	memset(lpKeyState, 0, 256);
3399	return(TRUE);
3400	}
3401	//******************************************************************************
3402	//******************************************************************************
3403	BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
3404	{
3405	#ifdef DEBUG
3406	WriteLog("USER32: SetKeyboardState, not implemented\n");
3407	#endif
3408	return(TRUE);
3409	}
3410	//******************************************************************************
3411	//******************************************************************************
3412	BOOL WIN32API SendNotifyMessageA(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3413	{
3414	#ifdef DEBUG
3415	WriteLog("USER32: SendNotifyMessageA, not completely implemented\n");
3416	#endif
3417	return(SendMessageA(hwnd, Msg, wParam, lParam));
3418	}
3419	//******************************************************************************
3420	//******************************************************************************
3421	BOOL WIN32API SendNotifyMessageW(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3422	{
3423	#ifdef DEBUG
3424	WriteLog("USER32: SendNotifyMessageW, not completely implemented\n");
3425	#endif
3426	return(SendMessageA(hwnd, Msg, wParam, lParam));
3427	}
3428	//******************************************************************************
3429	//2nd parameter not used according to SDK (yet?)
3430	//******************************************************************************
3431	VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
3432	{
3433	#ifdef DEBUG
3434	WriteLog("USER32: SetLastErrorEx\n");
3435	#endif
3436	SetLastError(dwErrCode);
3437	}
3438	//******************************************************************************
3439	//******************************************************************************
3440	LPARAM WIN32API SetMessageExtraInfo(LPARAM lParam)
3441	{
3442	#ifdef DEBUG
3443	WriteLog("USER32: SetMessageExtraInfo, not implemented\n");
3444	#endif
3445	return(0);
3446	}
3447	//******************************************************************************
3448	//******************************************************************************
3449	BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
3450	{
3451	#ifdef DEBUG
3452	WriteLog("USER32: ActivateKeyboardLayout, not implemented\n");
3453	#endif
3454	return(TRUE);
3455	}
3456	//******************************************************************************
3457	//******************************************************************************
3458	int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
3459	{
3460	#ifdef DEBUG
3461	WriteLog("USER32: GetKeyboardLayoutList, not implemented\n");
3462	#endif
3463	return(0);
3464	}
3465	//******************************************************************************
3466	//******************************************************************************
3467	HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
3468	{
3469	#ifdef DEBUG
3470	WriteLog("USER32: GetKeyboardLayout, not implemented\n");
3471	#endif
3472	return(0);
3473	}
3474	//******************************************************************************
3475	//******************************************************************************
3476	int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
3477	{
3478	#ifdef DEBUG
3479	WriteLog("USER32: LookupIconIdFromDirectory, not implemented\n");
3480	#endif
3481	return(0);
3482	}
3483	//******************************************************************************
3484	//******************************************************************************
3485	int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL fIcon,
3486	int cxDesired, int cyDesired,
3487	UINT Flags)
3488	{
3489	#ifdef DEBUG
3490	WriteLog("USER32: LookupIconIdFromDirectoryEx, not implemented\n");
3491	#endif
3492	return(0);
3493	}
3494	//******************************************************************************
3495	//DWORD idAttach; /* thread to attach */
3496	//DWORD idAttachTo; /* thread to attach to */
3497	//BOOL fAttach; /* attach or detach */
3498	//******************************************************************************
3499	BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
3500	{
3501	#ifdef DEBUG
3502	WriteLog("USER32: AttachThreadInput, not implemented\n");
3503	#endif
3504	return(TRUE);
3505	}
3506	//******************************************************************************
3507	//******************************************************************************
3508	BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
3509	{
3510	#ifdef DEBUG
3511	WriteLog("USER32: RegisterHotKey, not implemented\n");
3512	#endif
3513	return(TRUE);
3514	}
3515	//******************************************************************************
3516	//******************************************************************************
3517	BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
3518	{
3519	#ifdef DEBUG
3520	WriteLog("USER32: UnregisterHotKey, not implemented\n");
3521	#endif
3522	return(TRUE);
3523	}
3524	//******************************************************************************
3525	//******************************************************************************
3526	BOOL WIN32API DrawStateA(HDC hdc, HBRUSH hbc, DRAWSTATEPROC lpOutputFunc,
3527	LPARAM lData, WPARAM wData, int x, int y, int cx,
3528	int cy, UINT fuFlags)
3529	{
3530	#ifdef DEBUG
3531	WriteLog("USER32: DrawStateA, not implemented\n");
3532	#endif
3533	return(TRUE);
3534	}
3535	//******************************************************************************
3536	//******************************************************************************
3537	//******************************************************************************
3538	//******************************************************************************
3539	BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
3540	{
3541	#ifdef DEBUG
3542	WriteLog("USER32: SetWindowContextHelpId, not implemented\n");
3543	#endif
3544	return(TRUE);
3545	}
3546	//******************************************************************************
3547	//******************************************************************************
3548	DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
3549	{
3550	#ifdef DEBUG
3551	WriteLog("USER32: GetWindowContextHelpId, not implemented\n");
3552	#endif
3553	return(0);
3554	}
3555	//******************************************************************************
3556	//restores iconized window to previous size/position
3557	//******************************************************************************
3558	BOOL WIN32API OpenIcon(HWND hwnd)
3559	{
3560	#ifdef DEBUG
3561	WriteLog("USER32: OpenIcon\n");
3562	#endif
3563	if(!IsIconic(hwnd))
3564	return FALSE;
3565	ShowWindow(hwnd, SW_SHOWNORMAL);
3566	return TRUE;
3567	}
3568	//******************************************************************************
3569	//******************************************************************************
3570	BOOL WIN32API IsWindowUnicode(HWND hwnd)
3571	{
3572	#ifdef DEBUG
3573	WriteLog("USER32: IsWindowUnicode, not implemented\n");
3574	#endif
3575	return(FALSE);
3576	}
3577	//******************************************************************************
3578	//******************************************************************************
3579	BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
3580	{
3581	#ifdef DEBUG
3582	WriteLog("USER32: GetMonitorInfoA not supported!!\n");
3583	#endif
3584	return(FALSE);
3585	}
3586	//******************************************************************************
3587	//******************************************************************************
3588	BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
3589	{
3590	#ifdef DEBUG
3591	WriteLog("USER32: GetMonitorInfoW not supported!!\n");
3592	#endif
3593	return(FALSE);
3594	}
3595	//******************************************************************************
3596	//******************************************************************************
3597	HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
3598	{
3599	#ifdef DEBUG
3600	WriteLog("USER32: MonitorFromWindow not correctly supported??\n");
3601	#endif
3602	return(0);
3603	}
3604	//******************************************************************************
3605	//******************************************************************************
3606	HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
3607	{
3608	#ifdef DEBUG
3609	WriteLog("USER32: MonitorFromRect not correctly supported??\n");
3610	#endif
3611	return(0);
3612	}
3613	//******************************************************************************
3614	//******************************************************************************
3615	HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
3616	{
3617	#ifdef DEBUG
3618	WriteLog("USER32: MonitorFromPoint not correctly supported??\n");
3619	#endif
3620	return(0);
3621	}
3622	//******************************************************************************
3623	//******************************************************************************
3624	BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
3625	{
3626	#ifdef DEBUG
3627	WriteLog("USER32: EnumDisplayMonitors not supported??\n");
3628	#endif
3629	return(FALSE);
3630	}
3631	//******************************************************************************
3632	//******************************************************************************
3633	BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
3634	LPDEVMODEA lpDevMode)
3635	{
3636	#ifdef DEBUG
3637	WriteLog("USER32: EnumDisplaySettingsA FAKED\n");
3638	#endif
3639	switch(iModeNum) {
3640	case 0:
3641	lpDevMode->dmBitsPerPel = 16;
3642	lpDevMode->dmPelsWidth = 768;
3643	lpDevMode->dmPelsHeight = 1024;
3644	lpDevMode->dmDisplayFlags = 0;
3645	lpDevMode->dmDisplayFrequency = 70;
3646	break;
3647	case 1:
3648	lpDevMode->dmBitsPerPel = 16;
3649	lpDevMode->dmPelsWidth = 640;
3650	lpDevMode->dmPelsHeight = 480;
3651	lpDevMode->dmDisplayFlags = 0;
3652	lpDevMode->dmDisplayFrequency = 70;
3653	break;
3654	default:
3655	return(FALSE);
3656	}
3657	return(TRUE);
3658	}
3659	//******************************************************************************
3660	//******************************************************************************
3661	LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA lpDevMode, DWORD dwFlags)
3662	{
3663	#ifdef DEBUG
3664	if(lpDevMode) {
3665	WriteLog("USER32: ChangeDisplaySettingsA FAKED %X\n", dwFlags);
3666	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
3667	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsWidth %d\n", lpDevMode->dmPelsWidth);
3668	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
3669	}
3670	#endif
3671	return(DISP_CHANGE_SUCCESSFUL);
3672	}
3673	//******************************************************************************
3674	//******************************************************************************
3675
3676
3677	/*****************************************************************************
3678	* Name : BOOL WIN32API AnyPopup
3679	* Purpose : The AnyPopup function indicates whether an owned, visible,
3680	* top-level pop-up, or overlapped window exists on the screen. The
3681	* function searches the entire Windows screen, not just the calling
3682	* application's client area.
3683	* Parameters: VOID
3684	* Variables :
3685	* Result : If a pop-up window exists, the return value is TRUE even if the
3686	* pop-up window is completely covered by other windows. Otherwise,
3687	* it is FALSE.
3688	* Remark : AnyPopup is a Windows version 1.x function and is retained for
3689	* compatibility purposes. It is generally not useful.
3690	* Status : UNTESTED STUB
3691	*
3692	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3693	*****************************************************************************/
3694
3695	BOOL WIN32API AnyPopup(VOID)
3696	{
3697	dprintf(("USER32:AnyPopup() not implemented.\n"));
3698
3699	return (FALSE);
3700	}
3701
3702
3703	/*****************************************************************************
3704	* Name : long WIN32API BroadcastSystemMessage
3705	* Purpose : The BroadcastSystemMessage function sends a message to the given
3706	* recipients. The recipients can be applications, installable
3707	* drivers, Windows-based network drivers, system-level device
3708	* drivers, or any combination of these system components.
3709	* Parameters: DWORD dwFlags,
3710	LPDWORD lpdwRecipients,
3711	UINT uiMessage,
3712	WPARAM wParam,
3713	LPARAM lParam
3714	* Variables :
3715	* Result : If the function succeeds, the return value is a positive value.
3716	* If the function is unable to broadcast the message, the return value is -1.
3717	* If the dwFlags parameter is BSF_QUERY and at least one recipient returned FALSE to the corresponding message, the return value is zero.
3718	* Remark :
3719	* Status : UNTESTED STUB
3720	*
3721	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3722	*****************************************************************************/
3723
3724	long WIN32API BroadcastSystemMessage(DWORD dwFlags,
3725	LPDWORD lpdwRecipients,
3726	UINT uiMessage,
3727	WPARAM wParam,
3728	LPARAM lParam)
3729	{
3730	dprintf(("USER32:BroadcastSystemMessage(%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
3731	dwFlags,
3732	lpdwRecipients,
3733	uiMessage,
3734	wParam,
3735	lParam));
3736
3737	return (-1);
3738	}
3739
3740
3741	/*****************************************************************************
3742	* Name : WORD WIN32API CascadeWindows
3743	* Purpose : The CascadeWindows function cascades the specified windows or
3744	* the child windows of the specified parent window.
3745	* Parameters: HWND hwndParent handle of parent window
3746	* UINT wHow types of windows not to arrange
3747	* CONST RECT * lpRect rectangle to arrange windows in
3748	* UINT cKids number of windows to arrange
3749	* const HWND FAR * lpKids array of window handles
3750	* Variables :
3751	* Result : If the function succeeds, the return value is the number of windows arranged.
3752	* If the function fails, the return value is zero.
3753	* Remark :
3754	* Status : UNTESTED STUB
3755	*
3756	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3757	*****************************************************************************/
3758
3759	WORD WIN32API CascadeWindows(HWND hwndParent,
3760	UINT wHow,
3761	CONST LPRECT lpRect,
3762	UINT cKids,
3763	const HWND *lpKids)
3764	{
3765	dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
3766	hwndParent,
3767	wHow,
3768	lpRect,
3769	cKids,
3770	lpKids));
3771
3772	return (0);
3773	}
3774
3775
3776	/*****************************************************************************
3777	* Name : LONG WIN32API ChangeDisplaySettingsW
3778	* Purpose : The ChangeDisplaySettings function changes the display settings
3779	* to the specified graphics mode.
3780	* Parameters: LPDEVMODEW lpDevModeW
3781	* DWORD dwFlags
3782	* Variables :
3783	* Result : DISP_CHANGE_SUCCESSFUL The settings change was successful.
3784	* DISP_CHANGE_RESTART The computer must be restarted in order for the graphics mode to work.
3785	* DISP_CHANGE_BADFLAGS An invalid set of flags was passed in.
3786	* DISP_CHANGE_FAILED The display driver failed the specified graphics mode.
3787	* DISP_CHANGE_BADMODE The graphics mode is not supported.
3788	* DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
3789	* Remark :
3790	* Status : UNTESTED STUB
3791	*
3792	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3793	*****************************************************************************/
3794
3795	LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
3796	DWORD dwFlags)
3797	{
3798	dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
3799	lpDevMode,
3800	dwFlags));
3801
3802	return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
3803	dwFlags));
3804	}
3805
3806	/*****************************************************************************
3807	* Name : BOOL WIN32API CloseDesktop
3808	* Purpose : The CloseDesktop function closes an open handle of a desktop
3809	* object. A desktop is a secure object contained within a window
3810	* station object. A desktop has a logical display surface and
3811	* contains windows, menus and hooks.
3812	* Parameters: HDESK hDesktop
3813	* Variables :
3814	* Result : If the function succeeds, the return value is TRUE.
3815	* If the functions fails, the return value is FALSE. To get
3816	* extended error information, call GetLastError.
3817	* Remark :
3818	* Status : UNTESTED STUB
3819	*
3820	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3821	*****************************************************************************/
3822
3823	BOOL WIN32API CloseDesktop(HDESK hDesktop)
3824	{
3825	dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
3826	hDesktop));
3827
3828	return (FALSE);
3829	}
3830
3831
3832	/*****************************************************************************
3833	* Name : BOOL WIN32API CloseWindowStation
3834	* Purpose : The CloseWindowStation function closes an open window station handle.
3835	* Parameters: HWINSTA hWinSta
3836	* Variables :
3837	* Result :
3838	* Remark : If the function succeeds, the return value is TRUE.
3839	* If the functions fails, the return value is FALSE. To get
3840	* extended error information, call GetLastError.
3841	* Status : UNTESTED STUB
3842	*
3843	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3844	*****************************************************************************/
3845
3846	BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
3847	{
3848	dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
3849	hWinSta));
3850
3851	return (FALSE);
3852	}
3853
3854
3855	/*****************************************************************************
3856	* Name : HDESK WIN32API CreateDesktopA
3857	* Purpose : The CreateDesktop function creates a new desktop on the window
3858	* station associated with the calling process.
3859	* Parameters: LPCTSTR lpszDesktop name of the new desktop
3860	* LPCTSTR lpszDevice name of display device to assign to the desktop
3861	* LPDEVMODE pDevMode reserved; must be NULL
3862	* DWORD dwFlags flags to control interaction with other applications
3863	* DWORD dwDesiredAccess specifies access of returned handle
3864	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
3865	* Variables :
3866	* Result : If the function succeeds, the return value is a handle of the
3867	* newly created desktop.
3868	* If the function fails, the return value is NULL. To get extended
3869	* error information, call GetLastError.
3870	* Remark :
3871	* Status : UNTESTED STUB
3872	*
3873	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3874	*****************************************************************************/
3875
3876	HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
3877	LPCTSTR lpszDevice,
3878	LPDEVMODEA pDevMode,
3879	DWORD dwFlags,
3880	DWORD dwDesiredAccess,
3881	LPSECURITY_ATTRIBUTES lpsa)
3882	{
3883	dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
3884	lpszDesktop,
3885	lpszDevice,
3886	pDevMode,
3887	dwFlags,
3888	dwDesiredAccess,
3889	lpsa));
3890
3891	return (NULL);
3892	}
3893
3894
3895	/*****************************************************************************
3896	* Name : HDESK WIN32API CreateDesktopW
3897	* Purpose : The CreateDesktop function creates a new desktop on the window
3898	* station associated with the calling process.
3899	* Parameters: LPCTSTR lpszDesktop name of the new desktop
3900	* LPCTSTR lpszDevice name of display device to assign to the desktop
3901	* LPDEVMODE pDevMode reserved; must be NULL
3902	* DWORD dwFlags flags to control interaction with other applications
3903	* DWORD dwDesiredAccess specifies access of returned handle
3904	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
3905	* Variables :
3906	* Result : If the function succeeds, the return value is a handle of the
3907	* newly created desktop.
3908	* If the function fails, the return value is NULL. To get extended
3909	* error information, call GetLastError.
3910	* Remark :
3911	* Status : UNTESTED STUB
3912	*
3913	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3914	*****************************************************************************/
3915
3916	HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
3917	LPCTSTR lpszDevice,
3918	LPDEVMODEW pDevMode,
3919	DWORD dwFlags,
3920	DWORD dwDesiredAccess,
3921	LPSECURITY_ATTRIBUTES lpsa)
3922	{
3923	dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
3924	lpszDesktop,
3925	lpszDevice,
3926	pDevMode,
3927	dwFlags,
3928	dwDesiredAccess,
3929	lpsa));
3930
3931	return (NULL);
3932	}
3933
3934
3935	/*****************************************************************************
3936	* Name : HWINSTA WIN32API CreateWindowStationA
3937	* Purpose : The CreateWindowStation function creates a window station object.
3938	* It returns a handle that can be used to access the window station.
3939	* A window station is a secure object that contains a set of global
3940	* atoms, a clipboard, and a set of desktop objects.
3941	* Parameters: LPTSTR lpwinsta name of the new window station
3942	* DWORD dwReserved reserved; must be NULL
3943	* DWORD dwDesiredAccess specifies access of returned handle
3944	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
3945	* Variables :
3946	* Result : If the function succeeds, the return value is the handle to the
3947	* newly created window station.
3948	* If the function fails, the return value is NULL. To get extended
3949	* error information, call GetLastError.
3950	* Remark :
3951	* Status : UNTESTED STUB
3952	*
3953	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3954	*****************************************************************************/
3955
3956	HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
3957	DWORD dwReserved,
3958	DWORD dwDesiredAccess,
3959	LPSECURITY_ATTRIBUTES lpsa)
3960	{
3961	dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
3962	lpWinSta,
3963	dwReserved,
3964	dwDesiredAccess,
3965	lpsa));
3966
3967	return (NULL);
3968	}
3969
3970
3971	/*****************************************************************************
3972	* Name : HWINSTA WIN32API CreateWindowStationW
3973	* Purpose : The CreateWindowStation function creates a window station object.
3974	* It returns a handle that can be used to access the window station.
3975	* A window station is a secure object that contains a set of global
3976	* atoms, a clipboard, and a set of desktop objects.
3977	* Parameters: LPTSTR lpwinsta name of the new window station
3978	* DWORD dwReserved reserved; must be NULL
3979	* DWORD dwDesiredAccess specifies access of returned handle
3980	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
3981	* Variables :
3982	* Result : If the function succeeds, the return value is the handle to the
3983	* newly created window station.
3984	* If the function fails, the return value is NULL. To get extended
3985	* error information, call GetLastError.
3986	* Remark :
3987	* Status : UNTESTED STUB
3988	*
3989	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3990	*****************************************************************************/
3991
3992	HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
3993	DWORD dwReserved,
3994	DWORD dwDesiredAccess,
3995	LPSECURITY_ATTRIBUTES lpsa)
3996	{
3997	dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
3998	lpWinSta,
3999	dwReserved,
4000	dwDesiredAccess,
4001	lpsa));
4002
4003	return (NULL);
4004	}
4005
4006	/*****************************************************************************
4007	* Name : BOOL WIN32API DragDetect
4008	* Purpose : The DragDetect function captures the mouse and tracks its movement
4009	* Parameters: HWND hwnd
4010	* POINT pt
4011	* Variables :
4012	* Result : If the user moved the mouse outside of the drag rectangle while
4013	* holding the left button down, the return value is TRUE.
4014	* If the user did not move the mouse outside of the drag rectangle
4015	* while holding the left button down, the return value is FALSE.
4016	* Remark :
4017	* Status : UNTESTED STUB
4018	*
4019	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4020	*****************************************************************************/
4021
4022	BOOL WIN32API DragDetect(HWND hwnd,
4023	POINT pt)
4024	{
4025	dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
4026	hwnd));
4027
4028	return (FALSE);
4029	}
4030
4031
4032	/*****************************************************************************
4033	* Name : BOOL WIN32API DrawAnimatedRects
4034	* Purpose : The DrawAnimatedRects function draws a wire-frame rectangle
4035	* and animates it to indicate the opening of an icon or the
4036	* minimizing or maximizing of a window.
4037	* Parameters: HWND hwnd handle of clipping window
4038	* int idAni type of animation
4039	* CONST RECT * lprcFrom address of rectangle coordinates (minimized)
4040	* CONST RECT * lprcTo address of rectangle coordinates (restored)
4041	* Variables :
4042	* Result : If the function succeeds, the return value is TRUE.
4043	* If the function fails, the return value is FALSE.
4044	* Remark :
4045	* Status : UNTESTED STUB
4046	*
4047	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4048	*****************************************************************************/
4049
4050	BOOL WIN32API DrawAnimatedRects(HWND hwnd,
4051	int idAni,
4052	CONST RECT *lprcFrom,
4053	CONST RECT *lprcTo)
4054	{
4055	dprintf(("USER32:DrawAnimatedRects (%08xh,%u,%08xh,%08x) not implemented.\n",
4056	hwnd,
4057	idAni,
4058	lprcFrom,
4059	lprcTo));
4060
4061	return (TRUE);
4062	}
4063
4064
4065	/*****************************************************************************
4066	* Name : VOID WIN32API DrawCaption
4067	* Purpose : The DrawCaption function draws a window caption.
4068	* Parameters: HDC hdc handle of device context
4069	* LPRECT lprc address of bounding rectangle coordinates
4070	* HFONT hfont handle of font for caption
4071	* HICON hicon handle of icon in caption
4072	* LPSTR lpszText address of caption string
4073	* WORD wFlags drawing options
4074	* Variables :
4075	* Result :
4076	* Remark :
4077	* Status : UNTESTED STUB
4078	*
4079	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4080	*****************************************************************************/
4081
4082	BOOL WIN32API DrawCaption (HWND hwnd,
4083	HDC hdc,
4084	const RECT *lprc,
4085	UINT wFlags)
4086	{
4087	dprintf(("USER32:DrawCaption (%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4088	hwnd,
4089	hdc,
4090	lprc,
4091	wFlags));
4092
4093	return FALSE;
4094	}
4095
4096
4097	/*****************************************************************************
4098	* Name :
4099	* Purpose :
4100	* Parameters:
4101	* Variables :
4102	* Result :
4103	* Remark :
4104	* Status : UNTESTED STUB
4105	*
4106	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4107	*****************************************************************************/
4108
4109	BOOL WIN32API DrawStateW(HDC hdc,
4110	HBRUSH hBrush,
4111	DRAWSTATEPROC lpOutputFunc,
4112	LPARAM lParam,
4113	WPARAM wParam,
4114	int x,
4115	int y,
4116	int cx,
4117	int cy,
4118	UINT fuFlags)
4119	{
4120	dprintf(("USER32:DrawStateW (%08xh,%08xh,%08xh,%08xh,%08xh,%d,%d,%d,%d,%08x) not implemented.\n",
4121	hdc,
4122	hBrush,
4123	lpOutputFunc,
4124	lParam,
4125	wParam,
4126	x,
4127	y,
4128	cx,
4129	cy,
4130	fuFlags));
4131
4132	return(DrawStateA(hdc,
4133	hBrush,
4134	lpOutputFunc,
4135	lParam,
4136	wParam,
4137	x,
4138	y,
4139	cx,
4140	cy,
4141	fuFlags));
4142	}
4143
4144
4145	/*****************************************************************************
4146	* Name : BOOL WIN32API EnumDesktopWindows
4147	* Purpose : The EnumDesktopWindows function enumerates all windows in a
4148	* desktop by passing the handle of each window, in turn, to an
4149	* application-defined callback function.
4150	* Parameters: HDESK hDesktop handle of desktop to enumerate
4151	* WNDENUMPROC lpfn points to application's callback function
4152	* LPARAM lParam 32-bit value to pass to the callback function
4153	* Variables :
4154	* Result : If the function succeeds, the return value is TRUE.
4155	* If the function fails, the return value is FALSE. To get
4156	* extended error information, call GetLastError.
4157	* Remark :
4158	* Status : UNTESTED STUB
4159	*
4160	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4161	*****************************************************************************/
4162
4163	BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
4164	WNDENUMPROC lpfn,
4165	LPARAM lParam)
4166	{
4167	dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
4168	hDesktop,
4169	lpfn,
4170	lParam));
4171
4172	return (FALSE);
4173	}
4174
4175
4176	/*****************************************************************************
4177	* Name : BOOL WIN32API EnumDesktopsA
4178	* Purpose : The EnumDesktops function enumerates all desktops in the window
4179	* station assigned to the calling process. The function does so by
4180	* passing the name of each desktop, in turn, to an application-
4181	* defined callback function.
4182	* Parameters: HWINSTA hwinsta handle of window station to enumerate
4183	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
4184	* LPARAM lParam 32-bit value to pass to the callback function
4185	* Variables :
4186	* Result : If the function succeeds, the return value is TRUE.
4187	* If the function fails, the return value is FALSE. To get extended
4188	* error information, call GetLastError.
4189	* Remark :
4190	* Status : UNTESTED STUB
4191	*
4192	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4193	*****************************************************************************/
4194
4195	BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
4196	DESKTOPENUMPROCA lpEnumFunc,
4197	LPARAM lParam)
4198	{
4199	dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
4200	hWinSta,
4201	lpEnumFunc,
4202	lParam));
4203
4204	return (FALSE);
4205	}
4206
4207
4208	/*****************************************************************************
4209	* Name : BOOL WIN32API EnumDesktopsW
4210	* Purpose : The EnumDesktops function enumerates all desktops in the window
4211	* station assigned to the calling process. The function does so by
4212	* passing the name of each desktop, in turn, to an application-
4213	* defined callback function.
4214	* Parameters: HWINSTA hwinsta handle of window station to enumerate
4215	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
4216	* LPARAM lParam 32-bit value to pass to the callback function
4217	* Variables :
4218	* Result : If the function succeeds, the return value is TRUE.
4219	* If the function fails, the return value is FALSE. To get extended
4220	* error information, call GetLastError.
4221	* Remark :
4222	* Status : UNTESTED STUB
4223	*
4224	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4225	*****************************************************************************/
4226
4227	BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
4228	DESKTOPENUMPROCW lpEnumFunc,
4229	LPARAM lParam)
4230	{
4231	dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
4232	hWinSta,
4233	lpEnumFunc,
4234	lParam));
4235
4236	return (FALSE);
4237	}
4238
4239
4240
4241	/*****************************************************************************
4242	* Name : BOOL WIN32API EnumDisplaySettingsW
4243	* Purpose : The EnumDisplaySettings function obtains information about one
4244	* of a display device's graphics modes. You can obtain information
4245	* for all of a display device's graphics modes by making a series
4246	* of calls to this function.
4247	* Parameters: LPCTSTR lpszDeviceName specifies the display device
4248	* DWORD iModeNum specifies the graphics mode
4249	* LPDEVMODE lpDevMode points to structure to receive settings
4250	* Variables :
4251	* Result : If the function succeeds, the return value is TRUE.
4252	* If the function fails, the return value is FALSE.
4253	* Remark :
4254	* Status : UNTESTED STUB
4255	*
4256	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4257	*****************************************************************************/
4258
4259	BOOL WIN32API EnumDisplaySettingsW(LPCSTR lpszDeviceName,
4260	DWORD iModeNum,
4261	LPDEVMODEW lpDevMode)
4262	{
4263	dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
4264	lpszDeviceName,
4265	iModeNum,
4266	lpDevMode));
4267
4268	return (EnumDisplaySettingsA(lpszDeviceName,
4269	iModeNum,
4270	(LPDEVMODEA)lpDevMode));
4271	}
4272
4273
4274	/*****************************************************************************
4275	* Name : BOOL WIN32API EnumWindowStationsA
4276	* Purpose : The EnumWindowStations function enumerates all windowstations
4277	* in the system by passing the name of each window station, in
4278	* turn, to an application-defined callback function.
4279	* Parameters:
4280	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4281	* LPARAM lParam 32-bit value to pass to the callback function
4282	* Result : If the function succeeds, the return value is TRUE.
4283	* If the function fails the return value is FALSE. To get extended
4284	* error information, call GetLastError.
4285	* Remark :
4286	* Status : UNTESTED STUB
4287	*
4288	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4289	*****************************************************************************/
4290
4291	BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
4292	LPARAM lParam)
4293	{
4294	dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
4295	lpEnumFunc,
4296	lParam));
4297
4298	return (FALSE);
4299	}
4300
4301
4302	/*****************************************************************************
4303	* Name : BOOL WIN32API EnumWindowStationsW
4304	* Purpose : The EnumWindowStations function enumerates all windowstations
4305	* in the system by passing the name of each window station, in
4306	* turn, to an application-defined callback function.
4307	* Parameters:
4308	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4309	* LPARAM lParam 32-bit value to pass to the callback function
4310	* Result : If the function succeeds, the return value is TRUE.
4311	* If the function fails the return value is FALSE. To get extended
4312	* error information, call GetLastError.
4313	* Remark :
4314	* Status : UNTESTED STUB
4315	*
4316	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4317	*****************************************************************************/
4318
4319	BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
4320	LPARAM lParam)
4321	{
4322	dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
4323	lpEnumFunc,
4324	lParam));
4325
4326	return (FALSE);
4327	}
4328
4329
4330	/*****************************************************************************
4331	* Name : HWND WIN32API FindWindowExW
4332	* Purpose : The FindWindowEx function retrieves the handle of a window whose
4333	* class name and window name match the specified strings. The
4334	* function searches child windows, beginning with the one following
4335	* the given child window.
4336	* Parameters: HWND hwndParent handle of parent window
4337	* HWND hwndChildAfter handle of a child window
4338	* LPCTSTR lpszClass address of class name
4339	* LPCTSTR lpszWindow address of window name
4340	* Variables :
4341	* Result : If the function succeeds, the return value is the handle of the
4342	* window that has the specified class and window names.
4343	* If the function fails, the return value is NULL. To get extended
4344	* error information, call GetLastError.
4345	* Remark :
4346	* Status : UNTESTED STUB
4347	*
4348	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4349	*****************************************************************************/
4350
4351	HWND WIN32API FindWindowExW(HWND hwndParent,
4352	HWND hwndChildAfter,
4353	LPCWSTR lpszClass,
4354	LPCWSTR lpszWindow)
4355	{
4356	dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
4357	hwndParent,
4358	hwndChildAfter,
4359	lpszClass,
4360	lpszWindow));
4361
4362	return (NULL);
4363	}
4364
4365	/*****************************************************************************
4366	* Name : BOOL WIN32API GetInputState
4367	* Purpose : The GetInputState function determines whether there are
4368	* mouse-button or keyboard messages in the calling thread's message queue.
4369	* Parameters:
4370	* Variables :
4371	* Result : If the queue contains one or more new mouse-button or keyboard
4372	* messages, the return value is TRUE.
4373	* If the function fails, the return value is FALSE.
4374	* Remark :
4375	* Status : UNTESTED STUB
4376	*
4377	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4378	*****************************************************************************/
4379
4380	BOOL WIN32API GetInputState(VOID)
4381	{
4382	dprintf(("USER32:GetInputState () not implemented.\n"));
4383
4384	return (FALSE);
4385	}
4386
4387
4388	/*****************************************************************************
4389	* Name : UINT WIN32API GetKBCodePage
4390	* Purpose : The GetKBCodePage function is provided for compatibility with
4391	* earlier versions of Windows. In the Win32 application programming
4392	* interface (API) it just calls the GetOEMCP function.
4393	* Parameters:
4394	* Variables :
4395	* Result : If the function succeeds, the return value is an OEM code-page
4396	* identifier, or it is the default identifier if the registry
4397	* value is not readable. For a list of OEM code-page identifiers,
4398	* see GetOEMCP.
4399	* Remark :
4400	* Status : UNTESTED
4401	*
4402	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4403	*****************************************************************************/
4404
4405	UINT WIN32API GetKBCodePage(VOID)
4406	{
4407	return (GetOEMCP());
4408	}
4409
4410
4411	/*****************************************************************************
4412	* Name : BOOL WIN32API GetKeyboardLayoutNameA
4413	* Purpose : The GetKeyboardLayoutName function retrieves the name of the
4414	* active keyboard layout.
4415	* Parameters: LPTSTR pwszKLID address of buffer for layout name
4416	* Variables :
4417	* Result : If the function succeeds, the return value is TRUE.
4418	* If the function fails, the return value is FALSE. To get extended
4419	* error information, call GetLastError.
4420	* Remark :
4421	* Status : UNTESTED STUB
4422	*
4423	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4424	*****************************************************************************/
4425
4426	BOOL WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
4427	{
4428	dprintf(("USER32:GetKeyboardLayoutNameA (%08x) not implemented.",
4429	pwszKLID));
4430
4431	return(FALSE);
4432	}
4433
4434
4435	/*****************************************************************************
4436	* Name : BOOL WIN32API GetKeyboardLayoutNameW
4437	* Purpose : The GetKeyboardLayoutName function retrieves the name of the
4438	* active keyboard layout.
4439	* Parameters: LPTSTR pwszKLID address of buffer for layout name
4440	* Variables :
4441	* Result : If the function succeeds, the return value is TRUE.
4442	* If the function fails, the return value is FALSE. To get extended
4443	* error information, call GetLastError.
4444	* Remark :
4445	* Status : UNTESTED STUB
4446	*
4447	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4448	*****************************************************************************/
4449
4450	BOOL WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
4451	{
4452	dprintf(("USER32:GetKeyboardLayoutNameW (%08x) not implemented.",
4453	pwszKLID));
4454
4455	return(FALSE);
4456	}
4457
4458
4459
4460
4461	/*****************************************************************************
4462	* Name : HWINSTA WIN32API GetProcessWindowStation
4463	* Purpose : The GetProcessWindowStation function returns a handle of the
4464	* window station associated with the calling process.
4465	* Parameters:
4466	* Variables :
4467	* Result : If the function succeeds, the return value is a handle of the
4468	* window station associated with the calling process.
4469	* If the function fails, the return value is NULL. This can occur
4470	* if the calling process is not an application written for Windows
4471	* NT. To get extended error information, call GetLastError.
4472	* Remark :
4473	* Status : UNTESTED STUB
4474	*
4475	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4476	*****************************************************************************/
4477
4478	HWINSTA WIN32API GetProcessWindowStation(VOID)
4479	{
4480	dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
4481
4482	return (NULL);
4483	}
4484
4485
4486
4487	/*****************************************************************************
4488	* Name : HDESK WIN32API GetThreadDesktop
4489	* Purpose : The GetThreadDesktop function returns a handle to the desktop
4490	* associated with a specified thread.
4491	* Parameters: DWORD dwThreadId thread identifier
4492	* Variables :
4493	* Result : If the function succeeds, the return value is the handle of the
4494	* desktop associated with the specified thread.
4495	* Remark :
4496	* Status : UNTESTED STUB
4497	*
4498	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4499	*****************************************************************************/
4500
4501	HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
4502	{
4503	dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
4504	dwThreadId));
4505
4506	return (NULL);
4507	}
4508
4509
4510	/*****************************************************************************
4511	* Name : BOOL WIN32API GetUserObjectInformationA
4512	* Purpose : The GetUserObjectInformation function returns information about
4513	* a window station or desktop object.
4514	* Parameters: HANDLE hObj handle of object to get information for
4515	* int nIndex type of information to get
4516	* PVOID pvInfo points to buffer that receives the information
4517	* DWORD nLength size, in bytes, of pvInfo buffer
4518	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4519	* Variables :
4520	* Result : If the function succeeds, the return value is TRUE.
4521	* If the function fails, the return value is FALSE. To get extended
4522	* error information, call GetLastError.
4523	* Remark :
4524	* Status : UNTESTED STUB
4525	*
4526	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4527	*****************************************************************************/
4528
4529	BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
4530	int nIndex,
4531	PVOID pvInfo,
4532	DWORD nLength,
4533	LPDWORD lpnLengthNeeded)
4534	{
4535	dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4536	hObj,
4537	nIndex,
4538	pvInfo,
4539	nLength,
4540	lpnLengthNeeded));
4541
4542	return (FALSE);
4543	}
4544
4545
4546	/*****************************************************************************
4547	* Name : BOOL WIN32API GetUserObjectInformationW
4548	* Purpose : The GetUserObjectInformation function returns information about
4549	* a window station or desktop object.
4550	* Parameters: HANDLE hObj handle of object to get information for
4551	* int nIndex type of information to get
4552	* PVOID pvInfo points to buffer that receives the information
4553	* DWORD nLength size, in bytes, of pvInfo buffer
4554	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4555	* Variables :
4556	* Result : If the function succeeds, the return value is TRUE.
4557	* If the function fails, the return value is FALSE. To get extended
4558	* error information, call GetLastError.
4559	* Remark :
4560	* Status : UNTESTED STUB
4561	*
4562	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4563	*****************************************************************************/
4564
4565	BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
4566	int nIndex,
4567	PVOID pvInfo,
4568	DWORD nLength,
4569	LPDWORD lpnLengthNeeded)
4570	{
4571	dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4572	hObj,
4573	nIndex,
4574	pvInfo,
4575	nLength,
4576	lpnLengthNeeded));
4577
4578	return (FALSE);
4579	}
4580
4581
4582	/*****************************************************************************
4583	* Name : BOOL WIN32API GetUserObjectSecurity
4584	* Purpose : The GetUserObjectSecurity function retrieves security information
4585	* for the specified user object.
4586	* Parameters: HANDLE hObj handle of user object
4587	* SECURITY_INFORMATION * pSIRequested address of requested security information
4588	* LPSECURITY_DESCRIPTOR pSID address of security descriptor
4589	* DWORD nLength size of buffer for security descriptor
4590	* LPDWORD lpnLengthNeeded address of required size of buffer
4591	* Variables :
4592	* Result : If the function succeeds, the return value is TRUE.
4593	* If the function fails, the return value is FALSE. To get extended
4594	* error information, call GetLastError.
4595	* Remark :
4596	* Status : UNTESTED STUB
4597	*
4598	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4599	*****************************************************************************/
4600
4601	BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
4602	SECURITY_INFORMATION * pSIRequested,
4603	LPSECURITY_DESCRIPTOR pSID,
4604	DWORD nLength,
4605	LPDWORD lpnLengthNeeded)
4606	{
4607	dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4608	hObj,
4609	pSIRequested,
4610	pSID,
4611	nLength,
4612	lpnLengthNeeded));
4613
4614	return (FALSE);
4615	}
4616
4617
4618
4619	/*****************************************************************************
4620	* Name : int WIN32API GetWindowRgn
4621	* Purpose : The GetWindowRgn function obtains a copy of the window region of a window.
4622	* Parameters: HWND hWnd handle to window whose window region is to be obtained
4623	* HRGN hRgn handle to region that receives a copy of the window region
4624	* Variables :
4625	* Result : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
4626	* Remark :
4627	* Status : UNTESTED STUB
4628	*
4629	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4630	*****************************************************************************/
4631
4632	int WIN32API GetWindowRgn (HWND hWnd,
4633	HRGN hRgn)
4634	{
4635	dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
4636	hWnd,
4637	hRgn));
4638
4639	return (NULLREGION);
4640	}
4641
4642
4643
4644	/*****************************************************************************
4645	* Name : HCURSOR WIN32API LoadCursorFromFileA
4646	* Purpose : The LoadCursorFromFile function creates a cursor based on data
4647	* contained in a file. The file is specified by its name or by a
4648	* system cursor identifier. The function returns a handle to the
4649	* newly created cursor. Files containing cursor data may be in
4650	* either cursor (.CUR) or animated cursor (.ANI) format.
4651	* Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4652	* Variables :
4653	* Result : If the function is successful, the return value is a handle to
4654	* the new cursor.
4655	* If the function fails, the return value is NULL. To get extended
4656	* error information, call GetLastError. GetLastError may return
4657	* the following
4658	* Remark :
4659	* Status : UNTESTED STUB
4660	*
4661	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4662	*****************************************************************************/
4663
4664	HCURSOR WIN32API LoadCursorFromFileA(LPCTSTR lpFileName)
4665	{
4666	dprintf(("USER32:LoadCursorFromFileA (%s) not implemented.\n",
4667	lpFileName));
4668
4669	return (NULL);
4670	}
4671
4672
4673	/*****************************************************************************
4674	* Name : HCURSOR WIN32API LoadCursorFromFileW
4675	* Purpose : The LoadCursorFromFile function creates a cursor based on data
4676	* contained in a file. The file is specified by its name or by a
4677	* system cursor identifier. The function returns a handle to the
4678	* newly created cursor. Files containing cursor data may be in
4679	* either cursor (.CUR) or animated cursor (.ANI) format.
4680	* Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4681	* Variables :
4682	* Result : If the function is successful, the return value is a handle to
4683	* the new cursor.
4684	* If the function fails, the return value is NULL. To get extended
4685	* error information, call GetLastError. GetLastError may return
4686	* the following
4687	* Remark :
4688	* Status : UNTESTED STUB
4689	*
4690	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4691	*****************************************************************************/
4692
4693	HCURSOR WIN32API LoadCursorFromFileW(LPCWSTR lpFileName)
4694	{
4695	dprintf(("USER32:LoadCursorFromFileW (%s) not implemented.\n",
4696	lpFileName));
4697
4698	return (NULL);
4699	}
4700
4701
4702	/*****************************************************************************
4703	* Name : HLK WIN32API LoadKeyboardLayoutA
4704	* Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
4705	* the system. Several keyboard layouts can be loaded at a time, but
4706	* only one per process is active at a time. Loading multiple keyboard
4707	* layouts makes it possible to rapidly switch between layouts.
4708	* Parameters:
4709	* Variables :
4710	* Result : If the function succeeds, the return value is the handle of the
4711	* keyboard layout.
4712	* If the function fails, the return value is NULL. To get extended
4713	* error information, call GetLastError.
4714	* Remark :
4715	* Status : UNTESTED STUB
4716	*
4717	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4718	*****************************************************************************/
4719
4720	HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
4721	UINT Flags)
4722	{
4723	dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
4724	pwszKLID,
4725	Flags));
4726
4727	return (NULL);
4728	}
4729
4730
4731	/*****************************************************************************
4732	* Name : HLK WIN32API LoadKeyboardLayoutW
4733	* Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
4734	* the system. Several keyboard layouts can be loaded at a time, but
4735	* only one per process is active at a time. Loading multiple keyboard
4736	* layouts makes it possible to rapidly switch between layouts.
4737	* Parameters:
4738	* Variables :
4739	* Result : If the function succeeds, the return value is the handle of the
4740	* keyboard layout.
4741	* If the function fails, the return value is NULL. To get extended
4742	* error information, call GetLastError.
4743	* Remark :
4744	* Status : UNTESTED STUB
4745	*
4746	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4747	*****************************************************************************/
4748
4749	HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
4750	UINT Flags)
4751	{
4752	dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
4753	pwszKLID,
4754	Flags));
4755
4756	return (NULL);
4757	}
4758
4759
4760	/*****************************************************************************
4761	* Name : UINT WIN32API MapVirtualKeyExA
4762	* Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
4763	* code into a scan code or character value, or translates a scan
4764	* code into a virtual-key code. The function translates the codes
4765	* using the input language and physical keyboard layout identified
4766	* by the given keyboard layout handle.
4767	* Parameters:
4768	* Variables :
4769	* Result : The return value is either a scan code, a virtual-key code, or
4770	* a character value, depending on the value of uCode and uMapType.
4771	* If there is no translation, the return value is zero.
4772	* Remark :
4773	* Status : UNTESTED STUB
4774	*
4775	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4776	*****************************************************************************/
4777
4778	UINT WIN32API MapVirtualKeyExA(UINT uCode,
4779	UINT uMapType,
4780	HKL dwhkl)
4781	{
4782	dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
4783	uCode,
4784	uMapType,
4785	dwhkl));
4786
4787	return (0);
4788	}
4789
4790
4791	/*****************************************************************************
4792	* Name : UINT WIN32API MapVirtualKeyExW
4793	* Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
4794	* code into a scan code or character value, or translates a scan
4795	* code into a virtual-key code. The function translates the codes
4796	* using the input language and physical keyboard layout identified
4797	* by the given keyboard layout handle.
4798	* Parameters:
4799	* Variables :
4800	* Result : The return value is either a scan code, a virtual-key code, or
4801	* a character value, depending on the value of uCode and uMapType.
4802	* If there is no translation, the return value is zero.
4803	* Remark :
4804	* Status : UNTESTED STUB
4805
4806	*
4807	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4808	*****************************************************************************/
4809
4810	UINT WIN32API MapVirtualKeyExW(UINT uCode,
4811	UINT uMapType,
4812	HKL dwhkl)
4813	{
4814	dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
4815	uCode,
4816	uMapType,
4817	dwhkl));
4818
4819	return (0);
4820	}
4821
4822
4823	/*****************************************************************************
4824	* Name : int WIN32API MessageBoxExA
4825	* Purpose : The MessageBoxEx function creates, displays, and operates a message box.
4826	* Parameters: HWND hWnd handle of owner window
4827	* LPCTSTR lpText address of text in message box
4828	* LPCTSTR lpCaption address of title of message box
4829	* UINT uType style of message box
4830	* WORD wLanguageId language identifier
4831	* Variables :
4832	* Result : If the function succeeds, the return value is a nonzero menu-item
4833	* value returned by the dialog box.
4834	* Remark :
4835	* Status : UNTESTED STUB
4836	*
4837	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4838	*****************************************************************************/
4839
4840	int WIN32API MessageBoxExA(HWND hWnd,
4841	LPCTSTR lpText,
4842	LPCTSTR lpCaption,
4843	UINT uType,
4844	WORD wLanguageId)
4845	{
4846	dprintf(("USER32:MessageBoxExA (%08xh,%s,%s,%u,%08w) not implemented.\n",
4847	hWnd,
4848	lpText,
4849	lpCaption,
4850	uType,
4851	wLanguageId));
4852
4853	return (MessageBoxA(hWnd,
4854	lpText,
4855	lpCaption,
4856	uType));
4857	}
4858
4859
4860	/*****************************************************************************
4861	* Name : int WIN32API MessageBoxExW
4862	* Purpose : The MessageBoxEx function creates, displays, and operates a message box.
4863	* Parameters: HWND hWnd handle of owner window
4864	* LPCTSTR lpText address of text in message box
4865	* LPCTSTR lpCaption address of title of message box
4866	* UINT uType style of message box
4867	* WORD wLanguageId language identifier
4868	* Variables :
4869	* Result : If the function succeeds, the return value is a nonzero menu-item
4870	* value returned by the dialog box.
4871	* Remark :
4872	* Status : UNTESTED STUB
4873	*
4874	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4875	*****************************************************************************/
4876
4877	int WIN32API MessageBoxExW(HWND hWnd,
4878	LPCWSTR lpText,
4879	LPCWSTR lpCaption,
4880	UINT uType,
4881	WORD wLanguageId)
4882	{
4883
4884	dprintf(("USER32:MessageBoxExW (%08xh,%x,%x,%u,%08w) not implemented.\n",
4885	hWnd,
4886	lpText,
4887	lpCaption,
4888	uType,
4889	wLanguageId));
4890
4891	return MessageBoxW(hWnd, lpText, lpCaption, uType);
4892	}
4893
4894
4895	/*****************************************************************************
4896	* Name : BOOL WIN32API MessageBoxIndirectW
4897	* Purpose : The MessageBoxIndirect function creates, displays, and operates
4898	* a message box. The message box contains application-defined
4899	* message text and title, any icon, and any combination of
4900	* predefined push buttons.
4901	* Parameters:
4902	* Variables :
4903	* Result :
4904	* Remark :
4905	* Status : UNTESTED STUB
4906	*
4907	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4908	*****************************************************************************/
4909
4910	BOOL WIN32API MessageBoxIndirectW(LPMSGBOXPARAMSW lpMsgBoxParams)
4911	{
4912	dprintf(("USER32:MessageBoxIndirectW (%08x) not implemented.\n",
4913	lpMsgBoxParams));
4914
4915	return (FALSE);
4916	}
4917
4918
4919	/*****************************************************************************
4920	* Name : BOOL WIN32API MessageBoxIndirectA
4921	* Purpose : The MessageBoxIndirect function creates, displays, and operates
4922	* a message box. The message box contains application-defined
4923	* message text and title, any icon, and any combination of
4924	* predefined push buttons.
4925	* Parameters:
4926	* Variables :
4927	* Result :
4928	* Remark :
4929	* Status : UNTESTED STUB
4930	*
4931	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4932	*****************************************************************************/
4933
4934	BOOL WIN32API MessageBoxIndirectA(LPMSGBOXPARAMSA lpMsgBoxParams)
4935	{
4936	dprintf(("USER32:MessageBoxIndirectA (%08x) not implemented.\n",
4937	lpMsgBoxParams));
4938
4939	return (FALSE);
4940	}
4941
4942
4943	/*****************************************************************************
4944	* Name : DWORD WIN32API OemKeyScan
4945	* Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
4946	* into the OEM scan codes and shift states. The function provides
4947	* information that allows a program to send OEM text to another
4948	* program by simulating keyboard input.
4949	* Parameters:
4950	* Variables :
4951	* Result :
4952	* Remark :
4953	* Status : UNTESTED STUB
4954	*
4955	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4956	*****************************************************************************/
4957
4958	DWORD WIN32API OemKeyScan(WORD wOemChar)
4959	{
4960	dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
4961	wOemChar));
4962
4963	return (wOemChar);
4964	}
4965
4966
4967	/*****************************************************************************
4968	* Name : HDESK WIN32API OpenDesktopA
4969	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
4970	* A desktop is a secure object contained within a window station
4971	* object. A desktop has a logical display surface and contains
4972	* windows, menus and hooks.
4973	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
4974	* DWORD dwFlags flags to control interaction with other applications
4975	* BOOL fInherit specifies whether returned handle is inheritable
4976	* DWORD dwDesiredAccess specifies access of returned handle
4977	* Variables :
4978	* Result : If the function succeeds, the return value is the handle to the
4979	* opened desktop.
4980	* If the function fails, the return value is NULL. To get extended
4981	* error information, call GetLastError.
4982	* Remark :
4983	* Status : UNTESTED STUB
4984	*
4985	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4986	*****************************************************************************/
4987
4988	HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
4989	DWORD dwFlags,
4990	BOOL fInherit,
4991	DWORD dwDesiredAccess)
4992	{
4993	dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
4994	lpszDesktopName,
4995	dwFlags,
4996	fInherit,
4997	dwDesiredAccess));
4998
4999	return (NULL);
5000	}
5001
5002
5003	/*****************************************************************************
5004	* Name : HDESK WIN32API OpenDesktopW
5005	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
5006	* A desktop is a secure object contained within a window station
5007	* object. A desktop has a logical display surface and contains
5008	* windows, menus and hooks.
5009	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5010	* DWORD dwFlags flags to control interaction with other applications
5011	* BOOL fInherit specifies whether returned handle is inheritable
5012	* DWORD dwDesiredAccess specifies access of returned handle
5013	* Variables :
5014	* Result : If the function succeeds, the return value is the handle to the
5015	* opened desktop.
5016	* If the function fails, the return value is NULL. To get extended
5017	* error information, call GetLastError.
5018	* Remark :
5019	* Status : UNTESTED STUB
5020	*
5021	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5022	*****************************************************************************/
5023
5024	HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
5025	DWORD dwFlags,
5026	BOOL fInherit,
5027	DWORD dwDesiredAccess)
5028	{
5029	dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
5030	lpszDesktopName,
5031	dwFlags,
5032	fInherit,
5033	dwDesiredAccess));
5034
5035	return (NULL);
5036	}
5037
5038
5039	/*****************************************************************************
5040	* Name : HDESK WIN32API OpenInputDesktop
5041	* Purpose : The OpenInputDesktop function returns a handle to the desktop
5042	* that receives user input. The input desktop is a desktop on the
5043	* window station associated with the logged-on user.
5044	* Parameters: DWORD dwFlags flags to control interaction with other applications
5045	* BOOL fInherit specifies whether returned handle is inheritable
5046	* DWORD dwDesiredAccess specifies access of returned handle
5047	* Variables :
5048	* Result : If the function succeeds, the return value is a handle of the
5049	* desktop that receives user input.
5050	* If the function fails, the return value is NULL. To get extended
5051	* error information, call GetLastError.
5052	* Remark :
5053	* Status : UNTESTED STUB
5054	*
5055	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5056	*****************************************************************************/
5057
5058	HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
5059	BOOL fInherit,
5060	DWORD dwDesiredAccess)
5061	{
5062	dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
5063	dwFlags,
5064	fInherit,
5065	dwDesiredAccess));
5066
5067	return (NULL);
5068	}
5069
5070
5071	/*****************************************************************************
5072	* Name : HWINSTA WIN32API OpenWindowStationA
5073	* Purpose : The OpenWindowStation function returns a handle to an existing
5074	* window station.
5075	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
5076	* BOOL fInherit specifies whether returned handle is inheritable
5077	* DWORD dwDesiredAccess specifies access of returned handle
5078	* Variables :
5079	* Result : If the function succeeds, the return value is the handle to the
5080	* specified window station.
5081	* If the function fails, the return value is NULL. To get extended
5082	* error information, call GetLastError.
5083	* Remark :
5084	* Status : UNTESTED STUB
5085	*
5086	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5087	*****************************************************************************/
5088
5089	HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
5090	BOOL fInherit,
5091	DWORD dwDesiredAccess)
5092	{
5093	dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
5094	lpszWinStaName,
5095	fInherit,
5096	dwDesiredAccess));
5097
5098	return (NULL);
5099	}
5100
5101
5102	/*****************************************************************************
5103	* Name : HWINSTA WIN32API OpenWindowStationW
5104	* Purpose : The OpenWindowStation function returns a handle to an existing
5105	* window station.
5106	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
5107	* BOOL fInherit specifies whether returned handle is inheritable
5108	* DWORD dwDesiredAccess specifies access of returned handle
5109	* Variables :
5110	* Result : If the function succeeds, the return value is the handle to the
5111	* specified window station.
5112	* If the function fails, the return value is NULL. To get extended
5113	* error information, call GetLastError.
5114
5115
5116	* Remark :
5117	* Status : UNTESTED STUB
5118	*
5119	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5120	*****************************************************************************/
5121
5122	HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
5123	BOOL fInherit,
5124	DWORD dwDesiredAccess)
5125	{
5126	dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
5127	lpszWinStaName,
5128	fInherit,
5129	dwDesiredAccess));
5130
5131	return (NULL);
5132	}
5133
5134
5135	/*****************************************************************************
5136	* Name : BOOL WIN32API PaintDesktop
5137	* Purpose : The PaintDesktop function fills the clipping region in the
5138	* specified device context with the desktop pattern or wallpaper.
5139	* The function is provided primarily for shell desktops.
5140	* Parameters:
5141	* Variables :
5142	* Result : If the function succeeds, the return value is TRUE.
5143	* If the function fails, the return value is FALSE.
5144	* Remark :
5145	* Status : UNTESTED STUB
5146	*
5147	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5148	*****************************************************************************/
5149
5150	BOOL WIN32API PaintDesktop(HDC hdc)
5151	{
5152	dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
5153	hdc));
5154
5155	return (FALSE);
5156	}
5157
5158
5159	/*****************************************************************************
5160	* Name : BOOL WIN32API SendMessageCallbackA
5161	* Purpose : The SendMessageCallback function sends the specified message to
5162	* a window or windows. The function calls the window procedure for
5163	* the specified window and returns immediately. After the window
5164	* procedure processes the message, the system calls the specified
5165	* callback function, passing the result of the message processing
5166	* and an application-defined value to the callback function.
5167	* Parameters: HWND hwnd handle of destination window
5168	* UINT uMsg message to send
5169	* WPARAM wParam first message parameter
5170	* LPARAM lParam second message parameter
5171	* SENDASYNCPROC lpResultCallBack function to receive message value
5172	* DWORD dwData value to pass to callback function
5173	* Variables :
5174	* Result : If the function succeeds, the return value is TRUE.
5175	* If the function fails, the return value is FALSE. To get extended
5176	* error information, call GetLastError.
5177	* Remark :
5178	* Status : UNTESTED STUB
5179	*
5180	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5181	*****************************************************************************/
5182
5183	BOOL WIN32API SendMessageCallbackA(HWND hWnd,
5184	UINT uMsg,
5185	WPARAM wParam,
5186	LPARAM lParam,
5187	SENDASYNCPROC lpResultCallBack,
5188	DWORD dwData)
5189	{
5190	dprintf(("USER32:SendMessageCallBackA (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5191	hWnd,
5192	uMsg,
5193	wParam,
5194	lParam,
5195	lpResultCallBack,
5196	dwData));
5197
5198	return (FALSE);
5199	}
5200
5201
5202	/*****************************************************************************
5203	* Name : BOOL WIN32API SendMessageCallbackW
5204	* Purpose : The SendMessageCallback function sends the specified message to
5205	* a window or windows. The function calls the window procedure for
5206	* the specified window and returns immediately. After the window
5207	* procedure processes the message, the system calls the specified
5208	* callback function, passing the result of the message processing
5209	* and an application-defined value to the callback function.
5210	* Parameters: HWND hwnd handle of destination window
5211	* UINT uMsg message to send
5212	* WPARAM wParam first message parameter
5213	* LPARAM lParam second message parameter
5214	* SENDASYNCPROC lpResultCallBack function to receive message value
5215	* DWORD dwData value to pass to callback function
5216	* Variables :
5217	* Result : If the function succeeds, the return value is TRUE.
5218	* If the function fails, the return value is FALSE. To get extended
5219	* error information, call GetLastError.
5220	* Remark :
5221	* Status : UNTESTED STUB
5222	*
5223	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5224	*****************************************************************************/
5225
5226	BOOL WIN32API SendMessageCallbackW(HWND hWnd,
5227	UINT uMsg,
5228	WPARAM wParam,
5229	LPARAM lParam,
5230	SENDASYNCPROC lpResultCallBack,
5231	DWORD dwData)
5232	{
5233	dprintf(("USER32:SendMessageCallBackW (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5234	hWnd,
5235	uMsg,
5236	wParam,
5237	lParam,
5238	lpResultCallBack,
5239	dwData));
5240
5241	return (FALSE);
5242	}
5243
5244
5245	/*****************************************************************************
5246	* Name : VOID WIN32API SetDebugErrorLevel
5247	* Purpose : The SetDebugErrorLevel function sets the minimum error level at
5248	* which Windows will generate debugging events and pass them to a debugger.
5249	* Parameters: DWORD dwLevel debugging error level
5250	* Variables :
5251	* Result :
5252	* Remark :
5253	* Status : UNTESTED STUB
5254	*
5255	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5256	*****************************************************************************/
5257
5258	VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
5259	{
5260	dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
5261	dwLevel));
5262	}
5263
5264
5265	/*****************************************************************************
5266	* Name : BOOL WIN32API SetProcessWindowStation
5267	* Purpose : The SetProcessWindowStation function assigns a window station
5268	* to the calling process. This enables the process to access
5269	* objects in the window station such as desktops, the clipboard,
5270	* and global atoms. All subsequent operations on the window station
5271	* use the access rights granted to hWinSta.
5272	* Parameters:
5273	* Variables :
5274	* Result : If the function succeeds, the return value is TRUE.
5275	* If the function fails, the return value is FALSE. To get extended
5276	* error information, call GetLastError.
5277	* Remark :
5278	* Status : UNTESTED STUB
5279	*
5280	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5281	*****************************************************************************/
5282
5283	BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
5284	{
5285	dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
5286	hWinSta));
5287
5288	return (FALSE);
5289	}
5290
5291
5292	/*****************************************************************************
5293	* Name : BOOL WIN32API SetSystemCursor
5294	* Purpose : The SetSystemCursor function replaces the contents of the system
5295	* cursor specified by dwCursorId with the contents of the cursor
5296	* specified by hCursor, and then destroys hCursor. This function
5297	* lets an application customize the system cursors.
5298	* Parameters: HCURSOR hCursor set specified system cursor to this cursor's
5299	* contents, then destroy this
5300	* DWORD dwCursorID system cursor specified by its identifier
5301	* Variables :
5302	* Result : If the function succeeds, the return value is TRUE.
5303	* If the function fails, the return value is FALSE. To get extended
5304	* error information, call GetLastError.
5305	* Remark :
5306	* Status : UNTESTED STUB
5307	*
5308	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5309	*****************************************************************************/
5310
5311	BOOL WIN32API SetSystemCursor(HCURSOR hCursor,
5312	DWORD dwCursorId)
5313	{
5314	dprintf(("USER32:SetSystemCursor (%08xh,%08x) not implemented.\n",
5315	hCursor,
5316	dwCursorId));
5317
5318	return (FALSE);
5319	}
5320
5321
5322	/*****************************************************************************
5323	* Name : BOOL WIN32API SetThreadDesktop
5324	* Purpose : The SetThreadDesktop function assigns a desktop to the calling
5325	* thread. All subsequent operations on the desktop use the access
5326	* rights granted to hDesk.
5327	* Parameters: HDESK hDesk handle of the desktop to assign to this thread
5328	* Variables :
5329	* Result : If the function succeeds, the return value is TRUE.
5330	* If the function fails, the return value is FALSE. To get extended
5331	* error information, call GetLastError.
5332	* Remark :
5333	* Status : UNTESTED STUB
5334	*
5335	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5336	*****************************************************************************/
5337
5338	BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
5339	{
5340	dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
5341	hDesktop));
5342
5343	return (FALSE);
5344	}
5345
5346
5347	/*****************************************************************************
5348	* Name : BOOL WIN32API SetUserObjectInformationA
5349	* Purpose : The SetUserObjectInformation function sets information about a
5350	* window station or desktop object.
5351	* Parameters: HANDLE hObject handle of the object for which to set information
5352	* int nIndex type of information to set
5353	* PVOID lpvInfo points to a buffer that contains the information
5354	* DWORD cbInfo size, in bytes, of lpvInfo buffer
5355	* Variables :
5356	* Result : If the function succeeds, the return value is TRUE.
5357	* If the function fails the return value is FALSE. To get extended
5358	* error information, call GetLastError.
5359	* Remark :
5360	* Status : UNTESTED STUB
5361	*
5362	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5363	*****************************************************************************/
5364
5365	BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
5366	int nIndex,
5367	PVOID lpvInfo,
5368	DWORD cbInfo)
5369	{
5370	dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
5371	hObject,
5372	nIndex,
5373	lpvInfo,
5374	cbInfo));
5375
5376	return (FALSE);
5377	}
5378
5379
5380	/*****************************************************************************
5381	* Name : BOOL WIN32API SetUserObjectInformationW
5382	* Purpose : The SetUserObjectInformation function sets information about a
5383	* window station or desktop object.
5384	* Parameters: HANDLE hObject handle of the object for which to set information
5385	* int nIndex type of information to set
5386	* PVOID lpvInfo points to a buffer that contains the information
5387	* DWORD cbInfo size, in bytes, of lpvInfo buffer
5388	* Variables :
5389	* Result : If the function succeeds, the return value is TRUE.
5390	* If the function fails the return value is FALSE. To get extended
5391	* error information, call GetLastError.
5392	* Remark :
5393	* Status : UNTESTED STUB
5394	*
5395	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5396	*****************************************************************************/
5397
5398	BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
5399	int nIndex,
5400	PVOID lpvInfo,
5401	DWORD cbInfo)
5402	{
5403	dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
5404	hObject,
5405	nIndex,
5406	lpvInfo,
5407	cbInfo));
5408
5409	return (FALSE);
5410	}
5411
5412
5413	/*****************************************************************************
5414	* Name : BOOL WIN32API SetUserObjectSecurity
5415	* Purpose : The SetUserObjectSecurity function sets the security of a user
5416	* object. This can be, for example, a window or a DDE conversation
5417	* Parameters: HANDLE hObject handle of user object
5418	* SECURITY_INFORMATION * psi address of security information
5419	* LPSECURITY_DESCRIPTOR psd address of security descriptor
5420	* Variables :
5421	* Result : If the function succeeds, the return value is TRUE.
5422	* If the function fails, the return value is FALSE. To get extended
5423	* error information, call GetLastError.
5424	* Remark :
5425	* Status : UNTESTED STUB
5426	*
5427	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5428	*****************************************************************************/
5429
5430	BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
5431	SECURITY_INFORMATION * psi,
5432	LPSECURITY_DESCRIPTOR psd)
5433	{
5434	dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
5435	hObject,
5436	psi,
5437	psd));
5438
5439	return (FALSE);
5440	}
5441
5442
5443	/*****************************************************************************
5444	* Name : int WIN32API SetWindowRgn
5445	* Purpose : The SetWindowRgn function sets the window region of a window. The
5446	* window region determines the area within the window where the
5447	* operating system permits drawing. The operating system does not
5448	* display any portion of a window that lies outside of the window region
5449	* Parameters: HWND hWnd handle to window whose window region is to be set
5450	* HRGN hRgn handle to region
5451	* BOOL bRedraw window redraw flag
5452	* Variables :
5453	* Result : If the function succeeds, the return value is non-zero.
5454	* If the function fails, the return value is zero.
5455	* Remark :
5456	* Status : UNTESTED STUB
5457	*
5458	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5459	*****************************************************************************/
5460
5461	int WIN32API SetWindowRgn(HWND hWnd,
5462	HRGN hRgn,
5463	BOOL bRedraw)
5464	{
5465	dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
5466	hWnd,
5467	hRgn,
5468	bRedraw));
5469
5470	return (0);
5471	}
5472
5473
5474	/*****************************************************************************
5475	* Name : BOOL WIN32API SetWindowsHookW
5476	* Purpose : The SetWindowsHook function is not implemented in the Win32 API.
5477	* Win32-based applications should use the SetWindowsHookEx function.
5478	* Parameters:
5479	* Variables :
5480	* Result :
5481	* Remark : ARGH ! MICROSOFT !
5482	* Status : UNTESTED STUB
5483	*
5484	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5485	*****************************************************************************/
5486
5487	HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
5488
5489	{
5490	return (FALSE);
5491	}
5492
5493
5494	/*****************************************************************************
5495	* Name : BOOL WIN32API ShowWindowAsync
5496	* Purpose : The ShowWindowAsync function sets the show state of a window
5497	* created by a different thread.
5498	* Parameters: HWND hwnd handle of window
5499	* int nCmdShow show state of window
5500	* Variables :
5501	* Result : If the window was previously visible, the return value is TRUE.
5502	* If the window was previously hidden, the return value is FALSE.
5503	* Remark :
5504	* Status : UNTESTED STUB
5505	*
5506	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5507	*****************************************************************************/
5508
5509	BOOL WIN32API ShowWindowAsync (HWND hWnd,
5510	int nCmdShow)
5511	{
5512	dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
5513	hWnd,
5514	nCmdShow));
5515
5516	return (FALSE);
5517	}
5518
5519
5520	/*****************************************************************************
5521	* Name : BOOL WIN32API SwitchDesktop
5522	* Purpose : The SwitchDesktop function makes a desktop visible and activates
5523	* it. This enables the desktop to receive input from the user. The
5524	* calling process must have DESKTOP_SWITCHDESKTOP access to the
5525	* desktop for the SwitchDesktop function to succeed.
5526	* Parameters:
5527	* Variables :
5528	* Result : If the function succeeds, the return value is TRUE.
5529	* If the function fails, the return value is FALSE. To get extended
5530	* error information, call GetLastError.
5531	* Remark :
5532	* Status : UNTESTED STUB
5533	*
5534	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5535	*****************************************************************************/
5536
5537	BOOL WIN32API SwitchDesktop(HDESK hDesktop)
5538	{
5539	dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
5540	hDesktop));
5541
5542	return (FALSE);
5543	}
5544
5545
5546	/*****************************************************************************
5547	* Name : WORD WIN32API TileWindows
5548	* Purpose : The TileWindows function tiles the specified windows, or the child
5549	* windows of the specified parent window.
5550	* Parameters: HWND hwndParent handle of parent window
5551	* WORD wFlags types of windows not to arrange
5552	* LPCRECT lpRect rectangle to arrange windows in
5553	* WORD cChildrenb number of windows to arrange
5554	* const HWND *ahwndChildren array of window handles
5555	* Variables :
5556	* Result : If the function succeeds, the return value is the number of
5557	* windows arranged.
5558	* If the function fails, the return value is zero.
5559	* Remark :
5560	* Status : UNTESTED STUB
5561	*
5562	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5563	*****************************************************************************/
5564
5565	WORD WIN32API TileWindows(HWND hwndParent,
5566	UINT wFlags,
5567	const LPRECT lpRect,
5568	UINT cChildrenb,
5569	const HWND *ahwndChildren)
5570	{
5571	dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5572	hwndParent,
5573	wFlags,
5574	lpRect,
5575	cChildrenb,
5576	ahwndChildren));
5577
5578	return (0);
5579	}
5580
5581
5582	/*****************************************************************************
5583	* Name : int WIN32API ToAscii
5584	* Purpose : The ToAscii function translates the specified virtual-key code
5585	* and keyboard state to the corresponding Windows character or characters.
5586	* Parameters: UINT uVirtKey virtual-key code
5587	* UINT uScanCode scan code
5588	* PBYTE lpbKeyState address of key-state array
5589	* LPWORD lpwTransKey buffer for translated key
5590	* UINT fuState active-menu flag
5591	* Variables :
5592	* Result : 0 The specified virtual key has no translation for the current
5593	* state of the keyboard.
5594	* 1 One Windows character was copied to the buffer.
5595	* 2 Two characters were copied to the buffer. This usually happens
5596	* when a dead-key character (accent or diacritic) stored in the
5597	* keyboard layout cannot be composed with the specified virtual
5598	* key to form a single character.
5599	* Remark :
5600	* Status : UNTESTED STUB
5601	*
5602	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5603	*****************************************************************************/
5604
5605	int WIN32API ToAscii(UINT uVirtKey,
5606	UINT uScanCode,
5607	PBYTE lpbKeyState,
5608	LPWORD lpwTransKey,
5609	UINT fuState)
5610	{
5611	dprintf(("USER32:ToAscii (%u,%u,%08xh,%08xh,%u) not implemented.\n",
5612	uVirtKey,
5613	uScanCode,
5614	lpbKeyState,
5615	lpwTransKey,
5616	fuState));
5617
5618	return (0);
5619	}
5620
5621
5622	/*****************************************************************************
5623	* Name : int WIN32API ToAsciiEx
5624	* Purpose : The ToAscii function translates the specified virtual-key code
5625	* and keyboard state to the corresponding Windows character or characters.
5626	* Parameters: UINT uVirtKey virtual-key code
5627	* UINT uScanCode scan code
5628	* PBYTE lpbKeyState address of key-state array
5629	* LPWORD lpwTransKey buffer for translated key
5630	* UINT fuState active-menu flag
5631	* HLK hlk keyboard layout handle
5632	* Variables :
5633	* Result : 0 The specified virtual key has no translation for the current
5634	* state of the keyboard.
5635	* 1 One Windows character was copied to the buffer.
5636	* 2 Two characters were copied to the buffer. This usually happens
5637	* when a dead-key character (accent or diacritic) stored in the
5638	* keyboard layout cannot be composed with the specified virtual
5639	* key to form a single character.
5640	* Remark :
5641	* Status : UNTESTED STUB
5642	*
5643	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5644	*****************************************************************************/
5645
5646	int WIN32API ToAsciiEx(UINT uVirtKey,
5647	UINT uScanCode,
5648	PBYTE lpbKeyState,
5649	LPWORD lpwTransKey,
5650	UINT fuState,
5651	HKL hkl)
5652	{
5653	dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5654	uVirtKey,
5655	uScanCode,
5656	lpbKeyState,
5657	lpwTransKey,
5658	fuState,
5659	hkl));
5660
5661	return (0);
5662	}
5663
5664
5665	/*****************************************************************************
5666	* Name : int WIN32API ToUnicode
5667	* Purpose : The ToUnicode function translates the specified virtual-key code
5668	* and keyboard state to the corresponding Unicode character or characters.
5669	* Parameters: UINT wVirtKey virtual-key code
5670	* UINT wScanCode scan code
5671	* PBYTE lpKeyState address of key-state array
5672	* LPWSTR pwszBuff buffer for translated key
5673	* int cchBuff size of translated key buffer
5674	* UINT wFlags set of function-conditioning flags
5675	* Variables :
5676	* Result : - 1 The specified virtual key is a dead-key character (accent or
5677	* diacritic). This value is returned regardless of the keyboard
5678	* layout, even if several characters have been typed and are
5679	* stored in the keyboard state. If possible, even with Unicode
5680	* keyboard layouts, the function has written a spacing version of
5681	* the dead-key character to the buffer specified by pwszBuffer.
5682	* For example, the function writes the character SPACING ACUTE
5683	* (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
5684	* 0 The specified virtual key has no translation for the current
5685	* state of the keyboard. Nothing was written to the buffer
5686	* specified by pwszBuffer.
5687	* 1 One character was written to the buffer specified by pwszBuffer.
5688	* 2 or more Two or more characters were written to the buffer specified by
5689	* pwszBuff. The most common cause for this is that a dead-key
5690	* character (accent or diacritic) stored in the keyboard layout
5691	* could not be combined with the specified virtual key to form a
5692	* single character.
5693	* Remark :
5694	* Status : UNTESTED STUB
5695	*
5696	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5697	*****************************************************************************/
5698
5699	int WIN32API ToUnicode(UINT uVirtKey,
5700	UINT uScanCode,
5701	PBYTE lpKeyState,
5702	LPWSTR pwszBuff,
5703	int cchBuff,
5704	UINT wFlags)
5705	{
5706	dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5707	uVirtKey,
5708	uScanCode,
5709	lpKeyState,
5710	pwszBuff,
5711	cchBuff,
5712	wFlags));
5713
5714	return (0);
5715	}
5716
5717
5718	/*****************************************************************************
5719	* Name : BOOL WIN32API UnloadKeyboardLayout
5720	* Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
5721	* Parameters: HKL hkl handle of keyboard layout
5722	* Variables :
5723	* Result : If the function succeeds, the return value is the handle of the
5724	* keyboard layout; otherwise, it is NULL. To get extended error
5725	* information, use the GetLastError function.
5726	* Remark :
5727	* Status : UNTESTED STUB
5728	*
5729	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5730	*****************************************************************************/
5731
5732	BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
5733	{
5734	dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
5735	hkl));
5736
5737	return (0);
5738	}
5739
5740
5741	/*****************************************************************************
5742	* Name : SHORT WIN32API VkKeyScanExW
5743	* Purpose : The VkKeyScanEx function translates a character to the
5744	* corresponding virtual-key code and shift state. The function
5745	* translates the character using the input language and physical
5746	* keyboard layout identified by the given keyboard layout handle.
5747	* Parameters: UINT uChar character to translate
5748	* HKL hkl keyboard layout handle
5749	* Variables :
5750	* Result : see docs
5751	* Remark :
5752	* Status : UNTESTED STUB
5753	*
5754	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5755	*****************************************************************************/
5756
5757	WORD WIN32API VkKeyScanExW(WCHAR uChar,
5758	HKL hkl)
5759	{
5760	dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
5761	uChar,
5762	hkl));
5763
5764	return (uChar);
5765	}
5766
5767
5768	/*****************************************************************************
5769	* Name : SHORT WIN32API VkKeyScanExA
5770	* Purpose : The VkKeyScanEx function translates a character to the
5771	* corresponding virtual-key code and shift state. The function
5772	* translates the character using the input language and physical
5773	* keyboard layout identified by the given keyboard layout handle.
5774	* Parameters: UINT uChar character to translate
5775	* HKL hkl keyboard layout handle
5776	* Variables :
5777	* Result : see docs
5778	* Remark :
5779	* Status : UNTESTED STUB
5780	*
5781	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5782	*****************************************************************************/
5783
5784	WORD WIN32API VkKeyScanExA(CHAR uChar,
5785	HKL hkl)
5786	{
5787	dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
5788	uChar,
5789	hkl));
5790
5791	return (uChar);
5792	}
5793
5794
5795	/*****************************************************************************
5796	* Name : VOID WIN32API keybd_event
5797	* Purpose : The keybd_event function synthesizes a keystroke. The system
5798	* can use such a synthesized keystroke to generate a WM_KEYUP or
5799	* WM_KEYDOWN message. The keyboard driver's interrupt handler calls
5800	* the keybd_event function.
5801	* Parameters: BYTE bVk virtual-key code
5802
5803	* BYTE bScan hardware scan code
5804	* DWORD dwFlags flags specifying various function options
5805	* DWORD dwExtraInfo additional data associated with keystroke
5806	* Variables :
5807	* Result :
5808	* Remark :
5809	* Status : UNTESTED STUB
5810	*
5811	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5812	*****************************************************************************/
5813
5814	VOID WIN32API keybd_event (BYTE bVk,
5815	BYTE bScan,
5816	DWORD dwFlags,
5817	DWORD dwExtraInfo)
5818	{
5819	dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
5820	bVk,
5821	bScan,
5822	dwFlags,
5823	dwExtraInfo));
5824	}
5825
5826
5827	/*****************************************************************************
5828	* Name : VOID WIN32API mouse_event
5829	* Purpose : The mouse_event function synthesizes mouse motion and button clicks.
5830	* Parameters: DWORD dwFlags flags specifying various motion/click variants
5831	* DWORD dx horizontal mouse position or position change
5832	* DWORD dy vertical mouse position or position change
5833	* DWORD cButtons unused, reserved for future use, set to zero
5834	* DWORD dwExtraInfo 32 bits of application-defined information
5835	* Variables :
5836	* Result :
5837	* Remark :
5838	* Status : UNTESTED STUB
5839	*
5840	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5841	*****************************************************************************/
5842
5843	VOID WIN32API mouse_event(DWORD dwFlags,
5844	DWORD dx,
5845	DWORD dy,
5846	DWORD cButtons,
5847	DWORD dwExtraInfo)
5848	{
5849	dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
5850	dwFlags,
5851	dx,
5852	dy,
5853	cButtons,
5854	dwExtraInfo));
5855	}
5856
5857
5858	/*****************************************************************************
5859	* Name : BOOL WIN32API SetShellWindow
5860	* Purpose : Unknown
5861	* Parameters: Unknown
5862	* Variables :
5863	* Result :
5864	* Remark :
5865	* Status : UNTESTED UNKNOWN STUB
5866	*
5867	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
5868	*****************************************************************************/
5869
5870	BOOL WIN32API SetShellWindow(DWORD x1)
5871	{
5872	dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
5873	x1));
5874
5875	return (FALSE); /* default */
5876	}
5877
5878
5879	/*****************************************************************************
5880	* Name : BOOL WIN32API PlaySoundEvent
5881	* Purpose : Unknown
5882	* Parameters: Unknown
5883	* Variables :
5884	* Result :
5885	* Remark :
5886	* Status : UNTESTED UNKNOWN STUB
5887	*
5888	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
5889	*****************************************************************************/
5890
5891	BOOL WIN32API PlaySoundEvent(DWORD x1)
5892	{
5893	dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
5894	x1));
5895
5896	return (FALSE); /* default */
5897	}
5898
5899
5900	/*****************************************************************************
5901	* Name : BOOL WIN32API TileChildWindows
5902	* Purpose : Unknown
5903	* Parameters: Unknown
5904	* Variables :
5905	* Result :
5906	* Remark :
5907	* Status : UNTESTED UNKNOWN STUB
5908	*
5909	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
5910	*****************************************************************************/
5911
5912	BOOL WIN32API TileChildWindows(DWORD x1,
5913	DWORD x2)
5914	{
5915	dprintf(("USER32: TileChildWindows(%08xh,%08xh) not implemented.\n",
5916	x1,
5917	x2));
5918
5919	return (FALSE); /* default */
5920	}
5921
5922
5923	/*****************************************************************************
5924	* Name : BOOL WIN32API SetSysColorsTemp
5925	* Purpose : Unknown
5926	* Parameters: Unknown
5927	* Variables :
5928	* Result :
5929	* Remark :
5930	* Status : UNTESTED UNKNOWN STUB
5931	*
5932	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
5933	*****************************************************************************/
5934
5935	BOOL WIN32API SetSysColorsTemp(void)
5936	{
5937	dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
5938
5939	return (FALSE); /* default */
5940	}
5941
5942
5943	/*****************************************************************************
5944	* Name : BOOL WIN32API RegisterNetworkCapabilities
5945	* Purpose : Unknown
5946	* Parameters: Unknown
5947	* Variables :
5948	* Result :
5949	* Remark :
5950	* Status : UNTESTED UNKNOWN STUB
5951	*
5952	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
5953	*****************************************************************************/
5954
5955	BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
5956	DWORD x2)
5957	{
5958	dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
5959	x1,
5960	x2));
5961
5962	return (FALSE); /* default */
5963	}
5964
5965
5966	/*****************************************************************************
5967	* Name : BOOL WIN32API EndTask
5968	* Purpose : Unknown
5969	* Parameters: Unknown
5970	* Variables :
5971	* Result :
5972	* Remark :
5973	* Status : UNTESTED UNKNOWN STUB
5974	*
5975	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
5976	*****************************************************************************/
5977
5978	BOOL WIN32API EndTask(DWORD x1,
5979	DWORD x2,
5980	DWORD x3)
5981	{
5982	dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
5983	x1,
5984	x2,
5985	x3));
5986
5987	return (FALSE); /* default */
5988	}
5989
5990
5991	/*****************************************************************************
5992	* Name : BOOL WIN32API SwitchToThisWindow
5993	* Purpose : Unknown
5994	* Parameters: Unknown
5995	* Variables :
5996	* Result :
5997	* Remark :
5998	* Status : UNTESTED UNKNOWN STUB
5999	*
6000	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6001	*****************************************************************************/
6002
6003	BOOL WIN32API SwitchToThisWindow(HWND hwnd,
6004	BOOL x2)
6005	{
6006	dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
6007	hwnd,
6008	x2));
6009
6010	return (FALSE); /* default */
6011	}
6012
6013
6014	/*****************************************************************************
6015	* Name : BOOL WIN32API GetNextQueueWindow
6016	* Purpose : Unknown
6017	* Parameters: Unknown
6018	* Variables :
6019	* Result :
6020	* Remark :
6021	* Status : UNTESTED UNKNOWN STUB
6022	*
6023	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6024	*****************************************************************************/
6025
6026	BOOL WIN32API GetNextQueueWindow(DWORD x1,
6027	DWORD x2)
6028	{
6029	dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
6030	x1,
6031	x2));
6032
6033	return (FALSE); /* default */
6034	}
6035
6036
6037	/*****************************************************************************
6038	* Name : BOOL WIN32API YieldTask
6039	* Purpose : Unknown
6040	* Parameters: Unknown
6041	* Variables :
6042	* Result :
6043	* Remark :
6044	* Status : UNTESTED UNKNOWN STUB
6045	*
6046	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6047	*****************************************************************************/
6048
6049	BOOL WIN32API YieldTask(void)
6050	{
6051	dprintf(("USER32: YieldTask() not implemented.\n"));
6052
6053	return (FALSE); /* default */
6054	}
6055
6056
6057	/*****************************************************************************
6058	* Name : BOOL WIN32API WinOldAppHackoMatic
6059	* Purpose : Unknown
6060	* Parameters: Unknown
6061	* Variables :
6062	* Result :
6063	* Remark :
6064	* Status : UNTESTED UNKNOWN STUB
6065	*
6066	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6067	*****************************************************************************/
6068
6069	BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
6070	{
6071	dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
6072	x1));
6073
6074	return (FALSE); /* default */
6075	}
6076
6077
6078	/*****************************************************************************
6079	* Name : BOOL WIN32API DragObject
6080	* Purpose : Unknown
6081	* Parameters: Unknown
6082	* Variables :
6083	* Result :
6084	* Remark :
6085	* Status : UNTESTED UNKNOWN STUB
6086	*
6087	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6088	*****************************************************************************/
6089
6090	DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
6091	{
6092	dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6093	x1,
6094	x2,
6095	x3,
6096	x4,
6097	x5));
6098
6099	return (FALSE); /* default */
6100	}
6101
6102
6103	/*****************************************************************************
6104	* Name : BOOL WIN32API CascadeChildWindows
6105	* Purpose : Unknown
6106	* Parameters: Unknown
6107	* Variables :
6108	* Result :
6109	* Remark :
6110	* Status : UNTESTED UNKNOWN STUB
6111	*
6112	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6113	*****************************************************************************/
6114
6115	BOOL WIN32API CascadeChildWindows(DWORD x1,
6116	DWORD x2)
6117	{
6118	dprintf(("USER32: CascadeChildWindows(%08xh,%08xh) not implemented.\n",
6119	x1,
6120	x2));
6121
6122	return (FALSE); /* default */
6123	}
6124
6125
6126	/*****************************************************************************
6127	* Name : BOOL WIN32API RegisterSystemThread
6128	* Purpose : Unknown
6129	* Parameters: Unknown
6130	* Variables :
6131	* Result :
6132	* Remark :
6133	* Status : UNTESTED UNKNOWN STUB
6134	*
6135	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6136	*****************************************************************************/
6137
6138	BOOL WIN32API RegisterSystemThread(DWORD x1,
6139	DWORD x2)
6140	{
6141	dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
6142	x1,
6143	x2));
6144
6145	return (FALSE); /* default */
6146	}
6147
6148
6149	/*****************************************************************************
6150	* Name : BOOL WIN32API IsHungThread
6151	* Purpose : Unknown
6152	* Parameters: Unknown
6153	* Variables :
6154	* Result :
6155	* Remark :
6156	* Status : UNTESTED UNKNOWN STUB
6157	*
6158	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6159	*****************************************************************************/
6160
6161	BOOL WIN32API IsHungThread(DWORD x1)
6162	{
6163	dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
6164	x1));
6165
6166	return (FALSE); /* default */
6167	}
6168
6169
6170	/*****************************************************************************
6171	* Name : BOOL WIN32API SysErrorBox
6172	* Purpose : Unknown
6173	* Parameters: Unknown
6174	* Variables :
6175	* Result :
6176	* Remark : HARDERR like ?
6177	* Status : UNTESTED UNKNOWN STUB
6178	*
6179	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6180	*****************************************************************************/
6181
6182	BOOL WIN32API SysErrorBox(DWORD x1,
6183	DWORD x2,
6184	DWORD x3)
6185	{
6186	dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh) not implemented.\n",
6187	x1,
6188	x2,
6189	x3));
6190
6191	return (FALSE); /* default */
6192	}
6193
6194
6195	/*****************************************************************************
6196	* Name : BOOL WIN32API UserSignalProc
6197	* Purpose : Unknown
6198	* Parameters: Unknown
6199	* Variables :
6200	* Result :
6201	* Remark :
6202	* Status : UNTESTED UNKNOWN STUB
6203	*
6204	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6205	*****************************************************************************/
6206
6207	BOOL WIN32API UserSignalProc(DWORD x1,
6208	DWORD x2,
6209	DWORD x3,
6210	DWORD x4)
6211	{
6212	dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6213	x1,
6214	x2,
6215	x3,
6216	x4));
6217
6218	return (FALSE); /* default */
6219	}
6220
6221
6222	/*****************************************************************************
6223	* Name : BOOL WIN32API GetShellWindow
6224	* Purpose : Unknown
6225	* Parameters: Unknown
6226	* Variables :
6227	* Result :
6228	* Remark :
6229	* Status : UNTESTED UNKNOWN STUB
6230	*
6231	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6232	*****************************************************************************/
6233
6234	HWND WIN32API GetShellWindow(void)
6235	{
6236	dprintf(("USER32: GetShellWindow() not implemented.\n"));
6237
6238	return (0); /* default */
6239	}
6240
6241
6242
6243	/***********************************************************************
6244	* RegisterTasklist32 [USER32.436]
6245	*/
6246	DWORD WIN32API RegisterTasklist (DWORD x)
6247	{
6248	dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
6249	x));
6250
6251	return TRUE;
6252	}
6253
6254
6255	/***********************************************************************
6256	* DrawCaptionTemp32A [USER32.599]
6257	*
6258	* PARAMS
6259	*
6260	* RETURNS
6261	* Success:
6262	* Failure:
6263	*/
6264
6265	BOOL WIN32API DrawCaptionTempA(HWND hwnd,
6266	HDC hdc,
6267	const RECT *rect,
6268	HFONT hFont,
6269	HICON hIcon,
6270	LPCSTR str,
6271	UINT uFlags)
6272	{
6273	RECT rc = *rect;
6274
6275	dprintf(("USER32: DrawCaptionTempA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
6276	hwnd,
6277	hdc,
6278	rect,
6279	hFont,
6280	hIcon,
6281	str,
6282	uFlags));
6283
6284	/* drawing background */
6285	if (uFlags & DC_INBUTTON)
6286	{
6287	O32_FillRect (hdc,
6288	&rc,
6289	GetSysColorBrush (COLOR_3DFACE));
6290
6291	if (uFlags & DC_ACTIVE)
6292	{
6293	HBRUSH hbr = O32_SelectObject (hdc,
6294	GetSysColorBrush (COLOR_ACTIVECAPTION));
6295	O32_PatBlt (hdc,
6296	rc.left,
6297	rc.top,
6298	rc.right - rc.left,
6299	rc.bottom - rc.top,
6300	0xFA0089);
6301
6302	O32_SelectObject (hdc,
6303	hbr);
6304	}
6305	}
6306	else
6307	{
6308	O32_FillRect (hdc,
6309	&rc,
6310	GetSysColorBrush ((uFlags & DC_ACTIVE) ?
6311	COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
6312	}
6313
6314
6315	/* drawing icon */
6316	if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP))
6317	{
6318	POINT pt;
6319
6320	pt.x = rc.left + 2;
6321	pt.y = (rc.bottom + rc.top - O32_GetSystemMetrics(SM_CYSMICON)) / 2;
6322
6323	if (hIcon)
6324	{
6325	DrawIconEx (hdc,
6326	pt.x,
6327	pt.y,
6328	hIcon,
6329	O32_GetSystemMetrics(SM_CXSMICON),
6330	O32_GetSystemMetrics(SM_CYSMICON),
6331	0,
6332	0,
6333	DI_NORMAL);
6334	}
6335	else
6336	{
6337	/* @@@PH 1999/06/08 not ported yet, just don't draw any icon
6338	WND *wndPtr = WIN_FindWndPtr(hwnd);
6339	HICON hAppIcon = 0;
6340
6341	if (wndPtr->class->hIconSm)
6342	hAppIcon = wndPtr->class->hIconSm;
6343	else
6344	if (wndPtr->class->hIcon)
6345	hAppIcon = wndPtr->class->hIcon;
6346
6347	DrawIconEx (hdc,
6348	pt.x,
6349	pt.y,
6350	hAppIcon,
6351	GetSystemMetrics(SM_CXSMICON),
6352	GetSystemMetrics(SM_CYSMICON),
6353	0,
6354	0,
6355	DI_NORMAL);
6356
6357	WIN_ReleaseWndPtr(wndPtr);
6358	*/
6359	}
6360
6361	rc.left += (rc.bottom - rc.top);
6362	}
6363
6364	/* drawing text */
6365	if (uFlags & DC_TEXT)
6366	{
6367	HFONT hOldFont;
6368
6369	if (uFlags & DC_INBUTTON)
6370	O32_SetTextColor (hdc,
6371	O32_GetSysColor (COLOR_BTNTEXT));
6372	else
6373	if (uFlags & DC_ACTIVE)
6374	O32_SetTextColor (hdc,
6375	O32_GetSysColor (COLOR_CAPTIONTEXT));
6376	else
6377	O32_SetTextColor (hdc,
6378	O32_GetSysColor (COLOR_INACTIVECAPTIONTEXT));
6379
6380	O32_SetBkMode (hdc,
6381	TRANSPARENT);
6382
6383	if (hFont)
6384	hOldFont = O32_SelectObject (hdc,
6385	hFont);
6386	else
6387	{
6388	NONCLIENTMETRICSA nclm;
6389	HFONT hNewFont;
6390
6391	nclm.cbSize = sizeof(NONCLIENTMETRICSA);
6392	O32_SystemParametersInfo (SPI_GETNONCLIENTMETRICS,
6393	0,
6394	&nclm,
6395	0);
6396	hNewFont = O32_CreateFontIndirect ((uFlags & DC_SMALLCAP) ?
6397	&nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
6398	hOldFont = O32_SelectObject (hdc,
6399	hNewFont);
6400	}
6401
6402	if (str)
6403	O32_DrawText (hdc,
6404	str,
6405	-1,
6406	&rc,
6407	DT_SINGLELINE \| DT_VCENTER \| DT_NOPREFIX \| DT_LEFT);
6408	else
6409	{
6410	CHAR szText[128];
6411	INT nLen;
6412
6413	nLen = O32_GetWindowText (hwnd,
6414	szText,
6415	128);
6416
6417	O32_DrawText (hdc,
6418	szText,
6419	nLen,
6420	&rc,
6421	DT_SINGLELINE \| DT_VCENTER \| DT_NOPREFIX \| DT_LEFT);
6422	}
6423
6424	if (hFont)
6425	O32_SelectObject (hdc,
6426	hOldFont);
6427	else
6428	O32_DeleteObject (O32_SelectObject (hdc,
6429	hOldFont));
6430	}
6431
6432	/* drawing focus ??? */
6433	if (uFlags & 0x2000)
6434	{
6435	dprintf(("USER32: DrawCaptionTempA undocumented flag (0x2000)!\n"));
6436	}
6437
6438	return 0;
6439	}
6440
6441
6442	/***********************************************************************
6443	* DrawCaptionTemp32W [USER32.602]
6444	*
6445	* PARAMS
6446	*
6447	* RETURNS
6448	* Success:
6449	* Failure:
6450	*/
6451
6452	BOOL WIN32API DrawCaptionTempW (HWND hwnd,
6453	HDC hdc,
6454	const RECT *rect,
6455	HFONT hFont,
6456	HICON hIcon,
6457	LPCWSTR str,
6458	UINT uFlags)
6459	{
6460	LPSTR strAscii = UnicodeToAsciiString((LPWSTR)str);
6461
6462	BOOL res = DrawCaptionTempA (hwnd,
6463	hdc,
6464	rect,
6465	hFont,
6466	hIcon,
6467	strAscii,
6468	uFlags);
6469
6470	FreeAsciiString(strAscii);
6471
6472	return res;
6473	}
6474

Note: See TracBrowser for help on using the repository browser.

Download in other formats: