Context Navigation

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

Visit:

Last change on this file since 72 was 57, checked in by phaller, 26 years ago
Added USER32: DrawCaptionTempA, DrawCaptionTempW, InternalGetWindowText, GetInternalWindowPos and RegisterTasklist (undocumented functions which are of course required)
File size: 242.4 KB

Line
1	/* $Id: user32.cpp,v 1.5 1999-06-08 18:59:07 phaller 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 "wndsubproc.h"
27	#include "wndclass.h"
28	#include "icon.h"
29	#include "usrcall.h"
30	#include "syscolor.h"
31
32	#include <wchar.h>
33	#include <stdlib.h>
34	#include <string.h>
35
36	//undocumented stuff
37	// WIN32API CalcChildScroll
38	// WIN32API CascadeChildWindows
39	// WIN32API ClientThreadConnect
40	// WIN32API DragObject
41	// WIN32API DrawFrame
42	// WIN32API EditWndProc
43	// WIN32API EndTask
44	// WIN32API GetInputDesktop
45	// WIN32API GetNextQueueWindow
46	// WIN32API GetShellWindow
47	// WIN32API InitSharedTable
48	// WIN32API InitTask
49	// WIN32API IsHungThread
50	// WIN32API LockWindowStation
51	// WIN32API ModifyAccess
52	// WIN32API PlaySoundEvent
53	// WIN32API RegisterLogonProcess
54	// WIN32API RegisterNetworkCapabilities
55	// WIN32API RegisterSystemThread
56	// WIN32API SetDeskWallpaper
57	// WIN32API SetDesktopBitmap
58	// WIN32API SetInternalWindowPos
59	// WIN32API SetLogonNotifyWindow
60	// WIN32API SetShellWindow
61	// WIN32API SetSysColorsTemp
62	// WIN32API SetWindowFullScreenState
63	// WIN32API SwitchToThisWindow
64	// WIN32API SysErrorBox
65	// WIN32API TileChildWindows
66	// WIN32API UnlockWindowStation
67	// WIN32API UserClientDllInitialize
68	// WIN32API UserSignalProc
69	// WIN32API WinOldAppHackoMatic
70	// WIN32API WNDPROC_CALLBACK
71	// WIN32API YieldTask
72
73
74
75
76	//******************************************************************************
77	//******************************************************************************
78	HWND WIN32API GetActiveWindow()
79	{
80	return(O32_GetActiveWindow());
81	}
82	//******************************************************************************
83	//******************************************************************************
84	int __cdecl wsprintfA(char *lpOut, LPCSTR lpFmt, ...)
85	{
86	int rc;
87	va_list argptr;
88
89	#ifdef DEBUG
90	WriteLog("USER32: wsprintfA\n");
91	WriteLog("USER32: %s\n", lpFmt);
92	#endif
93	va_start(argptr, lpFmt);
94	rc = O32_wvsprintf(lpOut, (char *)lpFmt, argptr);
95	va_end(argptr);
96	#ifdef DEBUG
97	WriteLog("USER32: %s\n", lpOut);
98	#endif
99	return(rc);
100	}
101	//******************************************************************************
102	//******************************************************************************
103	int __cdecl wsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, ...)
104	{
105	int rc;
106	char *lpFmtA;
107	char szOut[512];
108	va_list argptr;
109
110	dprintf(("USER32: wsprintfW(%08xh,%08xh).\n",
111	lpOut,
112	lpFmt));
113
114	lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
115
116	/* @@@PH 98/07/13 transform "%s" to "%ls" does the unicode magic */
117	{
118	PSZ pszTemp;
119	PSZ pszTemp1;
120	ULONG ulStrings;
121	ULONG ulIndex; /* temporary string counter */
122
123	for (ulStrings = 0, /* determine number of placeholders */
124	pszTemp = lpFmtA;
125
126	(pszTemp != NULL) &&
127	(*pszTemp != 0);
128
129	ulStrings++)
130	{
131	pszTemp = strstr(pszTemp,
132	"%s");
133	if (pszTemp != NULL) /* skip 2 characters */
134	{
135	pszTemp++;
136	pszTemp++;
137	}
138	else
139	break; /* leave loop immediately */
140	}
141
142	if (ulStrings != 0) /* transformation required ? */
143	{
144	/* now reallocate lpFmt */
145	ulStrings += strlen(lpFmtA); /* calculate total string length */
146	pszTemp = lpFmtA; /* save string pointer */
147	pszTemp1 = lpFmtA; /* save string pointer */
148
149	/* @@@PH allocation has to be compatible to FreeAsciiString !!! */
150	lpFmtA = (char *)malloc(ulStrings + 1);
151	if (lpFmtA == NULL) /* check proper allocation */
152	return (0); /* raise error condition */
153
154	for (ulIndex = 0;
155	ulIndex <= ulStrings;
156	ulIndex++,
157	pszTemp++)
158	{
159	if ((pszTemp[0] == '%') &&
160	(pszTemp[1] == 's') )
161	{
162	/* replace %s by %ls */
163	lpFmtA[ulIndex++] = '%';
164	lpFmtA[ulIndex ] = 'l';
165	lpFmtA[ulIndex+1] = 's';
166	}
167	else
168	lpFmtA[ulIndex] = pszTemp; / just copy over the character */
169	}
170
171	lpFmtA[ulStrings] = 0; /* string termination */
172
173	FreeAsciiString(pszTemp1); /* the original string is obsolete */
174	}
175	}
176
177	dprintf(("USER32: wsprintfW (%s).\n",
178	lpFmt));
179
180	va_start(argptr,
181	lpFmt);
182
183	rc = O32_wvsprintf(szOut,
184	lpFmtA,
185	argptr);
186
187	AsciiToUnicode(szOut,
188	lpOut);
189
190	FreeAsciiString(lpFmtA);
191	return(rc);
192	}
193	//******************************************************************************
194	//******************************************************************************
195	int WIN32API MessageBoxA(HWND hwndOwner, LPCTSTR lpszText, LPCTSTR lpszTitle, UINT fuStyle)
196	{
197	dprintf(("USER32: MessageBoxA %s %s\n", lpszText, lpszTitle));
198	return(O32_MessageBox(hwndOwner, lpszText, lpszTitle, fuStyle));
199	}
200	//******************************************************************************
201	//******************************************************************************
202	BOOL WIN32API MessageBeep( UINT arg1)
203	{
204	#ifdef DEBUG
205	WriteLog("USER32: MessageBeep\n");
206	#endif
207	return O32_MessageBeep(arg1);
208	}
209	//******************************************************************************
210	//******************************************************************************
211	LONG WIN32API SendDlgItemMessageA( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
212	{
213	#ifdef DEBUG
214	WriteLog("USER32: SendDlgItemMessageA\n");
215	#endif
216	return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
217	}
218	//******************************************************************************
219	//******************************************************************************
220	VOID WIN32API PostQuitMessage( int arg1)
221	{
222	dprintf(("USER32: PostQuitMessage\n"));
223	O32_PostQuitMessage(arg1);
224	}
225	//******************************************************************************
226	// Not implemented by Open32 (31-5-99 Christoph Bratschi)
227	//******************************************************************************
228	BOOL WIN32API IsDlgButtonChecked( HWND arg1, UINT arg2)
229	{
230	#ifdef DEBUG
231	WriteLog("USER32: IsDlgButtonChecked\n");
232	#endif
233	// return O32_IsDlgButtonChecked(arg1, arg2);
234	return (BOOL)SendDlgItemMessageA(arg1,arg2,BM_GETCHECK,0,0);
235	}
236	//******************************************************************************
237	//******************************************************************************
238	int WIN32API GetWindowTextLengthA( HWND arg1)
239	{
240	dprintf(("USER32: GetWindowTextLength\n"));
241	return O32_GetWindowTextLength(arg1);
242	}
243	//******************************************************************************
244	//******************************************************************************
245	int WIN32API GetWindowTextA( HWND arg1, LPSTR arg2, int arg3)
246	{
247	dprintf(("USER32: GetWindowTextA\n"));
248	return O32_GetWindowText(arg1, arg2, arg3);
249	}
250	//******************************************************************************
251
252	/*******************************************************************
253	* InternalGetWindowText (USER32.326)
254	*/
255	int WIN32API InternalGetWindowText(HWND hwnd,
256	LPWSTR lpString,
257	INT nMaxCount )
258	{
259	dprintf(("USER32: InternalGetWindowText(%08xh,%08xh,%08xh) not properly implemented.\n",
260	hwnd,
261	lpString,
262	nMaxCount));
263
264	return GetWindowTextW(hwnd,lpString,nMaxCount);
265	}
266
267
268	//******************************************************************************
269	BOOL WIN32API GetWindowRect( HWND arg1, PRECT arg2)
270	{
271	BOOL rc;
272
273	rc = O32_GetWindowRect(arg1, arg2);
274	dprintf(("USER32: GetWindowRect %X returned %d\n", arg1, rc));
275	return(rc);
276	}
277	//******************************************************************************
278	//******************************************************************************
279	HWND WIN32API GetNextDlgTabItem( HWND arg1, HWND arg2, BOOL arg3)
280	{
281	dprintf(("USER32: GetNextDlgTabItem\n"));
282	return O32_GetNextDlgTabItem(arg1, arg2, arg3);
283	}
284	//******************************************************************************
285	//******************************************************************************
286	BOOL WIN32API GetMessageA( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
287	{
288	//// dprintf(("USER32: GetMessage\n"));
289	return O32_GetMessage(arg1, arg2, arg3, arg4);
290	}
291	//******************************************************************************
292	//******************************************************************************
293	HWND WIN32API GetFocus(void)
294	{
295	dprintf(("USER32: GetFocus\n"));
296	return O32_GetFocus();
297	}
298	//******************************************************************************
299	//******************************************************************************
300	HWND WIN32API GetDlgItem(HWND arg1, int arg2)
301	{
302	HWND rc;
303
304	rc = O32_GetDlgItem(arg1, arg2);
305	dprintf(("USER32: GetDlgItem %d returned %d\n", arg2, rc));
306	return(rc);
307	}
308	//******************************************************************************
309	//******************************************************************************
310	int WIN32API GetDlgCtrlID( HWND arg1)
311	{
312	dprintf(("USER32: GetDlgCtrlID\n"));
313	return O32_GetDlgCtrlID(arg1);
314	}
315	//******************************************************************************
316	//******************************************************************************
317	HWND WIN32API GetDesktopWindow(void)
318	{
319	dprintf(("USER32: GetDesktopWindow\n"));
320	return O32_GetDesktopWindow();
321	}
322	//******************************************************************************
323	//******************************************************************************
324	BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
325	{
326	BOOL rc;
327	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
328
329	dprintf(("USER32: EnumThreadWindows\n"));
330	rc = O32_EnumThreadWindows(dwThreadId, callback->GetOS2Callback(), (LPARAM)callback);
331	if(callback)
332	delete callback;
333	return(rc);
334	}
335	//******************************************************************************
336	//******************************************************************************
337	BOOL WIN32API EndDialog( HWND arg1, int arg2)
338	{
339	BOOL rc;
340
341	dprintf(("USER32: EndDialog\n"));
342	rc = O32_EndDialog(arg1, arg2);
343	return(rc);
344	}
345	//******************************************************************************
346	//******************************************************************************
347	LONG WIN32API DispatchMessageA( const MSG * arg1)
348	{
349	//// dprintf(("USER32: DispatchMessage\n"));
350	return O32_DispatchMessage(arg1);
351	}
352	//******************************************************************************
353	//******************************************************************************
354	BOOL WIN32API OffsetRect( PRECT arg1, int arg2, int arg3)
355	{
356	#ifdef DEBUG
357	//// WriteLog("USER32: OffsetRect\n");
358	#endif
359	return O32_OffsetRect(arg1, arg2, arg3);
360	}
361	//******************************************************************************
362	//******************************************************************************
363	BOOL WIN32API CopyRect( PRECT arg1, const RECT * arg2)
364	{
365	// ddprintf(("USER32: CopyRect\n"));
366	return O32_CopyRect(arg1, arg2);
367	}
368	//******************************************************************************
369	// Not implemented by Open32 (5-31-99 Christoph Bratschi)
370	//******************************************************************************
371	BOOL WIN32API CheckDlgButton( HWND arg1, int arg2, UINT arg3)
372	{
373	#ifdef DEBUG
374	WriteLog("USER32: CheckDlgButton\n");
375	#endif
376	// return O32_CheckDlgButton(arg1, arg2, arg3);
377	return (BOOL)SendDlgItemMessageA(arg1,arg2,BM_SETCHECK,arg3,0);
378	}
379	//******************************************************************************
380	//******************************************************************************
381	HWND WIN32API SetFocus( HWND arg1)
382	{
383	dprintf(("USER32: SetFocus\n"));
384	return O32_SetFocus(arg1);
385	}
386	//******************************************************************************
387	//******************************************************************************
388	BOOL WIN32API TranslateMessage( const MSG * arg1)
389	{
390	#ifdef DEBUG
391	//// WriteLog("USER32: TranslateMessage\n");
392	#endif
393	return O32_TranslateMessage(arg1);
394	}
395	//******************************************************************************
396	//******************************************************************************
397	BOOL WIN32API SetWindowPos( HWND arg1, HWND arg2, int arg3, int arg4, int arg5, int arg6, UINT arg7)
398	{
399	#ifdef DEBUG
400	WriteLog("USER32: SetWindowPos\n");
401	#endif
402	return O32_SetWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
403	}
404	//******************************************************************************
405	//******************************************************************************
406	BOOL WIN32API ShowWindow(HWND arg1, int arg2)
407	{
408	#ifdef DEBUG
409	WriteLog("USER32: ShowWindow %X %d\n", arg1, arg2);
410	#endif
411	return O32_ShowWindow(arg1, arg2);
412	}
413	//******************************************************************************
414	//******************************************************************************
415	BOOL WIN32API SetWindowTextA(HWND arg1, LPCSTR arg2)
416	{
417	#ifdef DEBUG
418	WriteLog("USER32: SetWindowText %s\n", arg2);
419	#endif
420	return O32_SetWindowText(arg1, arg2);
421	}
422	//******************************************************************************
423	//******************************************************************************
424	BOOL WIN32API SetForegroundWindow(HWND arg1)
425	{
426	#ifdef DEBUG
427	WriteLog("USER32: SetForegroundWindow\n");
428	#endif
429	return O32_SetForegroundWindow(arg1);
430	}
431	//******************************************************************************
432	//******************************************************************************
433	int WIN32API ReleaseDC( HWND arg1, HDC arg2)
434	{
435	#ifdef DEBUG
436	WriteLog("USER32: ReleaseDC\n");
437	#endif
438	return O32_ReleaseDC(arg1, arg2);
439	}
440	//******************************************************************************
441	//******************************************************************************
442	BOOL WIN32API InvalidateRect(HWND arg1, const RECT *arg2, BOOL arg3)
443	{
444	#ifdef DEBUG
445	if(arg2)
446	WriteLog("USER32: InvalidateRect for window %X (%d,%d)(%d,%d) %d\n", arg1, arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
447	else WriteLog("USER32: InvalidateRect for window %X NULL, %d\n", arg1, arg3);
448	#endif
449	return O32_InvalidateRect(arg1, arg2, arg3);
450	}
451	//******************************************************************************
452	//******************************************************************************
453	BOOL WIN32API GetUpdateRect( HWND arg1, PRECT arg2, BOOL arg3)
454	{
455	#ifdef DEBUG
456	WriteLog("USER32: GetUpdateRect\n");
457	#endif
458	return O32_GetUpdateRect(arg1, arg2, arg3);
459	}
460	//******************************************************************************
461	//******************************************************************************
462	HDC WIN32API GetDC( HWND arg1)
463	{
464	HDC hdc;
465
466	hdc = O32_GetDC(arg1);
467	#ifdef DEBUG
468	WriteLog("USER32: GetDC of %X returns %X\n", arg1, hdc);
469	#endif
470	return(hdc);
471	}
472	//******************************************************************************
473	//******************************************************************************
474	HDC WIN32API GetDCEx(HWND arg1, HRGN arg2, DWORD arg3)
475	{
476	#ifdef DEBUG
477	WriteLog("USER32: GetDCEx\n");
478	#endif
479	return O32_GetDCEx(arg1, arg2, arg3);
480	}
481	//******************************************************************************
482	//******************************************************************************
483	BOOL WIN32API GetClientRect( HWND arg1, PRECT arg2)
484	{
485	#ifdef DEBUG
486	WriteLog("USER32: GetClientRect of %X\n", arg1);
487	#endif
488
489	return O32_GetClientRect(arg1, arg2);
490	}
491	//******************************************************************************
492	//******************************************************************************
493	HWND WIN32API FindWindowA(LPCSTR arg1, LPCSTR arg2)
494	{
495	#ifdef DEBUG
496	WriteLog("USER32: FindWindow\n");
497	#endif
498	return O32_FindWindow(arg1, arg2);
499	}
500	//******************************************************************************
501	//******************************************************************************
502	HWND WIN32API FindWindowExA(HWND arg1, HWND arg2, LPCSTR arg3, LPCSTR arg4)
503	{
504	#ifdef DEBUG
505	WriteLog("USER32: FindWindowExA, not completely implemented\n");
506	#endif
507	return O32_FindWindow(arg3, arg4);
508	}
509	//******************************************************************************
510	//******************************************************************************
511	BOOL WIN32API FlashWindow( HWND arg1, BOOL arg2)
512	{
513	#ifdef DEBUG
514	WriteLog("USER32: FlashWindow\n");
515	#endif
516	return O32_FlashWindow(arg1, arg2);
517	}
518	//******************************************************************************
519	//******************************************************************************
520	BOOL WIN32API EndPaint( HWND arg1, const PAINTSTRUCT * arg2)
521	{
522	#ifdef DEBUG
523	WriteLog("USER32: EndPaint\n");
524	#endif
525	return O32_EndPaint(arg1, arg2);
526	}
527	//******************************************************************************
528	//******************************************************************************
529	BOOL WIN32API MoveWindow(HWND arg1, int arg2, int arg3, int arg4, int arg5, BOOL arg6)
530	{
531	BOOL rc;
532
533	rc = O32_MoveWindow(arg1, arg2, arg3, arg4, arg5, arg6);
534	dprintf(("USER32: MoveWindow %X to (%d,%d) size (%d,%d), repaint = %d returned %d\n", arg1, arg2, arg3, arg4, arg5, arg6, rc));
535	return(rc);
536	}
537	//******************************************************************************
538	//******************************************************************************
539	HWND WIN32API CreateWindowExA(DWORD dwExStyle,
540	LPCSTR arg2,
541	LPCSTR arg3,
542	DWORD dwStyle,
543	int x,
544	int y,
545	int nWidth,
546	int nHeight,
547	HWND arg9,
548	HMENU arg10,
549	HINSTANCE arg11,
550	PVOID arg12)
551	{
552	HWND hwnd;
553	Win32WindowProc *window = NULL;
554
555	/* @@@PH 98/06/12 CreateWindow crashes somewhere in Open32 */
556	if(arg3 == NULL)
557	arg3 = (LPCSTR)"CRASH, CRASH";
558
559	//SvL: This break generic.exe & notepad.exe (probably many others too)
560	//These parameters can be CW_USEDEFAULT, which is 0x80000000
561	#if 0
562	if (nWidth < 0) nWidth = 0;
563	if (x < 0) x = 0;
564	if (nHeight< 0) nHeight = 0;
565	if (y < 0) y = 0;
566	#endif
567
568	//SvL: Breaks applications
569	#if 0
570	/* @@@PH 98/06/21 redraw problems disappear when WS_SYNCPAINT is on */
571	#ifndef WS_VISIBLE
572	#define WS_VISIBLE 0x80000000L
573	#endif
574
575	#ifndef WS_SYNCPAINT
576	#define WS_SYNCPAINT 0x02000000L
577	#endif
578
579	#ifndef WS_CLIPSYBLINGS
580	#define WS_CLIPSYBLINGS 0x10000000L
581	#endif
582
583	dwStyle \|= WS_SYNCPAINT;
584
585	/* @@@PH 98/06/21 experimental fix for WinHlp32 */
586	// SOL.EXE crashes here, but WINHLP32 does not display the
587	// navigation buttons otherwise.
588	dwStyle \|= WS_VISIBLE;
589	#endif
590
591	#ifdef DEBUG
592	WriteLog("USER32: CreateWindow: dwExStyle = %X\n", dwExStyle);
593	if((int)arg2 >> 16 != 0)
594	WriteLog("USER32: CreateWindow: classname = %s\n", arg2);
595	else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
596	WriteLog("USER32: CreateWindow: windowname= %s\n", arg3);
597	WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
598	WriteLog("USER32: CreateWindow: x = %d\n", x);
599	WriteLog("USER32: CreateWindow: y = %d\n", y);
600	WriteLog("USER32: CreateWindow: nWidth = %d\n", nWidth);
601	WriteLog("USER32: CreateWindow: nHeight = %d\n", nHeight);
602	WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
603	WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
604	WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
605	WriteLog("USER32: CreateWindow: param = %X\n", arg12);
606	#endif
607
608	if((int) arg2 >> 16 != 0 && strcmp(arg2, "COMBOBOX") == 0)
609	{
610	dprintf(("COMBOBOX creation"));
611	//TODO: #%@#%$ Open32 doesn't support this
612	dwStyle &= ~(CBS_OWNERDRAWFIXED \| CBS_OWNERDRAWVARIABLE);
613
614	/* @@@PH 98/06/12 drop down combos are problematic too */
615	/* so we translate the styles to OS/2 style */
616	dwStyle \|= CBS_DROPDOWN \| CBS_DROPDOWNLIST;
617	}
618
619	//Classname might be name of system class, in which case we don't
620	//need to use our own callback
621	// if(Win32WindowClass::FindClass((LPSTR)arg2) != NULL) {
622	window = new Win32WindowProc(arg11, arg2);
623	// }
624
625	hwnd = O32_CreateWindowEx(dwExStyle,
626	arg2,
627	arg3,
628	dwStyle,
629	x,
630	y,
631	nWidth,
632	nHeight,
633	arg9,
634	arg10,
635	arg11,
636	arg12);
637
638	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
639	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
640	delete(window);
641	window = 0;
642	}
643	if(window) {
644	window->SetWindowHandle(hwnd);
645	}
646	dprintf(("USER32: ************CreateWindowExA %s (%d,%d,%d,%d), hwnd = %X\n", arg2, x, y, nWidth, nHeight, hwnd));
647	return(hwnd);
648	}
649	//******************************************************************************
650	//******************************************************************************
651	LRESULT WIN32API SendMessageA(HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
652	{
653	LRESULT rc;
654
655	#ifdef DEBUG
656	WriteLog("USER32: SendMessage....\n");
657	#endif
658	rc = O32_SendMessage(arg1, arg2, arg3, arg4);
659	#ifdef DEBUG
660	WriteLog("USER32: *****SendMessage %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
661	#endif
662	return(rc);
663	}
664	//******************************************************************************
665	//******************************************************************************
666	HWND WIN32API SetActiveWindow( HWND arg1)
667	{
668	#ifdef DEBUG
669	WriteLog("USER32: SetActiveWindow\n");
670	#endif
671	return O32_SetActiveWindow(arg1);
672	}
673	//******************************************************************************
674	//******************************************************************************
675	HDC WIN32API BeginPaint(HWND arg1, PPAINTSTRUCT arg2)
676	{
677	dprintf(("USER32: BeginPaint %X\n", arg2));
678	return O32_BeginPaint(arg1, arg2);
679	}
680	//******************************************************************************
681	//******************************************************************************
682	BOOL WIN32API IsDialogMessageA( HWND arg1, LPMSG arg2)
683	{
684	#ifdef DEBUG
685	//// WriteLog("USER32: IsDialogMessage\n");
686	#endif
687	return O32_IsDialogMessage(arg1, arg2);
688	}
689	//******************************************************************************
690	//******************************************************************************
691	int WIN32API DrawTextA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5)
692	{
693	#ifdef DEBUG
694	WriteLog("USER32: DrawTextA %s", arg2);
695	#endif
696	return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
697	}
698	//******************************************************************************
699	//******************************************************************************
700	int WIN32API DrawTextExA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
701	{
702	#ifdef DEBUG
703	WriteLog("USER32: DrawTextExA (not completely implemented) %s", arg2);
704	#endif
705	return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
706	}
707	//******************************************************************************
708	//******************************************************************************
709	int WIN32API GetSystemMetrics(int arg1)
710	{
711	int rc;
712
713	switch(arg1) {
714	case SM_CXICONSPACING: //TODO: size of grid cell for large icons
715	rc = O32_GetSystemMetrics(SM_CXICON);
716	break;
717	case SM_CYICONSPACING:
718	rc = O32_GetSystemMetrics(SM_CYICON);
719	break;
720	case SM_PENWINDOWS:
721	rc = FALSE;
722	break;
723	case SM_DBCSENABLED:
724	rc = FALSE;
725	break;
726	case SM_CXEDGE: //size of 3D window edge (not supported)
727	rc = 1;
728	break;
729	case SM_CYEDGE:
730	rc = 1;
731	break;
732	case SM_CXMINSPACING: //can be SM_CXMINIMIZED or larger
733	rc = O32_GetSystemMetrics(SM_CXMINIMIZED);
734	break;
735	case SM_CYMINSPACING:
736	rc = GetSystemMetrics(SM_CYMINIMIZED);
737	break;
738	case SM_CXSMICON: //recommended size of small icons (TODO: adjust to screen res.)
739	rc = 16;
740	break;
741	case SM_CYSMICON:
742	rc = 16;
743	break;
744	case SM_CYSMCAPTION: //size in pixels of a small caption (TODO: ????)
745	rc = 8;
746	break;
747	case SM_CXSMSIZE: //size of small caption buttons (pixels) (TODO: implement properly)
748	rc = 16;
749	break;
750	case SM_CYSMSIZE:
751	rc = 16;
752	break;
753	case SM_CXMENUSIZE: //TODO: size of menu bar buttons (such as MDI window close)
754	rc = 16;
755	break;
756	case SM_CYMENUSIZE:
757	rc = 16;
758	break;
759	case SM_ARRANGE:
760	rc = ARW_BOTTOMLEFT \| ARW_LEFT;
761	break;
762	case SM_CXMINIMIZED:
763	break;
764	case SM_CYMINIMIZED:
765	break;
766	case SM_CXMAXTRACK: //max window size
767	case SM_CXMAXIMIZED: //max toplevel window size
768	rc = O32_GetSystemMetrics(SM_CXSCREEN);
769	break;
770	case SM_CYMAXTRACK:
771	case SM_CYMAXIMIZED:
772	rc = O32_GetSystemMetrics(SM_CYSCREEN);
773	break;
774	case SM_NETWORK:
775	rc = 0x01; //TODO: default = yes
776	break;
777	case SM_CLEANBOOT:
778	rc = 0; //normal boot
779	break;
780	case SM_CXDRAG: //nr of pixels before drag becomes a real one
781	rc = 2;
782	break;
783	case SM_CYDRAG:
784	rc = 2;
785	break;
786	case SM_SHOWSOUNDS: //show instead of play sound
787	rc = FALSE;
788	break;
789	case SM_CXMENUCHECK:
790	rc = 4; //TODO
791	break;
792	case SM_CYMENUCHECK:
793	rc = O32_GetSystemMetrics(SM_CYMENU);
794	break;
795	case SM_SLOWMACHINE:
796	rc = FALSE; //even a slow machine is fast with OS/2 :)
797	break;
798	case SM_MIDEASTENABLED:
799	rc = FALSE;
800	break;
801	case SM_CMETRICS:
802	rc = O32_GetSystemMetrics(44); //Open32 changed this one
803	break;
804	default:
805	rc = O32_GetSystemMetrics(arg1);
806	break;
807	}
808	#ifdef DEBUG
809	WriteLog("USER32: GetSystemMetrics %d returned %d\n", arg1, rc);
810	#endif
811	return(rc);
812	}
813	//******************************************************************************
814	//******************************************************************************
815	UINT WIN32API SetTimer( HWND arg1, UINT arg2, UINT arg3, TIMERPROC arg4)
816	{
817	#ifdef DEBUG
818	WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
819	#endif
820	//SvL: Write callback handler class for this one
821	return O32_SetTimer(arg1, arg2, arg3, (TIMERPROC_O32)arg4);
822	}
823	//******************************************************************************
824	//******************************************************************************
825	BOOL WIN32API KillTimer(HWND arg1, UINT arg2)
826	{
827	#ifdef DEBUG
828	WriteLog("USER32: KillTimer\n");
829	#endif
830	return O32_KillTimer(arg1, arg2);
831	}
832	//******************************************************************************
833	//******************************************************************************
834	BOOL WIN32API DestroyWindow(HWND arg1)
835	{
836	#ifdef DEBUG
837	WriteLog("USER32: DestroyWindow\n");
838	#endif
839	return O32_DestroyWindow(arg1);
840	}
841	//******************************************************************************
842	//******************************************************************************
843	BOOL WIN32API PostMessageA( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
844	{
845	#ifdef DEBUG
846	WriteLog("USER32: PostMessageA %X %X %X %X\n", arg1, arg2, arg3, arg4);
847	#endif
848	return O32_PostMessage(arg1, arg2, arg3, arg4);
849	}
850	//******************************************************************************
851	//******************************************************************************
852	BOOL WIN32API InflateRect( PRECT arg1, int arg2, int arg3)
853	{
854	#ifdef DEBUG
855	WriteLog("USER32: InflateRect\n");
856	#endif
857	return O32_InflateRect(arg1, arg2, arg3);
858	}
859	//******************************************************************************
860	//TODO:How can we emulate this one in OS/2???
861	//******************************************************************************
862	DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
863	{
864	#ifdef DEBUG
865	WriteLog("USER32: WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
866	#endif
867
868	if(dwTimeOut == INFINITE) return(0);
869
870	// DosSleep(dwTimeOut/16);
871	return(0);
872	}
873	//******************************************************************************
874	//******************************************************************************
875	UINT WIN32API GetDlgItemTextA(HWND arg1, int arg2, LPSTR arg3, UINT arg4)
876	{
877	UINT rc;
878
879	rc = O32_GetDlgItemText(arg1, arg2, arg3, arg4);
880	#ifdef DEBUG
881	if(rc)
882	WriteLog("USER32: GetDlgItemTextA returned %s\n", arg3);
883	else WriteLog("USER32: GetDlgItemTextA returned 0 (%d)\n", GetLastError());
884	#endif
885	return(rc);
886	}
887	//******************************************************************************
888	//******************************************************************************
889	BOOL WIN32API PeekMessageA(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
890	{
891	#ifdef DEBUG
892	// WriteLog("USER32: PeekMessage\n");
893	#endif
894	return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
895	}
896	//******************************************************************************
897	//******************************************************************************
898	int WIN32API ShowCursor( BOOL arg1)
899	{
900	#ifdef DEBUG
901	WriteLog("USER32: ShowCursor\n");
902	#endif
903	return O32_ShowCursor(arg1);
904	}
905	//******************************************************************************
906	//BUGBUG: UpdateWindow sends a WM_ERASEBKGRND when it shouldn't!
907	// So we just do it manually
908	//******************************************************************************
909	BOOL WIN32API UpdateWindow(HWND hwnd)
910	{
911	RECT rect;
912
913	#ifdef DEBUG
914	WriteLog("USER32: UpdateWindow\n");
915	#endif
916	if(O32_GetUpdateRect(hwnd, &rect, FALSE) != FALSE) {//update region empty?
917	WndCallback(hwnd, WM_PAINT, 0, 0);
918	// O32_PostMessage(hwnd, WM_PAINT, 0, 0);
919	}
920	#ifdef DEBUG
921	else WriteLog("USER32: Update region empty!\n");
922	#endif
923	return(TRUE);
924	}
925	//******************************************************************************
926	//******************************************************************************
927	BOOL WIN32API AdjustWindowRect( PRECT arg1, DWORD arg2, BOOL arg3)
928	{
929	#ifdef DEBUG
930	WriteLog("USER32: AdjustWindowRect\n");
931	#endif
932	return O32_AdjustWindowRect(arg1, arg2, arg3);
933	}
934	//******************************************************************************
935	//******************************************************************************
936	BOOL WIN32API AdjustWindowRectEx( PRECT arg1, DWORD arg2, BOOL arg3, DWORD arg4)
937	{
938	#ifdef DEBUG
939	WriteLog("USER32: AdjustWindowRectEx\n");
940	#endif
941	return O32_AdjustWindowRectEx(arg1, arg2, arg3, arg4);
942	}
943	//******************************************************************************
944	//******************************************************************************
945	BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
946	{
947	#ifdef DEBUG
948	//// WriteLog("USER32: ClientToScreen\n");
949	#endif
950	return O32_ClientToScreen(arg1, arg2);
951	}
952	//******************************************************************************
953	//******************************************************************************
954	BOOL WIN32API SetRect( PRECT arg1, int arg2, int arg3, int arg4, int arg5)
955	{
956	#ifdef DEBUG
957	WriteLog("USER32: SetRect\n");
958	#endif
959	return O32_SetRect(arg1, arg2, arg3, arg4, arg5);
960	}
961	//******************************************************************************
962	//******************************************************************************
963	LONG WIN32API GetWindowLongA(HWND hwnd, int nIndex)
964	{
965	LONG rc;
966
967	#ifdef DEBUG
968	WriteLog("USER32: GetWindowLong %X %d\n", hwnd, nIndex);
969	#endif
970	if(nIndex == GWL_WNDPROC \|\| nIndex == DWL_DLGPROC) {
971	Win32WindowProc *window = Win32WindowProc::FindProc(hwnd);
972	if(window && !(nIndex == DWL_DLGPROC && window->IsWindow() == TRUE)) {
973	return (LONG)window->GetWin32Callback();
974	}
975	}
976	rc = O32_GetWindowLong(hwnd, nIndex);
977	#ifdef DEBUG
978	WriteLog("USER32: GetWindowLong returned %X\n", rc);
979	#endif
980	return(rc);
981	}
982	//******************************************************************************
983	//******************************************************************************
984	BOOL WIN32API SetDlgItemInt( HWND arg1, int arg2, UINT arg3, BOOL arg4)
985	{
986	#ifdef DEBUG
987	WriteLog("USER32: SetDlgItemInt\n");
988	#endif
989	return O32_SetDlgItemInt(arg1, arg2, arg3, arg4);
990	}
991	//******************************************************************************
992	//******************************************************************************
993	BOOL WIN32API SetDlgItemTextA( HWND arg1, int arg2, LPCSTR arg3)
994	{
995	#ifdef DEBUG
996	WriteLog("USER32: SetDlgItemText to %s\n", arg3);
997	#endif
998	return O32_SetDlgItemText(arg1, arg2, arg3);
999	}
1000	//******************************************************************************
1001	//******************************************************************************
1002	BOOL WIN32API WinHelpA( HWND arg1, LPCSTR arg2, UINT arg3, DWORD arg4)
1003	{
1004	#ifdef DEBUG
1005	WriteLog("USER32: WinHelp not implemented %s\n", arg2);
1006	#endif
1007	// return O32_WinHelp(arg1, arg2, arg3, arg4);
1008	return(TRUE);
1009	}
1010	//******************************************************************************
1011	//******************************************************************************
1012	BOOL WIN32API IsIconic( HWND arg1)
1013	{
1014	#ifdef DEBUG
1015	WriteLog("USER32: IsIconic\n");
1016	#endif
1017	return O32_IsIconic(arg1);
1018	}
1019	//******************************************************************************
1020	//******************************************************************************
1021	int WIN32API TranslateAcceleratorA(HWND arg1, HACCEL arg2, LPMSG arg3)
1022	{
1023	#ifdef DEBUG
1024	//// WriteLog("USER32: TranslateAccelerator\n");
1025	#endif
1026	return O32_TranslateAccelerator(arg1, arg2, arg3);
1027	}
1028	//******************************************************************************
1029	//******************************************************************************
1030	HWND WIN32API GetWindow(HWND arg1, UINT arg2)
1031	{
1032	HWND rc;
1033
1034	rc = O32_GetWindow(arg1, arg2);
1035	#ifdef DEBUG
1036	WriteLog("USER32: GetWindow %X %d returned %d\n", arg1, arg2, rc);
1037	#endif
1038	return(rc);
1039	}
1040	//******************************************************************************
1041	//******************************************************************************
1042	HDC WIN32API GetWindowDC(HWND arg1)
1043	{
1044	#ifdef DEBUG
1045	WriteLog("USER32: GetWindowDC\n");
1046	#endif
1047	return O32_GetWindowDC(arg1);
1048	}
1049	//******************************************************************************
1050	//******************************************************************************
1051	BOOL WIN32API SubtractRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
1052	{
1053	#ifdef DEBUG
1054	WriteLog("USER32: SubtractRect");
1055	#endif
1056	return O32_SubtractRect(arg1, arg2, arg3);
1057	}
1058	//******************************************************************************
1059	//SvL: 24-6-'97 - Added
1060	//******************************************************************************
1061	BOOL WIN32API ClipCursor(const RECT * arg1)
1062	{
1063	#ifdef DEBUG
1064	WriteLog("USER32: ClipCursor\n");
1065	#endif
1066	return O32_ClipCursor(arg1);
1067	}
1068	//******************************************************************************
1069	//SvL: 24-6-'97 - Added
1070	//TODO: Not implemented
1071	//******************************************************************************
1072	WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1073	{
1074	#ifdef DEBUG
1075	//// WriteLog("USER32: GetAsyncKeyState Not implemented\n");
1076	#endif
1077	return 0;
1078	}
1079	//******************************************************************************
1080	//SvL: 24-6-'97 - Added
1081	//******************************************************************************
1082	HCURSOR WIN32API GetCursor(void)
1083	{
1084	#ifdef DEBUG
1085	//// WriteLog("USER32: GetCursor\n");
1086	#endif
1087	return O32_GetCursor();
1088	}
1089	//******************************************************************************
1090	//SvL: 24-6-'97 - Added
1091	//******************************************************************************
1092	BOOL WIN32API GetCursorPos( PPOINT arg1)
1093	{
1094	#ifdef DEBUG
1095	//// WriteLog("USER32: GetCursorPos\n");
1096	#endif
1097	return O32_GetCursorPos(arg1);
1098	}
1099	//******************************************************************************
1100	//SvL: 24-6-'97 - Added
1101	//******************************************************************************
1102	UINT WIN32API RegisterWindowMessageA(LPCSTR arg1)
1103	{
1104	UINT rc;
1105
1106	rc = O32_RegisterWindowMessage(arg1);
1107	#ifdef DEBUG
1108	WriteLog("USER32: RegisterWindowMessageA %s returned %X\n", arg1, rc);
1109	#endif
1110	return(rc);
1111	}
1112	//******************************************************************************
1113	//SvL: 24-6-'97 - Added
1114	//******************************************************************************
1115	WORD WIN32API VkKeyScanA( char arg1)
1116	{
1117	#ifdef DEBUG
1118	WriteLog("USER32: VkKeyScanA\n");
1119	#endif
1120	return O32_VkKeyScan(arg1);
1121	}
1122	//******************************************************************************
1123	//SvL: 24-6-'97 - Added
1124	//******************************************************************************
1125	SHORT WIN32API GetKeyState( int arg1)
1126	{
1127	#ifdef DEBUG
1128	WriteLog("USER32: GetKeyState %d\n", arg1);
1129	#endif
1130	return O32_GetKeyState(arg1);
1131	}
1132	//******************************************************************************
1133	//******************************************************************************
1134	HCURSOR WIN32API SetCursor( HCURSOR arg1)
1135	{
1136	#ifdef DEBUG
1137	WriteLog("USER32: SetCursor\n");
1138	#endif
1139	return O32_SetCursor(arg1);
1140	}
1141	//******************************************************************************
1142	//******************************************************************************
1143	BOOL WIN32API SetCursorPos( int arg1, int arg2)
1144	{
1145	#ifdef DEBUG
1146	WriteLog("USER32: SetCursorPos\n");
1147	#endif
1148	return O32_SetCursorPos(arg1, arg2);
1149	}
1150	//******************************************************************************
1151	//******************************************************************************
1152	BOOL WIN32API EnableScrollBar( HWND arg1, INT arg2, UINT arg3)
1153	{
1154	#ifdef DEBUG
1155	WriteLog("USER32: EnableScrollBar\n");
1156	#endif
1157	return O32_EnableScrollBar(arg1, arg2, arg3);
1158	}
1159	//******************************************************************************
1160	//******************************************************************************
1161	BOOL WIN32API EnableWindow( HWND arg1, BOOL arg2)
1162	{
1163	#ifdef DEBUG
1164	WriteLog("USER32: EnableWindow\n");
1165	#endif
1166	return O32_EnableWindow(arg1, arg2);
1167	}
1168	//******************************************************************************
1169	//******************************************************************************
1170	HWND WIN32API SetCapture( HWND arg1)
1171	{
1172	#ifdef DEBUG
1173	WriteLog("USER32: SetCapture\n");
1174	#endif
1175	return O32_SetCapture(arg1);
1176	}
1177	//******************************************************************************
1178	//******************************************************************************
1179	BOOL WIN32API ReleaseCapture(void)
1180	{
1181	#ifdef DEBUG
1182	WriteLog("USER32: ReleaseCapture\n");
1183	#endif
1184	return O32_ReleaseCapture();
1185	}
1186	//******************************************************************************
1187	//******************************************************************************
1188	DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD arg5)
1189	{
1190	#ifdef DEBUG
1191	WriteLog("USER32: MsgWaitForMultipleObjects\n");
1192	#endif
1193	return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
1194	}
1195	//******************************************************************************
1196	//******************************************************************************
1197	HDWP WIN32API BeginDeferWindowPos( int arg1)
1198	{
1199	#ifdef DEBUG
1200	WriteLog("USER32: BeginDeferWindowPos\n");
1201	#endif
1202	return O32_BeginDeferWindowPos(arg1);
1203	}
1204	//******************************************************************************
1205	//******************************************************************************
1206	BOOL WIN32API BringWindowToTop( HWND arg1)
1207	{
1208	#ifdef DEBUG
1209	WriteLog("USER32: BringWindowToTop\n");
1210	#endif
1211	return O32_BringWindowToTop(arg1);
1212	}
1213	//******************************************************************************
1214	//******************************************************************************
1215	BOOL WIN32API CallMsgFilterA( LPMSG arg1, int arg2)
1216	{
1217	#ifdef DEBUG
1218	WriteLog("USER32: CallMsgFilterA\n");
1219	#endif
1220	return O32_CallMsgFilter(arg1, arg2);
1221	}
1222	//******************************************************************************
1223	//******************************************************************************
1224	BOOL WIN32API CallMsgFilterW( LPMSG arg1, int arg2)
1225	{
1226	#ifdef DEBUG
1227	WriteLog("USER32: CallMsgFilterW\n");
1228	#endif
1229	// NOTE: This will not work as is (needs UNICODE support)
1230	return O32_CallMsgFilter(arg1, arg2);
1231	}
1232	//******************************************************************************
1233	//******************************************************************************
1234	LRESULT WIN32API CallWindowProcA(WNDPROC wndprcPrev,
1235	HWND arg2,
1236	UINT arg3,
1237	WPARAM arg4,
1238	LPARAM arg5)
1239	{
1240	#ifdef DEBUG
1241	//// WriteLog("USER32: CallWindowProcA %X hwnd=%X, msg = %X\n", wndprcPrev, arg2, arg3);
1242	#endif
1243
1244	if(Win32WindowSubProc::FindSubProc((WNDPROC_O32)wndprcPrev) != NULL) {
1245	WNDPROC_O32 orgprc = (WNDPROC_O32)wndprcPrev; //is original Open32 system class callback (_System)
1246	return orgprc(arg2, arg3, arg4, arg5);
1247	}
1248	else return wndprcPrev(arg2, arg3, arg4, arg5); //win32 callback (__stdcall)
1249	}
1250	//******************************************************************************
1251	//******************************************************************************
1252	LRESULT WIN32API CallWindowProcW(WNDPROC arg1,
1253	HWND arg2,
1254	UINT arg3,
1255	WPARAM arg4,
1256	LPARAM arg5)
1257	{
1258	dprintf(("USER32: CallWindowProcW(%08xh,%08xh,%08xh,%08xh,%08xh) not properly implemented.\n",
1259	arg1,
1260	arg2,
1261	arg3,
1262	arg4,
1263	arg5));
1264
1265	return CallWindowProcA(arg1,
1266	arg2,
1267	arg3,
1268	arg4,
1269	arg5);
1270	}
1271	//******************************************************************************
1272	//******************************************************************************
1273	BOOL WIN32API ChangeClipboardChain( HWND arg1, HWND arg2)
1274	{
1275	#ifdef DEBUG
1276	WriteLog("USER32: ChangeClipboardChain\n");
1277	#endif
1278	return O32_ChangeClipboardChain(arg1, arg2);
1279	}
1280	//******************************************************************************
1281	//******************************************************************************
1282	UINT WIN32API ArrangeIconicWindows( HWND arg1)
1283	{
1284	#ifdef DEBUG
1285	WriteLog("USER32: ArrangeIconicWindows\n");
1286	#endif
1287	return O32_ArrangeIconicWindows(arg1);
1288	}
1289	//******************************************************************************
1290	// Not implemented by Open32 (5-31-99 Christoph Bratschi)
1291	// Quick and dirty implementation
1292	//******************************************************************************
1293	BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT arg4)
1294	{
1295	#ifdef DEBUG
1296	WriteLog("USER32: CheckRadioButton\n");
1297	#endif
1298	// return O32_CheckRadioButton(arg1, arg2, arg3, arg4);
1299	if (arg2 > arg3) return (FALSE);
1300	for (UINT x=arg2;x <= arg3;x++)
1301	{
1302	SendDlgItemMessageA(arg1,x,BM_SETCHECK,(x == arg4) ? BST_CHECKED : BST_UNCHECKED,0);
1303	}
1304	return (TRUE);
1305	}
1306	//******************************************************************************
1307	//******************************************************************************
1308	HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
1309	{
1310	#ifdef DEBUG
1311	WriteLog("USER32: ChildWindowFromPoint\n");
1312	#endif
1313	return O32_ChildWindowFromPoint(arg1, arg2);
1314	}
1315	//******************************************************************************
1316	//******************************************************************************
1317	HWND WIN32API ChildWindowFromPointEx(HWND arg1, POINT arg2, UINT uFlags)
1318	{
1319	#ifdef DEBUG
1320	WriteLog("USER32: ChildWindowFromPointEx, not completely supported!\n");
1321	#endif
1322	return O32_ChildWindowFromPoint(arg1, arg2);
1323	}
1324	//******************************************************************************
1325	//******************************************************************************
1326	BOOL WIN32API CloseClipboard(void)
1327	{
1328	#ifdef DEBUG
1329	WriteLog("USER32: CloseClipboard\n");
1330	#endif
1331	return O32_CloseClipboard();
1332	}
1333	//******************************************************************************
1334	//******************************************************************************
1335	BOOL WIN32API CloseWindow( HWND arg1)
1336	{
1337	#ifdef DEBUG
1338	WriteLog("USER32: CloseWindow\n");
1339	#endif
1340	return O32_CloseWindow(arg1);
1341	}
1342	//******************************************************************************
1343	//******************************************************************************
1344	HICON WIN32API CopyIcon( HICON arg1)
1345	{
1346	#ifdef DEBUG
1347	WriteLog("USER32: CopyIcon\n");
1348	#endif
1349	return O32_CopyIcon(arg1);
1350	}
1351	//******************************************************************************
1352	//******************************************************************************
1353	int WIN32API CountClipboardFormats(void)
1354	{
1355	#ifdef DEBUG
1356	WriteLog("USER32: CountClipboardFormats\n");
1357	#endif
1358	return O32_CountClipboardFormats();
1359	}
1360	//******************************************************************************
1361	//******************************************************************************
1362	HACCEL WIN32API CreateAcceleratorTableA( LPACCEL arg1, int arg2)
1363	{
1364	#ifdef DEBUG
1365	WriteLog("USER32: CreateAcceleratorTableA\n");
1366	#endif
1367	return O32_CreateAcceleratorTable(arg1, arg2);
1368	}
1369	//******************************************************************************
1370	//******************************************************************************
1371	HACCEL WIN32API CreateAcceleratorTableW( LPACCEL arg1, int arg2)
1372	{
1373	#ifdef DEBUG
1374	WriteLog("USER32: CreateAcceleratorTableW\n");
1375	#endif
1376	// NOTE: This will not work as is (needs UNICODE support)
1377	return O32_CreateAcceleratorTable(arg1, arg2);
1378	}
1379	//******************************************************************************
1380	//******************************************************************************
1381	BOOL WIN32API CreateCaret( HWND arg1, HBITMAP arg2, int arg3, int arg4)
1382	{
1383	#ifdef DEBUG
1384	WriteLog("USER32: CreateCaret\n");
1385	#endif
1386	return O32_CreateCaret(arg1, arg2, arg3, arg4);
1387	}
1388	//******************************************************************************
1389	//******************************************************************************
1390	HCURSOR WIN32API CreateCursor( HINSTANCE arg1, int arg2, int arg3, int arg4, int arg5, const VOID * arg6, const VOID * arg7)
1391	{
1392	#ifdef DEBUG
1393	WriteLog("USER32: CreateCursor\n");
1394	#endif
1395	return O32_CreateCursor(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1396	}
1397	//******************************************************************************
1398	//******************************************************************************
1399	HICON WIN32API CreateIcon( HINSTANCE arg1, INT arg2, INT arg3, BYTE arg4, BYTE arg5, LPCVOID arg6, LPCVOID arg7)
1400	{
1401	#ifdef DEBUG
1402	WriteLog("USER32: CreateIcon\n");
1403	#endif
1404	return O32_CreateIcon(arg1, arg2, arg3, arg4, arg5, (const BYTE )arg6, (const BYTE )arg7);
1405	}
1406	//******************************************************************************
1407	//ASSERT dwVer == win31 (ok according to SDK docs)
1408	//******************************************************************************
1409	HICON WIN32API CreateIconFromResource(PBYTE presbits, UINT dwResSize,
1410	BOOL fIcon, DWORD dwVer)
1411	{
1412	HICON hicon;
1413	DWORD OS2ResSize = 0;
1414	PBYTE OS2Icon = ConvertWin32Icon(presbits, dwResSize, &OS2ResSize);
1415
1416	hicon = O32_CreateIconFromResource(OS2Icon, OS2ResSize, fIcon, dwVer);
1417	#ifdef DEBUG
1418	WriteLog("USER32: CreateIconFromResource returned %X (%X)\n", hicon, GetLastError());
1419	#endif
1420	if(OS2Icon)
1421	FreeIcon(OS2Icon);
1422
1423	return(hicon);
1424	}
1425	//******************************************************************************
1426	//******************************************************************************
1427	HICON WIN32API CreateIconFromResourceEx(PBYTE presbits, UINT dwResSize,
1428	BOOL fIcon, DWORD dwVer,
1429	int cxDesired, int cyDesired,
1430	UINT Flags)
1431	{
1432	#ifdef DEBUG
1433	WriteLog("USER32: CreateIconFromResourceEx %X %d %d %X %d %d %X, not completely supported!\n", presbits, dwResSize, fIcon, dwVer, cxDesired, cyDesired, Flags);
1434	#endif
1435	return CreateIconFromResource(presbits, dwResSize, fIcon, dwVer);
1436	}
1437	//******************************************************************************
1438	//******************************************************************************
1439	HICON WIN32API CreateIconIndirect(LPICONINFO arg1)
1440	{
1441	#ifdef DEBUG
1442	WriteLog("USER32: CreateIconIndirect\n");
1443	#endif
1444	return O32_CreateIconIndirect(arg1);
1445	}
1446	//******************************************************************************
1447	//******************************************************************************
1448	HWND WIN32API CreateMDIWindowA(LPCSTR arg1, LPCSTR arg2, DWORD arg3,
1449	int arg4, int arg5, int arg6, int arg7,
1450	HWND arg8, HINSTANCE arg9, LPARAM arg10)
1451	{
1452	HWND hwnd;
1453
1454	#ifdef DEBUG
1455	WriteLog("USER32: CreateMDIWindowA\n");
1456	#endif
1457	Win32WindowProc *window = new Win32WindowProc(arg9, arg1);
1458	hwnd = O32_CreateMDIWindow((LPSTR)arg1, (LPSTR)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1459	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1460	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1461	delete(window);
1462	window = 0;
1463	}
1464
1465	#ifdef DEBUG
1466	WriteLog("USER32: CreateMDIWindowA returned %X\n", hwnd);
1467	#endif
1468	return hwnd;
1469	}
1470	//******************************************************************************
1471	//******************************************************************************
1472	HWND WIN32API CreateMDIWindowW(LPCWSTR arg1, LPCWSTR arg2, DWORD arg3, int arg4,
1473	int arg5, int arg6, int arg7, HWND arg8, HINSTANCE arg9,
1474	LPARAM arg10)
1475	{
1476	HWND hwnd;
1477	char astring1 = NULL, astring2 = NULL;
1478	Win32WindowProc *window = NULL;
1479
1480	if((int)arg1 >> 16 != 0) {
1481	astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1482	}
1483	else astring1 = (char *)arg2;
1484
1485	astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1486
1487	//Classname might be name of system class, in which case we don't
1488	//need to use our own callback
1489	// if(Win32WindowClass::FindClass((LPSTR)astring1) != NULL) {
1490	window = new Win32WindowProc(arg9, astring1);
1491	// }
1492	hwnd = O32_CreateMDIWindow(astring1, astring2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1493	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1494	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1495	delete(window);
1496	window = 0;
1497	}
1498	if(window) {
1499	window->SetWindowHandle(hwnd);
1500	}
1501
1502	if(astring1) FreeAsciiString(astring1);
1503	FreeAsciiString(astring2);
1504	#ifdef DEBUG
1505	WriteLog("USER32: CreateMDIWindowW hwnd = %X\n", hwnd);
1506	#endif
1507	return(hwnd);
1508	}
1509	//******************************************************************************
1510	//******************************************************************************
1511	HWND WIN32API CreateWindowExW(DWORD arg1,
1512	LPCWSTR arg2,
1513	LPCWSTR arg3,
1514	DWORD dwStyle,
1515	int arg5,
1516	int arg6,
1517	int arg7,
1518	int arg8,
1519	HWND arg9,
1520	HMENU arg10,
1521	HINSTANCE arg11,
1522	PVOID arg12)
1523	{
1524	HWND hwnd;
1525	char *astring1 = NULL,
1526	*astring2 = NULL;
1527	Win32WindowProc *window = NULL;
1528
1529	/* @@@PH 98/06/21 changed to call OS2CreateWindowExA */
1530	if((int)arg2 >> 16 != 0)
1531	astring1 = UnicodeToAsciiString((LPWSTR)arg2);
1532	else
1533	astring1 = (char *)arg2;
1534
1535	astring2 = UnicodeToAsciiString((LPWSTR)arg3);
1536
1537	#ifdef DEBUG
1538	WriteLog("USER32: CreateWindowExW: dwExStyle = %X\n", arg1);
1539	if((int)arg2 >> 16 != 0)
1540	WriteLog("USER32: CreateWindow: classname = %s\n", astring1);
1541	else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
1542	WriteLog("USER32: CreateWindow: windowname= %s\n", astring2);
1543	WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
1544	WriteLog("USER32: CreateWindow: x = %d\n", arg5);
1545	WriteLog("USER32: CreateWindow: y = %d\n", arg6);
1546	WriteLog("USER32: CreateWindow: nWidth = %d\n", arg7);
1547	WriteLog("USER32: CreateWindow: nHeight = %d\n", arg8);
1548	WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
1549	WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
1550	WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
1551	WriteLog("USER32: CreateWindow: param = %X\n", arg12);
1552	#endif
1553
1554	hwnd = CreateWindowExA(arg1,
1555	astring1,
1556	astring2,
1557	dwStyle,
1558	arg5,
1559	arg6,
1560	arg7,
1561	arg8,
1562	arg9,
1563	arg10,
1564	arg11,
1565	arg12);
1566
1567	if(astring1)
1568	FreeAsciiString(astring1);
1569
1570	FreeAsciiString(astring2);
1571
1572	#ifdef DEBUG
1573	WriteLog("USER32: ************CreateWindowExW hwnd = %X (%X)\n", hwnd, GetLastError());
1574	#endif
1575	return(hwnd);
1576	}
1577	//******************************************************************************
1578	//******************************************************************************
1579	HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
1580	{
1581	#ifdef DEBUG
1582	WriteLog("USER32: DeferWindowPos\n");
1583	#endif
1584	return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1585	}
1586	//******************************************************************************
1587	//******************************************************************************
1588	BOOL WIN32API DestroyAcceleratorTable( HACCEL arg1)
1589	{
1590	#ifdef DEBUG
1591	WriteLog("USER32: DestroyAcceleratorTable\n");
1592	#endif
1593	return O32_DestroyAcceleratorTable(arg1);
1594	}
1595	//******************************************************************************
1596	//******************************************************************************
1597	BOOL WIN32API DestroyCaret(void)
1598	{
1599	#ifdef DEBUG
1600	WriteLog("USER32: DestroyCaret\n");
1601	#endif
1602	return O32_DestroyCaret();
1603	}
1604	//******************************************************************************
1605	//******************************************************************************
1606	BOOL WIN32API DestroyCursor( HCURSOR arg1)
1607	{
1608	#ifdef DEBUG
1609	WriteLog("USER32: DestroyCursor\n");
1610	#endif
1611	return O32_DestroyCursor(arg1);
1612	}
1613	//******************************************************************************
1614	//******************************************************************************
1615	BOOL WIN32API DestroyIcon( HICON arg1)
1616	{
1617	#ifdef DEBUG
1618	WriteLog("USER32: DestroyIcon\n");
1619	#endif
1620	return O32_DestroyIcon(arg1);
1621	}
1622	//******************************************************************************
1623	//******************************************************************************
1624	LONG WIN32API DispatchMessageW( const MSG * arg1)
1625	{
1626	#ifdef DEBUG
1627	WriteLog("USER32: DispatchMessageW\n");
1628	#endif
1629	// NOTE: This will not work as is (needs UNICODE support)
1630	return O32_DispatchMessage(arg1);
1631	}
1632	//******************************************************************************
1633	//******************************************************************************
1634	int WIN32API DlgDirListA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1635	{
1636	#ifdef DEBUG
1637	WriteLog("USER32: DlgDirListA\n");
1638	#endif
1639	return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1640	}
1641	//******************************************************************************
1642	//******************************************************************************
1643	int WIN32API DlgDirListComboBoxA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1644	{
1645	#ifdef DEBUG
1646	WriteLog("USER32: DlgDirListComboBoxA\n");
1647	#endif
1648	return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1649	}
1650	//******************************************************************************
1651	//******************************************************************************
1652	int WIN32API DlgDirListComboBoxW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1653	{
1654	#ifdef DEBUG
1655	WriteLog("USER32: DlgDirListComboBoxW NOT WORKING\n");
1656	#endif
1657	// NOTE: This will not work as is (needs UNICODE support)
1658	return 0;
1659	// return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1660	}
1661	//******************************************************************************
1662	//******************************************************************************
1663	int WIN32API DlgDirListW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1664	{
1665	#ifdef DEBUG
1666	WriteLog("USER32: DlgDirListW NOT WORKING\n");
1667	#endif
1668	// NOTE: This will not work as is (needs UNICODE support)
1669	return 0;
1670	// return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1671	}
1672	//******************************************************************************
1673	//******************************************************************************
1674	BOOL WIN32API DlgDirSelectComboBoxExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1675	{
1676	#ifdef DEBUG
1677	WriteLog("USER32: DlgDirSelectComboBoxExA\n");
1678	#endif
1679	return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1680	}
1681	//******************************************************************************
1682	//******************************************************************************
1683	BOOL WIN32API DlgDirSelectComboBoxExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1684	{
1685	#ifdef DEBUG
1686	WriteLog("USER32: DlgDirSelectComboBoxExW NOT WORKING\n");
1687	#endif
1688	// NOTE: This will not work as is (needs UNICODE support)
1689	return 0;
1690	// return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1691	}
1692	//******************************************************************************
1693	//******************************************************************************
1694	BOOL WIN32API DlgDirSelectExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1695	{
1696	#ifdef DEBUG
1697	WriteLog("USER32: DlgDirSelectExA\n");
1698	#endif
1699	return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1700	}
1701	//******************************************************************************
1702	//******************************************************************************
1703	BOOL WIN32API DlgDirSelectExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1704	{
1705	#ifdef DEBUG
1706	WriteLog("USER32: DlgDirSelectExW NOT WORKING\n");
1707	#endif
1708	// NOTE: This will not work as is (needs UNICODE support)
1709	return 0;
1710	// return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1711	}
1712	//******************************************************************************
1713	//******************************************************************************
1714	BOOL WIN32API DrawFocusRect( HDC arg1, const RECT * arg2)
1715	{
1716	#ifdef DEBUG
1717	WriteLog("USER32: DrawFocusRect\n");
1718	#endif
1719	return O32_DrawFocusRect(arg1, arg2);
1720	}
1721	//******************************************************************************
1722	//******************************************************************************
1723	BOOL WIN32API DrawIcon( HDC arg1, int arg2, int arg3, HICON arg4)
1724	{
1725	#ifdef DEBUG
1726	WriteLog("USER32: DrawIcon\n");
1727	#endif
1728	return O32_DrawIcon(arg1, arg2, arg3, arg4);
1729	}
1730	//******************************************************************************
1731	//******************************************************************************
1732	BOOL WIN32API DrawIconEx(HDC hdc, int xLeft, int xRight, HICON hIcon,
1733	int cxWidth, int cyWidth, UINT istepIfAniCur,
1734	HBRUSH hbrFlickerFreeDraw, UINT diFlags)
1735	{
1736	#ifdef DEBUG
1737	WriteLog("USER32: DrawIcon, partially implemented\n");
1738	#endif
1739	return O32_DrawIcon(hdc, xLeft, xRight, hIcon);
1740	}
1741	//******************************************************************************
1742	//******************************************************************************
1743	BOOL WIN32API DrawMenuBar( HWND arg1)
1744	{
1745	#ifdef DEBUG
1746	WriteLog("USER32: DrawMenuBar\n");
1747	#endif
1748	return O32_DrawMenuBar(arg1);
1749	}
1750	//******************************************************************************
1751	//******************************************************************************
1752	int WIN32API DrawTextW( HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5)
1753	{
1754	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1755	int rc;
1756
1757	#ifdef DEBUG
1758	WriteLog("USER32: DrawTextW %s\n", astring);
1759	#endif
1760	rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1761	FreeAsciiString(astring);
1762	return(rc);
1763	}
1764	//******************************************************************************
1765	//******************************************************************************
1766	int WIN32API DrawTextExW(HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
1767	{
1768	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1769	int rc;
1770
1771	#ifdef DEBUG
1772	WriteLog("USER32: DrawTextExW (not completely supported) %s\n", astring);
1773	#endif
1774	rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1775	FreeAsciiString(astring);
1776	return(rc);
1777	}
1778	//******************************************************************************
1779	//******************************************************************************
1780	BOOL WIN32API EmptyClipboard(void)
1781	{
1782	#ifdef DEBUG
1783	WriteLog("USER32: EmptyClipboard\n");
1784	#endif
1785	return O32_EmptyClipboard();
1786	}
1787	//******************************************************************************
1788	//******************************************************************************
1789	BOOL WIN32API EndDeferWindowPos( HDWP arg1)
1790	{
1791	#ifdef DEBUG
1792	WriteLog("USER32: EndDeferWindowPos\n");
1793	#endif
1794	return O32_EndDeferWindowPos(arg1);
1795	}
1796	//******************************************************************************
1797	//******************************************************************************
1798	BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1799	{
1800	BOOL rc;
1801	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1802
1803	#ifdef DEBUG
1804	WriteLog("USER32: EnumChildWindows\n");
1805	#endif
1806	rc = O32_EnumChildWindows(hwnd, callback->GetOS2Callback(), (LPARAM)callback);
1807	if(callback)
1808	delete callback;
1809	return(rc);
1810	}
1811	//******************************************************************************
1812	//******************************************************************************
1813	UINT WIN32API EnumClipboardFormats(UINT arg1)
1814	{
1815	#ifdef DEBUG
1816	WriteLog("USER32: EnumClipboardFormats\n");
1817	#endif
1818	return O32_EnumClipboardFormats(arg1);
1819	}
1820	//******************************************************************************
1821	//******************************************************************************
1822	int WIN32API EnumPropsA(HWND arg1, PROPENUMPROCA arg2)
1823	{
1824	#ifdef DEBUG
1825	WriteLog("USER32: EnumPropsA DOES NOT WORK\n");
1826	#endif
1827	//calling convention problems
1828	return 0;
1829	// return O32_EnumProps(arg1, (PROPENUMPROC_O32)arg2);
1830	}
1831	//******************************************************************************
1832	//******************************************************************************
1833	int WIN32API EnumPropsExA( HWND arg1, PROPENUMPROCEXA arg2, LPARAM arg3)
1834	{
1835	#ifdef DEBUG
1836	WriteLog("USER32: EnumPropsExA DOES NOT WORK\n");
1837	#endif
1838	//calling convention problems
1839	return 0;
1840	// return O32_EnumPropsEx(arg1, arg2, (PROPENUMPROCEX_O32)arg3);
1841	}
1842	//******************************************************************************
1843	//******************************************************************************
1844	int WIN32API EnumPropsExW( HWND arg1, PROPENUMPROCEXW arg2, LPARAM arg3)
1845	{
1846	#ifdef DEBUG
1847	WriteLog("USER32: EnumPropsExW\n");
1848	#endif
1849	// NOTE: This will not work as is (needs UNICODE support)
1850	//calling convention problems
1851	return 0;
1852	// return O32_EnumPropsEx(arg1, arg2, arg3);
1853	}
1854	//******************************************************************************
1855	//******************************************************************************
1856	int WIN32API EnumPropsW( HWND arg1, PROPENUMPROCW arg2)
1857	{
1858	#ifdef DEBUG
1859	WriteLog("USER32: EnumPropsW\n");
1860	#endif
1861	// NOTE: This will not work as is (needs UNICODE support)
1862	//calling convention problems
1863	return 0;
1864	// return O32_EnumProps(arg1, arg2);
1865	}
1866	//******************************************************************************
1867	//******************************************************************************
1868	BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1869	{
1870	BOOL rc;
1871	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1872
1873	#ifdef DEBUG
1874	WriteLog("USER32: EnumWindows\n");
1875	#endif
1876	rc = O32_EnumWindows(callback->GetOS2Callback(), (LPARAM)callback);
1877	if(callback)
1878	delete callback;
1879	return(rc);
1880	}
1881	//******************************************************************************
1882	//******************************************************************************
1883	BOOL WIN32API EqualRect( const RECT * arg1, const RECT * arg2)
1884	{
1885	#ifdef DEBUG
1886	WriteLog("USER32: EqualRect\n");
1887	#endif
1888	return O32_EqualRect(arg1, arg2);
1889	}
1890	//******************************************************************************
1891	//******************************************************************************
1892	BOOL WIN32API ExcludeUpdateRgn( HDC arg1, HWND arg2)
1893	{
1894	#ifdef DEBUG
1895	WriteLog("USER32: ExcludeUpdateRgn\n");
1896	#endif
1897	return O32_ExcludeUpdateRgn(arg1, arg2);
1898	}
1899	//******************************************************************************
1900	//******************************************************************************
1901	BOOL WIN32API ExitWindowsEx( UINT arg1, DWORD arg2)
1902	{
1903	#ifdef DEBUG
1904	WriteLog("USER32: ExitWindowsEx\n");
1905	#endif
1906	return O32_ExitWindowsEx(arg1, arg2);
1907	}
1908	//******************************************************************************
1909	//******************************************************************************
1910	int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
1911	{
1912	#ifdef DEBUG
1913	WriteLog("USER32: FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
1914	#endif
1915	return O32_FillRect(arg1, arg2, arg3);
1916	}
1917	//******************************************************************************
1918	//******************************************************************************
1919	HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
1920	{
1921	char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1922	char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1923	HWND rc;
1924
1925	#ifdef DEBUG
1926	WriteLog("USER32: FindWindowW\n");
1927	#endif
1928	rc = O32_FindWindow(astring1, astring2);
1929	FreeAsciiString(astring1);
1930	FreeAsciiString(astring2);
1931	return rc;
1932	}
1933	//******************************************************************************
1934	//******************************************************************************
1935	int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH arg3)
1936	{
1937	#ifdef DEBUG
1938	WriteLog("USER32: FrameRect\n");
1939	#endif
1940	return O32_FrameRect(arg1, arg2, arg3);
1941	}
1942	//******************************************************************************
1943	//******************************************************************************
1944	HWND WIN32API GetCapture(void)
1945	{
1946	#ifdef DEBUG
1947	WriteLog("USER32: GetCapture\n");
1948	#endif
1949	return O32_GetCapture();
1950	}
1951	//******************************************************************************
1952	//******************************************************************************
1953	UINT WIN32API GetCaretBlinkTime(void)
1954	{
1955	#ifdef DEBUG
1956	WriteLog("USER32: GetCaretBlinkTime\n");
1957	#endif
1958	return O32_GetCaretBlinkTime();
1959	}
1960	//******************************************************************************
1961	//******************************************************************************
1962	BOOL WIN32API GetCaretPos( PPOINT arg1)
1963	{
1964	#ifdef DEBUG
1965	WriteLog("USER32: GetCaretPos\n");
1966	#endif
1967	return O32_GetCaretPos(arg1);
1968	}
1969	//******************************************************************************
1970	//******************************************************************************
1971	BOOL WIN32API GetClipCursor( PRECT arg1)
1972	{
1973	#ifdef DEBUG
1974	WriteLog("USER32: GetClipCursor\n");
1975	#endif
1976	return O32_GetClipCursor(arg1);
1977	}
1978	//******************************************************************************
1979	//******************************************************************************
1980	HANDLE WIN32API GetClipboardData( UINT arg1)
1981	{
1982	#ifdef DEBUG
1983	WriteLog("USER32: GetClipboardData\n");
1984	#endif
1985	return O32_GetClipboardData(arg1);
1986	}
1987	//******************************************************************************
1988	//******************************************************************************
1989	int WIN32API GetClipboardFormatNameA( UINT arg1, LPSTR arg2, int arg3)
1990	{
1991	#ifdef DEBUG
1992	WriteLog("USER32: GetClipboardFormatNameA %s\n", arg2);
1993	#endif
1994	return O32_GetClipboardFormatName(arg1, arg2, arg3);
1995	}
1996	//******************************************************************************
1997	//******************************************************************************
1998	int WIN32API GetClipboardFormatNameW(UINT arg1, LPWSTR arg2, int arg3)
1999	{
2000	int rc;
2001	char *astring = UnicodeToAsciiString(arg2);
2002
2003	#ifdef DEBUG
2004	WriteLog("USER32: GetClipboardFormatNameW %s\n", astring);
2005	#endif
2006	rc = O32_GetClipboardFormatName(arg1, astring, arg3);
2007	FreeAsciiString(astring);
2008	return(rc);
2009	}
2010	//******************************************************************************
2011	//******************************************************************************
2012	HWND WIN32API GetClipboardOwner(void)
2013	{
2014	#ifdef DEBUG
2015	WriteLog("USER32: GetClipboardOwner\n");
2016	#endif
2017	return O32_GetClipboardOwner();
2018	}
2019	//******************************************************************************
2020	//******************************************************************************
2021	HWND WIN32API GetClipboardViewer(void)
2022	{
2023	#ifdef DEBUG
2024	WriteLog("USER32: GetClipboardViewer\n");
2025	#endif
2026	return O32_GetClipboardViewer();
2027	}
2028	//******************************************************************************
2029	//******************************************************************************
2030	DWORD WIN32API GetDialogBaseUnits(void)
2031	{
2032	#ifdef DEBUG
2033	WriteLog("USER32: GetDialogBaseUnits\n");
2034	#endif
2035	return O32_GetDialogBaseUnits();
2036	}
2037	//******************************************************************************
2038	//******************************************************************************
2039	UINT WIN32API GetDlgItemInt( HWND arg1, int arg2, PBOOL arg3, BOOL arg4)
2040	{
2041	#ifdef DEBUG
2042	WriteLog("USER32: GetDlgItemInt\n");
2043	#endif
2044	return O32_GetDlgItemInt(arg1, arg2, arg3, arg4);
2045	}
2046	//******************************************************************************
2047	//******************************************************************************
2048	UINT WIN32API GetDlgItemTextW( HWND arg1, int arg2, LPWSTR arg3, UINT arg4)
2049	{
2050	#ifdef DEBUG
2051	WriteLog("USER32: GetDlgItemTextW NOT WORKING\n");
2052	#endif
2053	// NOTE: This will not work as is (needs UNICODE support)
2054	return 0;
2055	// return O32_GetDlgItemText(arg1, arg2, arg3, arg4);
2056	}
2057	//******************************************************************************
2058	//******************************************************************************
2059	UINT WIN32API GetDoubleClickTime(void)
2060	{
2061	#ifdef DEBUG
2062	WriteLog("USER32: GetDoubleClickTime\n");
2063	#endif
2064	return O32_GetDoubleClickTime();
2065	}
2066	//******************************************************************************
2067	//******************************************************************************
2068	HWND WIN32API GetForegroundWindow(void)
2069	{
2070	#ifdef DEBUG
2071	WriteLog("USER32: GetForegroundWindow\n");
2072	#endif
2073	return O32_GetForegroundWindow();
2074	}
2075	//******************************************************************************
2076	//******************************************************************************
2077	BOOL WIN32API GetIconInfo( HICON arg1, LPICONINFO arg2)
2078	{
2079	#ifdef DEBUG
2080	WriteLog("USER32: GetIconInfo\n");
2081	#endif
2082	return O32_GetIconInfo(arg1, arg2);
2083	}
2084	//******************************************************************************
2085	//******************************************************************************
2086	int WIN32API GetKeyNameTextA( LPARAM arg1, LPSTR arg2, int arg3)
2087	{
2088	#ifdef DEBUG
2089	WriteLog("USER32: GetKeyNameTextA\n");
2090	#endif
2091	return O32_GetKeyNameText(arg1, arg2, arg3);
2092	}
2093	//******************************************************************************
2094	//******************************************************************************
2095	int WIN32API GetKeyNameTextW( LPARAM arg1, LPWSTR arg2, int arg3)
2096	{
2097	#ifdef DEBUG
2098	WriteLog("USER32: GetKeyNameTextW DOES NOT WORK\n");
2099	#endif
2100	// NOTE: This will not work as is (needs UNICODE support)
2101	return 0;
2102	// return O32_GetKeyNameText(arg1, arg2, arg3);
2103	}
2104	//******************************************************************************
2105	//******************************************************************************
2106	int WIN32API GetKeyboardType( int arg1)
2107	{
2108	#ifdef DEBUG
2109	WriteLog("USER32: GetKeyboardType\n");
2110	#endif
2111	return O32_GetKeyboardType(arg1);
2112	}
2113	//******************************************************************************
2114	//******************************************************************************
2115	HWND WIN32API GetLastActivePopup( HWND arg1)
2116	{
2117	#ifdef DEBUG
2118	WriteLog("USER32: GetLastActivePopup\n");
2119	#endif
2120	return O32_GetLastActivePopup(arg1);
2121	}
2122	//******************************************************************************
2123	//******************************************************************************
2124	LONG WIN32API GetMessageExtraInfo(void)
2125	{
2126	dprintf(("USER32: GetMessageExtraInfo\n"));
2127	return O32_GetMessageExtraInfo();
2128	}
2129	//******************************************************************************
2130	//******************************************************************************
2131	DWORD WIN32API GetMessagePos(void)
2132	{
2133	dprintf(("USER32: GetMessagePos\n"));
2134	return O32_GetMessagePos();
2135	}
2136	//******************************************************************************
2137	//******************************************************************************
2138	LONG WIN32API GetMessageTime(void)
2139	{
2140	dprintf(("USER32: GetMessageTime\n"));
2141	return O32_GetMessageTime();
2142	}
2143	//******************************************************************************
2144	//******************************************************************************
2145	BOOL WIN32API GetMessageW(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
2146	{
2147	BOOL rc;
2148
2149	// NOTE: This will not work as is (needs UNICODE support)
2150	rc = O32_GetMessage(arg1, arg2, arg3, arg4);
2151	dprintf(("USER32: GetMessageW %X returned %d\n", arg2, rc));
2152	return(rc);
2153	}
2154	//******************************************************************************
2155	//******************************************************************************
2156	HWND WIN32API GetNextDlgGroupItem( HWND arg1, HWND arg2, BOOL arg3)
2157	{
2158	#ifdef DEBUG
2159	WriteLog("USER32: GetNextDlgGroupItem\n");
2160	#endif
2161	return O32_GetNextDlgGroupItem(arg1, arg2, arg3);
2162	}
2163	//******************************************************************************
2164	//******************************************************************************
2165	HWND WIN32API GetOpenClipboardWindow(void)
2166	{
2167	#ifdef DEBUG
2168	WriteLog("USER32: GetOpenClipboardWindow\n");
2169	#endif
2170	return O32_GetOpenClipboardWindow();
2171	}
2172	//******************************************************************************
2173	//******************************************************************************
2174	HWND WIN32API GetParent( HWND arg1)
2175	{
2176	#ifdef DEBUG
2177	//// WriteLog("USER32: GetParent\n");
2178	#endif
2179	return O32_GetParent(arg1);
2180	}
2181	//******************************************************************************
2182	//******************************************************************************
2183	int WIN32API GetPriorityClipboardFormat( PUINT arg1, int arg2)
2184	{
2185	#ifdef DEBUG
2186	WriteLog("USER32: GetPriorityClipboardFormat\n");
2187	#endif
2188	return O32_GetPriorityClipboardFormat(arg1, arg2);
2189	}
2190	//******************************************************************************
2191	//******************************************************************************
2192	HANDLE WIN32API GetPropA( HWND arg1, LPCSTR arg2)
2193	{
2194	#ifdef DEBUG
2195	if((int)arg2 >> 16 != 0)
2196	WriteLog("USER32: GetPropA %s\n", arg2);
2197	else WriteLog("USER32: GetPropA %X\n", arg2);
2198	#endif
2199	return O32_GetProp(arg1, arg2);
2200	}
2201	//******************************************************************************
2202	//******************************************************************************
2203	HANDLE WIN32API GetPropW(HWND arg1, LPCWSTR arg2)
2204	{
2205	BOOL handle;
2206	char *astring;
2207
2208	if((int)arg2 >> 16 != 0)
2209	astring = UnicodeToAsciiString((LPWSTR)arg2);
2210	else astring = (char *)arg2;
2211	#ifdef DEBUG
2212	if((int)arg2 >> 16 != 0)
2213	WriteLog("USER32: GetPropW %s\n", astring);
2214	else WriteLog("USER32: GetPropW %X\n", astring);
2215	#endif
2216	handle = GetPropA(arg1, (LPCSTR)astring);
2217	if((int)arg2 >> 16 != 0)
2218	FreeAsciiString(astring);
2219
2220	return(handle);
2221	}
2222	//******************************************************************************
2223	//******************************************************************************
2224	DWORD WIN32API GetQueueStatus( UINT arg1)
2225	{
2226	#ifdef DEBUG
2227	WriteLog("USER32: GetQueueStatus\n");
2228	#endif
2229	return O32_GetQueueStatus(arg1);
2230	}
2231	//******************************************************************************
2232	//******************************************************************************
2233	int WIN32API GetScrollPos(HWND hwnd, int fnBar)
2234	{
2235	int pos;
2236
2237	pos = O32_GetScrollPos(hwnd, fnBar);
2238	#ifdef DEBUG
2239	WriteLog("USER32: GetScrollPos of %X type %d returned %d\n", hwnd, fnBar, pos);
2240	#endif
2241	return(pos);
2242	}
2243	//******************************************************************************
2244	//******************************************************************************
2245	BOOL WIN32API GetScrollRange( HWND arg1, int arg2, int * arg3, int * arg4)
2246	{
2247	#ifdef DEBUG
2248	WriteLog("USER32: GetScrollRange\n");
2249	#endif
2250	return O32_GetScrollRange(arg1, arg2, arg3, arg4);
2251	}
2252	//******************************************************************************
2253	//******************************************************************************
2254	DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
2255	{
2256	#ifdef DEBUG
2257	WriteLog("USER32: GetTabbedTextExtentA\n");
2258	#endif
2259	return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
2260	}
2261	//******************************************************************************
2262	//******************************************************************************
2263	DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
2264	{
2265	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2266	DWORD rc;
2267
2268	#ifdef DEBUG
2269	WriteLog("USER32: GetTabbedTextExtentW\n");
2270	#endif
2271	rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
2272	FreeAsciiString(astring);
2273	return rc;
2274	}
2275	//******************************************************************************
2276	//******************************************************************************
2277	HWND WIN32API GetTopWindow( HWND arg1)
2278	{
2279	#ifdef DEBUG
2280	//// WriteLog("USER32: GetTopWindow\n");
2281	#endif
2282	return O32_GetTopWindow(arg1);
2283	}
2284	//******************************************************************************
2285	//******************************************************************************
2286	int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2287	{
2288	#ifdef DEBUG
2289	WriteLog("USER32: GetUpdateRgn\n");
2290	#endif
2291	return O32_GetUpdateRgn(arg1, arg2, arg3);
2292	}
2293	//******************************************************************************
2294	//******************************************************************************
2295	LONG WIN32API GetWindowLongW( HWND arg1, int arg2)
2296	{
2297	#ifdef DEBUG
2298	WriteLog("USER32: GetWindowLongW\n");
2299	#endif
2300	return GetWindowLongA(arg1, arg2); //class procedures..
2301	}
2302	//******************************************************************************
2303	//******************************************************************************
2304	BOOL WIN32API GetWindowPlacement( HWND arg1, LPWINDOWPLACEMENT arg2)
2305	{
2306	#ifdef DEBUG
2307	WriteLog("USER32: GetWindowPlacement\n");
2308	#endif
2309	return O32_GetWindowPlacement(arg1, arg2);
2310	}
2311	//******************************************************************************
2312
2313	/***********************************************************************
2314	* GetInternalWindowPos (USER32.245)
2315	*/
2316	UINT WIN32API GetInternalWindowPos(HWND hwnd,
2317	LPRECT rectWnd,
2318	LPPOINT ptIcon )
2319	{
2320	WINDOWPLACEMENT wndpl;
2321
2322	dprintf(("USER32: GetInternalWindowPos(%08xh,%08xh,%08xh)\n",
2323	hwnd,
2324	rectWnd,
2325	ptIcon));
2326
2327	if (O32_GetWindowPlacement( hwnd, &wndpl ))
2328	{
2329	if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
2330	if (ptIcon) *ptIcon = wndpl.ptMinPosition;
2331	return wndpl.showCmd;
2332	}
2333	return 0;
2334	}
2335
2336
2337	//******************************************************************************
2338	int WIN32API GetWindowTextLengthW( HWND arg1)
2339	{
2340	#ifdef DEBUG
2341	WriteLog("USER32: GetWindowTextLengthW\n");
2342	#endif
2343	return O32_GetWindowTextLength(arg1);
2344	}
2345	//******************************************************************************
2346	//******************************************************************************
2347	int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
2348	{
2349	char title[128];
2350	int rc;
2351
2352	rc = O32_GetWindowText(hwnd, title, sizeof(title));
2353	#ifdef DEBUG
2354	WriteLog("USER32: GetWindowTextW returned %s\n", title);
2355	#endif
2356	if(rc > cch) {
2357	title[cch-1] = 0;
2358	rc = cch;
2359	}
2360	AsciiToUnicode(title, lpsz);
2361	return(rc);
2362	}
2363	//******************************************************************************
2364	//******************************************************************************
2365	DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD arg2)
2366	{
2367	#ifdef DEBUG
2368	WriteLog("USER32: GetWindowThreadProcessId\n");
2369	#endif
2370	return O32_GetWindowThreadProcessId(arg1, arg2);
2371	}
2372	//******************************************************************************
2373	//******************************************************************************
2374	WORD WIN32API GetWindowWord( HWND arg1, int arg2)
2375	{
2376	#ifdef DEBUG
2377	WriteLog("USER32: GetWindowWord\n");
2378	#endif
2379	return O32_GetWindowWord(arg1, arg2);
2380	}
2381	//******************************************************************************
2382	//******************************************************************************
2383	BOOL WIN32API HideCaret( HWND arg1)
2384	{
2385	#ifdef DEBUG
2386	WriteLog("USER32: HideCaret\n");
2387	#endif
2388	return O32_HideCaret(arg1);
2389	}
2390	//******************************************************************************
2391	//******************************************************************************
2392	BOOL WIN32API InSendMessage(void)
2393	{
2394	#ifdef DEBUG
2395	WriteLog("USER32: InSendMessage\n");
2396	#endif
2397	return O32_InSendMessage();
2398	}
2399	//******************************************************************************
2400	//******************************************************************************
2401	BOOL WIN32API IntersectRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
2402	{
2403	#ifdef DEBUG
2404	//// WriteLog("USER32: IntersectRect\n");
2405	#endif
2406	return O32_IntersectRect(arg1, arg2, arg3);
2407	}
2408	//******************************************************************************
2409	//******************************************************************************
2410	BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2411	{
2412	#ifdef DEBUG
2413	WriteLog("USER32: InvalidateRgn\n");
2414	#endif
2415	return O32_InvalidateRgn(arg1, arg2, arg3);
2416	}
2417	//******************************************************************************
2418	//******************************************************************************
2419	BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
2420	{
2421	#ifdef DEBUG
2422	WriteLog("USER32: InvertRect\n");
2423	#endif
2424	return O32_InvertRect(arg1, arg2);
2425	}
2426	//******************************************************************************
2427	//******************************************************************************
2428	BOOL WIN32API IsChild( HWND arg1, HWND arg2)
2429	{
2430	#ifdef DEBUG
2431	WriteLog("USER32: IsChild\n");
2432	#endif
2433	return O32_IsChild(arg1, arg2);
2434	}
2435	//******************************************************************************
2436	//******************************************************************************
2437	BOOL WIN32API IsClipboardFormatAvailable( UINT arg1)
2438	{
2439	#ifdef DEBUG
2440	WriteLog("USER32: IsClipboardFormatAvailable\n");
2441	#endif
2442	return O32_IsClipboardFormatAvailable(arg1);
2443	}
2444	//******************************************************************************
2445	//******************************************************************************
2446	BOOL WIN32API IsDialogMessageW( HWND arg1, LPMSG arg2)
2447	{
2448	#ifdef DEBUG
2449	WriteLog("USER32: IsDialogMessageW\n");
2450	#endif
2451	// NOTE: This will not work as is (needs UNICODE support)
2452	return O32_IsDialogMessage(arg1, arg2);
2453	}
2454	//******************************************************************************
2455	//******************************************************************************
2456	BOOL WIN32API IsRectEmpty( const RECT * arg1)
2457	{
2458	#ifdef DEBUG
2459	WriteLog("USER32: IsRectEmpty\n");
2460	#endif
2461	return O32_IsRectEmpty(arg1);
2462	}
2463	//******************************************************************************
2464	//******************************************************************************
2465	BOOL WIN32API IsWindow( HWND arg1)
2466	{
2467	#ifdef DEBUG
2468	WriteLog("USER32: IsWindow\n");
2469	#endif
2470	return O32_IsWindow(arg1);
2471	}
2472	//******************************************************************************
2473	//******************************************************************************
2474	BOOL WIN32API IsWindowEnabled( HWND arg1)
2475	{
2476	#ifdef DEBUG
2477	WriteLog("USER32: IsWindowEnabled\n");
2478	#endif
2479	return O32_IsWindowEnabled(arg1);
2480	}
2481	//******************************************************************************
2482	//******************************************************************************
2483	BOOL WIN32API IsWindowVisible( HWND arg1)
2484	{
2485	#ifdef DEBUG
2486	WriteLog("USER32: IsWindowVisible\n");
2487	#endif
2488	return O32_IsWindowVisible(arg1);
2489	}
2490	//******************************************************************************
2491	//******************************************************************************
2492	BOOL WIN32API IsZoomed( HWND arg1)
2493	{
2494	#ifdef DEBUG
2495	WriteLog("USER32: IsZoomed\n");
2496	#endif
2497	return O32_IsZoomed(arg1);
2498	}
2499	//******************************************************************************
2500	//******************************************************************************
2501	BOOL WIN32API LockWindowUpdate( HWND arg1)
2502	{
2503	#ifdef DEBUG
2504	WriteLog("USER32: LockWindowUpdate\n");
2505	#endif
2506	return O32_LockWindowUpdate(arg1);
2507	}
2508	//******************************************************************************
2509	//******************************************************************************
2510	BOOL WIN32API MapDialogRect( HWND arg1, PRECT arg2)
2511	{
2512	#ifdef DEBUG
2513	WriteLog("USER32: MapDialogRect\n");
2514	#endif
2515	return O32_MapDialogRect(arg1, arg2);
2516	}
2517	//******************************************************************************
2518	//******************************************************************************
2519	UINT WIN32API MapVirtualKeyA( UINT arg1, UINT arg2)
2520	{
2521	#ifdef DEBUG
2522	WriteLog("USER32: MapVirtualKeyA\n");
2523	#endif
2524	return O32_MapVirtualKey(arg1, arg2);
2525	}
2526	//******************************************************************************
2527	//******************************************************************************
2528	UINT WIN32API MapVirtualKeyW( UINT arg1, UINT arg2)
2529	{
2530	#ifdef DEBUG
2531	WriteLog("USER32: MapVirtualKeyW\n");
2532	#endif
2533	// NOTE: This will not work as is (needs UNICODE support)
2534	return O32_MapVirtualKey(arg1, arg2);
2535	}
2536	//******************************************************************************
2537	//******************************************************************************
2538	int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
2539	{
2540	#ifdef DEBUG
2541	WriteLog("USER32: MapWindowPoints\n");
2542	#endif
2543	return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
2544	}
2545	//******************************************************************************
2546	//******************************************************************************
2547	int WIN32API MessageBoxW(HWND arg1, LPCWSTR arg2, LPCWSTR arg3, UINT arg4)
2548	{
2549	char astring1, astring2;
2550	int rc;
2551
2552	astring1 = UnicodeToAsciiString((LPWSTR)arg2);
2553	astring2 = UnicodeToAsciiString((LPWSTR)arg3);
2554	#ifdef DEBUG
2555	WriteLog("USER32: MessageBoxW %s %s\n", astring1, astring2);
2556	#endif
2557	rc = O32_MessageBox(arg1, astring1, astring2, arg4);
2558	FreeAsciiString(astring1);
2559	FreeAsciiString(astring2);
2560	return(rc);
2561	}
2562	//******************************************************************************
2563	//******************************************************************************
2564	BOOL WIN32API OpenClipboard( HWND arg1)
2565	{
2566	#ifdef DEBUG
2567	WriteLog("USER32: OpenClipboard\n");
2568	#endif
2569	return O32_OpenClipboard(arg1);
2570	}
2571	//******************************************************************************
2572	//******************************************************************************
2573	BOOL WIN32API PeekMessageW( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
2574	{
2575	#ifdef DEBUG
2576	WriteLog("USER32: PeekMessageW\n");
2577	#endif
2578	// NOTE: This will not work as is (needs UNICODE support)
2579	return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
2580	}
2581	//******************************************************************************
2582	//******************************************************************************
2583	// NOTE: Open32 function doesn't have the 'W'.
2584	BOOL WIN32API PostMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2585	{
2586	#ifdef DEBUG
2587	WriteLog("USER32: PostMessageW\n");
2588	#endif
2589	// NOTE: This will not work as is (needs UNICODE support)
2590	return O32_PostMessage(arg1, arg2, arg3, arg4);
2591	}
2592	//******************************************************************************
2593	//******************************************************************************
2594	BOOL WIN32API PostThreadMessageA( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2595	{
2596	#ifdef DEBUG
2597	WriteLog("USER32: PostThreadMessageA\n");
2598	#endif
2599	return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2600	}
2601	//******************************************************************************
2602	//******************************************************************************
2603	BOOL WIN32API PostThreadMessageW( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2604	{
2605	#ifdef DEBUG
2606	WriteLog("USER32: PostThreadMessageW\n");
2607	#endif
2608	// NOTE: This will not work as is (needs UNICODE support)
2609	return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2610	}
2611	//******************************************************************************
2612	//******************************************************************************
2613	BOOL WIN32API PtInRect( const RECT * arg1, POINT arg2)
2614	{
2615	#ifdef DEBUG
2616	WriteLog("USER32: PtInRect\n");
2617	#endif
2618	return O32_PtInRect(arg1, arg2);
2619	}
2620	//******************************************************************************
2621	//******************************************************************************
2622	BOOL WIN32API RedrawWindow( HWND arg1, const RECT * arg2, HRGN arg3, UINT arg4)
2623	{
2624	BOOL rc;
2625
2626	rc = O32_RedrawWindow(arg1, arg2, arg3, arg4);
2627	#ifdef DEBUG
2628	WriteLog("USER32: RedrawWindow %X , %X, %X, %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2629	#endif
2630	InvalidateRect(arg1, arg2, TRUE);
2631	UpdateWindow(arg1);
2632	SendMessageA(arg1, WM_PAINT, 0, 0);
2633	return(rc);
2634	}
2635	//******************************************************************************
2636	//******************************************************************************
2637	UINT WIN32API RegisterClipboardFormatA( LPCSTR arg1)
2638	{
2639	#ifdef DEBUG
2640	WriteLog("USER32: RegisterClipboardFormatA\n");
2641	#endif
2642	return O32_RegisterClipboardFormat(arg1);
2643	}
2644	//******************************************************************************
2645	//******************************************************************************
2646	UINT WIN32API RegisterClipboardFormatW(LPCWSTR arg1)
2647	{
2648	UINT rc;
2649	char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2650
2651	#ifdef DEBUG
2652	WriteLog("USER32: RegisterClipboardFormatW %s\n", astring);
2653	#endif
2654	rc = O32_RegisterClipboardFormat(astring);
2655	FreeAsciiString(astring);
2656	#ifdef DEBUG
2657	WriteLog("USER32: RegisterClipboardFormatW returned %d\n", rc);
2658	#endif
2659	return(rc);
2660	}
2661	//******************************************************************************
2662	//******************************************************************************
2663	UINT WIN32API RegisterWindowMessageW( LPCWSTR arg1)
2664	{
2665	char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2666	UINT rc;
2667
2668	#ifdef DEBUG
2669	WriteLog("USER32: RegisterWindowMessageW\n");
2670	#endif
2671	rc = O32_RegisterWindowMessage(astring);
2672	FreeAsciiString(astring);
2673	return rc;
2674	}
2675	//******************************************************************************
2676	//******************************************************************************
2677	HANDLE WIN32API RemovePropA( HWND arg1, LPCSTR arg2)
2678	{
2679	#ifdef DEBUG
2680	WriteLog("USER32: RemovePropA\n");
2681	#endif
2682	return O32_RemoveProp(arg1, arg2);
2683	}
2684	//******************************************************************************
2685	//******************************************************************************
2686	HANDLE WIN32API RemovePropW( HWND arg1, LPCWSTR arg2)
2687	{
2688	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2689	HANDLE rc;
2690
2691	#ifdef DEBUG
2692	WriteLog("USER32: RemovePropW\n");
2693	#endif
2694	rc = O32_RemoveProp(arg1, astring);
2695	FreeAsciiString(astring);
2696	return rc;
2697	}
2698	//******************************************************************************
2699	//******************************************************************************
2700	BOOL WIN32API ReplyMessage( LRESULT arg1)
2701	{
2702	#ifdef DEBUG
2703	WriteLog("USER32: ReplyMessage\n");
2704	#endif
2705	return O32_ReplyMessage(arg1);
2706	}
2707	//******************************************************************************
2708	//******************************************************************************
2709	BOOL WIN32API ScreenToClient( HWND arg1, LPPOINT arg2)
2710	{
2711	#ifdef DEBUG
2712	WriteLog("USER32: ScreenToClient\n");
2713	#endif
2714	return O32_ScreenToClient(arg1, arg2);
2715	}
2716	//******************************************************************************
2717	//******************************************************************************
2718	BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7)
2719	{
2720	#ifdef DEBUG
2721	WriteLog("USER32: ScrollDC\n");
2722	#endif
2723	return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2724	}
2725	//******************************************************************************
2726	//******************************************************************************
2727	BOOL WIN32API ScrollWindow( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5)
2728	{
2729	#ifdef DEBUG
2730	WriteLog("USER32: ScrollWindow\n");
2731	#endif
2732	return O32_ScrollWindow(arg1, arg2, arg3, arg4, arg5);
2733	}
2734	//******************************************************************************
2735	//******************************************************************************
2736	BOOL WIN32API ScrollWindowEx( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7, UINT arg8)
2737	{
2738	#ifdef DEBUG
2739	WriteLog("USER32: ScrollWindowEx\n");
2740	#endif
2741	return O32_ScrollWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2742	}
2743	//******************************************************************************
2744	//******************************************************************************
2745	LONG WIN32API SendDlgItemMessageW( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
2746	{
2747	#ifdef DEBUG
2748	WriteLog("USER32: SendDlgItemMessageW\n");
2749	#endif
2750	return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
2751	}
2752	//******************************************************************************
2753	//******************************************************************************
2754	LRESULT WIN32API SendMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2755	{
2756	LRESULT rc;
2757
2758	#ifdef DEBUG
2759	WriteLog("USER32: SendMessageW....\n");
2760	#endif
2761	rc = O32_SendMessage(arg1, arg2, arg3, arg4);
2762	#ifdef DEBUG
2763	WriteLog("USER32: SendMessageW %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2764	#endif
2765	return(rc);
2766	}
2767	//******************************************************************************
2768	//******************************************************************************
2769	BOOL WIN32API SetCaretBlinkTime( UINT arg1)
2770	{
2771	#ifdef DEBUG
2772	WriteLog("USER32: SetCaretBlinkTime\n");
2773	#endif
2774	return O32_SetCaretBlinkTime(arg1);
2775	}
2776	//******************************************************************************
2777	//******************************************************************************
2778	BOOL WIN32API SetCaretPos( int arg1, int arg2)
2779	{
2780	dprintf(("USER32: SetCaretPos\n"));
2781	return O32_SetCaretPos(arg1, arg2);
2782	}
2783	//******************************************************************************
2784	//******************************************************************************
2785	HANDLE WIN32API SetClipboardData( UINT arg1, HANDLE arg2)
2786	{
2787	dprintf(("USER32: SetClipboardData\n"));
2788	return O32_SetClipboardData(arg1, arg2);
2789	}
2790	//******************************************************************************
2791	//******************************************************************************
2792	HWND WIN32API SetClipboardViewer( HWND arg1)
2793	{
2794	dprintf(("USER32: SetClipboardViewer\n"));
2795	return O32_SetClipboardViewer(arg1);
2796	}
2797	//******************************************************************************
2798	//******************************************************************************
2799	BOOL WIN32API SetDlgItemTextW( HWND arg1, int arg2, LPCWSTR arg3)
2800	{
2801	char *astring = UnicodeToAsciiString((LPWSTR)arg3);
2802	BOOL rc;
2803
2804	#ifdef DEBUG
2805	WriteLog("USER32: SetDlgItemTextW\n");
2806	#endif
2807	// NOTE: This will not work as is (needs UNICODE support)
2808	rc = O32_SetDlgItemText(arg1, arg2, astring);
2809	FreeAsciiString(astring);
2810	return rc;
2811	}
2812	//******************************************************************************
2813	//******************************************************************************
2814	BOOL WIN32API SetDoubleClickTime( UINT arg1)
2815	{
2816	#ifdef DEBUG
2817	WriteLog("USER32: SetDoubleClickTime\n");
2818	#endif
2819	return O32_SetDoubleClickTime(arg1);
2820	}
2821	//******************************************************************************
2822	//******************************************************************************
2823	HWND WIN32API SetParent( HWND arg1, HWND arg2)
2824	{
2825	#ifdef DEBUG
2826	WriteLog("USER32: SetParent\n");
2827	#endif
2828	return O32_SetParent(arg1, arg2);
2829	}
2830	//******************************************************************************
2831	//******************************************************************************
2832	BOOL WIN32API SetPropA( HWND arg1, LPCSTR arg2, HANDLE arg3)
2833	{
2834	#ifdef DEBUG
2835	if((int)arg2 >> 16 != 0)
2836	WriteLog("USER32: SetPropA %S\n", arg2);
2837	else WriteLog("USER32: SetPropA %X\n", arg2);
2838	#endif
2839	return O32_SetProp(arg1, arg2, arg3);
2840	}
2841	//******************************************************************************
2842	//******************************************************************************
2843	BOOL WIN32API SetPropW(HWND arg1, LPCWSTR arg2, HANDLE arg3)
2844	{
2845	BOOL rc;
2846	char *astring;
2847
2848	if((int)arg2 >> 16 != 0)
2849	astring = UnicodeToAsciiString((LPWSTR)arg2);
2850	else astring = (char *)arg2;
2851
2852	#ifdef DEBUG
2853	if((int)arg2 >> 16 != 0)
2854	WriteLog("USER32: SetPropW %S\n", astring);
2855	else WriteLog("USER32: SetPropW %X\n", astring);
2856	#endif
2857	rc = O32_SetProp(arg1, astring, arg3);
2858	if((int)astring >> 16 != 0)
2859	FreeAsciiString(astring);
2860	return(rc);
2861	}
2862	//******************************************************************************
2863	//******************************************************************************
2864	BOOL WIN32API SetRectEmpty( PRECT arg1)
2865	{
2866	#ifdef DEBUG
2867	WriteLog("USER32: SetRectEmpty\n");
2868	#endif
2869	return O32_SetRectEmpty(arg1);
2870	}
2871	//******************************************************************************
2872	//******************************************************************************
2873	int WIN32API SetScrollPos( HWND arg1, int arg2, int arg3, BOOL arg4)
2874	{
2875	#ifdef DEBUG
2876	WriteLog("USER32: SetScrollPos\n");
2877	#endif
2878	return O32_SetScrollPos(arg1, arg2, arg3, arg4);
2879	}
2880	//******************************************************************************
2881	//******************************************************************************
2882	BOOL WIN32API SetScrollRange( HWND arg1, int arg2, int arg3, int arg4, BOOL arg5)
2883	{
2884	#ifdef DEBUG
2885	WriteLog("USER32: SetScrollRange\n");
2886	#endif
2887	return O32_SetScrollRange(arg1, arg2, arg3, arg4, arg5);
2888	}
2889	//******************************************************************************
2890	//******************************************************************************
2891	LONG WIN32API SetWindowLongA(HWND hwnd, int nIndex, LONG arg3)
2892	{
2893	LONG rc;
2894
2895	dprintf(("USER32: SetWindowLongA %X %d %X\n", hwnd, nIndex, arg3));
2896	if(nIndex == GWL_WNDPROC \|\| nIndex == DWL_DLGPROC) {
2897	Win32WindowProc *wndproc = Win32WindowProc::FindProc(hwnd);
2898	if(wndproc == NULL) {//created with system class and app wants to change the handler
2899	dprintf(("USER32: SetWindowLong new WindowProc for system class\n"));
2900	wndproc = new Win32WindowProc((WNDPROC)arg3);
2901	wndproc->SetWindowHandle(hwnd);
2902	rc = O32_GetWindowLong(hwnd, nIndex);
2903	Win32WindowSubProc *subwndproc = new Win32WindowSubProc(hwnd, (WNDPROC_O32)rc);
2904	O32_SetWindowLong(hwnd, nIndex, (LONG)wndproc->GetOS2Callback());
2905	return((LONG)subwndproc->GetWin32Callback());
2906	}
2907	else {
2908	if(!(nIndex == DWL_DLGPROC && wndproc->IsWindow() == TRUE)) {
2909	rc = (LONG)wndproc->GetWin32Callback();
2910	dprintf(("USER32: SetWindowLong change WindowProc %X to %X\n", rc, arg3));
2911	wndproc->SetWin32Callback((WNDPROC)arg3);
2912	return(rc);
2913	}
2914	//else window that accesses it's normal window data
2915	}
2916	}
2917	return O32_SetWindowLong(hwnd, nIndex, arg3);
2918	}
2919	//******************************************************************************
2920	//TODO: Is this always correct? (GWL_ID: window identifier??)
2921	//******************************************************************************
2922	LONG WIN32API SetWindowLongW(HWND arg1, int arg2, LONG arg3)
2923	{
2924	dprintf(("USER32: SetWindowLongW %X %d %X\n", arg1, arg2, arg3));
2925	return SetWindowLongA(arg1, arg2, arg3);
2926	}
2927	//******************************************************************************
2928	//******************************************************************************
2929	BOOL WIN32API SetWindowPlacement( HWND arg1, const WINDOWPLACEMENT * arg2)
2930	{
2931	dprintf(("USER32: SetWindowPlacement\n"));
2932	return O32_SetWindowPlacement(arg1, arg2);
2933	}
2934	//******************************************************************************
2935	//******************************************************************************
2936	BOOL WIN32API SetWindowTextW( HWND arg1, LPCWSTR arg2)
2937	{
2938	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2939	BOOL rc;
2940
2941	rc = SetWindowTextA(arg1, (LPCSTR)astring);
2942	dprintf(("USER32: SetWindowTextW %X %s returned %d\n", arg1, astring, rc));
2943	FreeAsciiString(astring);
2944	return(rc);
2945	}
2946	//******************************************************************************
2947	//******************************************************************************
2948	WORD WIN32API SetWindowWord( HWND arg1, int arg2, WORD arg3)
2949	{
2950	dprintf(("USER32: SetWindowWord\n"));
2951	return O32_SetWindowWord(arg1, arg2, arg3);
2952	}
2953	//******************************************************************************
2954	//******************************************************************************
2955	BOOL WIN32API ShowCaret( HWND arg1)
2956	{
2957	dprintf(("USER32: ShowCaret\n"));
2958	return O32_ShowCaret(arg1);
2959	}
2960	//******************************************************************************
2961	//******************************************************************************
2962	BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
2963	{
2964	dprintf(("USER32: ShowOwnedPopups\n"));
2965	return O32_ShowOwnedPopups(arg1, arg2);
2966	}
2967	//******************************************************************************
2968	//******************************************************************************
2969	BOOL WIN32API ShowScrollBar( HWND arg1, int arg2, BOOL arg3)
2970	{
2971	#ifdef DEBUG
2972	WriteLog("USER32: ShowScrollBar\n");
2973	#endif
2974	return O32_ShowScrollBar(arg1, arg2, arg3);
2975	}
2976	//******************************************************************************
2977	//******************************************************************************
2978	BOOL WIN32API SwapMouseButton( BOOL arg1)
2979	{
2980	#ifdef DEBUG
2981	WriteLog("USER32: SwapMouseButton\n");
2982	#endif
2983	return O32_SwapMouseButton(arg1);
2984	}
2985	//******************************************************************************
2986	//******************************************************************************
2987	BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
2988	{
2989	BOOL rc;
2990	NONCLIENTMETRICSA cmetric = (NONCLIENTMETRICSA )pvParam;
2991
2992	switch(uiAction) {
2993	case SPI_SCREENSAVERRUNNING:
2994	(BOOL )pvParam = FALSE;
2995	rc = TRUE;
2996	break;
2997	case SPI_GETDRAGFULLWINDOWS:
2998	(BOOL )pvParam = FALSE;
2999	rc = TRUE;
3000	break;
3001	case SPI_GETNONCLIENTMETRICS:
3002	memset(cmetric, 0, sizeof(NONCLIENTMETRICSA));
3003	cmetric->cbSize = sizeof(NONCLIENTMETRICSA);
3004	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfCaptionFont),0);
3005	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMenuFont),0);
3006	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfStatusFont),0);
3007	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMessageFont),0);
3008	cmetric->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
3009	cmetric->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
3010	cmetric->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
3011	cmetric->iCaptionWidth = 32; //TODO
3012	cmetric->iCaptionHeight = 16; //TODO
3013	cmetric->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
3014	cmetric->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
3015	cmetric->iMenuWidth = 32; //TODO
3016	cmetric->iMenuHeight = GetSystemMetrics(SM_CYMENU);
3017	rc = TRUE;
3018	break;
3019	case 104: //TODO: Undocumented
3020	rc = 16;
3021	break;
3022	default:
3023	rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
3024	break;
3025	}
3026	#ifdef DEBUG
3027	WriteLog("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc);
3028	#endif
3029	return(rc);
3030	}
3031	//******************************************************************************
3032	//TODO: Check for more options that have different structs for Unicode!!!!
3033	//******************************************************************************
3034	BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
3035	{
3036	BOOL rc;
3037	NONCLIENTMETRICSW clientMetricsW = (NONCLIENTMETRICSW )pvParam;
3038	NONCLIENTMETRICSA clientMetricsA = {0};
3039	PVOID pvParamA;
3040	UINT uiParamA;
3041
3042	switch(uiAction) {
3043	case SPI_SETNONCLIENTMETRICS:
3044	clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
3045	clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
3046	clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
3047	clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
3048	clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
3049	clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
3050	ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
3051	clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
3052	clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
3053	ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
3054	clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
3055	clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
3056	ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
3057	ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
3058	ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
3059	//no break
3060	case SPI_GETNONCLIENTMETRICS:
3061	uiParamA = sizeof(NONCLIENTMETRICSA);
3062	pvParamA = &clientMetricsA;
3063	break;
3064	default:
3065	pvParamA = pvParam;
3066	uiParamA = uiParam;
3067	break;
3068	}
3069	rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
3070
3071	switch(uiAction) {
3072	case SPI_GETNONCLIENTMETRICS:
3073	clientMetricsW->cbSize = sizeof(*clientMetricsW);
3074	clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
3075	clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
3076	clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
3077	clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
3078	clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
3079	ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
3080
3081	clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
3082	clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
3083	ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
3084
3085	clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
3086	clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
3087	ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
3088	ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
3089	ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
3090	break;
3091	}
3092	#ifdef DEBUG
3093	WriteLog("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc);
3094	#endif
3095	return(rc);
3096	}
3097	//******************************************************************************
3098	//******************************************************************************
3099	LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3100	{
3101	#ifdef DEBUG
3102	WriteLog("USER32: TabbedTextOutA\n");
3103	#endif
3104	return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
3105	}
3106	//******************************************************************************
3107	//******************************************************************************
3108	LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3109	{
3110	char *astring = UnicodeToAsciiString((LPWSTR)arg4);
3111	LONG rc;
3112
3113	#ifdef DEBUG
3114	WriteLog("USER32: TabbedTextOutW\n");
3115	#endif
3116	rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
3117	FreeAsciiString(astring);
3118	return rc;
3119	}
3120	//******************************************************************************
3121	//******************************************************************************
3122	int WIN32API TranslateAccelerator( HWND arg1, HACCEL arg2, LPMSG arg3)
3123	{
3124	#ifdef DEBUG
3125	WriteLog("USER32: TranslateAccelerator\n");
3126	#endif
3127	return O32_TranslateAccelerator(arg1, arg2, arg3);
3128	}
3129	//******************************************************************************
3130	//******************************************************************************
3131	int WIN32API TranslateAcceleratorW( HWND arg1, HACCEL arg2, LPMSG arg3)
3132	{
3133	#ifdef DEBUG
3134	WriteLog("USER32: TranslateAcceleratorW\n");
3135	#endif
3136	// NOTE: This will not work as is (needs UNICODE support)
3137	return O32_TranslateAccelerator(arg1, arg2, arg3);
3138	}
3139	//******************************************************************************
3140	//******************************************************************************
3141	BOOL WIN32API TranslateMDISysAccel( HWND arg1, LPMSG arg2)
3142	{
3143	#ifdef DEBUG
3144	//// WriteLog("USER32: TranslateMDISysAccel\n");
3145	#endif
3146	return O32_TranslateMDISysAccel(arg1, arg2);
3147	}
3148	//******************************************************************************
3149	//******************************************************************************
3150	BOOL WIN32API UnionRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
3151	{
3152	#ifdef DEBUG
3153	WriteLog("USER32: UnionRect\n");
3154	#endif
3155	return O32_UnionRect(arg1, arg2, arg3);
3156	}
3157	//******************************************************************************
3158	//******************************************************************************
3159	BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
3160	{
3161	#ifdef DEBUG
3162	WriteLog("USER32: ValidateRect\n");
3163	#endif
3164	return O32_ValidateRect(arg1, arg2);
3165	}
3166	//******************************************************************************
3167	//******************************************************************************
3168	BOOL WIN32API ValidateRgn( HWND arg1, HRGN arg2)
3169	{
3170	#ifdef DEBUG
3171	WriteLog("USER32: ValidateRgn\n");
3172	#endif
3173	return O32_ValidateRgn(arg1, arg2);
3174	}
3175	//******************************************************************************
3176	//******************************************************************************
3177	WORD WIN32API VkKeyScanW( WCHAR arg1)
3178	{
3179	#ifdef DEBUG
3180	WriteLog("USER32: VkKeyScanW\n");
3181	#endif
3182	// NOTE: This will not work as is (needs UNICODE support)
3183	return O32_VkKeyScan((char)arg1);
3184	}
3185	//******************************************************************************
3186	//******************************************************************************
3187	BOOL WIN32API WaitMessage(void)
3188	{
3189	#ifdef DEBUG
3190	WriteLog("USER32: WaitMessage\n");
3191	#endif
3192	return O32_WaitMessage();
3193	}
3194	//******************************************************************************
3195	//******************************************************************************
3196	BOOL WIN32API WinHelpW( HWND arg1, LPCWSTR arg2, UINT arg3, DWORD arg4)
3197	{
3198	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
3199	BOOL rc;
3200
3201	#ifdef DEBUG
3202	WriteLog("USER32: WinHelpW\n");
3203	#endif
3204	rc = WinHelpA(arg1, astring, arg3, arg4);
3205	FreeAsciiString(astring);
3206	return rc;
3207	}
3208	//******************************************************************************
3209	//******************************************************************************
3210	HWND WIN32API WindowFromDC( HDC arg1)
3211	{
3212	#ifdef DEBUG
3213	WriteLog("USER32: WindowFromDC\n");
3214	#endif
3215	return O32_WindowFromDC(arg1);
3216	}
3217	//******************************************************************************
3218	//******************************************************************************
3219	HWND WIN32API WindowFromPoint( POINT arg1)
3220	{
3221	#ifdef DEBUG
3222	WriteLog("USER32: WindowFromPoint\n");
3223	#endif
3224	return O32_WindowFromPoint(arg1);
3225	}
3226	//******************************************************************************
3227	//******************************************************************************
3228	int WIN32API wvsprintfA( LPSTR arg1, LPCSTR arg2, va_list arg3)
3229	{
3230	#ifdef DEBUG
3231	WriteLog("USER32: wvsprintfA\n");
3232	#endif
3233	return O32_wvsprintf(arg1, arg2, (LPCVOID *)arg3);
3234	}
3235	//******************************************************************************
3236	//******************************************************************************
3237	int WIN32API wvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, va_list argptr)
3238	{
3239	int rc;
3240	char szOut[256];
3241	char *lpFmtA;
3242
3243	lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
3244	#ifdef DEBUG
3245	WriteLog("USER32: wvsprintfW, DOES NOT HANDLE UNICODE STRINGS!\n");
3246	WriteLog("USER32: %s\n", lpFmt);
3247	#endif
3248	rc = O32_wvsprintf(szOut, lpFmtA, (LPCVOID)argptr);
3249
3250	AsciiToUnicode(szOut, lpOut);
3251	#ifdef DEBUG
3252	WriteLog("USER32: %s\n", lpOut);
3253	#endif
3254	FreeAsciiString(lpFmtA);
3255	return(rc);
3256	}
3257	//******************************************************************************
3258	//No need to support this
3259	//******************************************************************************
3260	BOOL WIN32API SetMessageQueue(int cMessagesMax)
3261	{
3262	#ifdef DEBUG
3263	WriteLog("USER32: SetMessageQueue\n");
3264	#endif
3265	return(TRUE);
3266	}
3267	//******************************************************************************
3268	//TODO: Not complete
3269	//******************************************************************************
3270	BOOL WIN32API GetScrollInfo(HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
3271	{
3272	#ifdef DEBUG
3273	WriteLog("USER32: GetScrollInfo\n");
3274	#endif
3275	if(lpsi == NULL)
3276	return(FALSE);
3277
3278	if(lpsi->fMask & SIF_POS)
3279	lpsi->nPos = GetScrollPos(hwnd, fnBar);
3280	if(lpsi->fMask & SIF_RANGE)
3281	GetScrollRange(hwnd, fnBar, &lpsi->nMin, &lpsi->nMax);
3282	if(lpsi->fMask & SIF_PAGE) {
3283	#ifdef DEBUG
3284	WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3285	#endif
3286	lpsi->nPage = 25;
3287	}
3288	return(TRUE);
3289	}
3290	//******************************************************************************
3291	//TODO: Not complete
3292	//******************************************************************************
3293	INT WIN32API SetScrollInfo(HWND hwnd, INT fnBar, const SCROLLINFO *lpsi, BOOL fRedraw)
3294	{
3295	int smin, smax;
3296
3297	#ifdef DEBUG
3298	WriteLog("USER32: SetScrollInfo\n");
3299	#endif
3300	if(lpsi == NULL)
3301	return(FALSE);
3302
3303	if(lpsi->fMask & SIF_POS)
3304	SetScrollPos(hwnd, fnBar, lpsi->nPos, fRedraw);
3305	if(lpsi->fMask & SIF_RANGE)
3306	SetScrollRange(hwnd, fnBar, lpsi->nMin, lpsi->nMax, fRedraw);
3307	if(lpsi->fMask & SIF_PAGE) {
3308	#ifdef DEBUG
3309	WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3310	#endif
3311	}
3312	if(lpsi->fMask & SIF_DISABLENOSCROLL) {
3313	#ifdef DEBUG
3314	WriteLog("USER32: GetScrollInfo, disable scrollbar not yet implemented\n");
3315	#endif
3316	}
3317	return(TRUE);
3318	}
3319	//******************************************************************************
3320	//******************************************************************************
3321	BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3322	LPARAM lpData, int nCount, int X, int Y, int nWidth,
3323	int nHeight)
3324	{
3325	BOOL rc;
3326	COLORREF curclr;
3327
3328	#ifdef DEBUG
3329	WriteLog("USER32: GrayStringA, not completely implemented\n");
3330	#endif
3331	if(lpOutputFunc == NULL && lpData == NULL) {
3332	#ifdef DEBUG
3333	WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3334	#endif
3335	return(FALSE);
3336	}
3337	if(lpOutputFunc) {
3338	return(lpOutputFunc(hdc, lpData, nCount));
3339	}
3340	curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3341	rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
3342	SetTextColor(hdc, curclr);
3343
3344	return(rc);
3345	}
3346	//******************************************************************************
3347	//******************************************************************************
3348	BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3349	LPARAM lpData, int nCount, int X, int Y, int nWidth,
3350	int nHeight)
3351	{
3352	BOOL rc;
3353	char *astring;
3354	COLORREF curclr;
3355
3356	#ifdef DEBUG
3357	WriteLog("USER32: GrayStringW, not completely implemented\n");
3358	#endif
3359
3360	if(lpOutputFunc == NULL && lpData == NULL) {
3361	#ifdef DEBUG
3362	WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3363	#endif
3364	return(FALSE);
3365	}
3366	if(nCount == 0)
3367	nCount = UniStrlen((UniChar*)lpData);
3368
3369	if(lpOutputFunc) {
3370	return(lpOutputFunc(hdc, lpData, nCount));
3371	}
3372	astring = UnicodeToAsciiString((LPWSTR)lpData);
3373
3374	curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3375	rc = TextOutA(hdc, X, Y, astring, nCount);
3376	SetTextColor(hdc, curclr);
3377
3378	FreeAsciiString(astring);
3379	return(rc);
3380	}
3381	//******************************************************************************
3382	//TODO:
3383	//******************************************************************************
3384	int WIN32API CopyAcceleratorTableA(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3385	int cAccelEntries)
3386	{
3387	#ifdef DEBUG
3388	WriteLog("USER32: CopyAcceleratorTableA, not implemented\n");
3389	#endif
3390	return(0);
3391	}
3392	//******************************************************************************
3393	//TODO:
3394	//******************************************************************************
3395	int WIN32API CopyAcceleratorTableW(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3396	int cAccelEntries)
3397	{
3398	#ifdef DEBUG
3399	WriteLog("USER32: CopyAcceleratorTableW, not implemented\n");
3400	#endif
3401	return(0);
3402	}
3403	//******************************************************************************
3404	//Stolen from Wine (controls\uitools.c)
3405	//******************************************************************************
3406	BOOL DrawEdgeDiag(HDC hdc, RECT *rect, UINT edge, UINT flags)
3407	{
3408	HPEN facePen, shadowPen, lightPen, blackPen, grayPen, nullPen;
3409	HPEN iPen, oPen, oldPen;
3410	HBRUSH oldBrush, faceBrush;
3411	int cl, cr, ct, cb;
3412	BOOL mainDiag;
3413	POINT tp;
3414	RECT r;
3415
3416	/* If both rasied and sunken is specified, they anihilate one another */
3417	if( !((flags & BF_MONO) \|\| (flags & BF_FLAT)) ){
3418	if( (edge & BDR_RAISEDOUTER) && (edge & BDR_SUNKENOUTER) )
3419	return FALSE;
3420	if( (edge & BDR_RAISEDINNER) && (edge & BDR_SUNKENINNER) )
3421	return FALSE;
3422	}
3423
3424	/* Create/get the tools of the trade... */
3425	facePen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNFACE));
3426	shadowPen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNSHADOW));
3427	lightPen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNHILIGHT));
3428	grayPen = CreatePen(PS_SOLID, 0, RGB(168, 152, 144));
3429	blackPen = GetStockObject(BLACK_PEN);
3430	nullPen = GetStockObject(NULL_PEN);
3431	faceBrush = GetSysColorBrush(COLOR_BTNFACE);
3432	oldPen = SelectObject(hdc, nullPen);
3433	oldBrush = SelectObject(hdc, faceBrush);
3434
3435	/* this is my working rectangle */
3436	r = *rect;
3437
3438	if(flags & BF_MONO){
3439	oPen = blackPen;
3440	iPen = nullPen;
3441	}else if(flags & BF_FLAT){
3442	oPen = shadowPen;
3443	iPen = facePen;
3444	}else {
3445	if(flags & BF_SOFT){
3446	if(flags & BF_BOTTOM){
3447	oPen = (edge & BDR_RAISEDOUTER) ? blackPen : lightPen;
3448	iPen = (edge & BDR_RAISEDINNER) ? shadowPen : grayPen;
3449	}
3450	else{
3451	oPen = (edge & BDR_RAISEDOUTER) ? lightPen : blackPen;
3452	iPen = (edge & BDR_RAISEDINNER) ? grayPen : shadowPen;
3453	}
3454	}
3455	else{
3456	if(flags & BF_BOTTOM){
3457	oPen = (edge & BDR_RAISEDOUTER) ? blackPen : lightPen;
3458	iPen = (edge & BDR_RAISEDINNER) ? shadowPen : grayPen;
3459	}
3460	else{
3461	oPen = (edge & BDR_RAISEDOUTER) ? grayPen : shadowPen;
3462	iPen = (edge & BDR_RAISEDINNER) ? lightPen : blackPen;
3463	}
3464	}
3465	}
3466
3467	if(flags & BF_BOTTOM){
3468	if(flags & BF_LEFT){
3469	cr = -1; cl = 0;
3470	ct = 0; cb = -1;
3471	mainDiag = TRUE;
3472	tp.x = r.left; tp.y = r.top;
3473	}
3474	else{ /* RIGHT */
3475	cr = -1; cl = 0;
3476	ct = 1; cb = 0;
3477	tp.x = r.left; tp.y = r.bottom-1;
3478	mainDiag = FALSE;
3479	}
3480	}
3481	else{ /* TOP */
3482	if(flags & BF_LEFT){
3483	cr = 0; cl = 1;
3484	ct = 0; cb = -1;
3485	mainDiag = FALSE;
3486	tp.x = r.right; tp.y = r.top;
3487	}
3488	else{ /* RIGHT */
3489	cr = 0; cl = 1;
3490	ct = 1; cb = 0;
3491	tp.x = r.right; tp.y = r.bottom-1;
3492	mainDiag = TRUE;
3493	}
3494	}
3495
3496	/* if it has external edge, draw it */
3497	if(edge & BDR_OUTER){
3498	SelectObject(hdc, oPen);
3499	MoveToEx(hdc, r.left, mainDiag ? r.bottom-1 : r.top, 0);
3500	LineTo(hdc, r.right, mainDiag ? r.top-1 : r.bottom);
3501	r.left += cl; r.right += cr; r.top += ct; r.bottom += cb;
3502	}
3503
3504	/* if it has internal edge, draw it */
3505	if(edge & BDR_INNER){
3506	SelectObject(hdc, iPen);
3507	MoveToEx(hdc, r.left, mainDiag ? r.bottom-1 : r.top, 0);
3508	LineTo(hdc, r.right, mainDiag ? r.top-1 : r.bottom);
3509	r.left += cl; r.right += cr; r.top += ct; r.bottom += cb;
3510	}
3511
3512	if((flags & BF_MIDDLE) && !(flags & BF_MONO)){
3513	POINT p[3];
3514	p[0].x = mainDiag ? r.right: r.left;
3515	p[0].y = r.top;
3516	p[1].x = mainDiag ? r.left : r.right;
3517	p[1].y = r.bottom;
3518	p[2].x = tp.x;
3519	p[2].y = tp.y;
3520	SelectObject(hdc, nullPen);
3521	SelectObject(hdc, faceBrush);
3522	Polygon(hdc, p, 3);
3523	}
3524
3525	if(flags & BF_ADJUST)
3526	*rect = r;
3527
3528	/* Restore the DC */
3529	SelectObject(hdc, oldPen);
3530	SelectObject(hdc, oldBrush);
3531
3532	/* Clean-up */
3533	DeleteObject(facePen);
3534	DeleteObject(shadowPen);
3535	DeleteObject(lightPen);
3536	DeleteObject(grayPen);
3537
3538	return TRUE;
3539	}
3540	//******************************************************************************
3541	//Stolen from Wine (controls\uitools.c)
3542	//******************************************************************************
3543	BOOL WIN32API DrawEdge(HDC hdc, LPRECT rect, UINT edge, UINT flags)
3544	{
3545	HBRUSH faceBrush, shadowBrush, lightBrush, blackBrush, grayBrush, nullBrush;
3546	HBRUSH iNBrush, iSBrush, iEBrush, iWBrush;
3547	HBRUSH oNBrush, oSBrush, oEBrush, oWBrush;
3548	HBRUSH oldBrush;
3549	POINT point[2];
3550	RECT r;
3551
3552	#ifdef DEBUG
3553	WriteLog("USER32: DrawEdge %X %X, partially implemented\n", edge, flags);
3554	WriteLog("USER32: DrawEdge (%d,%d) (%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom);
3555	#endif
3556
3557	if(flags & BF_DIAGONAL) {
3558	return DrawEdgeDiag(hdc, rect, edge, flags);
3559	}
3560	/* If both rasied and sunken is specified, they anihilate one another */
3561	if( !((flags & BF_MONO) \|\| (flags & BF_FLAT)) ){
3562	if( (edge & BDR_RAISEDOUTER) && (edge & BDR_SUNKENOUTER) )
3563	return FALSE;
3564	if( (edge & BDR_RAISEDINNER) && (edge & BDR_SUNKENINNER) )
3565	return FALSE;
3566	}
3567
3568	faceBrush = GetSysColorBrush(COLOR_BTNFACE);
3569	shadowBrush = GetSysColorBrush(COLOR_BTNSHADOW);
3570	lightBrush = GetSysColorBrush(COLOR_BTNHILIGHT);
3571	blackBrush = GetStockObject(BLACK_BRUSH);
3572	grayBrush = GetStockObject(LTGRAY_BRUSH);
3573	nullBrush = GetStockObject(NULL_BRUSH);
3574	oldBrush = SelectObject(hdc, nullBrush);
3575
3576	/* this is my working rectangle */
3577	r = *rect;
3578
3579	if(flags & BF_MONO){
3580	oNBrush = oSBrush = oEBrush = oWBrush = blackBrush;
3581	iNBrush = iSBrush = iEBrush = iWBrush = nullBrush;
3582	}else if(flags & BF_FLAT){
3583	oNBrush = oSBrush = oEBrush = oWBrush = shadowBrush;
3584	iNBrush = iSBrush = iEBrush = iWBrush = faceBrush;
3585	}else {
3586	if(flags & BF_SOFT){
3587	oNBrush = oWBrush = (edge & BDR_RAISEDOUTER) ? lightBrush : blackBrush;
3588	oSBrush = oEBrush = (edge & BDR_RAISEDOUTER) ? blackBrush : lightBrush;
3589	iNBrush = iWBrush = (edge & BDR_RAISEDINNER) ? grayBrush : shadowBrush;
3590	iSBrush = iEBrush = (edge & BDR_RAISEDINNER) ? shadowBrush : grayBrush;
3591	}
3592	else{
3593	oNBrush = oWBrush = (edge & BDR_RAISEDOUTER) ? grayBrush : shadowBrush;
3594	oSBrush = oEBrush = (edge & BDR_RAISEDOUTER) ? blackBrush : lightBrush;
3595	iNBrush = iWBrush = (edge & BDR_RAISEDINNER) ? lightBrush : blackBrush;
3596	iSBrush = iEBrush = (edge & BDR_RAISEDINNER) ? shadowBrush : grayBrush;
3597	}
3598	}
3599
3600	/* if it has external edge, draw it */
3601	if(edge & BDR_OUTER){
3602	if(flags & BF_RIGHT){
3603	SelectObject(hdc, oEBrush);
3604	PatBlt(hdc, r.right-1, r.top, 1, r.bottom - r.top, PATCOPY);
3605	r.right--;
3606	}
3607	if(flags & BF_BOTTOM){
3608	SelectObject(hdc, oSBrush);
3609	PatBlt(hdc, r.left, r.bottom-1, r.right-r.left, 1, PATCOPY);
3610	r.bottom--;
3611	}
3612	if(flags & BF_LEFT){
3613	SelectObject(hdc, oWBrush);
3614	PatBlt(hdc, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
3615	r.left++;
3616	}
3617	if(flags & BF_TOP){
3618	SelectObject(hdc, oNBrush);
3619	PatBlt(hdc, r.left, r.top, r.right-r.left, 1, PATCOPY);
3620	r.top++;
3621	}
3622	}
3623
3624	/* if it has internal edge, draw it */
3625	if(edge & BDR_INNER){
3626	if(flags & BF_RIGHT){
3627	SelectObject(hdc, iEBrush);
3628	PatBlt(hdc, r.right-1, r.top, 1, r.bottom - r.top, PATCOPY);
3629	r.right--;
3630	}
3631	if(flags & BF_BOTTOM){
3632	SelectObject(hdc, iSBrush);
3633	PatBlt(hdc, r.left, r.bottom-1, r.right-r.left, 1, PATCOPY);
3634	r.bottom--;
3635	}
3636	if(flags & BF_LEFT){
3637	SelectObject(hdc, iWBrush);
3638	PatBlt(hdc, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
3639	r.left++;
3640	}
3641	if(flags & BF_TOP){
3642	SelectObject(hdc, iNBrush);
3643	PatBlt(hdc, r.left, r.top, r.right-r.left, 1, PATCOPY);
3644	r.top++;
3645	}
3646	}
3647
3648	/* if we got to fill the middle, to it now */
3649	if((flags & BF_MIDDLE) && !(flags & BF_MONO))
3650	FillRect(hdc, &r, faceBrush);
3651
3652	/* adjust the rectangle if required */
3653	if(flags & BF_ADJUST)
3654	*rect = r;
3655
3656	/* Restore the DC */
3657	SelectObject(hdc, oldBrush);
3658
3659	return TRUE;
3660	}
3661	//******************************************************************************
3662	//******************************************************************************
3663	LRESULT WIN32API SendMessageTimeoutA(HWND hwnd, UINT Msg, WPARAM wParam,
3664	LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3665	LPDWORD lpdwResult)
3666	{
3667	#ifdef DEBUG
3668	WriteLog("USER32: SendMessageTimeoutA, partially implemented\n");
3669	#endif
3670	//ignore fuFlags & wTimeOut
3671	*lpdwResult = SendMessageA(hwnd, Msg, wParam, lParam);
3672	return(TRUE);
3673	}
3674	//******************************************************************************
3675	//******************************************************************************
3676	LRESULT WIN32API SendMessageTimeoutW(HWND hwnd, UINT Msg, WPARAM wParam,
3677	LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3678	LPDWORD lpdwResult)
3679	{
3680	#ifdef DEBUG
3681	WriteLog("USER32: SendMessageTimeoutW, partially implemented\n");
3682	#endif
3683	return(SendMessageTimeoutA(hwnd, Msg, wParam, lParam, fuFlags, uTimeOut, lpdwResult));
3684	}
3685	//******************************************************************************
3686	//******************************************************************************
3687	HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
3688	{
3689	#ifdef DEBUG
3690	WriteLog("USER32: CopyImage, not implemented\n");
3691	#endif
3692	switch(uType) {
3693	case IMAGE_BITMAP:
3694	case IMAGE_CURSOR:
3695	case IMAGE_ICON:
3696	default:
3697	#ifdef DEBUG
3698	WriteLog("USER32: CopyImage, unknown type\n");
3699	#endif
3700	return(NULL);
3701	}
3702	return(NULL);
3703	}
3704	//******************************************************************************
3705	//******************************************************************************
3706	BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
3707	{
3708	#ifdef DEBUG
3709	WriteLog("USER32: GetKeyboardState, not properly implemented\n");
3710	#endif
3711	memset(lpKeyState, 0, 256);
3712	return(TRUE);
3713	}
3714	//******************************************************************************
3715	//******************************************************************************
3716	BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
3717	{
3718	#ifdef DEBUG
3719	WriteLog("USER32: SetKeyboardState, not implemented\n");
3720	#endif
3721	return(TRUE);
3722	}
3723	//******************************************************************************
3724	//******************************************************************************
3725	BOOL WIN32API DrawFrameControl(HDC hdc, LPRECT lprc, UINT uType, UINT uState)
3726	{
3727	#ifdef DEBUG
3728	WriteLog("USER32: DrawFrameControl, not implemented\n");
3729	#endif
3730	return(TRUE);
3731	}
3732	//******************************************************************************
3733	//******************************************************************************
3734	BOOL WIN32API SendNotifyMessageA(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3735	{
3736	#ifdef DEBUG
3737	WriteLog("USER32: SendNotifyMessageA, not completely implemented\n");
3738	#endif
3739	return(SendMessageA(hwnd, Msg, wParam, lParam));
3740	}
3741	//******************************************************************************
3742	//******************************************************************************
3743	BOOL WIN32API SendNotifyMessageW(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3744	{
3745	#ifdef DEBUG
3746	WriteLog("USER32: SendNotifyMessageW, not completely implemented\n");
3747	#endif
3748	return(SendMessageA(hwnd, Msg, wParam, lParam));
3749	}
3750	//******************************************************************************
3751	//2nd parameter not used according to SDK (yet?)
3752	//******************************************************************************
3753	VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
3754	{
3755	#ifdef DEBUG
3756	WriteLog("USER32: SetLastErrorEx\n");
3757	#endif
3758	SetLastError(dwErrCode);
3759	}
3760	//******************************************************************************
3761	//******************************************************************************
3762	LPARAM WIN32API SetMessageExtraInfo(LPARAM lParam)
3763	{
3764	#ifdef DEBUG
3765	WriteLog("USER32: SetMessageExtraInfo, not implemented\n");
3766	#endif
3767	return(0);
3768	}
3769	//******************************************************************************
3770	//******************************************************************************
3771	BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
3772	{
3773	#ifdef DEBUG
3774	WriteLog("USER32: ActivateKeyboardLayout, not implemented\n");
3775	#endif
3776	return(TRUE);
3777	}
3778	//******************************************************************************
3779	//******************************************************************************
3780	int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
3781	{
3782	#ifdef DEBUG
3783	WriteLog("USER32: GetKeyboardLayoutList, not implemented\n");
3784	#endif
3785	return(0);
3786	}
3787	//******************************************************************************
3788	//******************************************************************************
3789	HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
3790	{
3791	#ifdef DEBUG
3792	WriteLog("USER32: GetKeyboardLayout, not implemented\n");
3793	#endif
3794	return(0);
3795	}
3796	//******************************************************************************
3797	//******************************************************************************
3798	int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
3799	{
3800	#ifdef DEBUG
3801	WriteLog("USER32: LookupIconIdFromDirectory, not implemented\n");
3802	#endif
3803	return(0);
3804	}
3805	//******************************************************************************
3806	//******************************************************************************
3807	int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL fIcon,
3808	int cxDesired, int cyDesired,
3809	UINT Flags)
3810	{
3811	#ifdef DEBUG
3812	WriteLog("USER32: LookupIconIdFromDirectoryEx, not implemented\n");
3813	#endif
3814	return(0);
3815	}
3816	//******************************************************************************
3817	//DWORD idAttach; /* thread to attach */
3818	//DWORD idAttachTo; /* thread to attach to */
3819	//BOOL fAttach; /* attach or detach */
3820	//******************************************************************************
3821	BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
3822	{
3823	#ifdef DEBUG
3824	WriteLog("USER32: AttachThreadInput, not implemented\n");
3825	#endif
3826	return(TRUE);
3827	}
3828	//******************************************************************************
3829	//******************************************************************************
3830	BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
3831	{
3832	#ifdef DEBUG
3833	WriteLog("USER32: RegisterHotKey, not implemented\n");
3834	#endif
3835	return(TRUE);
3836	}
3837	//******************************************************************************
3838	//******************************************************************************
3839	BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
3840	{
3841	#ifdef DEBUG
3842	WriteLog("USER32: UnregisterHotKey, not implemented\n");
3843	#endif
3844	return(TRUE);
3845	}
3846	//******************************************************************************
3847	//******************************************************************************
3848	BOOL WIN32API DrawStateA(HDC hdc, HBRUSH hbc, DRAWSTATEPROC lpOutputFunc,
3849	LPARAM lData, WPARAM wData, int x, int y, int cx,
3850	int cy, UINT fuFlags)
3851	{
3852	#ifdef DEBUG
3853	WriteLog("USER32: DrawStateA, not implemented\n");
3854	#endif
3855	return(TRUE);
3856	}
3857	//******************************************************************************
3858	//******************************************************************************
3859	//******************************************************************************
3860	//******************************************************************************
3861	BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
3862	{
3863	#ifdef DEBUG
3864	WriteLog("USER32: SetWindowContextHelpId, not implemented\n");
3865	#endif
3866	return(TRUE);
3867	}
3868	//******************************************************************************
3869	//******************************************************************************
3870	DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
3871	{
3872	#ifdef DEBUG
3873	WriteLog("USER32: GetWindowContextHelpId, not implemented\n");
3874	#endif
3875	return(0);
3876	}
3877	//******************************************************************************
3878	//restores iconized window to previous size/position
3879	//******************************************************************************
3880	BOOL WIN32API OpenIcon(HWND hwnd)
3881	{
3882	#ifdef DEBUG
3883	WriteLog("USER32: OpenIcon\n");
3884	#endif
3885	if(!IsIconic(hwnd))
3886	return FALSE;
3887	ShowWindow(hwnd, SW_SHOWNORMAL);
3888	return TRUE;
3889	}
3890	//******************************************************************************
3891	//******************************************************************************
3892	BOOL WIN32API IsWindowUnicode(HWND hwnd)
3893	{
3894	#ifdef DEBUG
3895	WriteLog("USER32: IsWindowUnicode, not implemented\n");
3896	#endif
3897	return(FALSE);
3898	}
3899	//******************************************************************************
3900	//******************************************************************************
3901	BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
3902	{
3903	#ifdef DEBUG
3904	WriteLog("USER32: GetMonitorInfoA not supported!!\n");
3905	#endif
3906	return(FALSE);
3907	}
3908	//******************************************************************************
3909	//******************************************************************************
3910	BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
3911	{
3912	#ifdef DEBUG
3913	WriteLog("USER32: GetMonitorInfoW not supported!!\n");
3914	#endif
3915	return(FALSE);
3916	}
3917	//******************************************************************************
3918	//******************************************************************************
3919	HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
3920	{
3921	#ifdef DEBUG
3922	WriteLog("USER32: MonitorFromWindow not correctly supported??\n");
3923	#endif
3924	return(0);
3925	}
3926	//******************************************************************************
3927	//******************************************************************************
3928	HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
3929	{
3930	#ifdef DEBUG
3931	WriteLog("USER32: MonitorFromRect not correctly supported??\n");
3932	#endif
3933	return(0);
3934	}
3935	//******************************************************************************
3936	//******************************************************************************
3937	HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
3938	{
3939	#ifdef DEBUG
3940	WriteLog("USER32: MonitorFromPoint not correctly supported??\n");
3941	#endif
3942	return(0);
3943	}
3944	//******************************************************************************
3945	//******************************************************************************
3946	BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
3947	{
3948	#ifdef DEBUG
3949	WriteLog("USER32: EnumDisplayMonitors not supported??\n");
3950	#endif
3951	return(FALSE);
3952	}
3953	//******************************************************************************
3954	//******************************************************************************
3955	BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
3956	LPDEVMODEA lpDevMode)
3957	{
3958	#ifdef DEBUG
3959	WriteLog("USER32: EnumDisplaySettingsA FAKED\n");
3960	#endif
3961	switch(iModeNum) {
3962	case 0:
3963	lpDevMode->dmBitsPerPel = 16;
3964	lpDevMode->dmPelsWidth = 768;
3965	lpDevMode->dmPelsHeight = 1024;
3966	lpDevMode->dmDisplayFlags = 0;
3967	lpDevMode->dmDisplayFrequency = 70;
3968	break;
3969	case 1:
3970	lpDevMode->dmBitsPerPel = 16;
3971	lpDevMode->dmPelsWidth = 640;
3972	lpDevMode->dmPelsHeight = 480;
3973	lpDevMode->dmDisplayFlags = 0;
3974	lpDevMode->dmDisplayFrequency = 70;
3975	break;
3976	default:
3977	return(FALSE);
3978	}
3979	return(TRUE);
3980	}
3981	//******************************************************************************
3982	//******************************************************************************
3983	LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA lpDevMode, DWORD dwFlags)
3984	{
3985	#ifdef DEBUG
3986	if(lpDevMode) {
3987	WriteLog("USER32: ChangeDisplaySettingsA FAKED %X\n", dwFlags);
3988	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
3989	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsWidth %d\n", lpDevMode->dmPelsWidth);
3990	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
3991	}
3992	#endif
3993	return(DISP_CHANGE_SUCCESSFUL);
3994	}
3995	//******************************************************************************
3996	//******************************************************************************
3997
3998
3999	/*****************************************************************************
4000	* Name : BOOL WIN32API AnyPopup
4001	* Purpose : The AnyPopup function indicates whether an owned, visible,
4002	* top-level pop-up, or overlapped window exists on the screen. The
4003	* function searches the entire Windows screen, not just the calling
4004	* application's client area.
4005	* Parameters: VOID
4006	* Variables :
4007	* Result : If a pop-up window exists, the return value is TRUE even if the
4008	* pop-up window is completely covered by other windows. Otherwise,
4009	* it is FALSE.
4010	* Remark : AnyPopup is a Windows version 1.x function and is retained for
4011	* compatibility purposes. It is generally not useful.
4012	* Status : UNTESTED STUB
4013	*
4014	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4015	*****************************************************************************/
4016
4017	BOOL WIN32API AnyPopup(VOID)
4018	{
4019	dprintf(("USER32:AnyPopup() not implemented.\n"));
4020
4021	return (FALSE);
4022	}
4023
4024
4025	/*****************************************************************************
4026	* Name : long WIN32API BroadcastSystemMessage
4027	* Purpose : The BroadcastSystemMessage function sends a message to the given
4028	* recipients. The recipients can be applications, installable
4029	* drivers, Windows-based network drivers, system-level device
4030	* drivers, or any combination of these system components.
4031	* Parameters: DWORD dwFlags,
4032	LPDWORD lpdwRecipients,
4033	UINT uiMessage,
4034	WPARAM wParam,
4035	LPARAM lParam
4036	* Variables :
4037	* Result : If the function succeeds, the return value is a positive value.
4038	* If the function is unable to broadcast the message, the return value is -1.
4039	* If the dwFlags parameter is BSF_QUERY and at least one recipient returned FALSE to the corresponding message, the return value is zero.
4040	* Remark :
4041	* Status : UNTESTED STUB
4042	*
4043	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4044	*****************************************************************************/
4045
4046	long WIN32API BroadcastSystemMessage(DWORD dwFlags,
4047	LPDWORD lpdwRecipients,
4048	UINT uiMessage,
4049	WPARAM wParam,
4050	LPARAM lParam)
4051	{
4052	dprintf(("USER32:BroadcastSystemMessage(%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4053	dwFlags,
4054	lpdwRecipients,
4055	uiMessage,
4056	wParam,
4057	lParam));
4058
4059	return (-1);
4060	}
4061
4062
4063	/*****************************************************************************
4064	* Name : WORD WIN32API CascadeWindows
4065	* Purpose : The CascadeWindows function cascades the specified windows or
4066	* the child windows of the specified parent window.
4067	* Parameters: HWND hwndParent handle of parent window
4068	* UINT wHow types of windows not to arrange
4069	* CONST RECT * lpRect rectangle to arrange windows in
4070	* UINT cKids number of windows to arrange
4071	* const HWND FAR * lpKids array of window handles
4072	* Variables :
4073	* Result : If the function succeeds, the return value is the number of windows arranged.
4074	* If the function fails, the return value is zero.
4075	* Remark :
4076	* Status : UNTESTED STUB
4077	*
4078	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4079	*****************************************************************************/
4080
4081	WORD WIN32API CascadeWindows(HWND hwndParent,
4082	UINT wHow,
4083	CONST LPRECT lpRect,
4084	UINT cKids,
4085	const HWND *lpKids)
4086	{
4087	dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
4088	hwndParent,
4089	wHow,
4090	lpRect,
4091	cKids,
4092	lpKids));
4093
4094	return (0);
4095	}
4096
4097
4098	/*****************************************************************************
4099	* Name : LONG WIN32API ChangeDisplaySettingsW
4100	* Purpose : The ChangeDisplaySettings function changes the display settings
4101	* to the specified graphics mode.
4102	* Parameters: LPDEVMODEW lpDevModeW
4103	* DWORD dwFlags
4104	* Variables :
4105	* Result : DISP_CHANGE_SUCCESSFUL The settings change was successful.
4106	* DISP_CHANGE_RESTART The computer must be restarted in order for the graphics mode to work.
4107	* DISP_CHANGE_BADFLAGS An invalid set of flags was passed in.
4108	* DISP_CHANGE_FAILED The display driver failed the specified graphics mode.
4109	* DISP_CHANGE_BADMODE The graphics mode is not supported.
4110	* DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
4111	* Remark :
4112	* Status : UNTESTED STUB
4113	*
4114	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4115	*****************************************************************************/
4116
4117	LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
4118	DWORD dwFlags)
4119	{
4120	dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
4121	lpDevMode,
4122	dwFlags));
4123
4124	return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
4125	dwFlags));
4126	}
4127
4128	/*****************************************************************************
4129	* Name : BOOL WIN32API CloseDesktop
4130	* Purpose : The CloseDesktop function closes an open handle of a desktop
4131	* object. A desktop is a secure object contained within a window
4132	* station object. A desktop has a logical display surface and
4133	* contains windows, menus and hooks.
4134	* Parameters: HDESK hDesktop
4135	* Variables :
4136	* Result : If the function succeeds, the return value is TRUE.
4137	* If the functions fails, the return value is FALSE. To get
4138	* extended error information, call GetLastError.
4139	* Remark :
4140	* Status : UNTESTED STUB
4141	*
4142	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4143	*****************************************************************************/
4144
4145	BOOL WIN32API CloseDesktop(HDESK hDesktop)
4146	{
4147	dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
4148	hDesktop));
4149
4150	return (FALSE);
4151	}
4152
4153
4154	/*****************************************************************************
4155	* Name : BOOL WIN32API CloseWindowStation
4156	* Purpose : The CloseWindowStation function closes an open window station handle.
4157	* Parameters: HWINSTA hWinSta
4158	* Variables :
4159	* Result :
4160	* Remark : If the function succeeds, the return value is TRUE.
4161	* If the functions fails, the return value is FALSE. To get
4162	* extended error information, call GetLastError.
4163	* Status : UNTESTED STUB
4164	*
4165	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4166	*****************************************************************************/
4167
4168	BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
4169	{
4170	dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
4171	hWinSta));
4172
4173	return (FALSE);
4174	}
4175
4176
4177	/*****************************************************************************
4178	* Name : HDESK WIN32API CreateDesktopA
4179	* Purpose : The CreateDesktop function creates a new desktop on the window
4180	* station associated with the calling process.
4181	* Parameters: LPCTSTR lpszDesktop name of the new desktop
4182	* LPCTSTR lpszDevice name of display device to assign to the desktop
4183	* LPDEVMODE pDevMode reserved; must be NULL
4184	* DWORD dwFlags flags to control interaction with other applications
4185	* DWORD dwDesiredAccess specifies access of returned handle
4186	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
4187	* Variables :
4188	* Result : If the function succeeds, the return value is a handle of the
4189	* newly created desktop.
4190	* If the function fails, the return value is NULL. To get extended
4191	* error information, call GetLastError.
4192	* Remark :
4193	* Status : UNTESTED STUB
4194	*
4195	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4196	*****************************************************************************/
4197
4198	HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
4199	LPCTSTR lpszDevice,
4200	LPDEVMODEA pDevMode,
4201	DWORD dwFlags,
4202	DWORD dwDesiredAccess,
4203	LPSECURITY_ATTRIBUTES lpsa)
4204	{
4205	dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4206	lpszDesktop,
4207	lpszDevice,
4208	pDevMode,
4209	dwFlags,
4210	dwDesiredAccess,
4211	lpsa));
4212
4213	return (NULL);
4214	}
4215
4216
4217	/*****************************************************************************
4218	* Name : HDESK WIN32API CreateDesktopW
4219	* Purpose : The CreateDesktop function creates a new desktop on the window
4220	* station associated with the calling process.
4221	* Parameters: LPCTSTR lpszDesktop name of the new desktop
4222	* LPCTSTR lpszDevice name of display device to assign to the desktop
4223	* LPDEVMODE pDevMode reserved; must be NULL
4224	* DWORD dwFlags flags to control interaction with other applications
4225	* DWORD dwDesiredAccess specifies access of returned handle
4226	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
4227	* Variables :
4228	* Result : If the function succeeds, the return value is a handle of the
4229	* newly created desktop.
4230	* If the function fails, the return value is NULL. To get extended
4231	* error information, call GetLastError.
4232	* Remark :
4233	* Status : UNTESTED STUB
4234	*
4235	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4236	*****************************************************************************/
4237
4238	HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
4239	LPCTSTR lpszDevice,
4240	LPDEVMODEW pDevMode,
4241	DWORD dwFlags,
4242	DWORD dwDesiredAccess,
4243	LPSECURITY_ATTRIBUTES lpsa)
4244	{
4245	dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4246	lpszDesktop,
4247	lpszDevice,
4248	pDevMode,
4249	dwFlags,
4250	dwDesiredAccess,
4251	lpsa));
4252
4253	return (NULL);
4254	}
4255
4256
4257	/*****************************************************************************
4258	* Name : HWINSTA WIN32API CreateWindowStationA
4259	* Purpose : The CreateWindowStation function creates a window station object.
4260	* It returns a handle that can be used to access the window station.
4261	* A window station is a secure object that contains a set of global
4262	* atoms, a clipboard, and a set of desktop objects.
4263	* Parameters: LPTSTR lpwinsta name of the new window station
4264	* DWORD dwReserved reserved; must be NULL
4265	* DWORD dwDesiredAccess specifies access of returned handle
4266	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4267	* Variables :
4268	* Result : If the function succeeds, the return value is the handle to the
4269	* newly created window station.
4270	* If the function fails, the return value is NULL. To get extended
4271	* error information, call GetLastError.
4272	* Remark :
4273	* Status : UNTESTED STUB
4274	*
4275	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4276	*****************************************************************************/
4277
4278	HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
4279	DWORD dwReserved,
4280	DWORD dwDesiredAccess,
4281	LPSECURITY_ATTRIBUTES lpsa)
4282	{
4283	dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
4284	lpWinSta,
4285	dwReserved,
4286	dwDesiredAccess,
4287	lpsa));
4288
4289	return (NULL);
4290	}
4291
4292
4293	/*****************************************************************************
4294	* Name : HWINSTA WIN32API CreateWindowStationW
4295	* Purpose : The CreateWindowStation function creates a window station object.
4296	* It returns a handle that can be used to access the window station.
4297	* A window station is a secure object that contains a set of global
4298	* atoms, a clipboard, and a set of desktop objects.
4299	* Parameters: LPTSTR lpwinsta name of the new window station
4300	* DWORD dwReserved reserved; must be NULL
4301	* DWORD dwDesiredAccess specifies access of returned handle
4302	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4303	* Variables :
4304	* Result : If the function succeeds, the return value is the handle to the
4305	* newly created window station.
4306	* If the function fails, the return value is NULL. To get extended
4307	* error information, call GetLastError.
4308	* Remark :
4309	* Status : UNTESTED STUB
4310	*
4311	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4312	*****************************************************************************/
4313
4314	HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
4315	DWORD dwReserved,
4316	DWORD dwDesiredAccess,
4317	LPSECURITY_ATTRIBUTES lpsa)
4318	{
4319	dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
4320	lpWinSta,
4321	dwReserved,
4322	dwDesiredAccess,
4323	lpsa));
4324
4325	return (NULL);
4326	}
4327
4328	/*****************************************************************************
4329	* Name : BOOL WIN32API DragDetect
4330	* Purpose : The DragDetect function captures the mouse and tracks its movement
4331	* Parameters: HWND hwnd
4332	* POINT pt
4333	* Variables :
4334	* Result : If the user moved the mouse outside of the drag rectangle while
4335	* holding the left button down, the return value is TRUE.
4336	* If the user did not move the mouse outside of the drag rectangle
4337	* while holding the left button down, the return value is FALSE.
4338	* Remark :
4339	* Status : UNTESTED STUB
4340	*
4341	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4342	*****************************************************************************/
4343
4344	BOOL WIN32API DragDetect(HWND hwnd,
4345	POINT pt)
4346	{
4347	dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
4348	hwnd));
4349
4350	return (FALSE);
4351	}
4352
4353
4354	/*****************************************************************************
4355	* Name : BOOL WIN32API DrawAnimatedRects
4356	* Purpose : The DrawAnimatedRects function draws a wire-frame rectangle
4357	* and animates it to indicate the opening of an icon or the
4358	* minimizing or maximizing of a window.
4359	* Parameters: HWND hwnd handle of clipping window
4360	* int idAni type of animation
4361	* CONST RECT * lprcFrom address of rectangle coordinates (minimized)
4362	* CONST RECT * lprcTo address of rectangle coordinates (restored)
4363	* Variables :
4364	* Result : If the function succeeds, the return value is TRUE.
4365	* If the function fails, the return value is FALSE.
4366	* Remark :
4367	* Status : UNTESTED STUB
4368	*
4369	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4370	*****************************************************************************/
4371
4372	BOOL WIN32API DrawAnimatedRects(HWND hwnd,
4373	int idAni,
4374	CONST RECT *lprcFrom,
4375	CONST RECT *lprcTo)
4376	{
4377	dprintf(("USER32:DrawAnimatedRects (%08xh,%u,%08xh,%08x) not implemented.\n",
4378	hwnd,
4379	idAni,
4380	lprcFrom,
4381	lprcTo));
4382
4383	return (TRUE);
4384	}
4385
4386
4387	/*****************************************************************************
4388	* Name : VOID WIN32API DrawCaption
4389	* Purpose : The DrawCaption function draws a window caption.
4390	* Parameters: HDC hdc handle of device context
4391	* LPRECT lprc address of bounding rectangle coordinates
4392	* HFONT hfont handle of font for caption
4393	* HICON hicon handle of icon in caption
4394	* LPSTR lpszText address of caption string
4395	* WORD wFlags drawing options
4396	* Variables :
4397	* Result :
4398	* Remark :
4399	* Status : UNTESTED STUB
4400	*
4401	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4402	*****************************************************************************/
4403
4404	BOOL WIN32API DrawCaption (HWND hwnd,
4405	HDC hdc,
4406	const RECT *lprc,
4407	UINT wFlags)
4408	{
4409	dprintf(("USER32:DrawCaption (%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4410	hwnd,
4411	hdc,
4412	lprc,
4413	wFlags));
4414
4415	return FALSE;
4416	}
4417
4418
4419	/*****************************************************************************
4420	* Name :
4421	* Purpose :
4422	* Parameters:
4423	* Variables :
4424	* Result :
4425	* Remark :
4426	* Status : UNTESTED STUB
4427	*
4428	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4429	*****************************************************************************/
4430
4431	BOOL WIN32API DrawStateW(HDC hdc,
4432	HBRUSH hBrush,
4433	DRAWSTATEPROC lpOutputFunc,
4434	LPARAM lParam,
4435	WPARAM wParam,
4436	int x,
4437	int y,
4438	int cx,
4439	int cy,
4440	UINT fuFlags)
4441	{
4442	dprintf(("USER32:DrawStateW (%08xh,%08xh,%08xh,%08xh,%08xh,%d,%d,%d,%d,%08x) not implemented.\n",
4443	hdc,
4444	hBrush,
4445	lpOutputFunc,
4446	lParam,
4447	wParam,
4448	x,
4449	y,
4450	cx,
4451	cy,
4452	fuFlags));
4453
4454	return(DrawStateA(hdc,
4455	hBrush,
4456	lpOutputFunc,
4457	lParam,
4458	wParam,
4459	x,
4460	y,
4461	cx,
4462	cy,
4463	fuFlags));
4464	}
4465
4466
4467	/*****************************************************************************
4468	* Name : BOOL WIN32API EnumDesktopWindows
4469	* Purpose : The EnumDesktopWindows function enumerates all windows in a
4470	* desktop by passing the handle of each window, in turn, to an
4471	* application-defined callback function.
4472	* Parameters: HDESK hDesktop handle of desktop to enumerate
4473	* WNDENUMPROC lpfn points to application's callback function
4474	* LPARAM lParam 32-bit value to pass to the callback function
4475	* Variables :
4476	* Result : If the function succeeds, the return value is TRUE.
4477	* If the function fails, the return value is FALSE. To get
4478	* extended error information, call GetLastError.
4479	* Remark :
4480	* Status : UNTESTED STUB
4481	*
4482	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4483	*****************************************************************************/
4484
4485	BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
4486	WNDENUMPROC lpfn,
4487	LPARAM lParam)
4488	{
4489	dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
4490	hDesktop,
4491	lpfn,
4492	lParam));
4493
4494	return (FALSE);
4495	}
4496
4497
4498	/*****************************************************************************
4499	* Name : BOOL WIN32API EnumDesktopsA
4500	* Purpose : The EnumDesktops function enumerates all desktops in the window
4501	* station assigned to the calling process. The function does so by
4502	* passing the name of each desktop, in turn, to an application-
4503	* defined callback function.
4504	* Parameters: HWINSTA hwinsta handle of window station to enumerate
4505	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
4506	* LPARAM lParam 32-bit value to pass to the callback function
4507	* Variables :
4508	* Result : If the function succeeds, the return value is TRUE.
4509	* If the function fails, the return value is FALSE. To get extended
4510	* error information, call GetLastError.
4511	* Remark :
4512	* Status : UNTESTED STUB
4513	*
4514	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4515	*****************************************************************************/
4516
4517	BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
4518	DESKTOPENUMPROCA lpEnumFunc,
4519	LPARAM lParam)
4520	{
4521	dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
4522	hWinSta,
4523	lpEnumFunc,
4524	lParam));
4525
4526	return (FALSE);
4527	}
4528
4529
4530	/*****************************************************************************
4531	* Name : BOOL WIN32API EnumDesktopsW
4532	* Purpose : The EnumDesktops function enumerates all desktops in the window
4533	* station assigned to the calling process. The function does so by
4534	* passing the name of each desktop, in turn, to an application-
4535	* defined callback function.
4536	* Parameters: HWINSTA hwinsta handle of window station to enumerate
4537	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
4538	* LPARAM lParam 32-bit value to pass to the callback function
4539	* Variables :
4540	* Result : If the function succeeds, the return value is TRUE.
4541	* If the function fails, the return value is FALSE. To get extended
4542	* error information, call GetLastError.
4543	* Remark :
4544	* Status : UNTESTED STUB
4545	*
4546	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4547	*****************************************************************************/
4548
4549	BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
4550	DESKTOPENUMPROCW lpEnumFunc,
4551	LPARAM lParam)
4552	{
4553	dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
4554	hWinSta,
4555	lpEnumFunc,
4556	lParam));
4557
4558	return (FALSE);
4559	}
4560
4561
4562
4563	/*****************************************************************************
4564	* Name : BOOL WIN32API EnumDisplaySettingsW
4565	* Purpose : The EnumDisplaySettings function obtains information about one
4566	* of a display device's graphics modes. You can obtain information
4567	* for all of a display device's graphics modes by making a series
4568	* of calls to this function.
4569	* Parameters: LPCTSTR lpszDeviceName specifies the display device
4570	* DWORD iModeNum specifies the graphics mode
4571	* LPDEVMODE lpDevMode points to structure to receive settings
4572	* Variables :
4573	* Result : If the function succeeds, the return value is TRUE.
4574	* If the function fails, the return value is FALSE.
4575	* Remark :
4576	* Status : UNTESTED STUB
4577	*
4578	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4579	*****************************************************************************/
4580
4581	BOOL WIN32API EnumDisplaySettingsW(LPCSTR lpszDeviceName,
4582	DWORD iModeNum,
4583	LPDEVMODEW lpDevMode)
4584	{
4585	dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
4586	lpszDeviceName,
4587	iModeNum,
4588	lpDevMode));
4589
4590	return (EnumDisplaySettingsA(lpszDeviceName,
4591	iModeNum,
4592	(LPDEVMODEA)lpDevMode));
4593	}
4594
4595
4596	/*****************************************************************************
4597	* Name : BOOL WIN32API EnumWindowStationsA
4598	* Purpose : The EnumWindowStations function enumerates all windowstations
4599	* in the system by passing the name of each window station, in
4600	* turn, to an application-defined callback function.
4601	* Parameters:
4602	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4603	* LPARAM lParam 32-bit value to pass to the callback function
4604	* Result : If the function succeeds, the return value is TRUE.
4605	* If the function fails the return value is FALSE. To get extended
4606	* error information, call GetLastError.
4607	* Remark :
4608	* Status : UNTESTED STUB
4609	*
4610	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4611	*****************************************************************************/
4612
4613	BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
4614	LPARAM lParam)
4615	{
4616	dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
4617	lpEnumFunc,
4618	lParam));
4619
4620	return (FALSE);
4621	}
4622
4623
4624	/*****************************************************************************
4625	* Name : BOOL WIN32API EnumWindowStationsW
4626	* Purpose : The EnumWindowStations function enumerates all windowstations
4627	* in the system by passing the name of each window station, in
4628	* turn, to an application-defined callback function.
4629	* Parameters:
4630	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4631	* LPARAM lParam 32-bit value to pass to the callback function
4632	* Result : If the function succeeds, the return value is TRUE.
4633	* If the function fails the return value is FALSE. To get extended
4634	* error information, call GetLastError.
4635	* Remark :
4636	* Status : UNTESTED STUB
4637	*
4638	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4639	*****************************************************************************/
4640
4641	BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
4642	LPARAM lParam)
4643	{
4644	dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
4645	lpEnumFunc,
4646	lParam));
4647
4648	return (FALSE);
4649	}
4650
4651
4652	/*****************************************************************************
4653	* Name : HWND WIN32API FindWindowExW
4654	* Purpose : The FindWindowEx function retrieves the handle of a window whose
4655	* class name and window name match the specified strings. The
4656	* function searches child windows, beginning with the one following
4657	* the given child window.
4658	* Parameters: HWND hwndParent handle of parent window
4659	* HWND hwndChildAfter handle of a child window
4660	* LPCTSTR lpszClass address of class name
4661	* LPCTSTR lpszWindow address of window name
4662	* Variables :
4663	* Result : If the function succeeds, the return value is the handle of the
4664	* window that has the specified class and window names.
4665	* If the function fails, the return value is NULL. To get extended
4666	* error information, call GetLastError.
4667	* Remark :
4668	* Status : UNTESTED STUB
4669	*
4670	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4671	*****************************************************************************/
4672
4673	HWND WIN32API FindWindowExW(HWND hwndParent,
4674	HWND hwndChildAfter,
4675	LPCWSTR lpszClass,
4676	LPCWSTR lpszWindow)
4677	{
4678	dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
4679	hwndParent,
4680	hwndChildAfter,
4681	lpszClass,
4682	lpszWindow));
4683
4684	return (NULL);
4685	}
4686
4687	/*****************************************************************************
4688	* Name : BOOL WIN32API GetInputState
4689	* Purpose : The GetInputState function determines whether there are
4690	* mouse-button or keyboard messages in the calling thread's message queue.
4691	* Parameters:
4692	* Variables :
4693	* Result : If the queue contains one or more new mouse-button or keyboard
4694	* messages, the return value is TRUE.
4695	* If the function fails, the return value is FALSE.
4696	* Remark :
4697	* Status : UNTESTED STUB
4698	*
4699	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4700	*****************************************************************************/
4701
4702	BOOL WIN32API GetInputState(VOID)
4703	{
4704	dprintf(("USER32:GetInputState () not implemented.\n"));
4705
4706	return (FALSE);
4707	}
4708
4709
4710	/*****************************************************************************
4711	* Name : UINT WIN32API GetKBCodePage
4712	* Purpose : The GetKBCodePage function is provided for compatibility with
4713	* earlier versions of Windows. In the Win32 application programming
4714	* interface (API) it just calls the GetOEMCP function.
4715	* Parameters:
4716	* Variables :
4717	* Result : If the function succeeds, the return value is an OEM code-page
4718	* identifier, or it is the default identifier if the registry
4719	* value is not readable. For a list of OEM code-page identifiers,
4720	* see GetOEMCP.
4721	* Remark :
4722	* Status : UNTESTED
4723	*
4724	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4725	*****************************************************************************/
4726
4727	UINT WIN32API GetKBCodePage(VOID)
4728	{
4729	return (GetOEMCP());
4730	}
4731
4732
4733	/*****************************************************************************
4734	* Name : BOOL WIN32API GetKeyboardLayoutNameA
4735	* Purpose : The GetKeyboardLayoutName function retrieves the name of the
4736	* active keyboard layout.
4737	* Parameters: LPTSTR pwszKLID address of buffer for layout name
4738	* Variables :
4739	* Result : If the function succeeds, the return value is TRUE.
4740	* If the function fails, the return value is FALSE. To get extended
4741	* error information, call GetLastError.
4742	* Remark :
4743	* Status : UNTESTED STUB
4744	*
4745	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4746	*****************************************************************************/
4747
4748	BOOL WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
4749	{
4750	dprintf(("USER32:GetKeyboardLayoutNameA (%08x) not implemented.",
4751	pwszKLID));
4752
4753	return(FALSE);
4754	}
4755
4756
4757	/*****************************************************************************
4758	* Name : BOOL WIN32API GetKeyboardLayoutNameW
4759	* Purpose : The GetKeyboardLayoutName function retrieves the name of the
4760	* active keyboard layout.
4761	* Parameters: LPTSTR pwszKLID address of buffer for layout name
4762	* Variables :
4763	* Result : If the function succeeds, the return value is TRUE.
4764	* If the function fails, the return value is FALSE. To get extended
4765	* error information, call GetLastError.
4766	* Remark :
4767	* Status : UNTESTED STUB
4768	*
4769	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4770	*****************************************************************************/
4771
4772	BOOL WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
4773	{
4774	dprintf(("USER32:GetKeyboardLayoutNameW (%08x) not implemented.",
4775	pwszKLID));
4776
4777	return(FALSE);
4778	}
4779
4780
4781
4782
4783	/*****************************************************************************
4784	* Name : HWINSTA WIN32API GetProcessWindowStation
4785	* Purpose : The GetProcessWindowStation function returns a handle of the
4786	* window station associated with the calling process.
4787	* Parameters:
4788	* Variables :
4789	* Result : If the function succeeds, the return value is a handle of the
4790	* window station associated with the calling process.
4791	* If the function fails, the return value is NULL. This can occur
4792	* if the calling process is not an application written for Windows
4793	* NT. To get extended error information, call GetLastError.
4794	* Remark :
4795	* Status : UNTESTED STUB
4796	*
4797	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4798	*****************************************************************************/
4799
4800	HWINSTA WIN32API GetProcessWindowStation(VOID)
4801	{
4802	dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
4803
4804	return (NULL);
4805	}
4806
4807
4808
4809	/*****************************************************************************
4810	* Name : HDESK WIN32API GetThreadDesktop
4811	* Purpose : The GetThreadDesktop function returns a handle to the desktop
4812	* associated with a specified thread.
4813	* Parameters: DWORD dwThreadId thread identifier
4814	* Variables :
4815	* Result : If the function succeeds, the return value is the handle of the
4816	* desktop associated with the specified thread.
4817	* Remark :
4818	* Status : UNTESTED STUB
4819	*
4820	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4821	*****************************************************************************/
4822
4823	HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
4824	{
4825	dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
4826	dwThreadId));
4827
4828	return (NULL);
4829	}
4830
4831
4832	/*****************************************************************************
4833	* Name : BOOL WIN32API GetUserObjectInformationA
4834	* Purpose : The GetUserObjectInformation function returns information about
4835	* a window station or desktop object.
4836	* Parameters: HANDLE hObj handle of object to get information for
4837	* int nIndex type of information to get
4838	* PVOID pvInfo points to buffer that receives the information
4839	* DWORD nLength size, in bytes, of pvInfo buffer
4840	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4841	* Variables :
4842	* Result : If the function succeeds, the return value is TRUE.
4843	* If the function fails, the return value is FALSE. To get extended
4844	* error information, call GetLastError.
4845	* Remark :
4846	* Status : UNTESTED STUB
4847	*
4848	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4849	*****************************************************************************/
4850
4851	BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
4852	int nIndex,
4853	PVOID pvInfo,
4854	DWORD nLength,
4855	LPDWORD lpnLengthNeeded)
4856	{
4857	dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4858	hObj,
4859	nIndex,
4860	pvInfo,
4861	nLength,
4862	lpnLengthNeeded));
4863
4864	return (FALSE);
4865	}
4866
4867
4868	/*****************************************************************************
4869	* Name : BOOL WIN32API GetUserObjectInformationW
4870	* Purpose : The GetUserObjectInformation function returns information about
4871	* a window station or desktop object.
4872	* Parameters: HANDLE hObj handle of object to get information for
4873	* int nIndex type of information to get
4874	* PVOID pvInfo points to buffer that receives the information
4875	* DWORD nLength size, in bytes, of pvInfo buffer
4876	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4877	* Variables :
4878	* Result : If the function succeeds, the return value is TRUE.
4879	* If the function fails, the return value is FALSE. To get extended
4880	* error information, call GetLastError.
4881	* Remark :
4882	* Status : UNTESTED STUB
4883	*
4884	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4885	*****************************************************************************/
4886
4887	BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
4888	int nIndex,
4889	PVOID pvInfo,
4890	DWORD nLength,
4891	LPDWORD lpnLengthNeeded)
4892	{
4893	dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4894	hObj,
4895	nIndex,
4896	pvInfo,
4897	nLength,
4898	lpnLengthNeeded));
4899
4900	return (FALSE);
4901	}
4902
4903
4904	/*****************************************************************************
4905	* Name : BOOL WIN32API GetUserObjectSecurity
4906	* Purpose : The GetUserObjectSecurity function retrieves security information
4907	* for the specified user object.
4908	* Parameters: HANDLE hObj handle of user object
4909	* SECURITY_INFORMATION * pSIRequested address of requested security information
4910	* LPSECURITY_DESCRIPTOR pSID address of security descriptor
4911	* DWORD nLength size of buffer for security descriptor
4912	* LPDWORD lpnLengthNeeded address of required size of buffer
4913	* Variables :
4914	* Result : If the function succeeds, the return value is TRUE.
4915	* If the function fails, the return value is FALSE. To get extended
4916	* error information, call GetLastError.
4917	* Remark :
4918	* Status : UNTESTED STUB
4919	*
4920	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4921	*****************************************************************************/
4922
4923	BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
4924	SECURITY_INFORMATION * pSIRequested,
4925	LPSECURITY_DESCRIPTOR pSID,
4926	DWORD nLength,
4927	LPDWORD lpnLengthNeeded)
4928	{
4929	dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4930	hObj,
4931	pSIRequested,
4932	pSID,
4933	nLength,
4934	lpnLengthNeeded));
4935
4936	return (FALSE);
4937	}
4938
4939
4940
4941	/*****************************************************************************
4942	* Name : int WIN32API GetWindowRgn
4943	* Purpose : The GetWindowRgn function obtains a copy of the window region of a window.
4944	* Parameters: HWND hWnd handle to window whose window region is to be obtained
4945	* HRGN hRgn handle to region that receives a copy of the window region
4946	* Variables :
4947	* Result : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
4948	* Remark :
4949	* Status : UNTESTED STUB
4950	*
4951	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4952	*****************************************************************************/
4953
4954	int WIN32API GetWindowRgn (HWND hWnd,
4955	HRGN hRgn)
4956	{
4957	dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
4958	hWnd,
4959	hRgn));
4960
4961	return (NULLREGION);
4962	}
4963
4964
4965
4966	/*****************************************************************************
4967	* Name : HCURSOR WIN32API LoadCursorFromFileA
4968	* Purpose : The LoadCursorFromFile function creates a cursor based on data
4969	* contained in a file. The file is specified by its name or by a
4970	* system cursor identifier. The function returns a handle to the
4971	* newly created cursor. Files containing cursor data may be in
4972	* either cursor (.CUR) or animated cursor (.ANI) format.
4973	* Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4974	* Variables :
4975	* Result : If the function is successful, the return value is a handle to
4976	* the new cursor.
4977	* If the function fails, the return value is NULL. To get extended
4978	* error information, call GetLastError. GetLastError may return
4979	* the following
4980	* Remark :
4981	* Status : UNTESTED STUB
4982	*
4983	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4984	*****************************************************************************/
4985
4986	HCURSOR WIN32API LoadCursorFromFileA(LPCTSTR lpFileName)
4987	{
4988	dprintf(("USER32:LoadCursorFromFileA (%s) not implemented.\n",
4989	lpFileName));
4990
4991	return (NULL);
4992	}
4993
4994
4995	/*****************************************************************************
4996	* Name : HCURSOR WIN32API LoadCursorFromFileW
4997	* Purpose : The LoadCursorFromFile function creates a cursor based on data
4998	* contained in a file. The file is specified by its name or by a
4999	* system cursor identifier. The function returns a handle to the
5000	* newly created cursor. Files containing cursor data may be in
5001	* either cursor (.CUR) or animated cursor (.ANI) format.
5002	* Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
5003	* Variables :
5004	* Result : If the function is successful, the return value is a handle to
5005	* the new cursor.
5006	* If the function fails, the return value is NULL. To get extended
5007	* error information, call GetLastError. GetLastError may return
5008	* the following
5009	* Remark :
5010	* Status : UNTESTED STUB
5011	*
5012	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5013	*****************************************************************************/
5014
5015	HCURSOR WIN32API LoadCursorFromFileW(LPCWSTR lpFileName)
5016	{
5017	dprintf(("USER32:LoadCursorFromFileW (%s) not implemented.\n",
5018	lpFileName));
5019
5020	return (NULL);
5021	}
5022
5023
5024	/*****************************************************************************
5025	* Name : HLK WIN32API LoadKeyboardLayoutA
5026	* Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
5027	* the system. Several keyboard layouts can be loaded at a time, but
5028	* only one per process is active at a time. Loading multiple keyboard
5029	* layouts makes it possible to rapidly switch between layouts.
5030	* Parameters:
5031	* Variables :
5032	* Result : If the function succeeds, the return value is the handle of the
5033	* keyboard layout.
5034	* If the function fails, the return value is NULL. To get extended
5035	* error information, call GetLastError.
5036	* Remark :
5037	* Status : UNTESTED STUB
5038	*
5039	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5040	*****************************************************************************/
5041
5042	HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
5043	UINT Flags)
5044	{
5045	dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
5046	pwszKLID,
5047	Flags));
5048
5049	return (NULL);
5050	}
5051
5052
5053	/*****************************************************************************
5054	* Name : HLK WIN32API LoadKeyboardLayoutW
5055	* Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
5056	* the system. Several keyboard layouts can be loaded at a time, but
5057	* only one per process is active at a time. Loading multiple keyboard
5058	* layouts makes it possible to rapidly switch between layouts.
5059	* Parameters:
5060	* Variables :
5061	* Result : If the function succeeds, the return value is the handle of the
5062	* keyboard layout.
5063	* If the function fails, the return value is NULL. To get extended
5064	* error information, call GetLastError.
5065	* Remark :
5066	* Status : UNTESTED STUB
5067	*
5068	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5069	*****************************************************************************/
5070
5071	HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
5072	UINT Flags)
5073	{
5074	dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
5075	pwszKLID,
5076	Flags));
5077
5078	return (NULL);
5079	}
5080
5081
5082	/*****************************************************************************
5083	* Name : UINT WIN32API MapVirtualKeyExA
5084	* Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
5085	* code into a scan code or character value, or translates a scan
5086	* code into a virtual-key code. The function translates the codes
5087	* using the input language and physical keyboard layout identified
5088	* by the given keyboard layout handle.
5089	* Parameters:
5090	* Variables :
5091	* Result : The return value is either a scan code, a virtual-key code, or
5092	* a character value, depending on the value of uCode and uMapType.
5093	* If there is no translation, the return value is zero.
5094	* Remark :
5095	* Status : UNTESTED STUB
5096	*
5097	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5098	*****************************************************************************/
5099
5100	UINT WIN32API MapVirtualKeyExA(UINT uCode,
5101	UINT uMapType,
5102	HKL dwhkl)
5103	{
5104	dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
5105	uCode,
5106	uMapType,
5107	dwhkl));
5108
5109	return (0);
5110	}
5111
5112
5113	/*****************************************************************************
5114	* Name : UINT WIN32API MapVirtualKeyExW
5115	* Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
5116	* code into a scan code or character value, or translates a scan
5117	* code into a virtual-key code. The function translates the codes
5118	* using the input language and physical keyboard layout identified
5119	* by the given keyboard layout handle.
5120	* Parameters:
5121	* Variables :
5122	* Result : The return value is either a scan code, a virtual-key code, or
5123	* a character value, depending on the value of uCode and uMapType.
5124	* If there is no translation, the return value is zero.
5125	* Remark :
5126	* Status : UNTESTED STUB
5127	*
5128	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5129	*****************************************************************************/
5130
5131	UINT WIN32API MapVirtualKeyExW(UINT uCode,
5132	UINT uMapType,
5133	HKL dwhkl)
5134	{
5135	dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
5136	uCode,
5137	uMapType,
5138	dwhkl));
5139
5140	return (0);
5141	}
5142
5143
5144	/*****************************************************************************
5145	* Name : int WIN32API MessageBoxExA
5146	* Purpose : The MessageBoxEx function creates, displays, and operates a message box.
5147	* Parameters: HWND hWnd handle of owner window
5148	* LPCTSTR lpText address of text in message box
5149	* LPCTSTR lpCaption address of title of message box
5150	* UINT uType style of message box
5151	* WORD wLanguageId language identifier
5152	* Variables :
5153	* Result : If the function succeeds, the return value is a nonzero menu-item
5154	* value returned by the dialog box.
5155	* Remark :
5156	* Status : UNTESTED STUB
5157	*
5158	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5159	*****************************************************************************/
5160
5161	int WIN32API MessageBoxExA(HWND hWnd,
5162	LPCTSTR lpText,
5163	LPCTSTR lpCaption,
5164	UINT uType,
5165	WORD wLanguageId)
5166	{
5167	dprintf(("USER32:MessageBoxExA (%08xh,%s,%s,%u,%08w) not implemented.\n",
5168	hWnd,
5169	lpText,
5170	lpCaption,
5171	uType,
5172	wLanguageId));
5173
5174	return (MessageBoxA(hWnd,
5175	lpText,
5176	lpCaption,
5177	uType));
5178	}
5179
5180
5181	/*****************************************************************************
5182	* Name : int WIN32API MessageBoxExW
5183	* Purpose : The MessageBoxEx function creates, displays, and operates a message box.
5184	* Parameters: HWND hWnd handle of owner window
5185	* LPCTSTR lpText address of text in message box
5186	* LPCTSTR lpCaption address of title of message box
5187	* UINT uType style of message box
5188	* WORD wLanguageId language identifier
5189	* Variables :
5190	* Result : If the function succeeds, the return value is a nonzero menu-item
5191	* value returned by the dialog box.
5192	* Remark :
5193	* Status : UNTESTED STUB
5194	*
5195	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5196	*****************************************************************************/
5197
5198	int WIN32API MessageBoxExW(HWND hWnd,
5199	LPCWSTR lpText,
5200	LPCWSTR lpCaption,
5201	UINT uType,
5202	WORD wLanguageId)
5203	{
5204
5205	dprintf(("USER32:MessageBoxExW (%08xh,%x,%x,%u,%08w) not implemented.\n",
5206	hWnd,
5207	lpText,
5208	lpCaption,
5209	uType,
5210	wLanguageId));
5211
5212	return MessageBoxW(hWnd, lpText, lpCaption, uType);
5213	}
5214
5215
5216	/*****************************************************************************
5217	* Name : BOOL WIN32API MessageBoxIndirectW
5218	* Purpose : The MessageBoxIndirect function creates, displays, and operates
5219	* a message box. The message box contains application-defined
5220	* message text and title, any icon, and any combination of
5221	* predefined push buttons.
5222	* Parameters:
5223	* Variables :
5224	* Result :
5225	* Remark :
5226	* Status : UNTESTED STUB
5227	*
5228	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5229	*****************************************************************************/
5230
5231	BOOL WIN32API MessageBoxIndirectW(LPMSGBOXPARAMSW lpMsgBoxParams)
5232	{
5233	dprintf(("USER32:MessageBoxIndirectW (%08x) not implemented.\n",
5234	lpMsgBoxParams));
5235
5236	return (FALSE);
5237	}
5238
5239
5240	/*****************************************************************************
5241	* Name : BOOL WIN32API MessageBoxIndirectA
5242	* Purpose : The MessageBoxIndirect function creates, displays, and operates
5243	* a message box. The message box contains application-defined
5244	* message text and title, any icon, and any combination of
5245	* predefined push buttons.
5246	* Parameters:
5247	* Variables :
5248	* Result :
5249	* Remark :
5250	* Status : UNTESTED STUB
5251	*
5252	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5253	*****************************************************************************/
5254
5255	BOOL WIN32API MessageBoxIndirectA(LPMSGBOXPARAMSA lpMsgBoxParams)
5256	{
5257	dprintf(("USER32:MessageBoxIndirectA (%08x) not implemented.\n",
5258	lpMsgBoxParams));
5259
5260	return (FALSE);
5261	}
5262
5263
5264	/*****************************************************************************
5265	* Name : DWORD WIN32API OemKeyScan
5266	* Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
5267	* into the OEM scan codes and shift states. The function provides
5268	* information that allows a program to send OEM text to another
5269	* program by simulating keyboard input.
5270	* Parameters:
5271	* Variables :
5272	* Result :
5273	* Remark :
5274	* Status : UNTESTED STUB
5275	*
5276	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5277	*****************************************************************************/
5278
5279	DWORD WIN32API OemKeyScan(WORD wOemChar)
5280	{
5281	dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
5282	wOemChar));
5283
5284	return (wOemChar);
5285	}
5286
5287
5288	/*****************************************************************************
5289	* Name : HDESK WIN32API OpenDesktopA
5290	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
5291	* A desktop is a secure object contained within a window station
5292	* object. A desktop has a logical display surface and contains
5293	* windows, menus and hooks.
5294	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5295	* DWORD dwFlags flags to control interaction with other applications
5296	* BOOL fInherit specifies whether returned handle is inheritable
5297	* DWORD dwDesiredAccess specifies access of returned handle
5298	* Variables :
5299	* Result : If the function succeeds, the return value is the handle to the
5300	* opened desktop.
5301	* If the function fails, the return value is NULL. To get extended
5302	* error information, call GetLastError.
5303	* Remark :
5304	* Status : UNTESTED STUB
5305	*
5306	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5307	*****************************************************************************/
5308
5309	HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
5310	DWORD dwFlags,
5311	BOOL fInherit,
5312	DWORD dwDesiredAccess)
5313	{
5314	dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
5315	lpszDesktopName,
5316	dwFlags,
5317	fInherit,
5318	dwDesiredAccess));
5319
5320	return (NULL);
5321	}
5322
5323
5324	/*****************************************************************************
5325	* Name : HDESK WIN32API OpenDesktopW
5326	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
5327	* A desktop is a secure object contained within a window station
5328	* object. A desktop has a logical display surface and contains
5329	* windows, menus and hooks.
5330	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5331	* DWORD dwFlags flags to control interaction with other applications
5332	* BOOL fInherit specifies whether returned handle is inheritable
5333	* DWORD dwDesiredAccess specifies access of returned handle
5334	* Variables :
5335	* Result : If the function succeeds, the return value is the handle to the
5336	* opened desktop.
5337	* If the function fails, the return value is NULL. To get extended
5338	* error information, call GetLastError.
5339	* Remark :
5340	* Status : UNTESTED STUB
5341	*
5342	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5343	*****************************************************************************/
5344
5345	HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
5346	DWORD dwFlags,
5347	BOOL fInherit,
5348	DWORD dwDesiredAccess)
5349	{
5350	dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
5351	lpszDesktopName,
5352	dwFlags,
5353	fInherit,
5354	dwDesiredAccess));
5355
5356	return (NULL);
5357	}
5358
5359
5360	/*****************************************************************************
5361	* Name : HDESK WIN32API OpenInputDesktop
5362	* Purpose : The OpenInputDesktop function returns a handle to the desktop
5363	* that receives user input. The input desktop is a desktop on the
5364	* window station associated with the logged-on user.
5365	* Parameters: DWORD dwFlags flags to control interaction with other applications
5366	* BOOL fInherit specifies whether returned handle is inheritable
5367	* DWORD dwDesiredAccess specifies access of returned handle
5368	* Variables :
5369	* Result : If the function succeeds, the return value is a handle of the
5370	* desktop that receives user input.
5371	* If the function fails, the return value is NULL. To get extended
5372	* error information, call GetLastError.
5373	* Remark :
5374	* Status : UNTESTED STUB
5375	*
5376	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5377	*****************************************************************************/
5378
5379	HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
5380	BOOL fInherit,
5381	DWORD dwDesiredAccess)
5382	{
5383	dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
5384	dwFlags,
5385	fInherit,
5386	dwDesiredAccess));
5387
5388	return (NULL);
5389	}
5390
5391
5392	/*****************************************************************************
5393	* Name : HWINSTA WIN32API OpenWindowStationA
5394	* Purpose : The OpenWindowStation function returns a handle to an existing
5395	* window station.
5396	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
5397	* BOOL fInherit specifies whether returned handle is inheritable
5398	* DWORD dwDesiredAccess specifies access of returned handle
5399	* Variables :
5400	* Result : If the function succeeds, the return value is the handle to the
5401	* specified window station.
5402	* If the function fails, the return value is NULL. To get extended
5403	* error information, call GetLastError.
5404	* Remark :
5405	* Status : UNTESTED STUB
5406	*
5407	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5408	*****************************************************************************/
5409
5410	HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
5411	BOOL fInherit,
5412	DWORD dwDesiredAccess)
5413	{
5414	dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
5415	lpszWinStaName,
5416	fInherit,
5417	dwDesiredAccess));
5418
5419	return (NULL);
5420	}
5421
5422
5423	/*****************************************************************************
5424	* Name : HWINSTA WIN32API OpenWindowStationW
5425	* Purpose : The OpenWindowStation function returns a handle to an existing
5426	* window station.
5427	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
5428	* BOOL fInherit specifies whether returned handle is inheritable
5429	* DWORD dwDesiredAccess specifies access of returned handle
5430	* Variables :
5431	* Result : If the function succeeds, the return value is the handle to the
5432	* specified window station.
5433	* If the function fails, the return value is NULL. To get extended
5434	* error information, call GetLastError.
5435
5436	* Remark :
5437	* Status : UNTESTED STUB
5438	*
5439	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5440	*****************************************************************************/
5441
5442	HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
5443	BOOL fInherit,
5444	DWORD dwDesiredAccess)
5445	{
5446	dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
5447	lpszWinStaName,
5448	fInherit,
5449	dwDesiredAccess));
5450
5451	return (NULL);
5452	}
5453
5454
5455	/*****************************************************************************
5456	* Name : BOOL WIN32API PaintDesktop
5457	* Purpose : The PaintDesktop function fills the clipping region in the
5458	* specified device context with the desktop pattern or wallpaper.
5459	* The function is provided primarily for shell desktops.
5460	* Parameters:
5461	* Variables :
5462	* Result : If the function succeeds, the return value is TRUE.
5463	* If the function fails, the return value is FALSE.
5464	* Remark :
5465	* Status : UNTESTED STUB
5466	*
5467	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5468	*****************************************************************************/
5469
5470	BOOL WIN32API PaintDesktop(HDC hdc)
5471	{
5472	dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
5473	hdc));
5474
5475	return (FALSE);
5476	}
5477
5478
5479	/*****************************************************************************
5480	* Name : BOOL WIN32API SendMessageCallbackA
5481	* Purpose : The SendMessageCallback function sends the specified message to
5482	* a window or windows. The function calls the window procedure for
5483	* the specified window and returns immediately. After the window
5484	* procedure processes the message, the system calls the specified
5485	* callback function, passing the result of the message processing
5486	* and an application-defined value to the callback function.
5487	* Parameters: HWND hwnd handle of destination window
5488	* UINT uMsg message to send
5489	* WPARAM wParam first message parameter
5490	* LPARAM lParam second message parameter
5491	* SENDASYNCPROC lpResultCallBack function to receive message value
5492	* DWORD dwData value to pass to callback function
5493	* Variables :
5494	* Result : If the function succeeds, the return value is TRUE.
5495	* If the function fails, the return value is FALSE. To get extended
5496	* error information, call GetLastError.
5497	* Remark :
5498	* Status : UNTESTED STUB
5499	*
5500	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5501	*****************************************************************************/
5502
5503	BOOL WIN32API SendMessageCallbackA(HWND hWnd,
5504	UINT uMsg,
5505	WPARAM wParam,
5506	LPARAM lParam,
5507	SENDASYNCPROC lpResultCallBack,
5508	DWORD dwData)
5509	{
5510	dprintf(("USER32:SendMessageCallBackA (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5511	hWnd,
5512	uMsg,
5513	wParam,
5514	lParam,
5515	lpResultCallBack,
5516	dwData));
5517
5518	return (FALSE);
5519	}
5520
5521
5522	/*****************************************************************************
5523	* Name : BOOL WIN32API SendMessageCallbackW
5524	* Purpose : The SendMessageCallback function sends the specified message to
5525	* a window or windows. The function calls the window procedure for
5526	* the specified window and returns immediately. After the window
5527	* procedure processes the message, the system calls the specified
5528	* callback function, passing the result of the message processing
5529	* and an application-defined value to the callback function.
5530	* Parameters: HWND hwnd handle of destination window
5531	* UINT uMsg message to send
5532	* WPARAM wParam first message parameter
5533	* LPARAM lParam second message parameter
5534	* SENDASYNCPROC lpResultCallBack function to receive message value
5535	* DWORD dwData value to pass to callback function
5536	* Variables :
5537	* Result : If the function succeeds, the return value is TRUE.
5538	* If the function fails, the return value is FALSE. To get extended
5539	* error information, call GetLastError.
5540	* Remark :
5541	* Status : UNTESTED STUB
5542	*
5543	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5544	*****************************************************************************/
5545
5546	BOOL WIN32API SendMessageCallbackW(HWND hWnd,
5547	UINT uMsg,
5548	WPARAM wParam,
5549	LPARAM lParam,
5550	SENDASYNCPROC lpResultCallBack,
5551	DWORD dwData)
5552	{
5553	dprintf(("USER32:SendMessageCallBackW (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5554	hWnd,
5555	uMsg,
5556	wParam,
5557	lParam,
5558	lpResultCallBack,
5559	dwData));
5560
5561	return (FALSE);
5562	}
5563
5564
5565	/*****************************************************************************
5566	* Name : VOID WIN32API SetDebugErrorLevel
5567	* Purpose : The SetDebugErrorLevel function sets the minimum error level at
5568	* which Windows will generate debugging events and pass them to a debugger.
5569	* Parameters: DWORD dwLevel debugging error level
5570	* Variables :
5571	* Result :
5572	* Remark :
5573	* Status : UNTESTED STUB
5574	*
5575	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5576	*****************************************************************************/
5577
5578	VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
5579	{
5580	dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
5581	dwLevel));
5582	}
5583
5584
5585	/*****************************************************************************
5586	* Name : BOOL WIN32API SetProcessWindowStation
5587	* Purpose : The SetProcessWindowStation function assigns a window station
5588	* to the calling process. This enables the process to access
5589	* objects in the window station such as desktops, the clipboard,
5590	* and global atoms. All subsequent operations on the window station
5591	* use the access rights granted to hWinSta.
5592	* Parameters:
5593	* Variables :
5594	* Result : If the function succeeds, the return value is TRUE.
5595	* If the function fails, the return value is FALSE. To get extended
5596	* error information, call GetLastError.
5597	* Remark :
5598	* Status : UNTESTED STUB
5599	*
5600	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5601	*****************************************************************************/
5602
5603	BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
5604	{
5605	dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
5606	hWinSta));
5607
5608	return (FALSE);
5609	}
5610
5611
5612	/*****************************************************************************
5613	* Name : BOOL WIN32API SetSystemCursor
5614	* Purpose : The SetSystemCursor function replaces the contents of the system
5615	* cursor specified by dwCursorId with the contents of the cursor
5616	* specified by hCursor, and then destroys hCursor. This function
5617	* lets an application customize the system cursors.
5618	* Parameters: HCURSOR hCursor set specified system cursor to this cursor's
5619	* contents, then destroy this
5620	* DWORD dwCursorID system cursor specified by its identifier
5621	* Variables :
5622	* Result : If the function succeeds, the return value is TRUE.
5623	* If the function fails, the return value is FALSE. To get extended
5624	* error information, call GetLastError.
5625	* Remark :
5626	* Status : UNTESTED STUB
5627	*
5628	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5629	*****************************************************************************/
5630
5631	BOOL WIN32API SetSystemCursor(HCURSOR hCursor,
5632	DWORD dwCursorId)
5633	{
5634	dprintf(("USER32:SetSystemCursor (%08xh,%08x) not implemented.\n",
5635	hCursor,
5636	dwCursorId));
5637
5638	return (FALSE);
5639	}
5640
5641
5642	/*****************************************************************************
5643	* Name : BOOL WIN32API SetThreadDesktop
5644	* Purpose : The SetThreadDesktop function assigns a desktop to the calling
5645	* thread. All subsequent operations on the desktop use the access
5646	* rights granted to hDesk.
5647	* Parameters: HDESK hDesk handle of the desktop to assign to this thread
5648	* Variables :
5649	* Result : If the function succeeds, the return value is TRUE.
5650	* If the function fails, the return value is FALSE. To get extended
5651	* error information, call GetLastError.
5652	* Remark :
5653	* Status : UNTESTED STUB
5654	*
5655	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5656	*****************************************************************************/
5657
5658	BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
5659	{
5660	dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
5661	hDesktop));
5662
5663	return (FALSE);
5664	}
5665
5666
5667	/*****************************************************************************
5668	* Name : BOOL WIN32API SetUserObjectInformationA
5669	* Purpose : The SetUserObjectInformation function sets information about a
5670	* window station or desktop object.
5671	* Parameters: HANDLE hObject handle of the object for which to set information
5672	* int nIndex type of information to set
5673	* PVOID lpvInfo points to a buffer that contains the information
5674	* DWORD cbInfo size, in bytes, of lpvInfo buffer
5675	* Variables :
5676	* Result : If the function succeeds, the return value is TRUE.
5677	* If the function fails the return value is FALSE. To get extended
5678	* error information, call GetLastError.
5679	* Remark :
5680	* Status : UNTESTED STUB
5681	*
5682	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5683	*****************************************************************************/
5684
5685	BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
5686	int nIndex,
5687	PVOID lpvInfo,
5688	DWORD cbInfo)
5689	{
5690	dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
5691	hObject,
5692	nIndex,
5693	lpvInfo,
5694	cbInfo));
5695
5696	return (FALSE);
5697	}
5698
5699
5700	/*****************************************************************************
5701	* Name : BOOL WIN32API SetUserObjectInformationW
5702	* Purpose : The SetUserObjectInformation function sets information about a
5703	* window station or desktop object.
5704	* Parameters: HANDLE hObject handle of the object for which to set information
5705	* int nIndex type of information to set
5706	* PVOID lpvInfo points to a buffer that contains the information
5707	* DWORD cbInfo size, in bytes, of lpvInfo buffer
5708	* Variables :
5709	* Result : If the function succeeds, the return value is TRUE.
5710	* If the function fails the return value is FALSE. To get extended
5711	* error information, call GetLastError.
5712	* Remark :
5713	* Status : UNTESTED STUB
5714	*
5715	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5716	*****************************************************************************/
5717
5718	BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
5719	int nIndex,
5720	PVOID lpvInfo,
5721	DWORD cbInfo)
5722	{
5723	dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
5724	hObject,
5725	nIndex,
5726	lpvInfo,
5727	cbInfo));
5728
5729	return (FALSE);
5730	}
5731
5732
5733	/*****************************************************************************
5734	* Name : BOOL WIN32API SetUserObjectSecurity
5735	* Purpose : The SetUserObjectSecurity function sets the security of a user
5736	* object. This can be, for example, a window or a DDE conversation
5737	* Parameters: HANDLE hObject handle of user object
5738	* SECURITY_INFORMATION * psi address of security information
5739	* LPSECURITY_DESCRIPTOR psd address of security descriptor
5740	* Variables :
5741	* Result : If the function succeeds, the return value is TRUE.
5742	* If the function fails, the return value is FALSE. To get extended
5743	* error information, call GetLastError.
5744	* Remark :
5745	* Status : UNTESTED STUB
5746	*
5747	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5748	*****************************************************************************/
5749
5750	BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
5751	SECURITY_INFORMATION * psi,
5752	LPSECURITY_DESCRIPTOR psd)
5753	{
5754	dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
5755	hObject,
5756	psi,
5757	psd));
5758
5759	return (FALSE);
5760	}
5761
5762
5763	/*****************************************************************************
5764	* Name : int WIN32API SetWindowRgn
5765	* Purpose : The SetWindowRgn function sets the window region of a window. The
5766	* window region determines the area within the window where the
5767	* operating system permits drawing. The operating system does not
5768	* display any portion of a window that lies outside of the window region
5769	* Parameters: HWND hWnd handle to window whose window region is to be set
5770	* HRGN hRgn handle to region
5771	* BOOL bRedraw window redraw flag
5772	* Variables :
5773	* Result : If the function succeeds, the return value is non-zero.
5774	* If the function fails, the return value is zero.
5775	* Remark :
5776	* Status : UNTESTED STUB
5777	*
5778	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5779	*****************************************************************************/
5780
5781	int WIN32API SetWindowRgn(HWND hWnd,
5782	HRGN hRgn,
5783	BOOL bRedraw)
5784	{
5785	dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
5786	hWnd,
5787	hRgn,
5788	bRedraw));
5789
5790	return (0);
5791	}
5792
5793
5794	/*****************************************************************************
5795	* Name : BOOL WIN32API SetWindowsHookW
5796	* Purpose : The SetWindowsHook function is not implemented in the Win32 API.
5797	* Win32-based applications should use the SetWindowsHookEx function.
5798	* Parameters:
5799	* Variables :
5800	* Result :
5801	* Remark : ARGH ! MICROSOFT !
5802	* Status : UNTESTED STUB
5803	*
5804	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5805	*****************************************************************************/
5806
5807	HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
5808
5809	{
5810	return (FALSE);
5811	}
5812
5813
5814	/*****************************************************************************
5815	* Name : BOOL WIN32API ShowWindowAsync
5816	* Purpose : The ShowWindowAsync function sets the show state of a window
5817	* created by a different thread.
5818	* Parameters: HWND hwnd handle of window
5819	* int nCmdShow show state of window
5820	* Variables :
5821	* Result : If the window was previously visible, the return value is TRUE.
5822	* If the window was previously hidden, the return value is FALSE.
5823	* Remark :
5824	* Status : UNTESTED STUB
5825	*
5826	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5827	*****************************************************************************/
5828
5829	BOOL WIN32API ShowWindowAsync (HWND hWnd,
5830	int nCmdShow)
5831	{
5832	dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
5833	hWnd,
5834	nCmdShow));
5835
5836	return (FALSE);
5837	}
5838
5839
5840	/*****************************************************************************
5841	* Name : BOOL WIN32API SwitchDesktop
5842	* Purpose : The SwitchDesktop function makes a desktop visible and activates
5843	* it. This enables the desktop to receive input from the user. The
5844	* calling process must have DESKTOP_SWITCHDESKTOP access to the
5845	* desktop for the SwitchDesktop function to succeed.
5846	* Parameters:
5847	* Variables :
5848	* Result : If the function succeeds, the return value is TRUE.
5849	* If the function fails, the return value is FALSE. To get extended
5850	* error information, call GetLastError.
5851	* Remark :
5852	* Status : UNTESTED STUB
5853	*
5854	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5855	*****************************************************************************/
5856
5857	BOOL WIN32API SwitchDesktop(HDESK hDesktop)
5858	{
5859	dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
5860	hDesktop));
5861
5862	return (FALSE);
5863	}
5864
5865
5866	/*****************************************************************************
5867	* Name : WORD WIN32API TileWindows
5868	* Purpose : The TileWindows function tiles the specified windows, or the child
5869	* windows of the specified parent window.
5870	* Parameters: HWND hwndParent handle of parent window
5871	* WORD wFlags types of windows not to arrange
5872	* LPCRECT lpRect rectangle to arrange windows in
5873	* WORD cChildrenb number of windows to arrange
5874	* const HWND *ahwndChildren array of window handles
5875	* Variables :
5876	* Result : If the function succeeds, the return value is the number of
5877	* windows arranged.
5878	* If the function fails, the return value is zero.
5879	* Remark :
5880	* Status : UNTESTED STUB
5881	*
5882	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5883	*****************************************************************************/
5884
5885	WORD WIN32API TileWindows(HWND hwndParent,
5886	UINT wFlags,
5887	const LPRECT lpRect,
5888	UINT cChildrenb,
5889	const HWND *ahwndChildren)
5890	{
5891	dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5892	hwndParent,
5893	wFlags,
5894	lpRect,
5895	cChildrenb,
5896	ahwndChildren));
5897
5898	return (0);
5899	}
5900
5901
5902	/*****************************************************************************
5903	* Name : int WIN32API ToAscii
5904	* Purpose : The ToAscii function translates the specified virtual-key code
5905	* and keyboard state to the corresponding Windows character or characters.
5906	* Parameters: UINT uVirtKey virtual-key code
5907	* UINT uScanCode scan code
5908	* PBYTE lpbKeyState address of key-state array
5909	* LPWORD lpwTransKey buffer for translated key
5910	* UINT fuState active-menu flag
5911	* Variables :
5912	* Result : 0 The specified virtual key has no translation for the current
5913	* state of the keyboard.
5914	* 1 One Windows character was copied to the buffer.
5915	* 2 Two characters were copied to the buffer. This usually happens
5916	* when a dead-key character (accent or diacritic) stored in the
5917	* keyboard layout cannot be composed with the specified virtual
5918	* key to form a single character.
5919	* Remark :
5920	* Status : UNTESTED STUB
5921	*
5922	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5923	*****************************************************************************/
5924
5925	int WIN32API ToAscii(UINT uVirtKey,
5926	UINT uScanCode,
5927	PBYTE lpbKeyState,
5928	LPWORD lpwTransKey,
5929	UINT fuState)
5930	{
5931	dprintf(("USER32:ToAscii (%u,%u,%08xh,%08xh,%u) not implemented.\n",
5932	uVirtKey,
5933	uScanCode,
5934	lpbKeyState,
5935	lpwTransKey,
5936	fuState));
5937
5938	return (0);
5939	}
5940
5941
5942	/*****************************************************************************
5943	* Name : int WIN32API ToAsciiEx
5944	* Purpose : The ToAscii function translates the specified virtual-key code
5945	* and keyboard state to the corresponding Windows character or characters.
5946	* Parameters: UINT uVirtKey virtual-key code
5947	* UINT uScanCode scan code
5948	* PBYTE lpbKeyState address of key-state array
5949	* LPWORD lpwTransKey buffer for translated key
5950	* UINT fuState active-menu flag
5951	* HLK hlk keyboard layout handle
5952	* Variables :
5953	* Result : 0 The specified virtual key has no translation for the current
5954	* state of the keyboard.
5955	* 1 One Windows character was copied to the buffer.
5956	* 2 Two characters were copied to the buffer. This usually happens
5957	* when a dead-key character (accent or diacritic) stored in the
5958	* keyboard layout cannot be composed with the specified virtual
5959	* key to form a single character.
5960	* Remark :
5961	* Status : UNTESTED STUB
5962	*
5963	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5964	*****************************************************************************/
5965
5966	int WIN32API ToAsciiEx(UINT uVirtKey,
5967	UINT uScanCode,
5968	PBYTE lpbKeyState,
5969	LPWORD lpwTransKey,
5970	UINT fuState,
5971	HKL hkl)
5972	{
5973	dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5974	uVirtKey,
5975	uScanCode,
5976	lpbKeyState,
5977	lpwTransKey,
5978	fuState,
5979	hkl));
5980
5981	return (0);
5982	}
5983
5984
5985	/*****************************************************************************
5986	* Name : int WIN32API ToUnicode
5987	* Purpose : The ToUnicode function translates the specified virtual-key code
5988	* and keyboard state to the corresponding Unicode character or characters.
5989	* Parameters: UINT wVirtKey virtual-key code
5990	* UINT wScanCode scan code
5991	* PBYTE lpKeyState address of key-state array
5992	* LPWSTR pwszBuff buffer for translated key
5993	* int cchBuff size of translated key buffer
5994	* UINT wFlags set of function-conditioning flags
5995	* Variables :
5996	* Result : - 1 The specified virtual key is a dead-key character (accent or
5997	* diacritic). This value is returned regardless of the keyboard
5998	* layout, even if several characters have been typed and are
5999	* stored in the keyboard state. If possible, even with Unicode
6000	* keyboard layouts, the function has written a spacing version of
6001	* the dead-key character to the buffer specified by pwszBuffer.
6002	* For example, the function writes the character SPACING ACUTE
6003	* (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
6004	* 0 The specified virtual key has no translation for the current
6005	* state of the keyboard. Nothing was written to the buffer
6006	* specified by pwszBuffer.
6007	* 1 One character was written to the buffer specified by pwszBuffer.
6008	* 2 or more Two or more characters were written to the buffer specified by
6009	* pwszBuff. The most common cause for this is that a dead-key
6010	* character (accent or diacritic) stored in the keyboard layout
6011	* could not be combined with the specified virtual key to form a
6012	* single character.
6013	* Remark :
6014	* Status : UNTESTED STUB
6015	*
6016	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6017	*****************************************************************************/
6018
6019	int WIN32API ToUnicode(UINT uVirtKey,
6020	UINT uScanCode,
6021	PBYTE lpKeyState,
6022	LPWSTR pwszBuff,
6023	int cchBuff,
6024	UINT wFlags)
6025	{
6026	dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
6027	uVirtKey,
6028	uScanCode,
6029	lpKeyState,
6030	pwszBuff,
6031	cchBuff,
6032	wFlags));
6033
6034	return (0);
6035	}
6036
6037
6038	/*****************************************************************************
6039	* Name : BOOL WIN32API UnloadKeyboardLayout
6040	* Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
6041	* Parameters: HKL hkl handle of keyboard layout
6042	* Variables :
6043	* Result : If the function succeeds, the return value is the handle of the
6044	* keyboard layout; otherwise, it is NULL. To get extended error
6045	* information, use the GetLastError function.
6046	* Remark :
6047	* Status : UNTESTED STUB
6048	*
6049	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6050	*****************************************************************************/
6051
6052	BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
6053	{
6054	dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
6055	hkl));
6056
6057	return (0);
6058	}
6059
6060
6061	/*****************************************************************************
6062	* Name : SHORT WIN32API VkKeyScanExW
6063	* Purpose : The VkKeyScanEx function translates a character to the
6064	* corresponding virtual-key code and shift state. The function
6065	* translates the character using the input language and physical
6066	* keyboard layout identified by the given keyboard layout handle.
6067	* Parameters: UINT uChar character to translate
6068	* HKL hkl keyboard layout handle
6069	* Variables :
6070	* Result : see docs
6071	* Remark :
6072	* Status : UNTESTED STUB
6073	*
6074	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6075	*****************************************************************************/
6076
6077	WORD WIN32API VkKeyScanExW(WCHAR uChar,
6078	HKL hkl)
6079	{
6080	dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
6081	uChar,
6082	hkl));
6083
6084	return (uChar);
6085	}
6086
6087
6088	/*****************************************************************************
6089	* Name : SHORT WIN32API VkKeyScanExA
6090	* Purpose : The VkKeyScanEx function translates a character to the
6091	* corresponding virtual-key code and shift state. The function
6092	* translates the character using the input language and physical
6093	* keyboard layout identified by the given keyboard layout handle.
6094	* Parameters: UINT uChar character to translate
6095	* HKL hkl keyboard layout handle
6096	* Variables :
6097	* Result : see docs
6098	* Remark :
6099	* Status : UNTESTED STUB
6100	*
6101	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6102	*****************************************************************************/
6103
6104	WORD WIN32API VkKeyScanExA(CHAR uChar,
6105	HKL hkl)
6106	{
6107	dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
6108	uChar,
6109	hkl));
6110
6111	return (uChar);
6112	}
6113
6114
6115	/*****************************************************************************
6116	* Name : VOID WIN32API keybd_event
6117	* Purpose : The keybd_event function synthesizes a keystroke. The system
6118	* can use such a synthesized keystroke to generate a WM_KEYUP or
6119	* WM_KEYDOWN message. The keyboard driver's interrupt handler calls
6120	* the keybd_event function.
6121	* Parameters: BYTE bVk virtual-key code
6122
6123	* BYTE bScan hardware scan code
6124	* DWORD dwFlags flags specifying various function options
6125	* DWORD dwExtraInfo additional data associated with keystroke
6126	* Variables :
6127	* Result :
6128	* Remark :
6129	* Status : UNTESTED STUB
6130	*
6131	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6132	*****************************************************************************/
6133
6134	VOID WIN32API keybd_event (BYTE bVk,
6135	BYTE bScan,
6136	DWORD dwFlags,
6137	DWORD dwExtraInfo)
6138	{
6139	dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
6140	bVk,
6141	bScan,
6142	dwFlags,
6143	dwExtraInfo));
6144	}
6145
6146
6147	/*****************************************************************************
6148	* Name : VOID WIN32API mouse_event
6149	* Purpose : The mouse_event function synthesizes mouse motion and button clicks.
6150	* Parameters: DWORD dwFlags flags specifying various motion/click variants
6151	* DWORD dx horizontal mouse position or position change
6152	* DWORD dy vertical mouse position or position change
6153	* DWORD cButtons unused, reserved for future use, set to zero
6154	* DWORD dwExtraInfo 32 bits of application-defined information
6155	* Variables :
6156	* Result :
6157	* Remark :
6158	* Status : UNTESTED STUB
6159	*
6160	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6161	*****************************************************************************/
6162
6163	VOID WIN32API mouse_event(DWORD dwFlags,
6164	DWORD dx,
6165	DWORD dy,
6166	DWORD cButtons,
6167	DWORD dwExtraInfo)
6168	{
6169	dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
6170	dwFlags,
6171	dx,
6172	dy,
6173	cButtons,
6174	dwExtraInfo));
6175	}
6176
6177
6178	/*****************************************************************************
6179	* Name : BOOL WIN32API SetShellWindow
6180	* Purpose : Unknown
6181	* Parameters: Unknown
6182	* Variables :
6183	* Result :
6184	* Remark :
6185	* Status : UNTESTED UNKNOWN STUB
6186	*
6187	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6188	*****************************************************************************/
6189
6190	BOOL WIN32API SetShellWindow(DWORD x1)
6191	{
6192	dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
6193	x1));
6194
6195	return (FALSE); /* default */
6196	}
6197
6198
6199	/*****************************************************************************
6200	* Name : BOOL WIN32API PlaySoundEvent
6201	* Purpose : Unknown
6202	* Parameters: Unknown
6203	* Variables :
6204	* Result :
6205	* Remark :
6206	* Status : UNTESTED UNKNOWN STUB
6207	*
6208	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6209	*****************************************************************************/
6210
6211	BOOL WIN32API PlaySoundEvent(DWORD x1)
6212	{
6213	dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
6214	x1));
6215
6216	return (FALSE); /* default */
6217	}
6218
6219
6220	/*****************************************************************************
6221	* Name : BOOL WIN32API TileChildWindows
6222	* Purpose : Unknown
6223	* Parameters: Unknown
6224	* Variables :
6225	* Result :
6226	* Remark :
6227	* Status : UNTESTED UNKNOWN STUB
6228	*
6229	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6230	*****************************************************************************/
6231
6232	BOOL WIN32API TileChildWindows(DWORD x1,
6233	DWORD x2)
6234	{
6235	dprintf(("USER32: TileChildWindows(%08xh,%08xh) not implemented.\n",
6236	x1,
6237	x2));
6238
6239	return (FALSE); /* default */
6240	}
6241
6242
6243	/*****************************************************************************
6244	* Name : BOOL WIN32API SetSysColorsTemp
6245	* Purpose : Unknown
6246	* Parameters: Unknown
6247	* Variables :
6248	* Result :
6249	* Remark :
6250	* Status : UNTESTED UNKNOWN STUB
6251	*
6252	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6253	*****************************************************************************/
6254
6255	BOOL WIN32API SetSysColorsTemp(void)
6256	{
6257	dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
6258
6259	return (FALSE); /* default */
6260	}
6261
6262
6263	/*****************************************************************************
6264	* Name : BOOL WIN32API RegisterNetworkCapabilities
6265	* Purpose : Unknown
6266	* Parameters: Unknown
6267	* Variables :
6268	* Result :
6269	* Remark :
6270	* Status : UNTESTED UNKNOWN STUB
6271	*
6272	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6273	*****************************************************************************/
6274
6275	BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
6276	DWORD x2)
6277	{
6278	dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
6279	x1,
6280	x2));
6281
6282	return (FALSE); /* default */
6283	}
6284
6285
6286	/*****************************************************************************
6287	* Name : BOOL WIN32API EndTask
6288	* Purpose : Unknown
6289	* Parameters: Unknown
6290	* Variables :
6291	* Result :
6292	* Remark :
6293	* Status : UNTESTED UNKNOWN STUB
6294	*
6295	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6296	*****************************************************************************/
6297
6298	BOOL WIN32API EndTask(DWORD x1,
6299	DWORD x2,
6300	DWORD x3)
6301	{
6302	dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
6303	x1,
6304	x2,
6305	x3));
6306
6307	return (FALSE); /* default */
6308	}
6309
6310
6311	/*****************************************************************************
6312	* Name : BOOL WIN32API SwitchToThisWindow
6313	* Purpose : Unknown
6314	* Parameters: Unknown
6315	* Variables :
6316	* Result :
6317	* Remark :
6318	* Status : UNTESTED UNKNOWN STUB
6319	*
6320	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6321	*****************************************************************************/
6322
6323	BOOL WIN32API SwitchToThisWindow(HWND hwnd,
6324	BOOL x2)
6325	{
6326	dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
6327	hwnd,
6328	x2));
6329
6330	return (FALSE); /* default */
6331	}
6332
6333
6334	/*****************************************************************************
6335	* Name : BOOL WIN32API GetNextQueueWindow
6336	* Purpose : Unknown
6337	* Parameters: Unknown
6338	* Variables :
6339	* Result :
6340	* Remark :
6341	* Status : UNTESTED UNKNOWN STUB
6342	*
6343	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6344	*****************************************************************************/
6345
6346	BOOL WIN32API GetNextQueueWindow(DWORD x1,
6347	DWORD x2)
6348	{
6349	dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
6350	x1,
6351	x2));
6352
6353	return (FALSE); /* default */
6354	}
6355
6356
6357	/*****************************************************************************
6358	* Name : BOOL WIN32API YieldTask
6359	* Purpose : Unknown
6360	* Parameters: Unknown
6361	* Variables :
6362	* Result :
6363	* Remark :
6364	* Status : UNTESTED UNKNOWN STUB
6365	*
6366	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6367	*****************************************************************************/
6368
6369	BOOL WIN32API YieldTask(void)
6370	{
6371	dprintf(("USER32: YieldTask() not implemented.\n"));
6372
6373	return (FALSE); /* default */
6374	}
6375
6376
6377	/*****************************************************************************
6378	* Name : BOOL WIN32API WinOldAppHackoMatic
6379	* Purpose : Unknown
6380	* Parameters: Unknown
6381	* Variables :
6382	* Result :
6383	* Remark :
6384	* Status : UNTESTED UNKNOWN STUB
6385	*
6386	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6387	*****************************************************************************/
6388
6389	BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
6390	{
6391	dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
6392	x1));
6393
6394	return (FALSE); /* default */
6395	}
6396
6397
6398	/*****************************************************************************
6399	* Name : BOOL WIN32API DragObject
6400	* Purpose : Unknown
6401	* Parameters: Unknown
6402	* Variables :
6403	* Result :
6404	* Remark :
6405	* Status : UNTESTED UNKNOWN STUB
6406	*
6407	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6408	*****************************************************************************/
6409
6410	DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
6411	{
6412	dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6413	x1,
6414	x2,
6415	x3,
6416	x4,
6417	x5));
6418
6419	return (FALSE); /* default */
6420	}
6421
6422
6423	/*****************************************************************************
6424	* Name : BOOL WIN32API CascadeChildWindows
6425	* Purpose : Unknown
6426	* Parameters: Unknown
6427	* Variables :
6428	* Result :
6429	* Remark :
6430	* Status : UNTESTED UNKNOWN STUB
6431	*
6432	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6433	*****************************************************************************/
6434
6435	BOOL WIN32API CascadeChildWindows(DWORD x1,
6436	DWORD x2)
6437	{
6438	dprintf(("USER32: CascadeChildWindows(%08xh,%08xh) not implemented.\n",
6439	x1,
6440	x2));
6441
6442	return (FALSE); /* default */
6443	}
6444
6445
6446	/*****************************************************************************
6447	* Name : BOOL WIN32API RegisterSystemThread
6448	* Purpose : Unknown
6449	* Parameters: Unknown
6450	* Variables :
6451	* Result :
6452	* Remark :
6453	* Status : UNTESTED UNKNOWN STUB
6454	*
6455	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6456	*****************************************************************************/
6457
6458	BOOL WIN32API RegisterSystemThread(DWORD x1,
6459	DWORD x2)
6460	{
6461	dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
6462	x1,
6463	x2));
6464
6465	return (FALSE); /* default */
6466	}
6467
6468
6469	/*****************************************************************************
6470	* Name : BOOL WIN32API IsHungThread
6471	* Purpose : Unknown
6472	* Parameters: Unknown
6473	* Variables :
6474	* Result :
6475	* Remark :
6476	* Status : UNTESTED UNKNOWN STUB
6477	*
6478	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6479	*****************************************************************************/
6480
6481	BOOL WIN32API IsHungThread(DWORD x1)
6482	{
6483	dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
6484	x1));
6485
6486	return (FALSE); /* default */
6487	}
6488
6489
6490	/*****************************************************************************
6491	* Name : BOOL WIN32API SysErrorBox
6492	* Purpose : Unknown
6493	* Parameters: Unknown
6494	* Variables :
6495	* Result :
6496	* Remark : HARDERR like ?
6497	* Status : UNTESTED UNKNOWN STUB
6498	*
6499	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6500	*****************************************************************************/
6501
6502	BOOL WIN32API SysErrorBox(DWORD x1,
6503	DWORD x2,
6504	DWORD x3)
6505	{
6506	dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh) not implemented.\n",
6507	x1,
6508	x2,
6509	x3));
6510
6511	return (FALSE); /* default */
6512	}
6513
6514
6515	/*****************************************************************************
6516	* Name : BOOL WIN32API UserSignalProc
6517	* Purpose : Unknown
6518	* Parameters: Unknown
6519	* Variables :
6520	* Result :
6521	* Remark :
6522	* Status : UNTESTED UNKNOWN STUB
6523	*
6524	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6525	*****************************************************************************/
6526
6527	BOOL WIN32API UserSignalProc(DWORD x1,
6528	DWORD x2,
6529	DWORD x3,
6530	DWORD x4)
6531	{
6532	dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6533	x1,
6534	x2,
6535	x3,
6536	x4));
6537
6538	return (FALSE); /* default */
6539	}
6540
6541
6542	/*****************************************************************************
6543	* Name : BOOL WIN32API GetShellWindow
6544	* Purpose : Unknown
6545	* Parameters: Unknown
6546	* Variables :
6547	* Result :
6548	* Remark :
6549	* Status : UNTESTED UNKNOWN STUB
6550	*
6551	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6552	*****************************************************************************/
6553
6554	HWND WIN32API GetShellWindow(void)
6555	{
6556	dprintf(("USER32: GetShellWindow() not implemented.\n"));
6557
6558	return (0); /* default */
6559	}
6560
6561
6562	/***********************************************************************
6563	* RegisterTasklist32 [USER32.436]
6564	*/
6565	DWORD WIN32API RegisterTasklist (DWORD x)
6566	{
6567	dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
6568	x));
6569
6570	return TRUE;
6571	}
6572
6573
6574	/***********************************************************************
6575	* DrawCaptionTemp32A [USER32.599]
6576	*
6577	* PARAMS
6578	*
6579	* RETURNS
6580	* Success:
6581	* Failure:
6582	*/
6583
6584	BOOL WIN32API DrawCaptionTempA(HWND hwnd,
6585	HDC hdc,
6586	const RECT *rect,
6587	HFONT hFont,
6588	HICON hIcon,
6589	LPCSTR str,
6590	UINT uFlags)
6591	{
6592	RECT rc = *rect;
6593
6594	dprintf(("USER32: DrawCaptionTempA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
6595	hwnd,
6596	hdc,
6597	rect,
6598	hFont,
6599	hIcon,
6600	str,
6601	uFlags));
6602
6603	/* drawing background */
6604	if (uFlags & DC_INBUTTON)
6605	{
6606	O32_FillRect (hdc,
6607	&rc,
6608	GetSysColorBrush (COLOR_3DFACE));
6609
6610	if (uFlags & DC_ACTIVE)
6611	{
6612	HBRUSH hbr = O32_SelectObject (hdc,
6613	GetSysColorBrush (COLOR_ACTIVECAPTION));
6614	O32_PatBlt (hdc,
6615	rc.left,
6616	rc.top,
6617	rc.right - rc.left,
6618	rc.bottom - rc.top,
6619	0xFA0089);
6620
6621	O32_SelectObject (hdc,
6622	hbr);
6623	}
6624	}
6625	else
6626	{
6627	O32_FillRect (hdc,
6628	&rc,
6629	GetSysColorBrush ((uFlags & DC_ACTIVE) ?
6630	COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
6631	}
6632
6633
6634	/* drawing icon */
6635	if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP))
6636	{
6637	POINT pt;
6638
6639	pt.x = rc.left + 2;
6640	pt.y = (rc.bottom + rc.top - O32_GetSystemMetrics(SM_CYSMICON)) / 2;
6641
6642	if (hIcon)
6643	{
6644	DrawIconEx (hdc,
6645	pt.x,
6646	pt.y,
6647	hIcon,
6648	O32_GetSystemMetrics(SM_CXSMICON),
6649	O32_GetSystemMetrics(SM_CYSMICON),
6650	0,
6651	0,
6652	DI_NORMAL);
6653	}
6654	else
6655	{
6656	/* @@@PH 1999/06/08 not ported yet, just don't draw any icon
6657	WND *wndPtr = WIN_FindWndPtr(hwnd);
6658	HICON hAppIcon = 0;
6659
6660	if (wndPtr->class->hIconSm)
6661	hAppIcon = wndPtr->class->hIconSm;
6662	else
6663	if (wndPtr->class->hIcon)
6664	hAppIcon = wndPtr->class->hIcon;
6665
6666	DrawIconEx (hdc,
6667	pt.x,
6668	pt.y,
6669	hAppIcon,
6670	GetSystemMetrics(SM_CXSMICON),
6671	GetSystemMetrics(SM_CYSMICON),
6672	0,
6673	0,
6674	DI_NORMAL);
6675
6676	WIN_ReleaseWndPtr(wndPtr);
6677	*/
6678	}
6679
6680	rc.left += (rc.bottom - rc.top);
6681	}
6682
6683	/* drawing text */
6684	if (uFlags & DC_TEXT)
6685	{
6686	HFONT hOldFont;
6687
6688	if (uFlags & DC_INBUTTON)
6689	O32_SetTextColor (hdc,
6690	O32_GetSysColor (COLOR_BTNTEXT));
6691	else
6692	if (uFlags & DC_ACTIVE)
6693	O32_SetTextColor (hdc,
6694	O32_GetSysColor (COLOR_CAPTIONTEXT));
6695	else
6696	O32_SetTextColor (hdc,
6697	O32_GetSysColor (COLOR_INACTIVECAPTIONTEXT));
6698
6699	O32_SetBkMode (hdc,
6700	TRANSPARENT);
6701
6702	if (hFont)
6703	hOldFont = O32_SelectObject (hdc,
6704	hFont);
6705	else
6706	{
6707	NONCLIENTMETRICSA nclm;
6708	HFONT hNewFont;
6709
6710	nclm.cbSize = sizeof(NONCLIENTMETRICSA);
6711	O32_SystemParametersInfo (SPI_GETNONCLIENTMETRICS,
6712	0,
6713	&nclm,
6714	0);
6715	hNewFont = O32_CreateFontIndirect ((uFlags & DC_SMALLCAP) ?
6716	&nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
6717	hOldFont = O32_SelectObject (hdc,
6718	hNewFont);
6719	}
6720
6721	if (str)
6722	O32_DrawText (hdc,
6723	str,
6724	-1,
6725	&rc,
6726	DT_SINGLELINE \| DT_VCENTER \| DT_NOPREFIX \| DT_LEFT);
6727	else
6728	{
6729	CHAR szText[128];
6730	INT nLen;
6731
6732	nLen = O32_GetWindowText (hwnd,
6733	szText,
6734	128);
6735
6736	O32_DrawText (hdc,
6737	szText,
6738	nLen,
6739	&rc,
6740	DT_SINGLELINE \| DT_VCENTER \| DT_NOPREFIX \| DT_LEFT);
6741	}
6742
6743	if (hFont)
6744	O32_SelectObject (hdc,
6745	hOldFont);
6746	else
6747	O32_DeleteObject (O32_SelectObject (hdc,
6748	hOldFont));
6749	}
6750
6751	/* drawing focus ??? */
6752	if (uFlags & 0x2000)
6753	{
6754	dprintf(("USER32: DrawCaptionTempA undocumented flag (0x2000)!\n"));
6755	}
6756
6757	return 0;
6758	}
6759
6760
6761	/***********************************************************************
6762	* DrawCaptionTemp32W [USER32.602]
6763	*
6764	* PARAMS
6765	*
6766	* RETURNS
6767	* Success:
6768	* Failure:
6769	*/
6770
6771	BOOL WIN32API DrawCaptionTempW (HWND hwnd,
6772	HDC hdc,
6773	const RECT *rect,
6774	HFONT hFont,
6775	HICON hIcon,
6776	LPCWSTR str,
6777	UINT uFlags)
6778	{
6779	LPSTR strAscii = UnicodeToAsciiString((LPWSTR)str);
6780
6781	BOOL res = DrawCaptionTempA (hwnd,
6782	hdc,
6783	rect,
6784	hFont,
6785	hIcon,
6786	strAscii,
6787	uFlags);
6788
6789	FreeAsciiString(strAscii);
6790
6791	return res;
6792	}

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

Download in other formats: