Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

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

Visit:

Last change on this file since 4 was 4, checked in by ktk, 26 years ago
Import
File size: 234.8 KB

Line
1	/* $Id: user32.cpp,v 1.1 1999-05-24 20:20:02 ktk 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	*
10	*
11	* Project Odin Software License can be found in LICENSE.TXT
12	*
13	*/
14	/*****************************************************************************
15	* Name : USER32.CPP
16	* Purpose : This module maps all Win32 functions contained in USER32.DLL
17	* to their OS/2-specific counterparts as far as possible.
18	*****************************************************************************/
19
20	#include <os2win.h>
21	#include "user32.h"
22	#include "wndproc.h"
23	#include "wndsubproc.h"
24	#include "wndclass.h"
25	#include "icon.h"
26	#include "usrcall.h"
27	#include "syscolor.h"
28
29	#include <wchar.h>
30	#include <stdlib.h>
31	#include <string.h>
32
33	//undocumented stuff
34	// WIN32API CalcChildScroll
35	// WIN32API CascadeChildWindows
36	// WIN32API ClientThreadConnect
37	// WIN32API DragObject
38	// WIN32API DrawCaptionTempA
39	// WIN32API DrawCaptionTempW
40	// WIN32API DrawFrame
41	// WIN32API EditWndProc
42	// WIN32API EndTask
43	// WIN32API GetInputDesktop
44	// WIN32API GetInternalWindowPos
45	// WIN32API GetNextQueueWindow
46	// WIN32API GetShellWindow
47	// WIN32API InitSharedTable
48	// WIN32API InitTask
49	// WIN32API InternalGetWindowText
50	// WIN32API IsHungThread
51	// WIN32API LockWindowStation
52	// WIN32API ModifyAccess
53	// WIN32API PlaySoundEvent
54	// WIN32API RegisterLogonProcess
55	// WIN32API RegisterNetworkCapabilities
56	// WIN32API RegisterSystemThread
57	// WIN32API RegisterTasklist
58	// WIN32API SetDeskWallpaper
59	// WIN32API SetDesktopBitmap
60	// WIN32API SetInternalWindowPos
61	// WIN32API SetLogonNotifyWindow
62	// WIN32API SetShellWindow
63	// WIN32API SetSysColorsTemp
64	// WIN32API SetWindowFullScreenState
65	// WIN32API SwitchToThisWindow
66	// WIN32API SysErrorBox
67	// WIN32API TileChildWindows
68	// WIN32API UnlockWindowStation
69	// WIN32API UserClientDllInitialize
70	// WIN32API UserSignalProc
71	// WIN32API WinOldAppHackoMatic
72	// WIN32API WNDPROC_CALLBACK
73	// WIN32API YieldTask
74
75
76
77
78	//******************************************************************************
79	//******************************************************************************
80	HWND WIN32API GetActiveWindow()
81	{
82	return(O32_GetActiveWindow());
83	}
84	//******************************************************************************
85	//******************************************************************************
86	int __cdecl wsprintfA(char *lpOut, LPCSTR lpFmt, ...)
87	{
88	int rc;
89	va_list argptr;
90
91	#ifdef DEBUG
92	WriteLog("USER32: wsprintfA\n");
93	WriteLog("USER32: %s\n", lpFmt);
94	#endif
95	va_start(argptr, lpFmt);
96	rc = O32_wvsprintf(lpOut, (char *)lpFmt, argptr);
97	va_end(argptr);
98	#ifdef DEBUG
99	WriteLog("USER32: %s\n", lpOut);
100	#endif
101	return(rc);
102	}
103	//******************************************************************************
104	//******************************************************************************
105	int __cdecl wsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, ...)
106	{
107	int rc;
108	char *lpFmtA;
109	char szOut[512];
110	va_list argptr;
111
112	dprintf(("USER32: wsprintfW(%08xh,%08xh).\n",
113	lpOut,
114	lpFmt));
115
116	lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
117
118	/* @@@PH 98/07/13 transform "%s" to "%ls" does the unicode magic */
119	{
120	PSZ pszTemp;
121	PSZ pszTemp1;
122	ULONG ulStrings;
123	ULONG ulIndex; /* temporary string counter */
124
125	for (ulStrings = 0, /* determine number of placeholders */
126	pszTemp = lpFmtA;
127
128	(pszTemp != NULL) &&
129	(*pszTemp != 0);
130
131	ulStrings++)
132	{
133	pszTemp = strstr(pszTemp,
134	"%s");
135	if (pszTemp != NULL) /* skip 2 characters */
136	{
137	pszTemp++;
138	pszTemp++;
139	}
140	else
141	break; /* leave loop immediately */
142	}
143
144	if (ulStrings != 0) /* transformation required ? */
145	{
146	/* now reallocate lpFmt */
147	ulStrings += strlen(lpFmtA); /* calculate total string length */
148	pszTemp = lpFmtA; /* save string pointer */
149	pszTemp1 = lpFmtA; /* save string pointer */
150
151	/* @@@PH allocation has to be compatible to FreeAsciiString !!! */
152	lpFmtA = (char *)malloc(ulStrings + 1);
153	if (lpFmtA == NULL) /* check proper allocation */
154	return (0); /* raise error condition */
155
156	for (ulIndex = 0;
157	ulIndex <= ulStrings;
158	ulIndex++,
159	pszTemp++)
160	{
161	if ((pszTemp[0] == '%') &&
162	(pszTemp[1] == 's') )
163	{
164	/* replace %s by %ls */
165	lpFmtA[ulIndex++] = '%';
166	lpFmtA[ulIndex ] = 'l';
167	lpFmtA[ulIndex+1] = 's';
168	}
169	else
170	lpFmtA[ulIndex] = pszTemp; / just copy over the character */
171	}
172
173	lpFmtA[ulStrings] = 0; /* string termination */
174
175	FreeAsciiString(pszTemp1); /* the original string is obsolete */
176	}
177	}
178
179	dprintf(("USER32: wsprintfW (%s).\n",
180	lpFmt));
181
182	va_start(argptr,
183	lpFmt);
184
185	rc = O32_wvsprintf(szOut,
186	lpFmtA,
187	argptr);
188
189	AsciiToUnicode(szOut,
190	lpOut);
191
192	FreeAsciiString(lpFmtA);
193	return(rc);
194	}
195	//******************************************************************************
196	//******************************************************************************
197	int WIN32API MessageBoxA(HWND hwndOwner, LPCTSTR lpszText, LPCTSTR lpszTitle, UINT fuStyle)
198	{
199	dprintf(("USER32: MessageBoxA %s %s\n", lpszText, lpszTitle));
200	return(O32_MessageBox(hwndOwner, lpszText, lpszTitle, fuStyle));
201	}
202	//******************************************************************************
203	//******************************************************************************
204	BOOL WIN32API MessageBeep( UINT arg1)
205	{
206	#ifdef DEBUG
207	WriteLog("USER32: MessageBeep\n");
208	#endif
209	return O32_MessageBeep(arg1);
210	}
211	//******************************************************************************
212	//******************************************************************************
213	LONG WIN32API SendDlgItemMessageA( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
214	{
215	#ifdef DEBUG
216	WriteLog("USER32: SendDlgItemMessageA\n");
217	#endif
218	return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
219	}
220	//******************************************************************************
221	//******************************************************************************
222	VOID WIN32API PostQuitMessage( int arg1)
223	{
224	dprintf(("USER32: PostQuitMessage\n"));
225	O32_PostQuitMessage(arg1);
226	}
227	//******************************************************************************
228	//******************************************************************************
229	BOOL WIN32API IsDlgButtonChecked( HWND arg1, UINT arg2)
230	{
231	dprintf(("USER32: IsDlgButtonChecked\n"));
232	return O32_IsDlgButtonChecked(arg1, arg2);
233	}
234	//******************************************************************************
235	//******************************************************************************
236	int WIN32API GetWindowTextLengthA( HWND arg1)
237	{
238	dprintf(("USER32: GetWindowTextLength\n"));
239	return O32_GetWindowTextLength(arg1);
240	}
241	//******************************************************************************
242	//******************************************************************************
243	int WIN32API GetWindowTextA( HWND arg1, LPSTR arg2, int arg3)
244	{
245	dprintf(("USER32: GetWindowText\n"));
246	return O32_GetWindowText(arg1, arg2, arg3);
247	}
248	//******************************************************************************
249	//******************************************************************************
250	BOOL WIN32API GetWindowRect( HWND arg1, PRECT arg2)
251	{
252	BOOL rc;
253
254	rc = O32_GetWindowRect(arg1, arg2);
255	dprintf(("USER32: GetWindowRect %X returned %d\n", arg1, rc));
256	return(rc);
257	}
258	//******************************************************************************
259	//******************************************************************************
260	HWND WIN32API GetNextDlgTabItem( HWND arg1, HWND arg2, BOOL arg3)
261	{
262	dprintf(("USER32: GetNextDlgTabItem\n"));
263	return O32_GetNextDlgTabItem(arg1, arg2, arg3);
264	}
265	//******************************************************************************
266	//******************************************************************************
267	BOOL WIN32API GetMessageA( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
268	{
269	//// dprintf(("USER32: GetMessage\n"));
270	return O32_GetMessage(arg1, arg2, arg3, arg4);
271	}
272	//******************************************************************************
273	//******************************************************************************
274	HWND WIN32API GetFocus(void)
275	{
276	dprintf(("USER32: GetFocus\n"));
277	return O32_GetFocus();
278	}
279	//******************************************************************************
280	//******************************************************************************
281	HWND WIN32API GetDlgItem(HWND arg1, int arg2)
282	{
283	HWND rc;
284
285	rc = O32_GetDlgItem(arg1, arg2);
286	dprintf(("USER32: GetDlgItem %d returned %d\n", arg2, rc));
287	return(rc);
288	}
289	//******************************************************************************
290	//******************************************************************************
291	int WIN32API GetDlgCtrlID( HWND arg1)
292	{
293	dprintf(("USER32: GetDlgCtrlID\n"));
294	return O32_GetDlgCtrlID(arg1);
295	}
296	//******************************************************************************
297	//******************************************************************************
298	HWND WIN32API GetDesktopWindow(void)
299	{
300	dprintf(("USER32: GetDesktopWindow\n"));
301	return O32_GetDesktopWindow();
302	}
303	//******************************************************************************
304	//******************************************************************************
305	BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
306	{
307	BOOL rc;
308	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
309
310	dprintf(("USER32: EnumThreadWindows\n"));
311	rc = O32_EnumThreadWindows(dwThreadId, callback->GetOS2Callback(), (LPARAM)callback);
312	if(callback)
313	delete callback;
314	return(rc);
315	}
316	//******************************************************************************
317	//******************************************************************************
318	BOOL WIN32API EndDialog( HWND arg1, int arg2)
319	{
320	BOOL rc;
321
322	dprintf(("USER32: EndDialog\n"));
323	rc = O32_EndDialog(arg1, arg2);
324	return(rc);
325	}
326	//******************************************************************************
327	//******************************************************************************
328	LONG WIN32API DispatchMessageA( const MSG * arg1)
329	{
330	//// dprintf(("USER32: DispatchMessage\n"));
331	return O32_DispatchMessage(arg1);
332	}
333	//******************************************************************************
334	//******************************************************************************
335	BOOL WIN32API OffsetRect( PRECT arg1, int arg2, int arg3)
336	{
337	#ifdef DEBUG
338	//// WriteLog("USER32: OffsetRect\n");
339	#endif
340	return O32_OffsetRect(arg1, arg2, arg3);
341	}
342	//******************************************************************************
343	//******************************************************************************
344	BOOL WIN32API CopyRect( PRECT arg1, const RECT * arg2)
345	{
346	// ddprintf(("USER32: CopyRect\n"));
347	return O32_CopyRect(arg1, arg2);
348	}
349	//******************************************************************************
350	//******************************************************************************
351	BOOL WIN32API CheckDlgButton( HWND arg1, int arg2, UINT arg3)
352	{
353	dprintf(("USER32: CheckDlgButton\n"));
354	return O32_CheckDlgButton(arg1, arg2, arg3);
355	}
356	//******************************************************************************
357	//******************************************************************************
358	HWND WIN32API SetFocus( HWND arg1)
359	{
360	dprintf(("USER32: SetFocus\n"));
361	return O32_SetFocus(arg1);
362	}
363	//******************************************************************************
364	//******************************************************************************
365	BOOL WIN32API TranslateMessage( const MSG * arg1)
366	{
367	#ifdef DEBUG
368	//// WriteLog("USER32: TranslateMessage\n");
369	#endif
370	return O32_TranslateMessage(arg1);
371	}
372	//******************************************************************************
373	//******************************************************************************
374	BOOL WIN32API SetWindowPos( HWND arg1, HWND arg2, int arg3, int arg4, int arg5, int arg6, UINT arg7)
375	{
376	#ifdef DEBUG
377	WriteLog("USER32: SetWindowPos\n");
378	#endif
379	return O32_SetWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
380	}
381	//******************************************************************************
382	//******************************************************************************
383	BOOL WIN32API ShowWindow(HWND arg1, int arg2)
384	{
385	#ifdef DEBUG
386	WriteLog("USER32: ShowWindow %X %d\n", arg1, arg2);
387	#endif
388	return O32_ShowWindow(arg1, arg2);
389	}
390	//******************************************************************************
391	//******************************************************************************
392	BOOL WIN32API SetWindowTextA(HWND arg1, LPCSTR arg2)
393	{
394	#ifdef DEBUG
395	WriteLog("USER32: SetWindowText %s\n", arg2);
396	#endif
397	return O32_SetWindowText(arg1, arg2);
398	}
399	//******************************************************************************
400	//******************************************************************************
401	BOOL WIN32API SetForegroundWindow(HWND arg1)
402	{
403	#ifdef DEBUG
404	WriteLog("USER32: SetForegroundWindow\n");
405	#endif
406	return O32_SetForegroundWindow(arg1);
407	}
408	//******************************************************************************
409	//******************************************************************************
410	int WIN32API ReleaseDC( HWND arg1, HDC arg2)
411	{
412	#ifdef DEBUG
413	WriteLog("USER32: ReleaseDC\n");
414	#endif
415	return O32_ReleaseDC(arg1, arg2);
416	}
417	//******************************************************************************
418	//******************************************************************************
419	BOOL WIN32API InvalidateRect(HWND arg1, const RECT *arg2, BOOL arg3)
420	{
421	#ifdef DEBUG
422	if(arg2)
423	WriteLog("USER32: InvalidateRect for window %X (%d,%d)(%d,%d) %d\n", arg1, arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
424	else WriteLog("USER32: InvalidateRect for window %X NULL, %d\n", arg1, arg3);
425	#endif
426	return O32_InvalidateRect(arg1, arg2, arg3);
427	}
428	//******************************************************************************
429	//******************************************************************************
430	BOOL WIN32API GetUpdateRect( HWND arg1, PRECT arg2, BOOL arg3)
431	{
432	#ifdef DEBUG
433	WriteLog("USER32: GetUpdateRect\n");
434	#endif
435	return O32_GetUpdateRect(arg1, arg2, arg3);
436	}
437	//******************************************************************************
438	//******************************************************************************
439	HDC WIN32API GetDC( HWND arg1)
440	{
441	HDC hdc;
442
443	hdc = O32_GetDC(arg1);
444	#ifdef DEBUG
445	WriteLog("USER32: GetDC of %X returns %X\n", arg1, hdc);
446	#endif
447	return(hdc);
448	}
449	//******************************************************************************
450	//******************************************************************************
451	HDC WIN32API GetDCEx(HWND arg1, HRGN arg2, DWORD arg3)
452	{
453	#ifdef DEBUG
454	WriteLog("USER32: GetDCEx\n");
455	#endif
456	return O32_GetDCEx(arg1, arg2, arg3);
457	}
458	//******************************************************************************
459	//******************************************************************************
460	BOOL WIN32API GetClientRect( HWND arg1, PRECT arg2)
461	{
462	#ifdef DEBUG
463	WriteLog("USER32: GetClientRect of %X\n", arg1);
464	#endif
465
466	return O32_GetClientRect(arg1, arg2);
467	}
468	//******************************************************************************
469	//******************************************************************************
470	HWND WIN32API FindWindowA(LPCSTR arg1, LPCSTR arg2)
471	{
472	#ifdef DEBUG
473	WriteLog("USER32: FindWindow\n");
474	#endif
475	return O32_FindWindow(arg1, arg2);
476	}
477	//******************************************************************************
478	//******************************************************************************
479	HWND WIN32API FindWindowExA(HWND arg1, HWND arg2, LPCSTR arg3, LPCSTR arg4)
480	{
481	#ifdef DEBUG
482	WriteLog("USER32: FindWindowExA, not completely implemented\n");
483	#endif
484	return O32_FindWindow(arg3, arg4);
485	}
486	//******************************************************************************
487	//******************************************************************************
488	BOOL WIN32API FlashWindow( HWND arg1, BOOL arg2)
489	{
490	#ifdef DEBUG
491	WriteLog("USER32: FlashWindow\n");
492	#endif
493	return O32_FlashWindow(arg1, arg2);
494	}
495	//******************************************************************************
496	//******************************************************************************
497	BOOL WIN32API EndPaint( HWND arg1, const PAINTSTRUCT * arg2)
498	{
499	#ifdef DEBUG
500	WriteLog("USER32: EndPaint\n");
501	#endif
502	return O32_EndPaint(arg1, arg2);
503	}
504	//******************************************************************************
505	//******************************************************************************
506	BOOL WIN32API MoveWindow(HWND arg1, int arg2, int arg3, int arg4, int arg5, BOOL arg6)
507	{
508	BOOL rc;
509
510	rc = O32_MoveWindow(arg1, arg2, arg3, arg4, arg5, arg6);
511	dprintf(("USER32: MoveWindow %X to (%d,%d) size (%d,%d), repaint = %d returned %d\n", arg1, arg2, arg3, arg4, arg5, arg6, rc));
512	return(rc);
513	}
514	//******************************************************************************
515	//******************************************************************************
516	HWND WIN32API CreateWindowExA(DWORD dwExStyle,
517	LPCSTR arg2,
518	LPCSTR arg3,
519	DWORD dwStyle,
520	int x,
521	int y,
522	int nWidth,
523	int nHeight,
524	HWND arg9,
525	HMENU arg10,
526	HINSTANCE arg11,
527	PVOID arg12)
528	{
529	HWND hwnd;
530	Win32WindowProc *window = NULL;
531
532	/* @@@PH 98/06/12 CreateWindow crashes somewhere in Open32 */
533	if(arg3 == NULL)
534	arg3 = (LPCSTR)"CRASH, CRASH";
535
536	//SvL: This break generic.exe & notepad.exe (probably many others too)
537	//These parameters can be CW_USEDEFAULT, which is 0x80000000
538	#if 0
539	if (nWidth < 0) nWidth = 0;
540	if (x < 0) x = 0;
541	if (nHeight< 0) nHeight = 0;
542	if (y < 0) y = 0;
543	#endif
544
545	//SvL: Breaks applications
546	#if 0
547	/* @@@PH 98/06/21 redraw problems disappear when WS_SYNCPAINT is on */
548	#ifndef WS_VISIBLE
549	#define WS_VISIBLE 0x80000000L
550	#endif
551
552	#ifndef WS_SYNCPAINT
553	#define WS_SYNCPAINT 0x02000000L
554	#endif
555
556	dwStyle \|= WS_SYNCPAINT;
557
558	/* @@@PH 98/06/21 experimental fix for WinHlp32 */
559	// SOL.EXE crashes here, but WINHLP32 does not display the
560	// navigation buttons otherwise.
561	dwStyle \|= WS_VISIBLE;
562	#endif
563
564	#ifdef DEBUG
565	WriteLog("USER32: CreateWindow: dwExStyle = %X\n", dwExStyle);
566	if((int)arg2 >> 16 != 0)
567	WriteLog("USER32: CreateWindow: classname = %s\n", arg2);
568	else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
569	WriteLog("USER32: CreateWindow: windowname= %s\n", arg3);
570	WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
571	WriteLog("USER32: CreateWindow: x = %d\n", x);
572	WriteLog("USER32: CreateWindow: y = %d\n", y);
573	WriteLog("USER32: CreateWindow: nWidth = %d\n", nWidth);
574	WriteLog("USER32: CreateWindow: nHeight = %d\n", nHeight);
575	WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
576	WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
577	WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
578	WriteLog("USER32: CreateWindow: param = %X\n", arg12);
579	#endif
580
581	if((int) arg2 >> 16 != 0 && strcmp(arg2, "COMBOBOX") == 0)
582	{
583	dprintf(("COMBOBOX creation"));
584	//TODO: #%@#%$ Open32 doesn't support this
585	dwStyle &= ~(CBS_OWNERDRAWFIXED \| CBS_OWNERDRAWVARIABLE);
586
587	/* @@@PH 98/06/12 drop down combos are problematic too */
588	/* so we translate the styles to OS/2 style */
589	dwStyle \|= CBS_DROPDOWN \| CBS_DROPDOWNLIST;
590	}
591
592	//Classname might be name of system class, in which case we don't
593	//need to use our own callback
594	// if(Win32WindowClass::FindClass((LPSTR)arg2) != NULL) {
595	window = new Win32WindowProc(arg11, arg2);
596	// }
597
598	hwnd = O32_CreateWindowEx(dwExStyle,
599	arg2,
600	arg3,
601	dwStyle,
602	x,
603	y,
604	nWidth,
605	nHeight,
606	arg9,
607	arg10,
608	arg11,
609	arg12);
610
611	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
612	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
613	delete(window);
614	window = 0;
615	}
616	if(window) {
617	window->SetWindowHandle(hwnd);
618	}
619	dprintf(("USER32: ************CreateWindowExA %s (%d,%d,%d,%d), hwnd = %X\n", arg2, x, y, nWidth, nHeight, hwnd));
620	return(hwnd);
621	}
622	//******************************************************************************
623	//******************************************************************************
624	LRESULT WIN32API SendMessageA(HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
625	{
626	LRESULT rc;
627
628	#ifdef DEBUG
629	WriteLog("USER32: SendMessage....\n");
630	#endif
631	rc = O32_SendMessage(arg1, arg2, arg3, arg4);
632	#ifdef DEBUG
633	WriteLog("USER32: *****SendMessage %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
634	#endif
635	return(rc);
636	}
637	//******************************************************************************
638	//******************************************************************************
639	HWND WIN32API SetActiveWindow( HWND arg1)
640	{
641	#ifdef DEBUG
642	WriteLog("USER32: SetActiveWindow\n");
643	#endif
644	return O32_SetActiveWindow(arg1);
645	}
646	//******************************************************************************
647	//******************************************************************************
648	HDC WIN32API BeginPaint(HWND arg1, PPAINTSTRUCT arg2)
649	{
650	dprintf(("USER32: BeginPaint %X\n", arg2));
651	return O32_BeginPaint(arg1, arg2);
652	}
653	//******************************************************************************
654	//******************************************************************************
655	BOOL WIN32API IsDialogMessageA( HWND arg1, LPMSG arg2)
656	{
657	#ifdef DEBUG
658	//// WriteLog("USER32: IsDialogMessage\n");
659	#endif
660	return O32_IsDialogMessage(arg1, arg2);
661	}
662	//******************************************************************************
663	//******************************************************************************
664	int WIN32API DrawTextA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5)
665	{
666	#ifdef DEBUG
667	WriteLog("USER32: DrawTextA %s", arg2);
668	#endif
669	return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
670	}
671	//******************************************************************************
672	//******************************************************************************
673	int WIN32API DrawTextExA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
674	{
675	#ifdef DEBUG
676	WriteLog("USER32: DrawTextExA (not completely implemented) %s", arg2);
677	#endif
678	return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
679	}
680	//******************************************************************************
681	//******************************************************************************
682	int WIN32API GetSystemMetrics(int arg1)
683	{
684	int rc;
685
686	switch(arg1) {
687	case SM_CXICONSPACING: //TODO: size of grid cell for large icons
688	rc = O32_GetSystemMetrics(SM_CXICON);
689	break;
690	case SM_CYICONSPACING:
691	rc = O32_GetSystemMetrics(SM_CYICON);
692	break;
693	case SM_PENWINDOWS:
694	rc = FALSE;
695	break;
696	case SM_DBCSENABLED:
697	rc = FALSE;
698	break;
699	case SM_CXEDGE: //size of 3D window edge (not supported)
700	rc = 1;
701	break;
702	case SM_CYEDGE:
703	rc = 1;
704	break;
705	case SM_CXMINSPACING: //can be SM_CXMINIMIZED or larger
706	rc = O32_GetSystemMetrics(SM_CXMINIMIZED);
707	break;
708	case SM_CYMINSPACING:
709	rc = GetSystemMetrics(SM_CYMINIMIZED);
710	break;
711	case SM_CXSMICON: //recommended size of small icons (TODO: adjust to screen res.)
712	rc = 16;
713	break;
714	case SM_CYSMICON:
715	rc = 16;
716	break;
717	case SM_CYSMCAPTION: //size in pixels of a small caption (TODO: ????)
718	rc = 8;
719	break;
720	case SM_CXSMSIZE: //size of small caption buttons (pixels) (TODO: implement properly)
721	rc = 16;
722	break;
723	case SM_CYSMSIZE:
724	rc = 16;
725	break;
726	case SM_CXMENUSIZE: //TODO: size of menu bar buttons (such as MDI window close)
727	rc = 16;
728	break;
729	case SM_CYMENUSIZE:
730	rc = 16;
731	break;
732	case SM_ARRANGE:
733	rc = ARW_BOTTOMLEFT \| ARW_LEFT;
734	break;
735	case SM_CXMINIMIZED:
736	break;
737	case SM_CYMINIMIZED:
738	break;
739	case SM_CXMAXTRACK: //max window size
740	case SM_CXMAXIMIZED: //max toplevel window size
741	rc = O32_GetSystemMetrics(SM_CXSCREEN);
742	break;
743	case SM_CYMAXTRACK:
744	case SM_CYMAXIMIZED:
745	rc = O32_GetSystemMetrics(SM_CYSCREEN);
746	break;
747	case SM_NETWORK:
748	rc = 0x01; //TODO: default = yes
749	break;
750	case SM_CLEANBOOT:
751	rc = 0; //normal boot
752	break;
753	case SM_CXDRAG: //nr of pixels before drag becomes a real one
754	rc = 2;
755	break;
756	case SM_CYDRAG:
757	rc = 2;
758	break;
759	case SM_SHOWSOUNDS: //show instead of play sound
760	rc = FALSE;
761	break;
762	case SM_CXMENUCHECK:
763	rc = 4; //TODO
764	break;
765	case SM_CYMENUCHECK:
766	rc = O32_GetSystemMetrics(SM_CYMENU);
767	break;
768	case SM_SLOWMACHINE:
769	rc = FALSE; //even a slow machine is fast with OS/2 :)
770	break;
771	case SM_MIDEASTENABLED:
772	rc = FALSE;
773	break;
774	case SM_CMETRICS:
775	rc = O32_GetSystemMetrics(44); //Open32 changed this one
776	break;
777	default:
778	rc = O32_GetSystemMetrics(arg1);
779	break;
780	}
781	#ifdef DEBUG
782	WriteLog("USER32: GetSystemMetrics %d returned %d\n", arg1, rc);
783	#endif
784	return(rc);
785	}
786	//******************************************************************************
787	//******************************************************************************
788	UINT WIN32API SetTimer( HWND arg1, UINT arg2, UINT arg3, TIMERPROC arg4)
789	{
790	#ifdef DEBUG
791	WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
792	#endif
793	//SvL: Write callback handler class for this one
794	return O32_SetTimer(arg1, arg2, arg3, (TIMERPROC_O32)arg4);
795	}
796	//******************************************************************************
797	//******************************************************************************
798	BOOL WIN32API KillTimer(HWND arg1, UINT arg2)
799	{
800	#ifdef DEBUG
801	WriteLog("USER32: KillTimer\n");
802	#endif
803	return O32_KillTimer(arg1, arg2);
804	}
805	//******************************************************************************
806	//******************************************************************************
807	BOOL WIN32API DestroyWindow(HWND arg1)
808	{
809	#ifdef DEBUG
810	WriteLog("USER32: DestroyWindow\n");
811	#endif
812	return O32_DestroyWindow(arg1);
813	}
814	//******************************************************************************
815	//******************************************************************************
816	BOOL WIN32API PostMessageA( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
817	{
818	#ifdef DEBUG
819	WriteLog("USER32: PostMessageA %X %X %X %X\n", arg1, arg2, arg3, arg4);
820	#endif
821	return O32_PostMessage(arg1, arg2, arg3, arg4);
822	}
823	//******************************************************************************
824	//******************************************************************************
825	BOOL WIN32API InflateRect( PRECT arg1, int arg2, int arg3)
826	{
827	#ifdef DEBUG
828	WriteLog("USER32: InflateRect\n");
829	#endif
830	return O32_InflateRect(arg1, arg2, arg3);
831	}
832	//******************************************************************************
833	//TODO:How can we emulate this one in OS/2???
834	//******************************************************************************
835	DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
836	{
837	#ifdef DEBUG
838	WriteLog("USER32: WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
839	#endif
840
841	if(dwTimeOut == INFINITE) return(0);
842
843	// DosSleep(dwTimeOut/16);
844	return(0);
845	}
846	//******************************************************************************
847	//******************************************************************************
848	UINT WIN32API GetDlgItemTextA(HWND arg1, int arg2, LPSTR arg3, UINT arg4)
849	{
850	UINT rc;
851
852	rc = O32_GetDlgItemText(arg1, arg2, arg3, arg4);
853	#ifdef DEBUG
854	if(rc)
855	WriteLog("USER32: GetDlgItemTextA returned %s\n", arg3);
856	else WriteLog("USER32: GetDlgItemTextA returned 0 (%d)\n", GetLastError());
857	#endif
858	return(rc);
859	}
860	//******************************************************************************
861	//******************************************************************************
862	BOOL WIN32API PeekMessageA(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
863	{
864	#ifdef DEBUG
865	// WriteLog("USER32: PeekMessage\n");
866	#endif
867	return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
868	}
869	//******************************************************************************
870	//******************************************************************************
871	int WIN32API ShowCursor( BOOL arg1)
872	{
873	#ifdef DEBUG
874	WriteLog("USER32: ShowCursor\n");
875	#endif
876	return O32_ShowCursor(arg1);
877	}
878	//******************************************************************************
879	//BUGBUG: UpdateWindow sends a WM_ERASEBKGRND when it shouldn't!
880	// So we just do it manually
881	//******************************************************************************
882	BOOL WIN32API UpdateWindow(HWND hwnd)
883	{
884	RECT rect;
885
886	#ifdef DEBUG
887	WriteLog("USER32: UpdateWindow\n");
888	#endif
889	if(O32_GetUpdateRect(hwnd, &rect, FALSE) != FALSE) {//update region empty?
890	WndCallback(hwnd, WM_PAINT, 0, 0);
891	// O32_PostMessage(hwnd, WM_PAINT, 0, 0);
892	}
893	#ifdef DEBUG
894	else WriteLog("USER32: Update region empty!\n");
895	#endif
896	return(TRUE);
897	}
898	//******************************************************************************
899	//******************************************************************************
900	BOOL WIN32API AdjustWindowRect( PRECT arg1, DWORD arg2, BOOL arg3)
901	{
902	#ifdef DEBUG
903	WriteLog("USER32: AdjustWindowRect\n");
904	#endif
905	return O32_AdjustWindowRect(arg1, arg2, arg3);
906	}
907	//******************************************************************************
908	//******************************************************************************
909	BOOL WIN32API AdjustWindowRectEx( PRECT arg1, DWORD arg2, BOOL arg3, DWORD arg4)
910	{
911	#ifdef DEBUG
912	WriteLog("USER32: AdjustWindowRectEx\n");
913	#endif
914	return O32_AdjustWindowRectEx(arg1, arg2, arg3, arg4);
915	}
916	//******************************************************************************
917	//******************************************************************************
918	BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
919	{
920	#ifdef DEBUG
921	//// WriteLog("USER32: ClientToScreen\n");
922	#endif
923	return O32_ClientToScreen(arg1, arg2);
924	}
925	//******************************************************************************
926	//******************************************************************************
927	BOOL WIN32API SetRect( PRECT arg1, int arg2, int arg3, int arg4, int arg5)
928	{
929	#ifdef DEBUG
930	WriteLog("USER32: SetRect\n");
931	#endif
932	return O32_SetRect(arg1, arg2, arg3, arg4, arg5);
933	}
934	//******************************************************************************
935	//******************************************************************************
936	LONG WIN32API GetWindowLongA(HWND hwnd, int nIndex)
937	{
938	LONG rc;
939
940	#ifdef DEBUG
941	WriteLog("USER32: GetWindowLong %X %d\n", hwnd, nIndex);
942	#endif
943	if(nIndex == GWL_WNDPROC \|\| nIndex == DWL_DLGPROC) {
944	Win32WindowProc *window = Win32WindowProc::FindProc(hwnd);
945	if(window && !(nIndex == DWL_DLGPROC && window->IsWindow() == TRUE)) {
946	return (LONG)window->GetWin32Callback();
947	}
948	}
949	rc = O32_GetWindowLong(hwnd, nIndex);
950	#ifdef DEBUG
951	WriteLog("USER32: GetWindowLong returned %X\n", rc);
952	#endif
953	return(rc);
954	}
955	//******************************************************************************
956	//******************************************************************************
957	BOOL WIN32API SetDlgItemInt( HWND arg1, int arg2, UINT arg3, BOOL arg4)
958	{
959	#ifdef DEBUG
960	WriteLog("USER32: SetDlgItemInt\n");
961	#endif
962	return O32_SetDlgItemInt(arg1, arg2, arg3, arg4);
963	}
964	//******************************************************************************
965	//******************************************************************************
966	BOOL WIN32API SetDlgItemTextA( HWND arg1, int arg2, LPCSTR arg3)
967	{
968	#ifdef DEBUG
969	WriteLog("USER32: SetDlgItemText to %s\n", arg3);
970	#endif
971	return O32_SetDlgItemText(arg1, arg2, arg3);
972	}
973	//******************************************************************************
974	//******************************************************************************
975	BOOL WIN32API WinHelpA( HWND arg1, LPCSTR arg2, UINT arg3, DWORD arg4)
976	{
977	#ifdef DEBUG
978	WriteLog("USER32: WinHelp not implemented %s\n", arg2);
979	#endif
980	// return O32_WinHelp(arg1, arg2, arg3, arg4);
981	return(TRUE);
982	}
983	//******************************************************************************
984	//******************************************************************************
985	BOOL WIN32API IsIconic( HWND arg1)
986	{
987	#ifdef DEBUG
988	WriteLog("USER32: IsIconic\n");
989	#endif
990	return O32_IsIconic(arg1);
991	}
992	//******************************************************************************
993	//******************************************************************************
994	int WIN32API TranslateAcceleratorA(HWND arg1, HACCEL arg2, LPMSG arg3)
995	{
996	#ifdef DEBUG
997	//// WriteLog("USER32: TranslateAccelerator\n");
998	#endif
999	return O32_TranslateAccelerator(arg1, arg2, arg3);
1000	}
1001	//******************************************************************************
1002	//******************************************************************************
1003	HWND WIN32API GetWindow(HWND arg1, UINT arg2)
1004	{
1005	HWND rc;
1006
1007	rc = O32_GetWindow(arg1, arg2);
1008	#ifdef DEBUG
1009	WriteLog("USER32: GetWindow %X %d returned %d\n", arg1, arg2, rc);
1010	#endif
1011	return(rc);
1012	}
1013	//******************************************************************************
1014	//******************************************************************************
1015	HDC WIN32API GetWindowDC(HWND arg1)
1016	{
1017	#ifdef DEBUG
1018	WriteLog("USER32: GetWindowDC\n");
1019	#endif
1020	return O32_GetWindowDC(arg1);
1021	}
1022	//******************************************************************************
1023	//******************************************************************************
1024	BOOL WIN32API SubtractRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
1025	{
1026	#ifdef DEBUG
1027	WriteLog("USER32: SubtractRect");
1028	#endif
1029	return O32_SubtractRect(arg1, arg2, arg3);
1030	}
1031	//******************************************************************************
1032	//SvL: 24-6-'97 - Added
1033	//******************************************************************************
1034	BOOL WIN32API ClipCursor(const RECT * arg1)
1035	{
1036	#ifdef DEBUG
1037	WriteLog("USER32: ClipCursor\n");
1038	#endif
1039	return O32_ClipCursor(arg1);
1040	}
1041	//******************************************************************************
1042	//SvL: 24-6-'97 - Added
1043	//TODO: Not implemented
1044	//******************************************************************************
1045	WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1046	{
1047	#ifdef DEBUG
1048	//// WriteLog("USER32: GetAsyncKeyState Not implemented\n");
1049	#endif
1050	return 0;
1051	}
1052	//******************************************************************************
1053	//SvL: 24-6-'97 - Added
1054	//******************************************************************************
1055	HCURSOR WIN32API GetCursor(void)
1056	{
1057	#ifdef DEBUG
1058	//// WriteLog("USER32: GetCursor\n");
1059	#endif
1060	return O32_GetCursor();
1061	}
1062	//******************************************************************************
1063	//SvL: 24-6-'97 - Added
1064	//******************************************************************************
1065	BOOL WIN32API GetCursorPos( PPOINT arg1)
1066	{
1067	#ifdef DEBUG
1068	//// WriteLog("USER32: GetCursorPos\n");
1069	#endif
1070	return O32_GetCursorPos(arg1);
1071	}
1072	//******************************************************************************
1073	//SvL: 24-6-'97 - Added
1074	//******************************************************************************
1075	UINT WIN32API RegisterWindowMessageA(LPCSTR arg1)
1076	{
1077	UINT rc;
1078
1079	rc = O32_RegisterWindowMessage(arg1);
1080	#ifdef DEBUG
1081	WriteLog("USER32: RegisterWindowMessageA %s returned %X\n", arg1, rc);
1082	#endif
1083	return(rc);
1084	}
1085	//******************************************************************************
1086	//SvL: 24-6-'97 - Added
1087	//******************************************************************************
1088	WORD WIN32API VkKeyScanA( char arg1)
1089	{
1090	#ifdef DEBUG
1091	WriteLog("USER32: VkKeyScanA\n");
1092	#endif
1093	return O32_VkKeyScan(arg1);
1094	}
1095	//******************************************************************************
1096	//SvL: 24-6-'97 - Added
1097	//******************************************************************************
1098	SHORT WIN32API GetKeyState( int arg1)
1099	{
1100	#ifdef DEBUG
1101	WriteLog("USER32: GetKeyState %d\n", arg1);
1102	#endif
1103	return O32_GetKeyState(arg1);
1104	}
1105	//******************************************************************************
1106	//******************************************************************************
1107	HCURSOR WIN32API SetCursor( HCURSOR arg1)
1108	{
1109	#ifdef DEBUG
1110	WriteLog("USER32: SetCursor\n");
1111	#endif
1112	return O32_SetCursor(arg1);
1113	}
1114	//******************************************************************************
1115	//******************************************************************************
1116	BOOL WIN32API SetCursorPos( int arg1, int arg2)
1117	{
1118	#ifdef DEBUG
1119	WriteLog("USER32: SetCursorPos\n");
1120	#endif
1121	return O32_SetCursorPos(arg1, arg2);
1122	}
1123	//******************************************************************************
1124	//******************************************************************************
1125	BOOL WIN32API EnableScrollBar( HWND arg1, INT arg2, UINT arg3)
1126	{
1127	#ifdef DEBUG
1128	WriteLog("USER32: EnableScrollBar\n");
1129	#endif
1130	return O32_EnableScrollBar(arg1, arg2, arg3);
1131	}
1132	//******************************************************************************
1133	//******************************************************************************
1134	BOOL WIN32API EnableWindow( HWND arg1, BOOL arg2)
1135	{
1136	#ifdef DEBUG
1137	WriteLog("USER32: EnableWindow\n");
1138	#endif
1139	return O32_EnableWindow(arg1, arg2);
1140	}
1141	//******************************************************************************
1142	//******************************************************************************
1143	HWND WIN32API SetCapture( HWND arg1)
1144	{
1145	#ifdef DEBUG
1146	WriteLog("USER32: SetCapture\n");
1147	#endif
1148	return O32_SetCapture(arg1);
1149	}
1150	//******************************************************************************
1151	//******************************************************************************
1152	BOOL WIN32API ReleaseCapture(void)
1153	{
1154	#ifdef DEBUG
1155	WriteLog("USER32: ReleaseCapture\n");
1156	#endif
1157	return O32_ReleaseCapture();
1158	}
1159	//******************************************************************************
1160	//******************************************************************************
1161	DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD arg5)
1162	{
1163	#ifdef DEBUG
1164	WriteLog("USER32: MsgWaitForMultipleObjects\n");
1165	#endif
1166	return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
1167	}
1168	//******************************************************************************
1169	//******************************************************************************
1170	HDWP WIN32API BeginDeferWindowPos( int arg1)
1171	{
1172	#ifdef DEBUG
1173	WriteLog("USER32: BeginDeferWindowPos\n");
1174	#endif
1175	return O32_BeginDeferWindowPos(arg1);
1176	}
1177	//******************************************************************************
1178	//******************************************************************************
1179	BOOL WIN32API BringWindowToTop( HWND arg1)
1180	{
1181	#ifdef DEBUG
1182	WriteLog("USER32: BringWindowToTop\n");
1183	#endif
1184	return O32_BringWindowToTop(arg1);
1185	}
1186	//******************************************************************************
1187	//******************************************************************************
1188	BOOL WIN32API CallMsgFilterA( LPMSG arg1, int arg2)
1189	{
1190	#ifdef DEBUG
1191	WriteLog("USER32: CallMsgFilterA\n");
1192	#endif
1193	return O32_CallMsgFilter(arg1, arg2);
1194	}
1195	//******************************************************************************
1196	//******************************************************************************
1197	BOOL WIN32API CallMsgFilterW( LPMSG arg1, int arg2)
1198	{
1199	#ifdef DEBUG
1200	WriteLog("USER32: CallMsgFilterW\n");
1201	#endif
1202	// NOTE: This will not work as is (needs UNICODE support)
1203	return O32_CallMsgFilter(arg1, arg2);
1204	}
1205	//******************************************************************************
1206	//******************************************************************************
1207	LRESULT WIN32API CallWindowProcA(WNDPROC wndprcPrev,
1208	HWND arg2,
1209	UINT arg3,
1210	WPARAM arg4,
1211	LPARAM arg5)
1212	{
1213	#ifdef DEBUG
1214	//// WriteLog("USER32: CallWindowProcA %X hwnd=%X, msg = %X\n", wndprcPrev, arg2, arg3);
1215	#endif
1216
1217	if(Win32WindowSubProc::FindSubProc((WNDPROC_O32)wndprcPrev) != NULL) {
1218	WNDPROC_O32 orgprc = (WNDPROC_O32)wndprcPrev; //is original Open32 system class callback (_System)
1219	return orgprc(arg2, arg3, arg4, arg5);
1220	}
1221	else return wndprcPrev(arg2, arg3, arg4, arg5); //win32 callback (__stdcall)
1222	}
1223	//******************************************************************************
1224	//******************************************************************************
1225	LRESULT WIN32API CallWindowProcW(WNDPROC arg1,
1226	HWND arg2,
1227	UINT arg3,
1228	WPARAM arg4,
1229	LPARAM arg5)
1230	{
1231	dprintf(("USER32: CallWindowProcW(%08xh,%08xh,%08xh,%08xh,%08xh) not properly implemented.\n",
1232	arg1,
1233	arg2,
1234	arg3,
1235	arg4,
1236	arg5));
1237
1238	return CallWindowProcA(arg1,
1239	arg2,
1240	arg3,
1241	arg4,
1242	arg5);
1243	}
1244	//******************************************************************************
1245	//******************************************************************************
1246	BOOL WIN32API ChangeClipboardChain( HWND arg1, HWND arg2)
1247	{
1248	#ifdef DEBUG
1249	WriteLog("USER32: ChangeClipboardChain\n");
1250	#endif
1251	return O32_ChangeClipboardChain(arg1, arg2);
1252	}
1253	//******************************************************************************
1254	//******************************************************************************
1255	UINT WIN32API ArrangeIconicWindows( HWND arg1)
1256	{
1257	#ifdef DEBUG
1258	WriteLog("USER32: ArrangeIconicWindows\n");
1259	#endif
1260	return O32_ArrangeIconicWindows(arg1);
1261	}
1262	//******************************************************************************
1263	//******************************************************************************
1264	BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT arg4)
1265	{
1266	#ifdef DEBUG
1267	WriteLog("USER32: CheckRadioButton\n");
1268	#endif
1269	return O32_CheckRadioButton(arg1, arg2, arg3, arg4);
1270	}
1271	//******************************************************************************
1272	//******************************************************************************
1273	HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
1274	{
1275	#ifdef DEBUG
1276	WriteLog("USER32: ChildWindowFromPoint\n");
1277	#endif
1278	return O32_ChildWindowFromPoint(arg1, arg2);
1279	}
1280	//******************************************************************************
1281	//******************************************************************************
1282	HWND WIN32API ChildWindowFromPointEx(HWND arg1, POINT arg2, UINT uFlags)
1283	{
1284	#ifdef DEBUG
1285	WriteLog("USER32: ChildWindowFromPointEx, not completely supported!\n");
1286	#endif
1287	return O32_ChildWindowFromPoint(arg1, arg2);
1288	}
1289	//******************************************************************************
1290	//******************************************************************************
1291	BOOL WIN32API CloseClipboard(void)
1292	{
1293	#ifdef DEBUG
1294	WriteLog("USER32: CloseClipboard\n");
1295	#endif
1296	return O32_CloseClipboard();
1297	}
1298	//******************************************************************************
1299	//******************************************************************************
1300	BOOL WIN32API CloseWindow( HWND arg1)
1301	{
1302	#ifdef DEBUG
1303	WriteLog("USER32: CloseWindow\n");
1304	#endif
1305	return O32_CloseWindow(arg1);
1306	}
1307	//******************************************************************************
1308	//******************************************************************************
1309	HICON WIN32API CopyIcon( HICON arg1)
1310	{
1311	#ifdef DEBUG
1312	WriteLog("USER32: CopyIcon\n");
1313	#endif
1314	return O32_CopyIcon(arg1);
1315	}
1316	//******************************************************************************
1317	//******************************************************************************
1318	int WIN32API CountClipboardFormats(void)
1319	{
1320	#ifdef DEBUG
1321	WriteLog("USER32: CountClipboardFormats\n");
1322	#endif
1323	return O32_CountClipboardFormats();
1324	}
1325	//******************************************************************************
1326	//******************************************************************************
1327	HACCEL WIN32API CreateAcceleratorTableA( LPACCEL arg1, int arg2)
1328	{
1329	#ifdef DEBUG
1330	WriteLog("USER32: CreateAcceleratorTableA\n");
1331	#endif
1332	return O32_CreateAcceleratorTable(arg1, arg2);
1333	}
1334	//******************************************************************************
1335	//******************************************************************************
1336	HACCEL WIN32API CreateAcceleratorTableW( LPACCEL arg1, int arg2)
1337	{
1338	#ifdef DEBUG
1339	WriteLog("USER32: CreateAcceleratorTableW\n");
1340	#endif
1341	// NOTE: This will not work as is (needs UNICODE support)
1342	return O32_CreateAcceleratorTable(arg1, arg2);
1343	}
1344	//******************************************************************************
1345	//******************************************************************************
1346	BOOL WIN32API CreateCaret( HWND arg1, HBITMAP arg2, int arg3, int arg4)
1347	{
1348	#ifdef DEBUG
1349	WriteLog("USER32: CreateCaret\n");
1350	#endif
1351	return O32_CreateCaret(arg1, arg2, arg3, arg4);
1352	}
1353	//******************************************************************************
1354	//******************************************************************************
1355	HCURSOR WIN32API CreateCursor( HINSTANCE arg1, int arg2, int arg3, int arg4, int arg5, const VOID * arg6, const VOID * arg7)
1356	{
1357	#ifdef DEBUG
1358	WriteLog("USER32: CreateCursor\n");
1359	#endif
1360	return O32_CreateCursor(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1361	}
1362	//******************************************************************************
1363	//******************************************************************************
1364	HICON WIN32API CreateIcon( HINSTANCE arg1, INT arg2, INT arg3, BYTE arg4, BYTE arg5, LPCVOID arg6, LPCVOID arg7)
1365	{
1366	#ifdef DEBUG
1367	WriteLog("USER32: CreateIcon\n");
1368	#endif
1369	return O32_CreateIcon(arg1, arg2, arg3, arg4, arg5, (const BYTE )arg6, (const BYTE )arg7);
1370	}
1371	//******************************************************************************
1372	//ASSERT dwVer == win31 (ok according to SDK docs)
1373	//******************************************************************************
1374	HICON WIN32API CreateIconFromResource(PBYTE presbits, UINT dwResSize,
1375	BOOL fIcon, DWORD dwVer)
1376	{
1377	HICON hicon;
1378	DWORD OS2ResSize = 0;
1379	PBYTE OS2Icon = ConvertWin32Icon(presbits, dwResSize, &OS2ResSize);
1380
1381	hicon = O32_CreateIconFromResource(OS2Icon, OS2ResSize, fIcon, dwVer);
1382	#ifdef DEBUG
1383	WriteLog("USER32: CreateIconFromResource returned %X (%X)\n", hicon, GetLastError());
1384	#endif
1385	if(OS2Icon)
1386	FreeIcon(OS2Icon);
1387
1388	return(hicon);
1389	}
1390	//******************************************************************************
1391	//******************************************************************************
1392	HICON WIN32API CreateIconFromResourceEx(PBYTE presbits, UINT dwResSize,
1393	BOOL fIcon, DWORD dwVer,
1394	int cxDesired, int cyDesired,
1395	UINT Flags)
1396	{
1397	#ifdef DEBUG
1398	WriteLog("USER32: CreateIconFromResourceEx %X %d %d %X %d %d %X, not completely supported!\n", presbits, dwResSize, fIcon, dwVer, cxDesired, cyDesired, Flags);
1399	#endif
1400	return CreateIconFromResource(presbits, dwResSize, fIcon, dwVer);
1401	}
1402	//******************************************************************************
1403	//******************************************************************************
1404	HICON WIN32API CreateIconIndirect(LPICONINFO arg1)
1405	{
1406	#ifdef DEBUG
1407	WriteLog("USER32: CreateIconIndirect\n");
1408	#endif
1409	return O32_CreateIconIndirect(arg1);
1410	}
1411	//******************************************************************************
1412	//******************************************************************************
1413	HWND WIN32API CreateMDIWindowA(LPCSTR arg1, LPCSTR arg2, DWORD arg3,
1414	int arg4, int arg5, int arg6, int arg7,
1415	HWND arg8, HINSTANCE arg9, LPARAM arg10)
1416	{
1417	HWND hwnd;
1418
1419	#ifdef DEBUG
1420	WriteLog("USER32: CreateMDIWindowA\n");
1421	#endif
1422	Win32WindowProc *window = new Win32WindowProc(arg9, arg1);
1423	hwnd = O32_CreateMDIWindow((LPSTR)arg1, (LPSTR)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1424	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1425	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1426	delete(window);
1427	window = 0;
1428	}
1429
1430	#ifdef DEBUG
1431	WriteLog("USER32: CreateMDIWindowA returned %X\n", hwnd);
1432	#endif
1433	return hwnd;
1434	}
1435	//******************************************************************************
1436	//******************************************************************************
1437	HWND WIN32API CreateMDIWindowW(LPCWSTR arg1, LPCWSTR arg2, DWORD arg3, int arg4,
1438	int arg5, int arg6, int arg7, HWND arg8, HINSTANCE arg9,
1439	LPARAM arg10)
1440	{
1441	HWND hwnd;
1442	char astring1 = NULL, astring2 = NULL;
1443	Win32WindowProc *window = NULL;
1444
1445	if((int)arg1 >> 16 != 0) {
1446	astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1447	}
1448	else astring1 = (char *)arg2;
1449
1450	astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1451
1452	//Classname might be name of system class, in which case we don't
1453	//need to use our own callback
1454	// if(Win32WindowClass::FindClass((LPSTR)astring1) != NULL) {
1455	window = new Win32WindowProc(arg9, astring1);
1456	// }
1457	hwnd = O32_CreateMDIWindow(astring1, astring2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1458	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1459	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1460	delete(window);
1461	window = 0;
1462	}
1463	if(window) {
1464	window->SetWindowHandle(hwnd);
1465	}
1466
1467	if(astring1) FreeAsciiString(astring1);
1468	FreeAsciiString(astring2);
1469	#ifdef DEBUG
1470	WriteLog("USER32: CreateMDIWindowW hwnd = %X\n", hwnd);
1471	#endif
1472	return(hwnd);
1473	}
1474	//******************************************************************************
1475	//******************************************************************************
1476	HWND WIN32API CreateWindowExW(DWORD arg1,
1477	LPCWSTR arg2,
1478	LPCWSTR arg3,
1479	DWORD dwStyle,
1480	int arg5,
1481	int arg6,
1482	int arg7,
1483	int arg8,
1484	HWND arg9,
1485	HMENU arg10,
1486	HINSTANCE arg11,
1487	PVOID arg12)
1488	{
1489	HWND hwnd;
1490	char *astring1 = NULL,
1491	*astring2 = NULL;
1492	Win32WindowProc *window = NULL;
1493
1494	/* @@@PH 98/06/21 changed to call OS2CreateWindowExA */
1495	if((int)arg2 >> 16 != 0)
1496	astring1 = UnicodeToAsciiString((LPWSTR)arg2);
1497	else
1498	astring1 = (char *)arg2;
1499
1500	astring2 = UnicodeToAsciiString((LPWSTR)arg3);
1501
1502	#ifdef DEBUG
1503	WriteLog("USER32: CreateWindowExW: dwExStyle = %X\n", arg1);
1504	if((int)arg2 >> 16 != 0)
1505	WriteLog("USER32: CreateWindow: classname = %s\n", astring1);
1506	else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
1507	WriteLog("USER32: CreateWindow: windowname= %s\n", astring2);
1508	WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
1509	WriteLog("USER32: CreateWindow: x = %d\n", arg5);
1510	WriteLog("USER32: CreateWindow: y = %d\n", arg6);
1511	WriteLog("USER32: CreateWindow: nWidth = %d\n", arg7);
1512	WriteLog("USER32: CreateWindow: nHeight = %d\n", arg8);
1513	WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
1514	WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
1515	WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
1516	WriteLog("USER32: CreateWindow: param = %X\n", arg12);
1517	#endif
1518
1519	hwnd = CreateWindowExA(arg1,
1520	astring1,
1521	astring2,
1522	dwStyle,
1523	arg5,
1524	arg6,
1525	arg7,
1526	arg8,
1527	arg9,
1528	arg10,
1529	arg11,
1530	arg12);
1531
1532	if(astring1)
1533	FreeAsciiString(astring1);
1534
1535	FreeAsciiString(astring2);
1536
1537	#ifdef DEBUG
1538	WriteLog("USER32: ************CreateWindowExW hwnd = %X (%X)\n", hwnd, GetLastError());
1539	#endif
1540	return(hwnd);
1541	}
1542	//******************************************************************************
1543	//******************************************************************************
1544	HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
1545	{
1546	#ifdef DEBUG
1547	WriteLog("USER32: DeferWindowPos\n");
1548	#endif
1549	return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1550	}
1551	//******************************************************************************
1552	//******************************************************************************
1553	BOOL WIN32API DestroyAcceleratorTable( HACCEL arg1)
1554	{
1555	#ifdef DEBUG
1556	WriteLog("USER32: DestroyAcceleratorTable\n");
1557	#endif
1558	return O32_DestroyAcceleratorTable(arg1);
1559	}
1560	//******************************************************************************
1561	//******************************************************************************
1562	BOOL WIN32API DestroyCaret(void)
1563	{
1564	#ifdef DEBUG
1565	WriteLog("USER32: DestroyCaret\n");
1566	#endif
1567	return O32_DestroyCaret();
1568	}
1569	//******************************************************************************
1570	//******************************************************************************
1571	BOOL WIN32API DestroyCursor( HCURSOR arg1)
1572	{
1573	#ifdef DEBUG
1574	WriteLog("USER32: DestroyCursor\n");
1575	#endif
1576	return O32_DestroyCursor(arg1);
1577	}
1578	//******************************************************************************
1579	//******************************************************************************
1580	BOOL WIN32API DestroyIcon( HICON arg1)
1581	{
1582	#ifdef DEBUG
1583	WriteLog("USER32: DestroyIcon\n");
1584	#endif
1585	return O32_DestroyIcon(arg1);
1586	}
1587	//******************************************************************************
1588	//******************************************************************************
1589	LONG WIN32API DispatchMessageW( const MSG * arg1)
1590	{
1591	#ifdef DEBUG
1592	WriteLog("USER32: DispatchMessageW\n");
1593	#endif
1594	// NOTE: This will not work as is (needs UNICODE support)
1595	return O32_DispatchMessage(arg1);
1596	}
1597	//******************************************************************************
1598	//******************************************************************************
1599	int WIN32API DlgDirListA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1600	{
1601	#ifdef DEBUG
1602	WriteLog("USER32: DlgDirListA\n");
1603	#endif
1604	return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1605	}
1606	//******************************************************************************
1607	//******************************************************************************
1608	int WIN32API DlgDirListComboBoxA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1609	{
1610	#ifdef DEBUG
1611	WriteLog("USER32: DlgDirListComboBoxA\n");
1612	#endif
1613	return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1614	}
1615	//******************************************************************************
1616	//******************************************************************************
1617	int WIN32API DlgDirListComboBoxW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1618	{
1619	#ifdef DEBUG
1620	WriteLog("USER32: DlgDirListComboBoxW NOT WORKING\n");
1621	#endif
1622	// NOTE: This will not work as is (needs UNICODE support)
1623	return 0;
1624	// return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1625	}
1626	//******************************************************************************
1627	//******************************************************************************
1628	int WIN32API DlgDirListW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1629	{
1630	#ifdef DEBUG
1631	WriteLog("USER32: DlgDirListW NOT WORKING\n");
1632	#endif
1633	// NOTE: This will not work as is (needs UNICODE support)
1634	return 0;
1635	// return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1636	}
1637	//******************************************************************************
1638	//******************************************************************************
1639	BOOL WIN32API DlgDirSelectComboBoxExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1640	{
1641	#ifdef DEBUG
1642	WriteLog("USER32: DlgDirSelectComboBoxExA\n");
1643	#endif
1644	return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1645	}
1646	//******************************************************************************
1647	//******************************************************************************
1648	BOOL WIN32API DlgDirSelectComboBoxExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1649	{
1650	#ifdef DEBUG
1651	WriteLog("USER32: DlgDirSelectComboBoxExW NOT WORKING\n");
1652	#endif
1653	// NOTE: This will not work as is (needs UNICODE support)
1654	return 0;
1655	// return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1656	}
1657	//******************************************************************************
1658	//******************************************************************************
1659	BOOL WIN32API DlgDirSelectExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1660	{
1661	#ifdef DEBUG
1662	WriteLog("USER32: DlgDirSelectExA\n");
1663	#endif
1664	return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1665	}
1666	//******************************************************************************
1667	//******************************************************************************
1668	BOOL WIN32API DlgDirSelectExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1669	{
1670	#ifdef DEBUG
1671	WriteLog("USER32: DlgDirSelectExW NOT WORKING\n");
1672	#endif
1673	// NOTE: This will not work as is (needs UNICODE support)
1674	return 0;
1675	// return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1676	}
1677	//******************************************************************************
1678	//******************************************************************************
1679	BOOL WIN32API DrawFocusRect( HDC arg1, const RECT * arg2)
1680	{
1681	#ifdef DEBUG
1682	WriteLog("USER32: DrawFocusRect\n");
1683	#endif
1684	return O32_DrawFocusRect(arg1, arg2);
1685	}
1686	//******************************************************************************
1687	//******************************************************************************
1688	BOOL WIN32API DrawIcon( HDC arg1, int arg2, int arg3, HICON arg4)
1689	{
1690	#ifdef DEBUG
1691	WriteLog("USER32: DrawIcon\n");
1692	#endif
1693	return O32_DrawIcon(arg1, arg2, arg3, arg4);
1694	}
1695	//******************************************************************************
1696	//******************************************************************************
1697	BOOL WIN32API DrawIconEx(HDC hdc, int xLeft, int xRight, HICON hIcon,
1698	int cxWidth, int cyWidth, UINT istepIfAniCur,
1699	HBRUSH hbrFlickerFreeDraw, UINT diFlags)
1700	{
1701	#ifdef DEBUG
1702	WriteLog("USER32: DrawIcon, partially implemented\n");
1703	#endif
1704	return O32_DrawIcon(hdc, xLeft, xRight, hIcon);
1705	}
1706	//******************************************************************************
1707	//******************************************************************************
1708	BOOL WIN32API DrawMenuBar( HWND arg1)
1709	{
1710	#ifdef DEBUG
1711	WriteLog("USER32: DrawMenuBar\n");
1712	#endif
1713	return O32_DrawMenuBar(arg1);
1714	}
1715	//******************************************************************************
1716	//******************************************************************************
1717	int WIN32API DrawTextW( HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5)
1718	{
1719	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1720	int rc;
1721
1722	#ifdef DEBUG
1723	WriteLog("USER32: DrawTextW %s\n", astring);
1724	#endif
1725	rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1726	FreeAsciiString(astring);
1727	return(rc);
1728	}
1729	//******************************************************************************
1730	//******************************************************************************
1731	int WIN32API DrawTextExW(HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
1732	{
1733	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1734	int rc;
1735
1736	#ifdef DEBUG
1737	WriteLog("USER32: DrawTextExW (not completely supported) %s\n", astring);
1738	#endif
1739	rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1740	FreeAsciiString(astring);
1741	return(rc);
1742	}
1743	//******************************************************************************
1744	//******************************************************************************
1745	BOOL WIN32API EmptyClipboard(void)
1746	{
1747	#ifdef DEBUG
1748	WriteLog("USER32: EmptyClipboard\n");
1749	#endif
1750	return O32_EmptyClipboard();
1751	}
1752	//******************************************************************************
1753	//******************************************************************************
1754	BOOL WIN32API EndDeferWindowPos( HDWP arg1)
1755	{
1756	#ifdef DEBUG
1757	WriteLog("USER32: EndDeferWindowPos\n");
1758	#endif
1759	return O32_EndDeferWindowPos(arg1);
1760	}
1761	//******************************************************************************
1762	//******************************************************************************
1763	BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1764	{
1765	BOOL rc;
1766	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1767
1768	#ifdef DEBUG
1769	WriteLog("USER32: EnumChildWindows\n");
1770	#endif
1771	rc = O32_EnumChildWindows(hwnd, callback->GetOS2Callback(), (LPARAM)callback);
1772	if(callback)
1773	delete callback;
1774	return(rc);
1775	}
1776	//******************************************************************************
1777	//******************************************************************************
1778	UINT WIN32API EnumClipboardFormats(UINT arg1)
1779	{
1780	#ifdef DEBUG
1781	WriteLog("USER32: EnumClipboardFormats\n");
1782	#endif
1783	return O32_EnumClipboardFormats(arg1);
1784	}
1785	//******************************************************************************
1786	//******************************************************************************
1787	int WIN32API EnumPropsA(HWND arg1, PROPENUMPROCA arg2)
1788	{
1789	#ifdef DEBUG
1790	WriteLog("USER32: EnumPropsA DOES NOT WORK\n");
1791	#endif
1792	//calling convention problems
1793	return 0;
1794	// return O32_EnumProps(arg1, (PROPENUMPROC_O32)arg2);
1795	}
1796	//******************************************************************************
1797	//******************************************************************************
1798	int WIN32API EnumPropsExA( HWND arg1, PROPENUMPROCEXA arg2, LPARAM arg3)
1799	{
1800	#ifdef DEBUG
1801	WriteLog("USER32: EnumPropsExA DOES NOT WORK\n");
1802	#endif
1803	//calling convention problems
1804	return 0;
1805	// return O32_EnumPropsEx(arg1, arg2, (PROPENUMPROCEX_O32)arg3);
1806	}
1807	//******************************************************************************
1808	//******************************************************************************
1809	int WIN32API EnumPropsExW( HWND arg1, PROPENUMPROCEXW arg2, LPARAM arg3)
1810	{
1811	#ifdef DEBUG
1812	WriteLog("USER32: EnumPropsExW\n");
1813	#endif
1814	// NOTE: This will not work as is (needs UNICODE support)
1815	//calling convention problems
1816	return 0;
1817	// return O32_EnumPropsEx(arg1, arg2, arg3);
1818	}
1819	//******************************************************************************
1820	//******************************************************************************
1821	int WIN32API EnumPropsW( HWND arg1, PROPENUMPROCW arg2)
1822	{
1823	#ifdef DEBUG
1824	WriteLog("USER32: EnumPropsW\n");
1825	#endif
1826	// NOTE: This will not work as is (needs UNICODE support)
1827	//calling convention problems
1828	return 0;
1829	// return O32_EnumProps(arg1, arg2);
1830	}
1831	//******************************************************************************
1832	//******************************************************************************
1833	BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1834	{
1835	BOOL rc;
1836	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1837
1838	#ifdef DEBUG
1839	WriteLog("USER32: EnumWindows\n");
1840	#endif
1841	rc = O32_EnumWindows(callback->GetOS2Callback(), (LPARAM)callback);
1842	if(callback)
1843	delete callback;
1844	return(rc);
1845	}
1846	//******************************************************************************
1847	//******************************************************************************
1848	BOOL WIN32API EqualRect( const RECT * arg1, const RECT * arg2)
1849	{
1850	#ifdef DEBUG
1851	WriteLog("USER32: EqualRect\n");
1852	#endif
1853	return O32_EqualRect(arg1, arg2);
1854	}
1855	//******************************************************************************
1856	//******************************************************************************
1857	BOOL WIN32API ExcludeUpdateRgn( HDC arg1, HWND arg2)
1858	{
1859	#ifdef DEBUG
1860	WriteLog("USER32: ExcludeUpdateRgn\n");
1861	#endif
1862	return O32_ExcludeUpdateRgn(arg1, arg2);
1863	}
1864	//******************************************************************************
1865	//******************************************************************************
1866	BOOL WIN32API ExitWindowsEx( UINT arg1, DWORD arg2)
1867	{
1868	#ifdef DEBUG
1869	WriteLog("USER32: ExitWindowsEx\n");
1870	#endif
1871	return O32_ExitWindowsEx(arg1, arg2);
1872	}
1873	//******************************************************************************
1874	//******************************************************************************
1875	int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
1876	{
1877	#ifdef DEBUG
1878	WriteLog("USER32: FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
1879	#endif
1880	return O32_FillRect(arg1, arg2, arg3);
1881	}
1882	//******************************************************************************
1883	//******************************************************************************
1884	HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
1885	{
1886	char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1887	char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1888	HWND rc;
1889
1890	#ifdef DEBUG
1891	WriteLog("USER32: FindWindowW\n");
1892	#endif
1893	rc = O32_FindWindow(astring1, astring2);
1894	FreeAsciiString(astring1);
1895	FreeAsciiString(astring2);
1896	return rc;
1897	}
1898	//******************************************************************************
1899	//******************************************************************************
1900	int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH arg3)
1901	{
1902	#ifdef DEBUG
1903	WriteLog("USER32: FrameRect\n");
1904	#endif
1905	return O32_FrameRect(arg1, arg2, arg3);
1906	}
1907	//******************************************************************************
1908	//******************************************************************************
1909	HWND WIN32API GetCapture(void)
1910	{
1911	#ifdef DEBUG
1912	WriteLog("USER32: GetCapture\n");
1913	#endif
1914	return O32_GetCapture();
1915	}
1916	//******************************************************************************
1917	//******************************************************************************
1918	UINT WIN32API GetCaretBlinkTime(void)
1919	{
1920	#ifdef DEBUG
1921	WriteLog("USER32: GetCaretBlinkTime\n");
1922	#endif
1923	return O32_GetCaretBlinkTime();
1924	}
1925	//******************************************************************************
1926	//******************************************************************************
1927	BOOL WIN32API GetCaretPos( PPOINT arg1)
1928	{
1929	#ifdef DEBUG
1930	WriteLog("USER32: GetCaretPos\n");
1931	#endif
1932	return O32_GetCaretPos(arg1);
1933	}
1934	//******************************************************************************
1935	//******************************************************************************
1936	BOOL WIN32API GetClipCursor( PRECT arg1)
1937	{
1938	#ifdef DEBUG
1939	WriteLog("USER32: GetClipCursor\n");
1940	#endif
1941	return O32_GetClipCursor(arg1);
1942	}
1943	//******************************************************************************
1944	//******************************************************************************
1945	HANDLE WIN32API GetClipboardData( UINT arg1)
1946	{
1947	#ifdef DEBUG
1948	WriteLog("USER32: GetClipboardData\n");
1949	#endif
1950	return O32_GetClipboardData(arg1);
1951	}
1952	//******************************************************************************
1953	//******************************************************************************
1954	int WIN32API GetClipboardFormatNameA( UINT arg1, LPSTR arg2, int arg3)
1955	{
1956	#ifdef DEBUG
1957	WriteLog("USER32: GetClipboardFormatNameA %s\n", arg2);
1958	#endif
1959	return O32_GetClipboardFormatName(arg1, arg2, arg3);
1960	}
1961	//******************************************************************************
1962	//******************************************************************************
1963	int WIN32API GetClipboardFormatNameW(UINT arg1, LPWSTR arg2, int arg3)
1964	{
1965	int rc;
1966	char *astring = UnicodeToAsciiString(arg2);
1967
1968	#ifdef DEBUG
1969	WriteLog("USER32: GetClipboardFormatNameW %s\n", astring);
1970	#endif
1971	rc = O32_GetClipboardFormatName(arg1, astring, arg3);
1972	FreeAsciiString(astring);
1973	return(rc);
1974	}
1975	//******************************************************************************
1976	//******************************************************************************
1977	HWND WIN32API GetClipboardOwner(void)
1978	{
1979	#ifdef DEBUG
1980	WriteLog("USER32: GetClipboardOwner\n");
1981	#endif
1982	return O32_GetClipboardOwner();
1983	}
1984	//******************************************************************************
1985	//******************************************************************************
1986	HWND WIN32API GetClipboardViewer(void)
1987	{
1988	#ifdef DEBUG
1989	WriteLog("USER32: GetClipboardViewer\n");
1990	#endif
1991	return O32_GetClipboardViewer();
1992	}
1993	//******************************************************************************
1994	//******************************************************************************
1995	DWORD WIN32API GetDialogBaseUnits(void)
1996	{
1997	#ifdef DEBUG
1998	WriteLog("USER32: GetDialogBaseUnits\n");
1999	#endif
2000	return O32_GetDialogBaseUnits();
2001	}
2002	//******************************************************************************
2003	//******************************************************************************
2004	UINT WIN32API GetDlgItemInt( HWND arg1, int arg2, PBOOL arg3, BOOL arg4)
2005	{
2006	#ifdef DEBUG
2007	WriteLog("USER32: GetDlgItemInt\n");
2008	#endif
2009	return O32_GetDlgItemInt(arg1, arg2, arg3, arg4);
2010	}
2011	//******************************************************************************
2012	//******************************************************************************
2013	UINT WIN32API GetDlgItemTextW( HWND arg1, int arg2, LPWSTR arg3, UINT arg4)
2014	{
2015	#ifdef DEBUG
2016	WriteLog("USER32: GetDlgItemTextW NOT WORKING\n");
2017	#endif
2018	// NOTE: This will not work as is (needs UNICODE support)
2019	return 0;
2020	// return O32_GetDlgItemText(arg1, arg2, arg3, arg4);
2021	}
2022	//******************************************************************************
2023	//******************************************************************************
2024	UINT WIN32API GetDoubleClickTime(void)
2025	{
2026	#ifdef DEBUG
2027	WriteLog("USER32: GetDoubleClickTime\n");
2028	#endif
2029	return O32_GetDoubleClickTime();
2030	}
2031	//******************************************************************************
2032	//******************************************************************************
2033	HWND WIN32API GetForegroundWindow(void)
2034	{
2035	#ifdef DEBUG
2036	WriteLog("USER32: GetForegroundWindow\n");
2037	#endif
2038	return O32_GetForegroundWindow();
2039	}
2040	//******************************************************************************
2041	//******************************************************************************
2042	BOOL WIN32API GetIconInfo( HICON arg1, LPICONINFO arg2)
2043	{
2044	#ifdef DEBUG
2045	WriteLog("USER32: GetIconInfo\n");
2046	#endif
2047	return O32_GetIconInfo(arg1, arg2);
2048	}
2049	//******************************************************************************
2050	//******************************************************************************
2051	int WIN32API GetKeyNameTextA( LPARAM arg1, LPSTR arg2, int arg3)
2052	{
2053	#ifdef DEBUG
2054	WriteLog("USER32: GetKeyNameTextA\n");
2055	#endif
2056	return O32_GetKeyNameText(arg1, arg2, arg3);
2057	}
2058	//******************************************************************************
2059	//******************************************************************************
2060	int WIN32API GetKeyNameTextW( LPARAM arg1, LPWSTR arg2, int arg3)
2061	{
2062	#ifdef DEBUG
2063	WriteLog("USER32: GetKeyNameTextW DOES NOT WORK\n");
2064	#endif
2065	// NOTE: This will not work as is (needs UNICODE support)
2066	return 0;
2067	// return O32_GetKeyNameText(arg1, arg2, arg3);
2068	}
2069	//******************************************************************************
2070	//******************************************************************************
2071	int WIN32API GetKeyboardType( int arg1)
2072	{
2073	#ifdef DEBUG
2074	WriteLog("USER32: GetKeyboardType\n");
2075	#endif
2076	return O32_GetKeyboardType(arg1);
2077	}
2078	//******************************************************************************
2079	//******************************************************************************
2080	HWND WIN32API GetLastActivePopup( HWND arg1)
2081	{
2082	#ifdef DEBUG
2083	WriteLog("USER32: GetLastActivePopup\n");
2084	#endif
2085	return O32_GetLastActivePopup(arg1);
2086	}
2087	//******************************************************************************
2088	//******************************************************************************
2089	LONG WIN32API GetMessageExtraInfo(void)
2090	{
2091	dprintf(("USER32: GetMessageExtraInfo\n"));
2092	return O32_GetMessageExtraInfo();
2093	}
2094	//******************************************************************************
2095	//******************************************************************************
2096	DWORD WIN32API GetMessagePos(void)
2097	{
2098	dprintf(("USER32: GetMessagePos\n"));
2099	return O32_GetMessagePos();
2100	}
2101	//******************************************************************************
2102	//******************************************************************************
2103	LONG WIN32API GetMessageTime(void)
2104	{
2105	dprintf(("USER32: GetMessageTime\n"));
2106	return O32_GetMessageTime();
2107	}
2108	//******************************************************************************
2109	//******************************************************************************
2110	BOOL WIN32API GetMessageW(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
2111	{
2112	BOOL rc;
2113
2114	// NOTE: This will not work as is (needs UNICODE support)
2115	rc = O32_GetMessage(arg1, arg2, arg3, arg4);
2116	dprintf(("USER32: GetMessageW %X returned %d\n", arg2, rc));
2117	return(rc);
2118	}
2119	//******************************************************************************
2120	//******************************************************************************
2121	HWND WIN32API GetNextDlgGroupItem( HWND arg1, HWND arg2, BOOL arg3)
2122	{
2123	#ifdef DEBUG
2124	WriteLog("USER32: GetNextDlgGroupItem\n");
2125	#endif
2126	return O32_GetNextDlgGroupItem(arg1, arg2, arg3);
2127	}
2128	//******************************************************************************
2129	//******************************************************************************
2130	HWND WIN32API GetOpenClipboardWindow(void)
2131	{
2132	#ifdef DEBUG
2133	WriteLog("USER32: GetOpenClipboardWindow\n");
2134	#endif
2135	return O32_GetOpenClipboardWindow();
2136	}
2137	//******************************************************************************
2138	//******************************************************************************
2139	HWND WIN32API GetParent( HWND arg1)
2140	{
2141	#ifdef DEBUG
2142	//// WriteLog("USER32: GetParent\n");
2143	#endif
2144	return O32_GetParent(arg1);
2145	}
2146	//******************************************************************************
2147	//******************************************************************************
2148	int WIN32API GetPriorityClipboardFormat( PUINT arg1, int arg2)
2149	{
2150	#ifdef DEBUG
2151	WriteLog("USER32: GetPriorityClipboardFormat\n");
2152	#endif
2153	return O32_GetPriorityClipboardFormat(arg1, arg2);
2154	}
2155	//******************************************************************************
2156	//******************************************************************************
2157	HANDLE WIN32API GetPropA( HWND arg1, LPCSTR arg2)
2158	{
2159	#ifdef DEBUG
2160	if((int)arg2 >> 16 != 0)
2161	WriteLog("USER32: GetPropA %s\n", arg2);
2162	else WriteLog("USER32: GetPropA %X\n", arg2);
2163	#endif
2164	return O32_GetProp(arg1, arg2);
2165	}
2166	//******************************************************************************
2167	//******************************************************************************
2168	HANDLE WIN32API GetPropW(HWND arg1, LPCWSTR arg2)
2169	{
2170	BOOL handle;
2171	char *astring;
2172
2173	if((int)arg2 >> 16 != 0)
2174	astring = UnicodeToAsciiString((LPWSTR)arg2);
2175	else astring = (char *)arg2;
2176	#ifdef DEBUG
2177	if((int)arg2 >> 16 != 0)
2178	WriteLog("USER32: GetPropW %s\n", astring);
2179	else WriteLog("USER32: GetPropW %X\n", astring);
2180	#endif
2181	handle = GetPropA(arg1, (LPCSTR)astring);
2182	if((int)arg2 >> 16 != 0)
2183	FreeAsciiString(astring);
2184
2185	return(handle);
2186	}
2187	//******************************************************************************
2188	//******************************************************************************
2189	DWORD WIN32API GetQueueStatus( UINT arg1)
2190	{
2191	#ifdef DEBUG
2192	WriteLog("USER32: GetQueueStatus\n");
2193	#endif
2194	return O32_GetQueueStatus(arg1);
2195	}
2196	//******************************************************************************
2197	//******************************************************************************
2198	int WIN32API GetScrollPos(HWND hwnd, int fnBar)
2199	{
2200	int pos;
2201
2202	pos = GetScrollPos(hwnd, fnBar);
2203	#ifdef DEBUG
2204	WriteLog("USER32: GetScrollPos of %X type %d returned %d\n", hwnd, fnBar, pos);
2205	#endif
2206	return(pos);
2207	}
2208	//******************************************************************************
2209	//******************************************************************************
2210	BOOL WIN32API GetScrollRange( HWND arg1, int arg2, int * arg3, int * arg4)
2211	{
2212	#ifdef DEBUG
2213	WriteLog("USER32: GetScrollRange\n");
2214	#endif
2215	return O32_GetScrollRange(arg1, arg2, arg3, arg4);
2216	}
2217	//******************************************************************************
2218	//******************************************************************************
2219	DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
2220	{
2221	#ifdef DEBUG
2222	WriteLog("USER32: GetTabbedTextExtentA\n");
2223	#endif
2224	return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
2225	}
2226	//******************************************************************************
2227	//******************************************************************************
2228	DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
2229	{
2230	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2231	DWORD rc;
2232
2233	#ifdef DEBUG
2234	WriteLog("USER32: GetTabbedTextExtentW\n");
2235	#endif
2236	rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
2237	FreeAsciiString(astring);
2238	return rc;
2239	}
2240	//******************************************************************************
2241	//******************************************************************************
2242	HWND WIN32API GetTopWindow( HWND arg1)
2243	{
2244	#ifdef DEBUG
2245	//// WriteLog("USER32: GetTopWindow\n");
2246	#endif
2247	return O32_GetTopWindow(arg1);
2248	}
2249	//******************************************************************************
2250	//******************************************************************************
2251	int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2252	{
2253	#ifdef DEBUG
2254	WriteLog("USER32: GetUpdateRgn\n");
2255	#endif
2256	return O32_GetUpdateRgn(arg1, arg2, arg3);
2257	}
2258	//******************************************************************************
2259	//******************************************************************************
2260	LONG WIN32API GetWindowLongW( HWND arg1, int arg2)
2261	{
2262	#ifdef DEBUG
2263	WriteLog("USER32: GetWindowLongW\n");
2264	#endif
2265	return GetWindowLongA(arg1, arg2); //class procedures..
2266	}
2267	//******************************************************************************
2268	//******************************************************************************
2269	BOOL WIN32API GetWindowPlacement( HWND arg1, LPWINDOWPLACEMENT arg2)
2270	{
2271	#ifdef DEBUG
2272	WriteLog("USER32: GetWindowPlacement\n");
2273	#endif
2274	return O32_GetWindowPlacement(arg1, arg2);
2275	}
2276	//******************************************************************************
2277	//******************************************************************************
2278	int WIN32API GetWindowTextLengthW( HWND arg1)
2279	{
2280	#ifdef DEBUG
2281	WriteLog("USER32: GetWindowTextLengthW\n");
2282	#endif
2283	return O32_GetWindowTextLength(arg1);
2284	}
2285	//******************************************************************************
2286	//******************************************************************************
2287	int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
2288	{
2289	char title[128];
2290	int rc;
2291
2292	rc = O32_GetWindowText(hwnd, title, sizeof(title));
2293	#ifdef DEBUG
2294	WriteLog("USER32: GetWindowTextW returned %s\n", title);
2295	#endif
2296	if(rc > cch) {
2297	title[cch-1] = 0;
2298	rc = cch;
2299	}
2300	AsciiToUnicode(title, lpsz);
2301	return(rc);
2302	}
2303	//******************************************************************************
2304	//******************************************************************************
2305	DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD arg2)
2306	{
2307	#ifdef DEBUG
2308	WriteLog("USER32: GetWindowThreadProcessId\n");
2309	#endif
2310	return O32_GetWindowThreadProcessId(arg1, arg2);
2311	}
2312	//******************************************************************************
2313	//******************************************************************************
2314	WORD WIN32API GetWindowWord( HWND arg1, int arg2)
2315	{
2316	#ifdef DEBUG
2317	WriteLog("USER32: GetWindowWord\n");
2318	#endif
2319	return O32_GetWindowWord(arg1, arg2);
2320	}
2321	//******************************************************************************
2322	//******************************************************************************
2323	BOOL WIN32API HideCaret( HWND arg1)
2324	{
2325	#ifdef DEBUG
2326	WriteLog("USER32: HideCaret\n");
2327	#endif
2328	return O32_HideCaret(arg1);
2329	}
2330	//******************************************************************************
2331	//******************************************************************************
2332	BOOL WIN32API InSendMessage(void)
2333	{
2334	#ifdef DEBUG
2335	WriteLog("USER32: InSendMessage\n");
2336	#endif
2337	return O32_InSendMessage();
2338	}
2339	//******************************************************************************
2340	//******************************************************************************
2341	BOOL WIN32API IntersectRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
2342	{
2343	#ifdef DEBUG
2344	//// WriteLog("USER32: IntersectRect\n");
2345	#endif
2346	return O32_IntersectRect(arg1, arg2, arg3);
2347	}
2348	//******************************************************************************
2349	//******************************************************************************
2350	BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2351	{
2352	#ifdef DEBUG
2353	WriteLog("USER32: InvalidateRgn\n");
2354	#endif
2355	return O32_InvalidateRgn(arg1, arg2, arg3);
2356	}
2357	//******************************************************************************
2358	//******************************************************************************
2359	BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
2360	{
2361	#ifdef DEBUG
2362	WriteLog("USER32: InvertRect\n");
2363	#endif
2364	return O32_InvertRect(arg1, arg2);
2365	}
2366	//******************************************************************************
2367	//******************************************************************************
2368	BOOL WIN32API IsChild( HWND arg1, HWND arg2)
2369	{
2370	#ifdef DEBUG
2371	WriteLog("USER32: IsChild\n");
2372	#endif
2373	return O32_IsChild(arg1, arg2);
2374	}
2375	//******************************************************************************
2376	//******************************************************************************
2377	BOOL WIN32API IsClipboardFormatAvailable( UINT arg1)
2378	{
2379	#ifdef DEBUG
2380	WriteLog("USER32: IsClipboardFormatAvailable\n");
2381	#endif
2382	return O32_IsClipboardFormatAvailable(arg1);
2383	}
2384	//******************************************************************************
2385	//******************************************************************************
2386	BOOL WIN32API IsDialogMessageW( HWND arg1, LPMSG arg2)
2387	{
2388	#ifdef DEBUG
2389	WriteLog("USER32: IsDialogMessageW\n");
2390	#endif
2391	// NOTE: This will not work as is (needs UNICODE support)
2392	return O32_IsDialogMessage(arg1, arg2);
2393	}
2394	//******************************************************************************
2395	//******************************************************************************
2396	BOOL WIN32API IsRectEmpty( const RECT * arg1)
2397	{
2398	#ifdef DEBUG
2399	WriteLog("USER32: IsRectEmpty\n");
2400	#endif
2401	return O32_IsRectEmpty(arg1);
2402	}
2403	//******************************************************************************
2404	//******************************************************************************
2405	BOOL WIN32API IsWindow( HWND arg1)
2406	{
2407	#ifdef DEBUG
2408	WriteLog("USER32: IsWindow\n");
2409	#endif
2410	return O32_IsWindow(arg1);
2411	}
2412	//******************************************************************************
2413	//******************************************************************************
2414	BOOL WIN32API IsWindowEnabled( HWND arg1)
2415	{
2416	#ifdef DEBUG
2417	WriteLog("USER32: IsWindowEnabled\n");
2418	#endif
2419	return O32_IsWindowEnabled(arg1);
2420	}
2421	//******************************************************************************
2422	//******************************************************************************
2423	BOOL WIN32API IsWindowVisible( HWND arg1)
2424	{
2425	#ifdef DEBUG
2426	WriteLog("USER32: IsWindowVisible\n");
2427	#endif
2428	return O32_IsWindowVisible(arg1);
2429	}
2430	//******************************************************************************
2431	//******************************************************************************
2432	BOOL WIN32API IsZoomed( HWND arg1)
2433	{
2434	#ifdef DEBUG
2435	WriteLog("USER32: IsZoomed\n");
2436	#endif
2437	return O32_IsZoomed(arg1);
2438	}
2439	//******************************************************************************
2440	//******************************************************************************
2441	BOOL WIN32API LockWindowUpdate( HWND arg1)
2442	{
2443	#ifdef DEBUG
2444	WriteLog("USER32: LockWindowUpdate\n");
2445	#endif
2446	return O32_LockWindowUpdate(arg1);
2447	}
2448	//******************************************************************************
2449	//******************************************************************************
2450	BOOL WIN32API MapDialogRect( HWND arg1, PRECT arg2)
2451	{
2452	#ifdef DEBUG
2453	WriteLog("USER32: MapDialogRect\n");
2454	#endif
2455	return O32_MapDialogRect(arg1, arg2);
2456	}
2457	//******************************************************************************
2458	//******************************************************************************
2459	UINT WIN32API MapVirtualKeyA( UINT arg1, UINT arg2)
2460	{
2461	#ifdef DEBUG
2462	WriteLog("USER32: MapVirtualKeyA\n");
2463	#endif
2464	return O32_MapVirtualKey(arg1, arg2);
2465	}
2466	//******************************************************************************
2467	//******************************************************************************
2468	UINT WIN32API MapVirtualKeyW( UINT arg1, UINT arg2)
2469	{
2470	#ifdef DEBUG
2471	WriteLog("USER32: MapVirtualKeyW\n");
2472	#endif
2473	// NOTE: This will not work as is (needs UNICODE support)
2474	return O32_MapVirtualKey(arg1, arg2);
2475	}
2476	//******************************************************************************
2477	//******************************************************************************
2478	int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
2479	{
2480	#ifdef DEBUG
2481	WriteLog("USER32: MapWindowPoints\n");
2482	#endif
2483	return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
2484	}
2485	//******************************************************************************
2486	//******************************************************************************
2487	int WIN32API MessageBoxW(HWND arg1, LPCWSTR arg2, LPCWSTR arg3, UINT arg4)
2488	{
2489	char astring1, astring2;
2490	int rc;
2491
2492	astring1 = UnicodeToAsciiString((LPWSTR)arg2);
2493	astring2 = UnicodeToAsciiString((LPWSTR)arg3);
2494	#ifdef DEBUG
2495	WriteLog("USER32: MessageBoxW %s %s\n", astring1, astring2);
2496	#endif
2497	rc = O32_MessageBox(arg1, astring1, astring2, arg4);
2498	FreeAsciiString(astring1);
2499	FreeAsciiString(astring2);
2500	return(rc);
2501	}
2502	//******************************************************************************
2503	//******************************************************************************
2504	BOOL WIN32API OpenClipboard( HWND arg1)
2505	{
2506	#ifdef DEBUG
2507	WriteLog("USER32: OpenClipboard\n");
2508	#endif
2509	return O32_OpenClipboard(arg1);
2510	}
2511	//******************************************************************************
2512	//******************************************************************************
2513	BOOL WIN32API PeekMessageW( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
2514	{
2515	#ifdef DEBUG
2516	WriteLog("USER32: PeekMessageW\n");
2517	#endif
2518	// NOTE: This will not work as is (needs UNICODE support)
2519	return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
2520	}
2521	//******************************************************************************
2522	//******************************************************************************
2523	// NOTE: Open32 function doesn't have the 'W'.
2524	BOOL WIN32API PostMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2525	{
2526	#ifdef DEBUG
2527	WriteLog("USER32: PostMessageW\n");
2528	#endif
2529	// NOTE: This will not work as is (needs UNICODE support)
2530	return O32_PostMessage(arg1, arg2, arg3, arg4);
2531	}
2532	//******************************************************************************
2533	//******************************************************************************
2534	BOOL WIN32API PostThreadMessageA( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2535	{
2536	#ifdef DEBUG
2537	WriteLog("USER32: PostThreadMessageA\n");
2538	#endif
2539	return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2540	}
2541	//******************************************************************************
2542	//******************************************************************************
2543	BOOL WIN32API PostThreadMessageW( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2544	{
2545	#ifdef DEBUG
2546	WriteLog("USER32: PostThreadMessageW\n");
2547	#endif
2548	// NOTE: This will not work as is (needs UNICODE support)
2549	return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2550	}
2551	//******************************************************************************
2552	//******************************************************************************
2553	BOOL WIN32API PtInRect( const RECT * arg1, POINT arg2)
2554	{
2555	#ifdef DEBUG
2556	WriteLog("USER32: PtInRect\n");
2557	#endif
2558	return O32_PtInRect(arg1, arg2);
2559	}
2560	//******************************************************************************
2561	//******************************************************************************
2562	BOOL WIN32API RedrawWindow( HWND arg1, const RECT * arg2, HRGN arg3, UINT arg4)
2563	{
2564	BOOL rc;
2565
2566	rc = O32_RedrawWindow(arg1, arg2, arg3, arg4);
2567	#ifdef DEBUG
2568	WriteLog("USER32: RedrawWindow %X , %X, %X, %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2569	#endif
2570	InvalidateRect(arg1, arg2, TRUE);
2571	UpdateWindow(arg1);
2572	SendMessageA(arg1, WM_PAINT, 0, 0);
2573	return(rc);
2574	}
2575	//******************************************************************************
2576	//******************************************************************************
2577	UINT WIN32API RegisterClipboardFormatA( LPCSTR arg1)
2578	{
2579	#ifdef DEBUG
2580	WriteLog("USER32: RegisterClipboardFormatA\n");
2581	#endif
2582	return O32_RegisterClipboardFormat(arg1);
2583	}
2584	//******************************************************************************
2585	//******************************************************************************
2586	UINT WIN32API RegisterClipboardFormatW(LPCWSTR arg1)
2587	{
2588	UINT rc;
2589	char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2590
2591	#ifdef DEBUG
2592	WriteLog("USER32: RegisterClipboardFormatW %s\n", astring);
2593	#endif
2594	rc = O32_RegisterClipboardFormat(astring);
2595	FreeAsciiString(astring);
2596	#ifdef DEBUG
2597	WriteLog("USER32: RegisterClipboardFormatW returned %d\n", rc);
2598	#endif
2599	return(rc);
2600	}
2601	//******************************************************************************
2602	//******************************************************************************
2603	UINT WIN32API RegisterWindowMessageW( LPCWSTR arg1)
2604	{
2605	char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2606	UINT rc;
2607
2608	#ifdef DEBUG
2609	WriteLog("USER32: RegisterWindowMessageW\n");
2610	#endif
2611	rc = O32_RegisterWindowMessage(astring);
2612	FreeAsciiString(astring);
2613	return rc;
2614	}
2615	//******************************************************************************
2616	//******************************************************************************
2617	HANDLE WIN32API RemovePropA( HWND arg1, LPCSTR arg2)
2618	{
2619	#ifdef DEBUG
2620	WriteLog("USER32: RemovePropA\n");
2621	#endif
2622	return O32_RemoveProp(arg1, arg2);
2623	}
2624	//******************************************************************************
2625	//******************************************************************************
2626	HANDLE WIN32API RemovePropW( HWND arg1, LPCWSTR arg2)
2627	{
2628	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2629	HANDLE rc;
2630
2631	#ifdef DEBUG
2632	WriteLog("USER32: RemovePropW\n");
2633	#endif
2634	rc = O32_RemoveProp(arg1, astring);
2635	FreeAsciiString(astring);
2636	return rc;
2637	}
2638	//******************************************************************************
2639	//******************************************************************************
2640	BOOL WIN32API ReplyMessage( LRESULT arg1)
2641	{
2642	#ifdef DEBUG
2643	WriteLog("USER32: ReplyMessage\n");
2644	#endif
2645	return O32_ReplyMessage(arg1);
2646	}
2647	//******************************************************************************
2648	//******************************************************************************
2649	BOOL WIN32API ScreenToClient( HWND arg1, LPPOINT arg2)
2650	{
2651	#ifdef DEBUG
2652	WriteLog("USER32: ScreenToClient\n");
2653	#endif
2654	return O32_ScreenToClient(arg1, arg2);
2655	}
2656	//******************************************************************************
2657	//******************************************************************************
2658	BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7)
2659	{
2660	#ifdef DEBUG
2661	WriteLog("USER32: ScrollDC\n");
2662	#endif
2663	return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2664	}
2665	//******************************************************************************
2666	//******************************************************************************
2667	BOOL WIN32API ScrollWindow( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5)
2668	{
2669	#ifdef DEBUG
2670	WriteLog("USER32: ScrollWindow\n");
2671	#endif
2672	return O32_ScrollWindow(arg1, arg2, arg3, arg4, arg5);
2673	}
2674	//******************************************************************************
2675	//******************************************************************************
2676	BOOL WIN32API ScrollWindowEx( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7, UINT arg8)
2677	{
2678	#ifdef DEBUG
2679	WriteLog("USER32: ScrollWindowEx\n");
2680	#endif
2681	return O32_ScrollWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2682	}
2683	//******************************************************************************
2684	//******************************************************************************
2685	LONG WIN32API SendDlgItemMessageW( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
2686	{
2687	#ifdef DEBUG
2688	WriteLog("USER32: SendDlgItemMessageW\n");
2689	#endif
2690	return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
2691	}
2692	//******************************************************************************
2693	//******************************************************************************
2694	LRESULT WIN32API SendMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2695	{
2696	LRESULT rc;
2697
2698	#ifdef DEBUG
2699	WriteLog("USER32: SendMessageW....\n");
2700	#endif
2701	rc = O32_SendMessage(arg1, arg2, arg3, arg4);
2702	#ifdef DEBUG
2703	WriteLog("USER32: SendMessageW %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2704	#endif
2705	return(rc);
2706	}
2707	//******************************************************************************
2708	//******************************************************************************
2709	BOOL WIN32API SetCaretBlinkTime( UINT arg1)
2710	{
2711	#ifdef DEBUG
2712	WriteLog("USER32: SetCaretBlinkTime\n");
2713	#endif
2714	return O32_SetCaretBlinkTime(arg1);
2715	}
2716	//******************************************************************************
2717	//******************************************************************************
2718	BOOL WIN32API SetCaretPos( int arg1, int arg2)
2719	{
2720	dprintf(("USER32: SetCaretPos\n"));
2721	return O32_SetCaretPos(arg1, arg2);
2722	}
2723	//******************************************************************************
2724	//******************************************************************************
2725	HANDLE WIN32API SetClipboardData( UINT arg1, HANDLE arg2)
2726	{
2727	dprintf(("USER32: SetClipboardData\n"));
2728	return O32_SetClipboardData(arg1, arg2);
2729	}
2730	//******************************************************************************
2731	//******************************************************************************
2732	HWND WIN32API SetClipboardViewer( HWND arg1)
2733	{
2734	dprintf(("USER32: SetClipboardViewer\n"));
2735	return O32_SetClipboardViewer(arg1);
2736	}
2737	//******************************************************************************
2738	//******************************************************************************
2739	BOOL WIN32API SetDlgItemTextW( HWND arg1, int arg2, LPCWSTR arg3)
2740	{
2741	char *astring = UnicodeToAsciiString((LPWSTR)arg3);
2742	BOOL rc;
2743
2744	#ifdef DEBUG
2745	WriteLog("USER32: SetDlgItemTextW\n");
2746	#endif
2747	// NOTE: This will not work as is (needs UNICODE support)
2748	rc = O32_SetDlgItemText(arg1, arg2, astring);
2749	FreeAsciiString(astring);
2750	return rc;
2751	}
2752	//******************************************************************************
2753	//******************************************************************************
2754	BOOL WIN32API SetDoubleClickTime( UINT arg1)
2755	{
2756	#ifdef DEBUG
2757	WriteLog("USER32: SetDoubleClickTime\n");
2758	#endif
2759	return O32_SetDoubleClickTime(arg1);
2760	}
2761	//******************************************************************************
2762	//******************************************************************************
2763	HWND WIN32API SetParent( HWND arg1, HWND arg2)
2764	{
2765	#ifdef DEBUG
2766	WriteLog("USER32: SetParent\n");
2767	#endif
2768	return O32_SetParent(arg1, arg2);
2769	}
2770	//******************************************************************************
2771	//******************************************************************************
2772	BOOL WIN32API SetPropA( HWND arg1, LPCSTR arg2, HANDLE arg3)
2773	{
2774	#ifdef DEBUG
2775	if((int)arg2 >> 16 != 0)
2776	WriteLog("USER32: SetPropA %S\n", arg2);
2777	else WriteLog("USER32: SetPropA %X\n", arg2);
2778	#endif
2779	return O32_SetProp(arg1, arg2, arg3);
2780	}
2781	//******************************************************************************
2782	//******************************************************************************
2783	BOOL WIN32API SetPropW(HWND arg1, LPCWSTR arg2, HANDLE arg3)
2784	{
2785	BOOL rc;
2786	char *astring;
2787
2788	if((int)arg2 >> 16 != 0)
2789	astring = UnicodeToAsciiString((LPWSTR)arg2);
2790	else astring = (char *)arg2;
2791
2792	#ifdef DEBUG
2793	if((int)arg2 >> 16 != 0)
2794	WriteLog("USER32: SetPropW %S\n", astring);
2795	else WriteLog("USER32: SetPropW %X\n", astring);
2796	#endif
2797	rc = O32_SetProp(arg1, astring, arg3);
2798	if((int)astring >> 16 != 0)
2799	FreeAsciiString(astring);
2800	return(rc);
2801	}
2802	//******************************************************************************
2803	//******************************************************************************
2804	BOOL WIN32API SetRectEmpty( PRECT arg1)
2805	{
2806	#ifdef DEBUG
2807	WriteLog("USER32: SetRectEmpty\n");
2808	#endif
2809	return O32_SetRectEmpty(arg1);
2810	}
2811	//******************************************************************************
2812	//******************************************************************************
2813	int WIN32API SetScrollPos( HWND arg1, int arg2, int arg3, BOOL arg4)
2814	{
2815	#ifdef DEBUG
2816	WriteLog("USER32: SetScrollPos\n");
2817	#endif
2818	return O32_SetScrollPos(arg1, arg2, arg3, arg4);
2819	}
2820	//******************************************************************************
2821	//******************************************************************************
2822	BOOL WIN32API SetScrollRange( HWND arg1, int arg2, int arg3, int arg4, BOOL arg5)
2823	{
2824	#ifdef DEBUG
2825	WriteLog("USER32: SetScrollRange\n");
2826	#endif
2827	return O32_SetScrollRange(arg1, arg2, arg3, arg4, arg5);
2828	}
2829	//******************************************************************************
2830	//******************************************************************************
2831	LONG WIN32API SetWindowLongA(HWND hwnd, int nIndex, LONG arg3)
2832	{
2833	LONG rc;
2834
2835	dprintf(("USER32: SetWindowLongA %X %d %X\n", hwnd, nIndex, arg3));
2836	if(nIndex == GWL_WNDPROC \|\| nIndex == DWL_DLGPROC) {
2837	Win32WindowProc *wndproc = Win32WindowProc::FindProc(hwnd);
2838	if(wndproc == NULL) {//created with system class and app wants to change the handler
2839	dprintf(("USER32: SetWindowLong new WindowProc for system class\n"));
2840	wndproc = new Win32WindowProc((WNDPROC)arg3);
2841	wndproc->SetWindowHandle(hwnd);
2842	rc = O32_GetWindowLong(hwnd, nIndex);
2843	Win32WindowSubProc *subwndproc = new Win32WindowSubProc(hwnd, (WNDPROC_O32)rc);
2844	O32_SetWindowLong(hwnd, nIndex, (LONG)wndproc->GetOS2Callback());
2845	return((LONG)subwndproc->GetWin32Callback());
2846	}
2847	else {
2848	if(!(nIndex == DWL_DLGPROC && wndproc->IsWindow() == TRUE)) {
2849	rc = (LONG)wndproc->GetWin32Callback();
2850	dprintf(("USER32: SetWindowLong change WindowProc %X to %X\n", rc, arg3));
2851	wndproc->SetWin32Callback((WNDPROC)arg3);
2852	return(rc);
2853	}
2854	//else window that accesses it's normal window data
2855	}
2856	}
2857	return O32_SetWindowLong(hwnd, nIndex, arg3);
2858	}
2859	//******************************************************************************
2860	//TODO: Is this always correct? (GWL_ID: window identifier??)
2861	//******************************************************************************
2862	LONG WIN32API SetWindowLongW(HWND arg1, int arg2, LONG arg3)
2863	{
2864	dprintf(("USER32: SetWindowLongW %X %d %X\n", arg1, arg2, arg3));
2865	return SetWindowLongA(arg1, arg2, arg3);
2866	}
2867	//******************************************************************************
2868	//******************************************************************************
2869	BOOL WIN32API SetWindowPlacement( HWND arg1, const WINDOWPLACEMENT * arg2)
2870	{
2871	dprintf(("USER32: SetWindowPlacement\n"));
2872	return O32_SetWindowPlacement(arg1, arg2);
2873	}
2874	//******************************************************************************
2875	//******************************************************************************
2876	BOOL WIN32API SetWindowTextW( HWND arg1, LPCWSTR arg2)
2877	{
2878	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2879	BOOL rc;
2880
2881	rc = SetWindowTextA(arg1, (LPCSTR)astring);
2882	dprintf(("USER32: SetWindowTextW %X %s returned %d\n", arg1, astring, rc));
2883	FreeAsciiString(astring);
2884	return(rc);
2885	}
2886	//******************************************************************************
2887	//******************************************************************************
2888	WORD WIN32API SetWindowWord( HWND arg1, int arg2, WORD arg3)
2889	{
2890	dprintf(("USER32: SetWindowWord\n"));
2891	return O32_SetWindowWord(arg1, arg2, arg3);
2892	}
2893	//******************************************************************************
2894	//******************************************************************************
2895	BOOL WIN32API ShowCaret( HWND arg1)
2896	{
2897	dprintf(("USER32: ShowCaret\n"));
2898	return O32_ShowCaret(arg1);
2899	}
2900	//******************************************************************************
2901	//******************************************************************************
2902	BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
2903	{
2904	dprintf(("USER32: ShowOwnedPopups\n"));
2905	return O32_ShowOwnedPopups(arg1, arg2);
2906	}
2907	//******************************************************************************
2908	//******************************************************************************
2909	BOOL WIN32API ShowScrollBar( HWND arg1, int arg2, BOOL arg3)
2910	{
2911	#ifdef DEBUG
2912	WriteLog("USER32: ShowScrollBar\n");
2913	#endif
2914	return O32_ShowScrollBar(arg1, arg2, arg3);
2915	}
2916	//******************************************************************************
2917	//******************************************************************************
2918	BOOL WIN32API SwapMouseButton( BOOL arg1)
2919	{
2920	#ifdef DEBUG
2921	WriteLog("USER32: SwapMouseButton\n");
2922	#endif
2923	return O32_SwapMouseButton(arg1);
2924	}
2925	//******************************************************************************
2926	//******************************************************************************
2927	BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
2928	{
2929	BOOL rc;
2930	NONCLIENTMETRICSA cmetric = (NONCLIENTMETRICSA )pvParam;
2931
2932	switch(uiAction) {
2933	case SPI_SCREENSAVERRUNNING:
2934	(BOOL )pvParam = FALSE;
2935	rc = TRUE;
2936	break;
2937	case SPI_GETDRAGFULLWINDOWS:
2938	(BOOL )pvParam = FALSE;
2939	rc = TRUE;
2940	break;
2941	case SPI_GETNONCLIENTMETRICS:
2942	memset(cmetric, 0, sizeof(NONCLIENTMETRICSA));
2943	cmetric->cbSize = sizeof(NONCLIENTMETRICSA);
2944	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfCaptionFont),0);
2945	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMenuFont),0);
2946	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfStatusFont),0);
2947	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMessageFont),0);
2948	cmetric->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
2949	cmetric->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
2950	cmetric->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
2951	cmetric->iCaptionWidth = 32; //TODO
2952	cmetric->iCaptionHeight = 16; //TODO
2953	cmetric->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
2954	cmetric->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
2955	cmetric->iMenuWidth = 32; //TODO
2956	cmetric->iMenuHeight = GetSystemMetrics(SM_CYMENU);
2957	rc = TRUE;
2958	break;
2959	case 104: //TODO: Undocumented
2960	rc = 16;
2961	break;
2962	default:
2963	rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
2964	break;
2965	}
2966	#ifdef DEBUG
2967	WriteLog("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc);
2968	#endif
2969	return(rc);
2970	}
2971	//******************************************************************************
2972	//TODO: Check for more options that have different structs for Unicode!!!!
2973	//******************************************************************************
2974	BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
2975	{
2976	BOOL rc;
2977	NONCLIENTMETRICSW clientMetricsW = (NONCLIENTMETRICSW )pvParam;
2978	NONCLIENTMETRICSA clientMetricsA = {0};
2979	PVOID pvParamA;
2980	UINT uiParamA;
2981
2982	switch(uiAction) {
2983	case SPI_SETNONCLIENTMETRICS:
2984	clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
2985	clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
2986	clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
2987	clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
2988	clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
2989	clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
2990	ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
2991	clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
2992	clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
2993	ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
2994	clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
2995	clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
2996	ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
2997	ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
2998	ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
2999	//no break
3000	case SPI_GETNONCLIENTMETRICS:
3001	uiParamA = sizeof(NONCLIENTMETRICSA);
3002	pvParamA = &clientMetricsA;
3003	break;
3004	default:
3005	pvParamA = pvParam;
3006	uiParamA = uiParam;
3007	break;
3008	}
3009	rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
3010
3011	switch(uiAction) {
3012	case SPI_GETNONCLIENTMETRICS:
3013	clientMetricsW->cbSize = sizeof(*clientMetricsW);
3014	clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
3015	clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
3016	clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
3017	clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
3018	clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
3019	ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
3020
3021	clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
3022	clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
3023	ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
3024
3025	clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
3026	clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
3027	ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
3028	ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
3029	ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
3030	break;
3031	}
3032	#ifdef DEBUG
3033	WriteLog("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc);
3034	#endif
3035	return(rc);
3036	}
3037	//******************************************************************************
3038	//******************************************************************************
3039	LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3040	{
3041	#ifdef DEBUG
3042	WriteLog("USER32: TabbedTextOutA\n");
3043	#endif
3044	return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
3045	}
3046	//******************************************************************************
3047	//******************************************************************************
3048	LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3049	{
3050	char *astring = UnicodeToAsciiString((LPWSTR)arg4);
3051	LONG rc;
3052
3053	#ifdef DEBUG
3054	WriteLog("USER32: TabbedTextOutW\n");
3055	#endif
3056	rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
3057	FreeAsciiString(astring);
3058	return rc;
3059	}
3060	//******************************************************************************
3061	//******************************************************************************
3062	int WIN32API TranslateAccelerator( HWND arg1, HACCEL arg2, LPMSG arg3)
3063	{
3064	#ifdef DEBUG
3065	WriteLog("USER32: TranslateAccelerator\n");
3066	#endif
3067	return O32_TranslateAccelerator(arg1, arg2, arg3);
3068	}
3069	//******************************************************************************
3070	//******************************************************************************
3071	int WIN32API TranslateAcceleratorW( HWND arg1, HACCEL arg2, LPMSG arg3)
3072	{
3073	#ifdef DEBUG
3074	WriteLog("USER32: TranslateAcceleratorW\n");
3075	#endif
3076	// NOTE: This will not work as is (needs UNICODE support)
3077	return O32_TranslateAccelerator(arg1, arg2, arg3);
3078	}
3079	//******************************************************************************
3080	//******************************************************************************
3081	BOOL WIN32API TranslateMDISysAccel( HWND arg1, LPMSG arg2)
3082	{
3083	#ifdef DEBUG
3084	//// WriteLog("USER32: TranslateMDISysAccel\n");
3085	#endif
3086	return O32_TranslateMDISysAccel(arg1, arg2);
3087	}
3088	//******************************************************************************
3089	//******************************************************************************
3090	BOOL WIN32API UnionRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
3091	{
3092	#ifdef DEBUG
3093	WriteLog("USER32: UnionRect\n");
3094	#endif
3095	return O32_UnionRect(arg1, arg2, arg3);
3096	}
3097	//******************************************************************************
3098	//******************************************************************************
3099	BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
3100	{
3101	#ifdef DEBUG
3102	WriteLog("USER32: ValidateRect\n");
3103	#endif
3104	return O32_ValidateRect(arg1, arg2);
3105	}
3106	//******************************************************************************
3107	//******************************************************************************
3108	BOOL WIN32API ValidateRgn( HWND arg1, HRGN arg2)
3109	{
3110	#ifdef DEBUG
3111	WriteLog("USER32: ValidateRgn\n");
3112	#endif
3113	return O32_ValidateRgn(arg1, arg2);
3114	}
3115	//******************************************************************************
3116	//******************************************************************************
3117	WORD WIN32API VkKeyScanW( WCHAR arg1)
3118	{
3119	#ifdef DEBUG
3120	WriteLog("USER32: VkKeyScanW\n");
3121	#endif
3122	// NOTE: This will not work as is (needs UNICODE support)
3123	return O32_VkKeyScan((char)arg1);
3124	}
3125	//******************************************************************************
3126	//******************************************************************************
3127	BOOL WIN32API WaitMessage(void)
3128	{
3129	#ifdef DEBUG
3130	WriteLog("USER32: WaitMessage\n");
3131	#endif
3132	return O32_WaitMessage();
3133	}
3134	//******************************************************************************
3135	//******************************************************************************
3136	BOOL WIN32API WinHelpW( HWND arg1, LPCWSTR arg2, UINT arg3, DWORD arg4)
3137	{
3138	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
3139	BOOL rc;
3140
3141	#ifdef DEBUG
3142	WriteLog("USER32: WinHelpW\n");
3143	#endif
3144	rc = WinHelpA(arg1, astring, arg3, arg4);
3145	FreeAsciiString(astring);
3146	return rc;
3147	}
3148	//******************************************************************************
3149	//******************************************************************************
3150	HWND WIN32API WindowFromDC( HDC arg1)
3151	{
3152	#ifdef DEBUG
3153	WriteLog("USER32: WindowFromDC\n");
3154	#endif
3155	return O32_WindowFromDC(arg1);
3156	}
3157	//******************************************************************************
3158	//******************************************************************************
3159	HWND WIN32API WindowFromPoint( POINT arg1)
3160	{
3161	#ifdef DEBUG
3162	WriteLog("USER32: WindowFromPoint\n");
3163	#endif
3164	return O32_WindowFromPoint(arg1);
3165	}
3166	//******************************************************************************
3167	//******************************************************************************
3168	int WIN32API wvsprintfA( LPSTR arg1, LPCSTR arg2, va_list arg3)
3169	{
3170	#ifdef DEBUG
3171	WriteLog("USER32: wvsprintfA\n");
3172	#endif
3173	return O32_wvsprintf(arg1, arg2, (LPCVOID *)arg3);
3174	}
3175	//******************************************************************************
3176	//******************************************************************************
3177	int WIN32API wvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, va_list argptr)
3178	{
3179	int rc;
3180	char szOut[256];
3181	char *lpFmtA;
3182
3183	lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
3184	#ifdef DEBUG
3185	WriteLog("USER32: wvsprintfW, DOES NOT HANDLE UNICODE STRINGS!\n");
3186	WriteLog("USER32: %s\n", lpFmt);
3187	#endif
3188	rc = O32_wvsprintf(szOut, lpFmtA, (LPCVOID)argptr);
3189
3190	AsciiToUnicode(szOut, lpOut);
3191	#ifdef DEBUG
3192	WriteLog("USER32: %s\n", lpOut);
3193	#endif
3194	FreeAsciiString(lpFmtA);
3195	return(rc);
3196	}
3197	//******************************************************************************
3198	//No need to support this
3199	//******************************************************************************
3200	BOOL WIN32API SetMessageQueue(int cMessagesMax)
3201	{
3202	#ifdef DEBUG
3203	WriteLog("USER32: SetMessageQueue\n");
3204	#endif
3205	return(TRUE);
3206	}
3207	//******************************************************************************
3208	//TODO: Not complete
3209	//******************************************************************************
3210	BOOL WIN32API GetScrollInfo(HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
3211	{
3212	#ifdef DEBUG
3213	WriteLog("USER32: GetScrollInfo\n");
3214	#endif
3215	if(lpsi == NULL)
3216	return(FALSE);
3217
3218	if(lpsi->fMask & SIF_POS)
3219	lpsi->nPos = GetScrollPos(hwnd, fnBar);
3220	if(lpsi->fMask & SIF_RANGE)
3221	GetScrollRange(hwnd, fnBar, &lpsi->nMin, &lpsi->nMax);
3222	if(lpsi->fMask & SIF_PAGE) {
3223	#ifdef DEBUG
3224	WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3225	#endif
3226	lpsi->nPage = 25;
3227	}
3228	return(TRUE);
3229	}
3230	//******************************************************************************
3231	//TODO: Not complete
3232	//******************************************************************************
3233	INT WIN32API SetScrollInfo(HWND hwnd, INT fnBar, const SCROLLINFO *lpsi, BOOL fRedraw)
3234	{
3235	int smin, smax;
3236
3237	#ifdef DEBUG
3238	WriteLog("USER32: SetScrollInfo\n");
3239	#endif
3240	if(lpsi == NULL)
3241	return(FALSE);
3242
3243	if(lpsi->fMask & SIF_POS)
3244	SetScrollPos(hwnd, fnBar, lpsi->nPos, fRedraw);
3245	if(lpsi->fMask & SIF_RANGE)
3246	SetScrollRange(hwnd, fnBar, lpsi->nMin, lpsi->nMax, fRedraw);
3247	if(lpsi->fMask & SIF_PAGE) {
3248	#ifdef DEBUG
3249	WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3250	#endif
3251	}
3252	if(lpsi->fMask & SIF_DISABLENOSCROLL) {
3253	#ifdef DEBUG
3254	WriteLog("USER32: GetScrollInfo, disable scrollbar not yet implemented\n");
3255	#endif
3256	}
3257	return(TRUE);
3258	}
3259	//******************************************************************************
3260	//******************************************************************************
3261	BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3262	LPARAM lpData, int nCount, int X, int Y, int nWidth,
3263	int nHeight)
3264	{
3265	BOOL rc;
3266	COLORREF curclr;
3267
3268	#ifdef DEBUG
3269	WriteLog("USER32: GrayStringA, not completely implemented\n");
3270	#endif
3271	if(lpOutputFunc == NULL && lpData == NULL) {
3272	#ifdef DEBUG
3273	WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3274	#endif
3275	return(FALSE);
3276	}
3277	if(lpOutputFunc) {
3278	return(lpOutputFunc(hdc, lpData, nCount));
3279	}
3280	curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3281	rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
3282	SetTextColor(hdc, curclr);
3283
3284	return(rc);
3285	}
3286	//******************************************************************************
3287	//******************************************************************************
3288	BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3289	LPARAM lpData, int nCount, int X, int Y, int nWidth,
3290	int nHeight)
3291	{
3292	BOOL rc;
3293	char *astring;
3294	COLORREF curclr;
3295
3296	#ifdef DEBUG
3297	WriteLog("USER32: GrayStringW, not completely implemented\n");
3298	#endif
3299
3300	if(lpOutputFunc == NULL && lpData == NULL) {
3301	#ifdef DEBUG
3302	WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3303	#endif
3304	return(FALSE);
3305	}
3306	if(nCount == 0)
3307	nCount = UniStrlen((UniChar*)lpData);
3308
3309	if(lpOutputFunc) {
3310	return(lpOutputFunc(hdc, lpData, nCount));
3311	}
3312	astring = UnicodeToAsciiString((LPWSTR)lpData);
3313
3314	curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3315	rc = TextOutA(hdc, X, Y, astring, nCount);
3316	SetTextColor(hdc, curclr);
3317
3318	FreeAsciiString(astring);
3319	return(rc);
3320	}
3321	//******************************************************************************
3322	//TODO:
3323	//******************************************************************************
3324	int WIN32API CopyAcceleratorTableA(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3325	int cAccelEntries)
3326	{
3327	#ifdef DEBUG
3328	WriteLog("USER32: CopyAcceleratorTableA, not implemented\n");
3329	#endif
3330	return(0);
3331	}
3332	//******************************************************************************
3333	//TODO:
3334	//******************************************************************************
3335	int WIN32API CopyAcceleratorTableW(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3336	int cAccelEntries)
3337	{
3338	#ifdef DEBUG
3339	WriteLog("USER32: CopyAcceleratorTableW, not implemented\n");
3340	#endif
3341	return(0);
3342	}
3343	//******************************************************************************
3344	//Stolen from Wine (controls\uitools.c)
3345	//******************************************************************************
3346	BOOL DrawEdgeDiag(HDC hdc, RECT *rect, UINT edge, UINT flags)
3347	{
3348	HPEN facePen, shadowPen, lightPen, blackPen, grayPen, nullPen;
3349	HPEN iPen, oPen, oldPen;
3350	HBRUSH oldBrush, faceBrush;
3351	int cl, cr, ct, cb;
3352	BOOL mainDiag;
3353	POINT tp;
3354	RECT r;
3355
3356	/* If both rasied and sunken is specified, they anihilate one another */
3357	if( !((flags & BF_MONO) \|\| (flags & BF_FLAT)) ){
3358	if( (edge & BDR_RAISEDOUTER) && (edge & BDR_SUNKENOUTER) )
3359	return FALSE;
3360	if( (edge & BDR_RAISEDINNER) && (edge & BDR_SUNKENINNER) )
3361	return FALSE;
3362	}
3363
3364	/* Create/get the tools of the trade... */
3365	facePen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNFACE));
3366	shadowPen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNSHADOW));
3367	lightPen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNHILIGHT));
3368	grayPen = CreatePen(PS_SOLID, 0, RGB(168, 152, 144));
3369	blackPen = GetStockObject(BLACK_PEN);
3370	nullPen = GetStockObject(NULL_PEN);
3371	faceBrush = GetSysColorBrush(COLOR_BTNFACE);
3372	oldPen = SelectObject(hdc, nullPen);
3373	oldBrush = SelectObject(hdc, faceBrush);
3374
3375	/* this is my working rectangle */
3376	r = *rect;
3377
3378	if(flags & BF_MONO){
3379	oPen = blackPen;
3380	iPen = nullPen;
3381	}else if(flags & BF_FLAT){
3382	oPen = shadowPen;
3383	iPen = facePen;
3384	}else {
3385	if(flags & BF_SOFT){
3386	if(flags & BF_BOTTOM){
3387	oPen = (edge & BDR_RAISEDOUTER) ? blackPen : lightPen;
3388	iPen = (edge & BDR_RAISEDINNER) ? shadowPen : grayPen;
3389	}
3390	else{
3391	oPen = (edge & BDR_RAISEDOUTER) ? lightPen : blackPen;
3392	iPen = (edge & BDR_RAISEDINNER) ? grayPen : shadowPen;
3393	}
3394	}
3395	else{
3396	if(flags & BF_BOTTOM){
3397	oPen = (edge & BDR_RAISEDOUTER) ? blackPen : lightPen;
3398	iPen = (edge & BDR_RAISEDINNER) ? shadowPen : grayPen;
3399	}
3400	else{
3401	oPen = (edge & BDR_RAISEDOUTER) ? grayPen : shadowPen;
3402	iPen = (edge & BDR_RAISEDINNER) ? lightPen : blackPen;
3403	}
3404	}
3405	}
3406
3407	if(flags & BF_BOTTOM){
3408	if(flags & BF_LEFT){
3409	cr = -1; cl = 0;
3410	ct = 0; cb = -1;
3411	mainDiag = TRUE;
3412	tp.x = r.left; tp.y = r.top;
3413	}
3414	else{ /* RIGHT */
3415	cr = -1; cl = 0;
3416	ct = 1; cb = 0;
3417	tp.x = r.left; tp.y = r.bottom-1;
3418	mainDiag = FALSE;
3419	}
3420	}
3421	else{ /* TOP */
3422	if(flags & BF_LEFT){
3423	cr = 0; cl = 1;
3424	ct = 0; cb = -1;
3425	mainDiag = FALSE;
3426	tp.x = r.right; tp.y = r.top;
3427	}
3428	else{ /* RIGHT */
3429	cr = 0; cl = 1;
3430	ct = 1; cb = 0;
3431	tp.x = r.right; tp.y = r.bottom-1;
3432	mainDiag = TRUE;
3433	}
3434	}
3435
3436	/* if it has external edge, draw it */
3437	if(edge & BDR_OUTER){
3438	SelectObject(hdc, oPen);
3439	MoveToEx(hdc, r.left, mainDiag ? r.bottom-1 : r.top, 0);
3440	LineTo(hdc, r.right, mainDiag ? r.top-1 : r.bottom);
3441	r.left += cl; r.right += cr; r.top += ct; r.bottom += cb;
3442	}
3443
3444	/* if it has internal edge, draw it */
3445	if(edge & BDR_INNER){
3446	SelectObject(hdc, iPen);
3447	MoveToEx(hdc, r.left, mainDiag ? r.bottom-1 : r.top, 0);
3448	LineTo(hdc, r.right, mainDiag ? r.top-1 : r.bottom);
3449	r.left += cl; r.right += cr; r.top += ct; r.bottom += cb;
3450	}
3451
3452	if((flags & BF_MIDDLE) && !(flags & BF_MONO)){
3453	POINT p[3];
3454	p[0].x = mainDiag ? r.right: r.left;
3455	p[0].y = r.top;
3456	p[1].x = mainDiag ? r.left : r.right;
3457	p[1].y = r.bottom;
3458	p[2].x = tp.x;
3459	p[2].y = tp.y;
3460	SelectObject(hdc, nullPen);
3461	SelectObject(hdc, faceBrush);
3462	Polygon(hdc, p, 3);
3463	}
3464
3465	if(flags & BF_ADJUST)
3466	*rect = r;
3467
3468	/* Restore the DC */
3469	SelectObject(hdc, oldPen);
3470	SelectObject(hdc, oldBrush);
3471
3472	/* Clean-up */
3473	DeleteObject(facePen);
3474	DeleteObject(shadowPen);
3475	DeleteObject(lightPen);
3476	DeleteObject(grayPen);
3477
3478	return TRUE;
3479	}
3480	//******************************************************************************
3481	//Stolen from Wine (controls\uitools.c)
3482	//******************************************************************************
3483	BOOL WIN32API DrawEdge(HDC hdc, LPRECT rect, UINT edge, UINT flags)
3484	{
3485	HBRUSH faceBrush, shadowBrush, lightBrush, blackBrush, grayBrush, nullBrush;
3486	HBRUSH iNBrush, iSBrush, iEBrush, iWBrush;
3487	HBRUSH oNBrush, oSBrush, oEBrush, oWBrush;
3488	HBRUSH oldBrush;
3489	POINT point[2];
3490	RECT r;
3491
3492	#ifdef DEBUG
3493	WriteLog("USER32: DrawEdge %X %X, partially implemented\n", edge, flags);
3494	WriteLog("USER32: DrawEdge (%d,%d) (%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom);
3495	#endif
3496
3497	if(flags & BF_DIAGONAL) {
3498	return DrawEdgeDiag(hdc, rect, edge, flags);
3499	}
3500	/* If both rasied and sunken is specified, they anihilate one another */
3501	if( !((flags & BF_MONO) \|\| (flags & BF_FLAT)) ){
3502	if( (edge & BDR_RAISEDOUTER) && (edge & BDR_SUNKENOUTER) )
3503	return FALSE;
3504	if( (edge & BDR_RAISEDINNER) && (edge & BDR_SUNKENINNER) )
3505	return FALSE;
3506	}
3507
3508	faceBrush = GetSysColorBrush(COLOR_BTNFACE);
3509	shadowBrush = GetSysColorBrush(COLOR_BTNSHADOW);
3510	lightBrush = GetSysColorBrush(COLOR_BTNHILIGHT);
3511	blackBrush = GetStockObject(BLACK_BRUSH);
3512	grayBrush = GetStockObject(LTGRAY_BRUSH);
3513	nullBrush = GetStockObject(NULL_BRUSH);
3514	oldBrush = SelectObject(hdc, nullBrush);
3515
3516	/* this is my working rectangle */
3517	r = *rect;
3518
3519	if(flags & BF_MONO){
3520	oNBrush = oSBrush = oEBrush = oWBrush = blackBrush;
3521	iNBrush = iSBrush = iEBrush = iWBrush = nullBrush;
3522	}else if(flags & BF_FLAT){
3523	oNBrush = oSBrush = oEBrush = oWBrush = shadowBrush;
3524	iNBrush = iSBrush = iEBrush = iWBrush = faceBrush;
3525	}else {
3526	if(flags & BF_SOFT){
3527	oNBrush = oWBrush = (edge & BDR_RAISEDOUTER) ? lightBrush : blackBrush;
3528	oSBrush = oEBrush = (edge & BDR_RAISEDOUTER) ? blackBrush : lightBrush;
3529	iNBrush = iWBrush = (edge & BDR_RAISEDINNER) ? grayBrush : shadowBrush;
3530	iSBrush = iEBrush = (edge & BDR_RAISEDINNER) ? shadowBrush : grayBrush;
3531	}
3532	else{
3533	oNBrush = oWBrush = (edge & BDR_RAISEDOUTER) ? grayBrush : shadowBrush;
3534	oSBrush = oEBrush = (edge & BDR_RAISEDOUTER) ? blackBrush : lightBrush;
3535	iNBrush = iWBrush = (edge & BDR_RAISEDINNER) ? lightBrush : blackBrush;
3536	iSBrush = iEBrush = (edge & BDR_RAISEDINNER) ? shadowBrush : grayBrush;
3537	}
3538	}
3539
3540	/* if it has external edge, draw it */
3541	if(edge & BDR_OUTER){
3542	if(flags & BF_RIGHT){
3543	SelectObject(hdc, oEBrush);
3544	PatBlt(hdc, r.right-1, r.top, 1, r.bottom - r.top, PATCOPY);
3545	r.right--;
3546	}
3547	if(flags & BF_BOTTOM){
3548	SelectObject(hdc, oSBrush);
3549	PatBlt(hdc, r.left, r.bottom-1, r.right-r.left, 1, PATCOPY);
3550	r.bottom--;
3551	}
3552	if(flags & BF_LEFT){
3553	SelectObject(hdc, oWBrush);
3554	PatBlt(hdc, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
3555	r.left++;
3556	}
3557	if(flags & BF_TOP){
3558	SelectObject(hdc, oNBrush);
3559	PatBlt(hdc, r.left, r.top, r.right-r.left, 1, PATCOPY);
3560	r.top++;
3561	}
3562	}
3563
3564	/* if it has internal edge, draw it */
3565	if(edge & BDR_INNER){
3566	if(flags & BF_RIGHT){
3567	SelectObject(hdc, iEBrush);
3568	PatBlt(hdc, r.right-1, r.top, 1, r.bottom - r.top, PATCOPY);
3569	r.right--;
3570	}
3571	if(flags & BF_BOTTOM){
3572	SelectObject(hdc, iSBrush);
3573	PatBlt(hdc, r.left, r.bottom-1, r.right-r.left, 1, PATCOPY);
3574	r.bottom--;
3575	}
3576	if(flags & BF_LEFT){
3577	SelectObject(hdc, iWBrush);
3578	PatBlt(hdc, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
3579	r.left++;
3580	}
3581	if(flags & BF_TOP){
3582	SelectObject(hdc, iNBrush);
3583	PatBlt(hdc, r.left, r.top, r.right-r.left, 1, PATCOPY);
3584	r.top++;
3585	}
3586	}
3587
3588	/* if we got to fill the middle, to it now */
3589	if((flags & BF_MIDDLE) && !(flags & BF_MONO))
3590	FillRect(hdc, &r, faceBrush);
3591
3592	/* adjust the rectangle if required */
3593	if(flags & BF_ADJUST)
3594	*rect = r;
3595
3596	/* Restore the DC */
3597	SelectObject(hdc, oldBrush);
3598
3599	return TRUE;
3600	}
3601	//******************************************************************************
3602	//******************************************************************************
3603	LRESULT WIN32API SendMessageTimeoutA(HWND hwnd, UINT Msg, WPARAM wParam,
3604	LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3605	LPDWORD lpdwResult)
3606	{
3607	#ifdef DEBUG
3608	WriteLog("USER32: SendMessageTimeoutA, partially implemented\n");
3609	#endif
3610	//ignore fuFlags & wTimeOut
3611	*lpdwResult = SendMessageA(hwnd, Msg, wParam, lParam);
3612	return(TRUE);
3613	}
3614	//******************************************************************************
3615	//******************************************************************************
3616	LRESULT WIN32API SendMessageTimeoutW(HWND hwnd, UINT Msg, WPARAM wParam,
3617	LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3618	LPDWORD lpdwResult)
3619	{
3620	#ifdef DEBUG
3621	WriteLog("USER32: SendMessageTimeoutW, partially implemented\n");
3622	#endif
3623	return(SendMessageTimeoutA(hwnd, Msg, wParam, lParam, fuFlags, uTimeOut, lpdwResult));
3624	}
3625	//******************************************************************************
3626	//******************************************************************************
3627	HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
3628	{
3629	#ifdef DEBUG
3630	WriteLog("USER32: CopyImage, not implemented\n");
3631	#endif
3632	switch(uType) {
3633	case IMAGE_BITMAP:
3634	case IMAGE_CURSOR:
3635	case IMAGE_ICON:
3636	default:
3637	#ifdef DEBUG
3638	WriteLog("USER32: CopyImage, unknown type\n");
3639	#endif
3640	return(NULL);
3641	}
3642	return(NULL);
3643	}
3644	//******************************************************************************
3645	//******************************************************************************
3646	BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
3647	{
3648	#ifdef DEBUG
3649	WriteLog("USER32: GetKeyboardState, not properly implemented\n");
3650	#endif
3651	memset(lpKeyState, 0, 256);
3652	return(TRUE);
3653	}
3654	//******************************************************************************
3655	//******************************************************************************
3656	BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
3657	{
3658	#ifdef DEBUG
3659	WriteLog("USER32: SetKeyboardState, not implemented\n");
3660	#endif
3661	return(TRUE);
3662	}
3663	//******************************************************************************
3664	//******************************************************************************
3665	BOOL WIN32API DrawFrameControl(HDC hdc, LPRECT lprc, UINT uType, UINT uState)
3666	{
3667	#ifdef DEBUG
3668	WriteLog("USER32: DrawFrameControl, not implemented\n");
3669	#endif
3670	return(TRUE);
3671	}
3672	//******************************************************************************
3673	//******************************************************************************
3674	BOOL WIN32API SendNotifyMessageA(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3675	{
3676	#ifdef DEBUG
3677	WriteLog("USER32: SendNotifyMessageA, not completely implemented\n");
3678	#endif
3679	return(SendMessageA(hwnd, Msg, wParam, lParam));
3680	}
3681	//******************************************************************************
3682	//******************************************************************************
3683	BOOL WIN32API SendNotifyMessageW(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3684	{
3685	#ifdef DEBUG
3686	WriteLog("USER32: SendNotifyMessageW, not completely implemented\n");
3687	#endif
3688	return(SendMessageA(hwnd, Msg, wParam, lParam));
3689	}
3690	//******************************************************************************
3691	//2nd parameter not used according to SDK (yet?)
3692	//******************************************************************************
3693	VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
3694	{
3695	#ifdef DEBUG
3696	WriteLog("USER32: SetLastErrorEx\n");
3697	#endif
3698	SetLastError(dwErrCode);
3699	}
3700	//******************************************************************************
3701	//******************************************************************************
3702	LPARAM WIN32API SetMessageExtraInfo(LPARAM lParam)
3703	{
3704	#ifdef DEBUG
3705	WriteLog("USER32: SetMessageExtraInfo, not implemented\n");
3706	#endif
3707	return(0);
3708	}
3709	//******************************************************************************
3710	//******************************************************************************
3711	BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
3712	{
3713	#ifdef DEBUG
3714	WriteLog("USER32: ActivateKeyboardLayout, not implemented\n");
3715	#endif
3716	return(TRUE);
3717	}
3718	//******************************************************************************
3719	//******************************************************************************
3720	int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
3721	{
3722	#ifdef DEBUG
3723	WriteLog("USER32: GetKeyboardLayoutList, not implemented\n");
3724	#endif
3725	return(0);
3726	}
3727	//******************************************************************************
3728	//******************************************************************************
3729	HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
3730	{
3731	#ifdef DEBUG
3732	WriteLog("USER32: GetKeyboardLayout, not implemented\n");
3733	#endif
3734	return(0);
3735	}
3736	//******************************************************************************
3737	//******************************************************************************
3738	int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
3739	{
3740	#ifdef DEBUG
3741	WriteLog("USER32: LookupIconIdFromDirectory, not implemented\n");
3742	#endif
3743	return(0);
3744	}
3745	//******************************************************************************
3746	//******************************************************************************
3747	int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL fIcon,
3748	int cxDesired, int cyDesired,
3749	UINT Flags)
3750	{
3751	#ifdef DEBUG
3752	WriteLog("USER32: LookupIconIdFromDirectoryEx, not implemented\n");
3753	#endif
3754	return(0);
3755	}
3756	//******************************************************************************
3757	//DWORD idAttach; /* thread to attach */
3758	//DWORD idAttachTo; /* thread to attach to */
3759	//BOOL fAttach; /* attach or detach */
3760	//******************************************************************************
3761	BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
3762	{
3763	#ifdef DEBUG
3764	WriteLog("USER32: AttachThreadInput, not implemented\n");
3765	#endif
3766	return(TRUE);
3767	}
3768	//******************************************************************************
3769	//******************************************************************************
3770	BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
3771	{
3772	#ifdef DEBUG
3773	WriteLog("USER32: RegisterHotKey, not implemented\n");
3774	#endif
3775	return(TRUE);
3776	}
3777	//******************************************************************************
3778	//******************************************************************************
3779	BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
3780	{
3781	#ifdef DEBUG
3782	WriteLog("USER32: UnregisterHotKey, not implemented\n");
3783	#endif
3784	return(TRUE);
3785	}
3786	//******************************************************************************
3787	//******************************************************************************
3788	BOOL WIN32API DrawStateA(HDC hdc, HBRUSH hbc, DRAWSTATEPROC lpOutputFunc,
3789	LPARAM lData, WPARAM wData, int x, int y, int cx,
3790	int cy, UINT fuFlags)
3791	{
3792	#ifdef DEBUG
3793	WriteLog("USER32: DrawStateA, not implemented\n");
3794	#endif
3795	return(TRUE);
3796	}
3797	//******************************************************************************
3798	//******************************************************************************
3799	//******************************************************************************
3800	//******************************************************************************
3801	BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
3802	{
3803	#ifdef DEBUG
3804	WriteLog("USER32: SetWindowContextHelpId, not implemented\n");
3805	#endif
3806	return(TRUE);
3807	}
3808	//******************************************************************************
3809	//******************************************************************************
3810	DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
3811	{
3812	#ifdef DEBUG
3813	WriteLog("USER32: GetWindowContextHelpId, not implemented\n");
3814	#endif
3815	return(0);
3816	}
3817	//******************************************************************************
3818	//restores iconized window to previous size/position
3819	//******************************************************************************
3820	BOOL WIN32API OpenIcon(HWND hwnd)
3821	{
3822	#ifdef DEBUG
3823	WriteLog("USER32: OpenIcon\n");
3824	#endif
3825	if(!IsIconic(hwnd))
3826	return FALSE;
3827	ShowWindow(hwnd, SW_SHOWNORMAL);
3828	return TRUE;
3829	}
3830	//******************************************************************************
3831	//******************************************************************************
3832	BOOL WIN32API IsWindowUnicode(HWND hwnd)
3833	{
3834	#ifdef DEBUG
3835	WriteLog("USER32: IsWindowUnicode, not implemented\n");
3836	#endif
3837	return(FALSE);
3838	}
3839	//******************************************************************************
3840	//******************************************************************************
3841	BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
3842	{
3843	#ifdef DEBUG
3844	WriteLog("USER32: GetMonitorInfoA not supported!!\n");
3845	#endif
3846	return(FALSE);
3847	}
3848	//******************************************************************************
3849	//******************************************************************************
3850	BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
3851	{
3852	#ifdef DEBUG
3853	WriteLog("USER32: GetMonitorInfoW not supported!!\n");
3854	#endif
3855	return(FALSE);
3856	}
3857	//******************************************************************************
3858	//******************************************************************************
3859	HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
3860	{
3861	#ifdef DEBUG
3862	WriteLog("USER32: MonitorFromWindow not correctly supported??\n");
3863	#endif
3864	return(0);
3865	}
3866	//******************************************************************************
3867	//******************************************************************************
3868	HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
3869	{
3870	#ifdef DEBUG
3871	WriteLog("USER32: MonitorFromRect not correctly supported??\n");
3872	#endif
3873	return(0);
3874	}
3875	//******************************************************************************
3876	//******************************************************************************
3877	HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
3878	{
3879	#ifdef DEBUG
3880	WriteLog("USER32: MonitorFromPoint not correctly supported??\n");
3881	#endif
3882	return(0);
3883	}
3884	//******************************************************************************
3885	//******************************************************************************
3886	BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
3887	{
3888	#ifdef DEBUG
3889	WriteLog("USER32: EnumDisplayMonitors not supported??\n");
3890	#endif
3891	return(FALSE);
3892	}
3893	//******************************************************************************
3894	//******************************************************************************
3895	BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
3896	LPDEVMODEA lpDevMode)
3897	{
3898	#ifdef DEBUG
3899	WriteLog("USER32: EnumDisplaySettingsA FAKED\n");
3900	#endif
3901	switch(iModeNum) {
3902	case 0:
3903	lpDevMode->dmBitsPerPel = 16;
3904	lpDevMode->dmPelsWidth = 768;
3905	lpDevMode->dmPelsHeight = 1024;
3906	lpDevMode->dmDisplayFlags = 0;
3907	lpDevMode->dmDisplayFrequency = 70;
3908	break;
3909	case 1:
3910	lpDevMode->dmBitsPerPel = 16;
3911	lpDevMode->dmPelsWidth = 640;
3912	lpDevMode->dmPelsHeight = 480;
3913	lpDevMode->dmDisplayFlags = 0;
3914	lpDevMode->dmDisplayFrequency = 70;
3915	break;
3916	default:
3917	return(FALSE);
3918	}
3919	return(TRUE);
3920	}
3921	//******************************************************************************
3922	//******************************************************************************
3923	LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA lpDevMode, DWORD dwFlags)
3924	{
3925	#ifdef DEBUG
3926	if(lpDevMode) {
3927	WriteLog("USER32: ChangeDisplaySettingsA FAKED %X\n", dwFlags);
3928	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
3929	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsWidth %d\n", lpDevMode->dmPelsWidth);
3930	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
3931	}
3932	#endif
3933	return(DISP_CHANGE_SUCCESSFUL);
3934	}
3935	//******************************************************************************
3936	//******************************************************************************
3937
3938
3939	/*****************************************************************************
3940	* Name : BOOL WIN32API AnyPopup
3941	* Purpose : The AnyPopup function indicates whether an owned, visible,
3942	* top-level pop-up, or overlapped window exists on the screen. The
3943	* function searches the entire Windows screen, not just the calling
3944	* application's client area.
3945	* Parameters: VOID
3946	* Variables :
3947	* Result : If a pop-up window exists, the return value is TRUE even if the
3948	* pop-up window is completely covered by other windows. Otherwise,
3949	* it is FALSE.
3950	* Remark : AnyPopup is a Windows version 1.x function and is retained for
3951	* compatibility purposes. It is generally not useful.
3952	* Status : UNTESTED STUB
3953	*
3954	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3955	*****************************************************************************/
3956
3957	BOOL WIN32API AnyPopup(VOID)
3958	{
3959	dprintf(("USER32:AnyPopup() not implemented.\n"));
3960
3961	return (FALSE);
3962	}
3963
3964
3965	/*****************************************************************************
3966	* Name : long WIN32API BroadcastSystemMessage
3967	* Purpose : The BroadcastSystemMessage function sends a message to the given
3968	* recipients. The recipients can be applications, installable
3969	* drivers, Windows-based network drivers, system-level device
3970	* drivers, or any combination of these system components.
3971	* Parameters: DWORD dwFlags,
3972	LPDWORD lpdwRecipients,
3973	UINT uiMessage,
3974	WPARAM wParam,
3975	LPARAM lParam
3976	* Variables :
3977	* Result : If the function succeeds, the return value is a positive value.
3978	* If the function is unable to broadcast the message, the return value is -1.
3979	* If the dwFlags parameter is BSF_QUERY and at least one recipient returned FALSE to the corresponding message, the return value is zero.
3980	* Remark :
3981	* Status : UNTESTED STUB
3982	*
3983	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3984	*****************************************************************************/
3985
3986	long WIN32API BroadcastSystemMessage(DWORD dwFlags,
3987	LPDWORD lpdwRecipients,
3988	UINT uiMessage,
3989	WPARAM wParam,
3990	LPARAM lParam)
3991	{
3992	dprintf(("USER32:BroadcastSystemMessage(%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
3993	dwFlags,
3994	lpdwRecipients,
3995	uiMessage,
3996	wParam,
3997	lParam));
3998
3999	return (-1);
4000	}
4001
4002
4003	/*****************************************************************************
4004	* Name : WORD WIN32API CascadeWindows
4005	* Purpose : The CascadeWindows function cascades the specified windows or
4006	* the child windows of the specified parent window.
4007	* Parameters: HWND hwndParent handle of parent window
4008	* UINT wHow types of windows not to arrange
4009	* CONST RECT * lpRect rectangle to arrange windows in
4010	* UINT cKids number of windows to arrange
4011	* const HWND FAR * lpKids array of window handles
4012	* Variables :
4013	* Result : If the function succeeds, the return value is the number of windows arranged.
4014	* If the function fails, the return value is zero.
4015	* Remark :
4016	* Status : UNTESTED STUB
4017	*
4018	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4019	*****************************************************************************/
4020
4021	WORD WIN32API CascadeWindows(HWND hwndParent,
4022	UINT wHow,
4023	CONST LPRECT lpRect,
4024	UINT cKids,
4025	const HWND *lpKids)
4026	{
4027	dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
4028	hwndParent,
4029	wHow,
4030	lpRect,
4031	cKids,
4032	lpKids));
4033
4034	return (0);
4035	}
4036
4037
4038	/*****************************************************************************
4039	* Name : LONG WIN32API ChangeDisplaySettingsW
4040	* Purpose : The ChangeDisplaySettings function changes the display settings
4041	* to the specified graphics mode.
4042	* Parameters: LPDEVMODEW lpDevModeW
4043	* DWORD dwFlags
4044	* Variables :
4045	* Result : DISP_CHANGE_SUCCESSFUL The settings change was successful.
4046	* DISP_CHANGE_RESTART The computer must be restarted in order for the graphics mode to work.
4047	* DISP_CHANGE_BADFLAGS An invalid set of flags was passed in.
4048	* DISP_CHANGE_FAILED The display driver failed the specified graphics mode.
4049	* DISP_CHANGE_BADMODE The graphics mode is not supported.
4050	* DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
4051	* Remark :
4052	* Status : UNTESTED STUB
4053	*
4054	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4055	*****************************************************************************/
4056
4057	LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
4058	DWORD dwFlags)
4059	{
4060	dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
4061	lpDevMode,
4062	dwFlags));
4063
4064	return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
4065	dwFlags));
4066	}
4067
4068	/*****************************************************************************
4069	* Name : BOOL WIN32API CloseDesktop
4070	* Purpose : The CloseDesktop function closes an open handle of a desktop
4071	* object. A desktop is a secure object contained within a window
4072	* station object. A desktop has a logical display surface and
4073	* contains windows, menus and hooks.
4074	* Parameters: HDESK hDesktop
4075	* Variables :
4076	* Result : If the function succeeds, the return value is TRUE.
4077	* If the functions fails, the return value is FALSE. To get
4078	* extended error information, call GetLastError.
4079	* Remark :
4080	* Status : UNTESTED STUB
4081	*
4082	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4083	*****************************************************************************/
4084
4085	BOOL WIN32API CloseDesktop(HDESK hDesktop)
4086	{
4087	dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
4088	hDesktop));
4089
4090	return (FALSE);
4091	}
4092
4093
4094	/*****************************************************************************
4095	* Name : BOOL WIN32API CloseWindowStation
4096	* Purpose : The CloseWindowStation function closes an open window station handle.
4097	* Parameters: HWINSTA hWinSta
4098	* Variables :
4099	* Result :
4100	* Remark : If the function succeeds, the return value is TRUE.
4101	* If the functions fails, the return value is FALSE. To get
4102	* extended error information, call GetLastError.
4103	* Status : UNTESTED STUB
4104	*
4105	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4106	*****************************************************************************/
4107
4108	BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
4109	{
4110	dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
4111	hWinSta));
4112
4113	return (FALSE);
4114	}
4115
4116
4117	/*****************************************************************************
4118	* Name : HDESK WIN32API CreateDesktopA
4119	* Purpose : The CreateDesktop function creates a new desktop on the window
4120	* station associated with the calling process.
4121	* Parameters: LPCTSTR lpszDesktop name of the new desktop
4122	* LPCTSTR lpszDevice name of display device to assign to the desktop
4123	* LPDEVMODE pDevMode reserved; must be NULL
4124	* DWORD dwFlags flags to control interaction with other applications
4125	* DWORD dwDesiredAccess specifies access of returned handle
4126	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
4127	* Variables :
4128	* Result : If the function succeeds, the return value is a handle of the
4129	* newly created desktop.
4130	* If the function fails, the return value is NULL. To get extended
4131	* error information, call GetLastError.
4132	* Remark :
4133	* Status : UNTESTED STUB
4134	*
4135	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4136	*****************************************************************************/
4137
4138	HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
4139	LPCTSTR lpszDevice,
4140	LPDEVMODEA pDevMode,
4141	DWORD dwFlags,
4142	DWORD dwDesiredAccess,
4143	LPSECURITY_ATTRIBUTES lpsa)
4144	{
4145	dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4146	lpszDesktop,
4147	lpszDevice,
4148	pDevMode,
4149	dwFlags,
4150	dwDesiredAccess,
4151	lpsa));
4152
4153	return (NULL);
4154	}
4155
4156
4157	/*****************************************************************************
4158	* Name : HDESK WIN32API CreateDesktopW
4159	* Purpose : The CreateDesktop function creates a new desktop on the window
4160	* station associated with the calling process.
4161	* Parameters: LPCTSTR lpszDesktop name of the new desktop
4162	* LPCTSTR lpszDevice name of display device to assign to the desktop
4163	* LPDEVMODE pDevMode reserved; must be NULL
4164	* DWORD dwFlags flags to control interaction with other applications
4165	* DWORD dwDesiredAccess specifies access of returned handle
4166	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
4167	* Variables :
4168	* Result : If the function succeeds, the return value is a handle of the
4169	* newly created desktop.
4170	* If the function fails, the return value is NULL. To get extended
4171	* error information, call GetLastError.
4172	* Remark :
4173	* Status : UNTESTED STUB
4174	*
4175	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4176	*****************************************************************************/
4177
4178	HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
4179	LPCTSTR lpszDevice,
4180	LPDEVMODEW pDevMode,
4181	DWORD dwFlags,
4182	DWORD dwDesiredAccess,
4183	LPSECURITY_ATTRIBUTES lpsa)
4184	{
4185	dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4186	lpszDesktop,
4187	lpszDevice,
4188	pDevMode,
4189	dwFlags,
4190	dwDesiredAccess,
4191	lpsa));
4192
4193	return (NULL);
4194	}
4195
4196
4197	/*****************************************************************************
4198	* Name : HWINSTA WIN32API CreateWindowStationA
4199	* Purpose : The CreateWindowStation function creates a window station object.
4200	* It returns a handle that can be used to access the window station.
4201	* A window station is a secure object that contains a set of global
4202	* atoms, a clipboard, and a set of desktop objects.
4203	* Parameters: LPTSTR lpwinsta name of the new window station
4204	* DWORD dwReserved reserved; must be NULL
4205	* DWORD dwDesiredAccess specifies access of returned handle
4206	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4207	* Variables :
4208	* Result : If the function succeeds, the return value is the handle to the
4209	* newly created window station.
4210	* If the function fails, the return value is NULL. To get extended
4211	* error information, call GetLastError.
4212	* Remark :
4213	* Status : UNTESTED STUB
4214	*
4215	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4216	*****************************************************************************/
4217
4218	HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
4219	DWORD dwReserved,
4220	DWORD dwDesiredAccess,
4221	LPSECURITY_ATTRIBUTES lpsa)
4222	{
4223	dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
4224	lpWinSta,
4225	dwReserved,
4226	dwDesiredAccess,
4227	lpsa));
4228
4229	return (NULL);
4230	}
4231
4232
4233	/*****************************************************************************
4234	* Name : HWINSTA WIN32API CreateWindowStationW
4235	* Purpose : The CreateWindowStation function creates a window station object.
4236	* It returns a handle that can be used to access the window station.
4237	* A window station is a secure object that contains a set of global
4238	* atoms, a clipboard, and a set of desktop objects.
4239	* Parameters: LPTSTR lpwinsta name of the new window station
4240	* DWORD dwReserved reserved; must be NULL
4241	* DWORD dwDesiredAccess specifies access of returned handle
4242	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4243	* Variables :
4244	* Result : If the function succeeds, the return value is the handle to the
4245	* newly created window station.
4246	* If the function fails, the return value is NULL. To get extended
4247	* error information, call GetLastError.
4248	* Remark :
4249	* Status : UNTESTED STUB
4250	*
4251	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4252	*****************************************************************************/
4253
4254	HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
4255	DWORD dwReserved,
4256	DWORD dwDesiredAccess,
4257	LPSECURITY_ATTRIBUTES lpsa)
4258	{
4259	dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
4260	lpWinSta,
4261	dwReserved,
4262	dwDesiredAccess,
4263	lpsa));
4264
4265	return (NULL);
4266	}
4267
4268	/*****************************************************************************
4269	* Name : BOOL WIN32API DragDetect
4270	* Purpose : The DragDetect function captures the mouse and tracks its movement
4271	* Parameters: HWND hwnd
4272	* POINT pt
4273	* Variables :
4274	* Result : If the user moved the mouse outside of the drag rectangle while
4275	* holding the left button down, the return value is TRUE.
4276	* If the user did not move the mouse outside of the drag rectangle
4277	* while holding the left button down, the return value is FALSE.
4278	* Remark :
4279	* Status : UNTESTED STUB
4280	*
4281	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4282	*****************************************************************************/
4283
4284	BOOL WIN32API DragDetect(HWND hwnd,
4285	POINT pt)
4286	{
4287	dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
4288	hwnd));
4289
4290	return (FALSE);
4291	}
4292
4293
4294	/*****************************************************************************
4295	* Name : BOOL WIN32API DrawAnimatedRects
4296	* Purpose : The DrawAnimatedRects function draws a wire-frame rectangle
4297	* and animates it to indicate the opening of an icon or the
4298	* minimizing or maximizing of a window.
4299	* Parameters: HWND hwnd handle of clipping window
4300	* int idAni type of animation
4301	* CONST RECT * lprcFrom address of rectangle coordinates (minimized)
4302	* CONST RECT * lprcTo address of rectangle coordinates (restored)
4303	* Variables :
4304	* Result : If the function succeeds, the return value is TRUE.
4305	* If the function fails, the return value is FALSE.
4306	* Remark :
4307	* Status : UNTESTED STUB
4308	*
4309	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4310	*****************************************************************************/
4311
4312	BOOL WIN32API DrawAnimatedRects(HWND hwnd,
4313	int idAni,
4314	CONST RECT *lprcFrom,
4315	CONST RECT *lprcTo)
4316	{
4317	dprintf(("USER32:DrawAnimatedRects (%08xh,%u,%08xh,%08x) not implemented.\n",
4318	hwnd,
4319	idAni,
4320	lprcFrom,
4321	lprcTo));
4322
4323	return (TRUE);
4324	}
4325
4326
4327	/*****************************************************************************
4328	* Name : VOID WIN32API DrawCaption
4329	* Purpose : The DrawCaption function draws a window caption.
4330	* Parameters: HDC hdc handle of device context
4331	* LPRECT lprc address of bounding rectangle coordinates
4332	* HFONT hfont handle of font for caption
4333	* HICON hicon handle of icon in caption
4334	* LPSTR lpszText address of caption string
4335	* WORD wFlags drawing options
4336	* Variables :
4337	* Result :
4338	* Remark :
4339	* Status : UNTESTED STUB
4340	*
4341	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4342	*****************************************************************************/
4343
4344	BOOL WIN32API DrawCaption (HWND hwnd,
4345	HDC hdc,
4346	const RECT *lprc,
4347	UINT wFlags)
4348	{
4349	dprintf(("USER32:DrawCaption (%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4350	hwnd,
4351	hdc,
4352	lprc,
4353	wFlags));
4354
4355	return FALSE;
4356	}
4357
4358
4359	/*****************************************************************************
4360	* Name :
4361	* Purpose :
4362	* Parameters:
4363	* Variables :
4364	* Result :
4365	* Remark :
4366	* Status : UNTESTED STUB
4367	*
4368	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4369	*****************************************************************************/
4370
4371	BOOL WIN32API DrawStateW(HDC hdc,
4372	HBRUSH hBrush,
4373	DRAWSTATEPROC lpOutputFunc,
4374	LPARAM lParam,
4375	WPARAM wParam,
4376	int x,
4377	int y,
4378	int cx,
4379	int cy,
4380	UINT fuFlags)
4381	{
4382	dprintf(("USER32:DrawStateW (%08xh,%08xh,%08xh,%08xh,%08xh,%d,%d,%d,%d,%08x) not implemented.\n",
4383	hdc,
4384	hBrush,
4385	lpOutputFunc,
4386	lParam,
4387	wParam,
4388	x,
4389	y,
4390	cx,
4391	cy,
4392	fuFlags));
4393
4394	return(DrawStateA(hdc,
4395	hBrush,
4396	lpOutputFunc,
4397	lParam,
4398	wParam,
4399	x,
4400	y,
4401	cx,
4402	cy,
4403	fuFlags));
4404	}
4405
4406
4407	/*****************************************************************************
4408	* Name : BOOL WIN32API EnumDesktopWindows
4409	* Purpose : The EnumDesktopWindows function enumerates all windows in a
4410	* desktop by passing the handle of each window, in turn, to an
4411	* application-defined callback function.
4412	* Parameters: HDESK hDesktop handle of desktop to enumerate
4413	* WNDENUMPROC lpfn points to application's callback function
4414	* LPARAM lParam 32-bit value to pass to the callback function
4415	* Variables :
4416	* Result : If the function succeeds, the return value is TRUE.
4417	* If the function fails, the return value is FALSE. To get
4418	* extended error information, call GetLastError.
4419	* Remark :
4420	* Status : UNTESTED STUB
4421	*
4422	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4423	*****************************************************************************/
4424
4425	BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
4426	WNDENUMPROC lpfn,
4427	LPARAM lParam)
4428	{
4429	dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
4430	hDesktop,
4431	lpfn,
4432	lParam));
4433
4434	return (FALSE);
4435	}
4436
4437
4438	/*****************************************************************************
4439	* Name : BOOL WIN32API EnumDesktopsA
4440	* Purpose : The EnumDesktops function enumerates all desktops in the window
4441	* station assigned to the calling process. The function does so by
4442	* passing the name of each desktop, in turn, to an application-
4443	* defined callback function.
4444	* Parameters: HWINSTA hwinsta handle of window station to enumerate
4445	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
4446	* LPARAM lParam 32-bit value to pass to the callback function
4447	* Variables :
4448	* Result : If the function succeeds, the return value is TRUE.
4449	* If the function fails, the return value is FALSE. To get extended
4450	* error information, call GetLastError.
4451	* Remark :
4452	* Status : UNTESTED STUB
4453	*
4454	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4455	*****************************************************************************/
4456
4457	BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
4458	DESKTOPENUMPROCA lpEnumFunc,
4459	LPARAM lParam)
4460	{
4461	dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
4462	hWinSta,
4463	lpEnumFunc,
4464	lParam));
4465
4466	return (FALSE);
4467	}
4468
4469
4470	/*****************************************************************************
4471	* Name : BOOL WIN32API EnumDesktopsW
4472	* Purpose : The EnumDesktops function enumerates all desktops in the window
4473	* station assigned to the calling process. The function does so by
4474	* passing the name of each desktop, in turn, to an application-
4475	* defined callback function.
4476	* Parameters: HWINSTA hwinsta handle of window station to enumerate
4477	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
4478	* LPARAM lParam 32-bit value to pass to the callback function
4479	* Variables :
4480	* Result : If the function succeeds, the return value is TRUE.
4481	* If the function fails, the return value is FALSE. To get extended
4482	* error information, call GetLastError.
4483	* Remark :
4484	* Status : UNTESTED STUB
4485	*
4486	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4487	*****************************************************************************/
4488
4489	BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
4490	DESKTOPENUMPROCW lpEnumFunc,
4491	LPARAM lParam)
4492	{
4493	dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
4494	hWinSta,
4495	lpEnumFunc,
4496	lParam));
4497
4498	return (FALSE);
4499	}
4500
4501
4502
4503	/*****************************************************************************
4504	* Name : BOOL WIN32API EnumDisplaySettingsW
4505	* Purpose : The EnumDisplaySettings function obtains information about one
4506	* of a display device's graphics modes. You can obtain information
4507	* for all of a display device's graphics modes by making a series
4508	* of calls to this function.
4509	* Parameters: LPCTSTR lpszDeviceName specifies the display device
4510	* DWORD iModeNum specifies the graphics mode
4511	* LPDEVMODE lpDevMode points to structure to receive settings
4512	* Variables :
4513	* Result : If the function succeeds, the return value is TRUE.
4514	* If the function fails, the return value is FALSE.
4515	* Remark :
4516	* Status : UNTESTED STUB
4517	*
4518	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4519	*****************************************************************************/
4520
4521	BOOL WIN32API EnumDisplaySettingsW(LPCSTR lpszDeviceName,
4522	DWORD iModeNum,
4523	LPDEVMODEW lpDevMode)
4524	{
4525	dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
4526	lpszDeviceName,
4527	iModeNum,
4528	lpDevMode));
4529
4530	return (EnumDisplaySettingsA(lpszDeviceName,
4531	iModeNum,
4532	(LPDEVMODEA)lpDevMode));
4533	}
4534
4535
4536	/*****************************************************************************
4537	* Name : BOOL WIN32API EnumWindowStationsA
4538	* Purpose : The EnumWindowStations function enumerates all windowstations
4539	* in the system by passing the name of each window station, in
4540	* turn, to an application-defined callback function.
4541	* Parameters:
4542	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4543	* LPARAM lParam 32-bit value to pass to the callback function
4544	* Result : If the function succeeds, the return value is TRUE.
4545	* If the function fails the return value is FALSE. To get extended
4546	* error information, call GetLastError.
4547	* Remark :
4548	* Status : UNTESTED STUB
4549	*
4550	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4551	*****************************************************************************/
4552
4553	BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
4554	LPARAM lParam)
4555	{
4556	dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
4557	lpEnumFunc,
4558	lParam));
4559
4560	return (FALSE);
4561	}
4562
4563
4564	/*****************************************************************************
4565	* Name : BOOL WIN32API EnumWindowStationsW
4566	* Purpose : The EnumWindowStations function enumerates all windowstations
4567	* in the system by passing the name of each window station, in
4568	* turn, to an application-defined callback function.
4569	* Parameters:
4570	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4571	* LPARAM lParam 32-bit value to pass to the callback function
4572	* Result : If the function succeeds, the return value is TRUE.
4573	* If the function fails the return value is FALSE. To get extended
4574	* error information, call GetLastError.
4575	* Remark :
4576	* Status : UNTESTED STUB
4577	*
4578	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4579	*****************************************************************************/
4580
4581	BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
4582	LPARAM lParam)
4583	{
4584	dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
4585	lpEnumFunc,
4586	lParam));
4587
4588	return (FALSE);
4589	}
4590
4591
4592	/*****************************************************************************
4593	* Name : HWND WIN32API FindWindowExW
4594	* Purpose : The FindWindowEx function retrieves the handle of a window whose
4595	* class name and window name match the specified strings. The
4596	* function searches child windows, beginning with the one following
4597	* the given child window.
4598	* Parameters: HWND hwndParent handle of parent window
4599	* HWND hwndChildAfter handle of a child window
4600	* LPCTSTR lpszClass address of class name
4601	* LPCTSTR lpszWindow address of window name
4602	* Variables :
4603	* Result : If the function succeeds, the return value is the handle of the
4604	* window that has the specified class and window names.
4605	* If the function fails, the return value is NULL. 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	HWND WIN32API FindWindowExW(HWND hwndParent,
4614	HWND hwndChildAfter,
4615	LPCWSTR lpszClass,
4616	LPCWSTR lpszWindow)
4617	{
4618	dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
4619	hwndParent,
4620	hwndChildAfter,
4621	lpszClass,
4622	lpszWindow));
4623
4624	return (NULL);
4625	}
4626
4627	/*****************************************************************************
4628	* Name : BOOL WIN32API GetInputState
4629	* Purpose : The GetInputState function determines whether there are
4630	* mouse-button or keyboard messages in the calling thread's message queue.
4631	* Parameters:
4632	* Variables :
4633	* Result : If the queue contains one or more new mouse-button or keyboard
4634	* messages, the return value is TRUE.
4635	* If the function fails, the return value is FALSE.
4636	* Remark :
4637	* Status : UNTESTED STUB
4638	*
4639	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4640	*****************************************************************************/
4641
4642	BOOL WIN32API GetInputState(VOID)
4643	{
4644	dprintf(("USER32:GetInputState () not implemented.\n"));
4645
4646	return (FALSE);
4647	}
4648
4649
4650	/*****************************************************************************
4651	* Name : UINT WIN32API GetKBCodePage
4652	* Purpose : The GetKBCodePage function is provided for compatibility with
4653	* earlier versions of Windows. In the Win32 application programming
4654	* interface (API) it just calls the GetOEMCP function.
4655	* Parameters:
4656	* Variables :
4657	* Result : If the function succeeds, the return value is an OEM code-page
4658	* identifier, or it is the default identifier if the registry
4659	* value is not readable. For a list of OEM code-page identifiers,
4660	* see GetOEMCP.
4661	* Remark :
4662	* Status : UNTESTED
4663	*
4664	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4665	*****************************************************************************/
4666
4667	UINT WIN32API GetKBCodePage(VOID)
4668	{
4669	return (GetOEMCP());
4670	}
4671
4672
4673	/*****************************************************************************
4674	* Name : BOOL WIN32API GetKeyboardLayoutNameA
4675	* Purpose : The GetKeyboardLayoutName function retrieves the name of the
4676	* active keyboard layout.
4677	* Parameters: LPTSTR pwszKLID address of buffer for layout name
4678	* Variables :
4679	* Result : If the function succeeds, the return value is TRUE.
4680	* If the function fails, the return value is FALSE. To get extended
4681	* error information, call GetLastError.
4682	* Remark :
4683	* Status : UNTESTED STUB
4684	*
4685	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4686	*****************************************************************************/
4687
4688	BOOL WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
4689	{
4690	dprintf(("USER32:GetKeyboardLayoutNameA (%08x) not implemented.",
4691	pwszKLID));
4692
4693	return(FALSE);
4694	}
4695
4696
4697	/*****************************************************************************
4698	* Name : BOOL WIN32API GetKeyboardLayoutNameW
4699	* Purpose : The GetKeyboardLayoutName function retrieves the name of the
4700	* active keyboard layout.
4701	* Parameters: LPTSTR pwszKLID address of buffer for layout name
4702	* Variables :
4703	* Result : If the function succeeds, the return value is TRUE.
4704	* If the function fails, the return value is FALSE. To get extended
4705	* error information, call GetLastError.
4706	* Remark :
4707	* Status : UNTESTED STUB
4708	*
4709	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4710	*****************************************************************************/
4711
4712	BOOL WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
4713	{
4714	dprintf(("USER32:GetKeyboardLayoutNameW (%08x) not implemented.",
4715	pwszKLID));
4716
4717	return(FALSE);
4718	}
4719
4720
4721
4722
4723	/*****************************************************************************
4724	* Name : HWINSTA WIN32API GetProcessWindowStation
4725	* Purpose : The GetProcessWindowStation function returns a handle of the
4726	* window station associated with the calling process.
4727	* Parameters:
4728	* Variables :
4729	* Result : If the function succeeds, the return value is a handle of the
4730	* window station associated with the calling process.
4731	* If the function fails, the return value is NULL. This can occur
4732	* if the calling process is not an application written for Windows
4733	* NT. To get extended error information, call GetLastError.
4734	* Remark :
4735	* Status : UNTESTED STUB
4736	*
4737	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4738	*****************************************************************************/
4739
4740	HWINSTA WIN32API GetProcessWindowStation(VOID)
4741	{
4742	dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
4743
4744	return (NULL);
4745	}
4746
4747
4748
4749	/*****************************************************************************
4750	* Name : HDESK WIN32API GetThreadDesktop
4751	* Purpose : The GetThreadDesktop function returns a handle to the desktop
4752	* associated with a specified thread.
4753	* Parameters: DWORD dwThreadId thread identifier
4754	* Variables :
4755	* Result : If the function succeeds, the return value is the handle of the
4756	* desktop associated with the specified thread.
4757	* Remark :
4758	* Status : UNTESTED STUB
4759	*
4760	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4761	*****************************************************************************/
4762
4763	HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
4764	{
4765	dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
4766	dwThreadId));
4767
4768	return (NULL);
4769	}
4770
4771
4772	/*****************************************************************************
4773	* Name : BOOL WIN32API GetUserObjectInformationA
4774	* Purpose : The GetUserObjectInformation function returns information about
4775	* a window station or desktop object.
4776	* Parameters: HANDLE hObj handle of object to get information for
4777	* int nIndex type of information to get
4778	* PVOID pvInfo points to buffer that receives the information
4779	* DWORD nLength size, in bytes, of pvInfo buffer
4780	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4781	* Variables :
4782	* Result : If the function succeeds, the return value is TRUE.
4783	* If the function fails, the return value is FALSE. To get extended
4784	* error information, call GetLastError.
4785	* Remark :
4786	* Status : UNTESTED STUB
4787	*
4788	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4789	*****************************************************************************/
4790
4791	BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
4792	int nIndex,
4793	PVOID pvInfo,
4794	DWORD nLength,
4795	LPDWORD lpnLengthNeeded)
4796	{
4797	dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4798	hObj,
4799	nIndex,
4800	pvInfo,
4801	nLength,
4802	lpnLengthNeeded));
4803
4804	return (FALSE);
4805	}
4806
4807
4808	/*****************************************************************************
4809	* Name : BOOL WIN32API GetUserObjectInformationW
4810	* Purpose : The GetUserObjectInformation function returns information about
4811	* a window station or desktop object.
4812	* Parameters: HANDLE hObj handle of object to get information for
4813	* int nIndex type of information to get
4814	* PVOID pvInfo points to buffer that receives the information
4815	* DWORD nLength size, in bytes, of pvInfo buffer
4816	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4817	* Variables :
4818	* Result : If the function succeeds, the return value is TRUE.
4819	* If the function fails, the return value is FALSE. To get extended
4820	* error information, call GetLastError.
4821	* Remark :
4822	* Status : UNTESTED STUB
4823	*
4824	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4825	*****************************************************************************/
4826
4827	BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
4828	int nIndex,
4829	PVOID pvInfo,
4830	DWORD nLength,
4831	LPDWORD lpnLengthNeeded)
4832	{
4833	dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4834	hObj,
4835	nIndex,
4836	pvInfo,
4837	nLength,
4838	lpnLengthNeeded));
4839
4840	return (FALSE);
4841	}
4842
4843
4844	/*****************************************************************************
4845	* Name : BOOL WIN32API GetUserObjectSecurity
4846	* Purpose : The GetUserObjectSecurity function retrieves security information
4847	* for the specified user object.
4848	* Parameters: HANDLE hObj handle of user object
4849	* SECURITY_INFORMATION * pSIRequested address of requested security information
4850	* LPSECURITY_DESCRIPTOR pSID address of security descriptor
4851	* DWORD nLength size of buffer for security descriptor
4852	* LPDWORD lpnLengthNeeded address of required size of buffer
4853	* Variables :
4854	* Result : If the function succeeds, the return value is TRUE.
4855	* If the function fails, the return value is FALSE. To get extended
4856	* error information, call GetLastError.
4857	* Remark :
4858	* Status : UNTESTED STUB
4859	*
4860	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4861	*****************************************************************************/
4862
4863	BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
4864	SECURITY_INFORMATION * pSIRequested,
4865	LPSECURITY_DESCRIPTOR pSID,
4866	DWORD nLength,
4867	LPDWORD lpnLengthNeeded)
4868	{
4869	dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4870	hObj,
4871	pSIRequested,
4872	pSID,
4873	nLength,
4874	lpnLengthNeeded));
4875
4876	return (FALSE);
4877	}
4878
4879
4880
4881	/*****************************************************************************
4882	* Name : int WIN32API GetWindowRgn
4883	* Purpose : The GetWindowRgn function obtains a copy of the window region of a window.
4884	* Parameters: HWND hWnd handle to window whose window region is to be obtained
4885	* HRGN hRgn handle to region that receives a copy of the window region
4886	* Variables :
4887	* Result : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
4888	* Remark :
4889	* Status : UNTESTED STUB
4890	*
4891	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4892	*****************************************************************************/
4893
4894	int WIN32API GetWindowRgn (HWND hWnd,
4895	HRGN hRgn)
4896	{
4897	dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
4898	hWnd,
4899	hRgn));
4900
4901	return (NULLREGION);
4902	}
4903
4904
4905
4906	/*****************************************************************************
4907	* Name : HCURSOR WIN32API LoadCursorFromFileA
4908	* Purpose : The LoadCursorFromFile function creates a cursor based on data
4909	* contained in a file. The file is specified by its name or by a
4910	* system cursor identifier. The function returns a handle to the
4911	* newly created cursor. Files containing cursor data may be in
4912	* either cursor (.CUR) or animated cursor (.ANI) format.
4913	* Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4914	* Variables :
4915	* Result : If the function is successful, the return value is a handle to
4916	* the new cursor.
4917	* If the function fails, the return value is NULL. To get extended
4918	* error information, call GetLastError. GetLastError may return
4919	* the following
4920	* Remark :
4921	* Status : UNTESTED STUB
4922	*
4923	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4924	*****************************************************************************/
4925
4926	HCURSOR WIN32API LoadCursorFromFileA(LPCTSTR lpFileName)
4927	{
4928	dprintf(("USER32:LoadCursorFromFileA (%s) not implemented.\n",
4929	lpFileName));
4930
4931	return (NULL);
4932	}
4933
4934
4935	/*****************************************************************************
4936	* Name : HCURSOR WIN32API LoadCursorFromFileW
4937	* Purpose : The LoadCursorFromFile function creates a cursor based on data
4938	* contained in a file. The file is specified by its name or by a
4939	* system cursor identifier. The function returns a handle to the
4940	* newly created cursor. Files containing cursor data may be in
4941	* either cursor (.CUR) or animated cursor (.ANI) format.
4942	* Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4943	* Variables :
4944	* Result : If the function is successful, the return value is a handle to
4945	* the new cursor.
4946	* If the function fails, the return value is NULL. To get extended
4947	* error information, call GetLastError. GetLastError may return
4948	* the following
4949	* Remark :
4950	* Status : UNTESTED STUB
4951	*
4952	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4953	*****************************************************************************/
4954
4955	HCURSOR WIN32API LoadCursorFromFileW(LPCWSTR lpFileName)
4956	{
4957	dprintf(("USER32:LoadCursorFromFileW (%s) not implemented.\n",
4958	lpFileName));
4959
4960	return (NULL);
4961	}
4962
4963
4964	/*****************************************************************************
4965	* Name : HLK WIN32API LoadKeyboardLayoutA
4966	* Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
4967	* the system. Several keyboard layouts can be loaded at a time, but
4968	* only one per process is active at a time. Loading multiple keyboard
4969	* layouts makes it possible to rapidly switch between layouts.
4970	* Parameters:
4971	* Variables :
4972	* Result : If the function succeeds, the return value is the handle of the
4973	* keyboard layout.
4974	* If the function fails, the return value is NULL. To get extended
4975	* error information, call GetLastError.
4976	* Remark :
4977	* Status : UNTESTED STUB
4978	*
4979	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4980	*****************************************************************************/
4981
4982	HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
4983	UINT Flags)
4984	{
4985	dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
4986	pwszKLID,
4987	Flags));
4988
4989	return (NULL);
4990	}
4991
4992
4993	/*****************************************************************************
4994	* Name : HLK WIN32API LoadKeyboardLayoutW
4995	* Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
4996	* the system. Several keyboard layouts can be loaded at a time, but
4997	* only one per process is active at a time. Loading multiple keyboard
4998	* layouts makes it possible to rapidly switch between layouts.
4999	* Parameters:
5000	* Variables :
5001	* Result : If the function succeeds, the return value is the handle of the
5002	* keyboard layout.
5003	* If the function fails, the return value is NULL. To get extended
5004	* error information, call GetLastError.
5005	* Remark :
5006	* Status : UNTESTED STUB
5007	*
5008	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5009	*****************************************************************************/
5010
5011	HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
5012	UINT Flags)
5013	{
5014	dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
5015	pwszKLID,
5016	Flags));
5017
5018	return (NULL);
5019	}
5020
5021
5022	/*****************************************************************************
5023	* Name : UINT WIN32API MapVirtualKeyExA
5024	* Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
5025	* code into a scan code or character value, or translates a scan
5026	* code into a virtual-key code. The function translates the codes
5027	* using the input language and physical keyboard layout identified
5028	* by the given keyboard layout handle.
5029	* Parameters:
5030	* Variables :
5031	* Result : The return value is either a scan code, a virtual-key code, or
5032	* a character value, depending on the value of uCode and uMapType.
5033	* If there is no translation, the return value is zero.
5034	* Remark :
5035	* Status : UNTESTED STUB
5036	*
5037	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5038	*****************************************************************************/
5039
5040	UINT WIN32API MapVirtualKeyExA(UINT uCode,
5041	UINT uMapType,
5042	HKL dwhkl)
5043	{
5044	dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
5045	uCode,
5046	uMapType,
5047	dwhkl));
5048
5049	return (0);
5050	}
5051
5052
5053	/*****************************************************************************
5054	* Name : UINT WIN32API MapVirtualKeyExW
5055	* Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
5056	* code into a scan code or character value, or translates a scan
5057	* code into a virtual-key code. The function translates the codes
5058	* using the input language and physical keyboard layout identified
5059	* by the given keyboard layout handle.
5060	* Parameters:
5061	* Variables :
5062	* Result : The return value is either a scan code, a virtual-key code, or
5063	* a character value, depending on the value of uCode and uMapType.
5064	* If there is no translation, the return value is zero.
5065	* Remark :
5066	* Status : UNTESTED STUB
5067	*
5068	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5069	*****************************************************************************/
5070
5071	UINT WIN32API MapVirtualKeyExW(UINT uCode,
5072	UINT uMapType,
5073	HKL dwhkl)
5074	{
5075	dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
5076	uCode,
5077	uMapType,
5078	dwhkl));
5079
5080	return (0);
5081	}
5082
5083
5084	/*****************************************************************************
5085	* Name : int WIN32API MessageBoxExA
5086	* Purpose : The MessageBoxEx function creates, displays, and operates a message box.
5087	* Parameters: HWND hWnd handle of owner window
5088	* LPCTSTR lpText address of text in message box
5089	* LPCTSTR lpCaption address of title of message box
5090	* UINT uType style of message box
5091	* WORD wLanguageId language identifier
5092	* Variables :
5093	* Result : If the function succeeds, the return value is a nonzero menu-item
5094	* value returned by the dialog box.
5095	* Remark :
5096	* Status : UNTESTED STUB
5097	*
5098	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5099	*****************************************************************************/
5100
5101	int WIN32API MessageBoxExA(HWND hWnd,
5102	LPCTSTR lpText,
5103	LPCTSTR lpCaption,
5104	UINT uType,
5105	WORD wLanguageId)
5106	{
5107	dprintf(("USER32:MessageBoxExA (%08xh,%s,%s,%u,%08w) not implemented.\n",
5108	hWnd,
5109	lpText,
5110	lpCaption,
5111	uType,
5112	wLanguageId));
5113
5114	return (MessageBoxA(hWnd,
5115	lpText,
5116	lpCaption,
5117	uType));
5118	}
5119
5120
5121	/*****************************************************************************
5122	* Name : int WIN32API MessageBoxExW
5123	* Purpose : The MessageBoxEx function creates, displays, and operates a message box.
5124	* Parameters: HWND hWnd handle of owner window
5125	* LPCTSTR lpText address of text in message box
5126	* LPCTSTR lpCaption address of title of message box
5127	* UINT uType style of message box
5128	* WORD wLanguageId language identifier
5129	* Variables :
5130	* Result : If the function succeeds, the return value is a nonzero menu-item
5131	* value returned by the dialog box.
5132	* Remark :
5133	* Status : UNTESTED STUB
5134	*
5135	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5136	*****************************************************************************/
5137
5138	int WIN32API MessageBoxExW(HWND hWnd,
5139	LPCWSTR lpText,
5140	LPCWSTR lpCaption,
5141	UINT uType,
5142	WORD wLanguageId)
5143	{
5144
5145	dprintf(("USER32:MessageBoxExW (%08xh,%x,%x,%u,%08w) not implemented.\n",
5146	hWnd,
5147	lpText,
5148	lpCaption,
5149	uType,
5150	wLanguageId));
5151
5152	return MessageBoxW(hWnd, lpText, lpCaption, uType);
5153	}
5154
5155
5156	/*****************************************************************************
5157	* Name : BOOL WIN32API MessageBoxIndirectW
5158	* Purpose : The MessageBoxIndirect function creates, displays, and operates
5159	* a message box. The message box contains application-defined
5160	* message text and title, any icon, and any combination of
5161	* predefined push buttons.
5162	* Parameters:
5163	* Variables :
5164	* Result :
5165	* Remark :
5166	* Status : UNTESTED STUB
5167	*
5168	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5169	*****************************************************************************/
5170
5171	BOOL WIN32API MessageBoxIndirectW(LPMSGBOXPARAMSW lpMsgBoxParams)
5172	{
5173	dprintf(("USER32:MessageBoxIndirectW (%08x) not implemented.\n",
5174	lpMsgBoxParams));
5175
5176	return (FALSE);
5177	}
5178
5179
5180	/*****************************************************************************
5181	* Name : BOOL WIN32API MessageBoxIndirectA
5182	* Purpose : The MessageBoxIndirect function creates, displays, and operates
5183	* a message box. The message box contains application-defined
5184	* message text and title, any icon, and any combination of
5185	* predefined push buttons.
5186	* Parameters:
5187	* Variables :
5188	* Result :
5189	* Remark :
5190	* Status : UNTESTED STUB
5191	*
5192	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5193	*****************************************************************************/
5194
5195	BOOL WIN32API MessageBoxIndirectA(LPMSGBOXPARAMSA lpMsgBoxParams)
5196	{
5197	dprintf(("USER32:MessageBoxIndirectA (%08x) not implemented.\n",
5198	lpMsgBoxParams));
5199
5200	return (FALSE);
5201	}
5202
5203
5204	/*****************************************************************************
5205	* Name : DWORD WIN32API OemKeyScan
5206	* Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
5207	* into the OEM scan codes and shift states. The function provides
5208	* information that allows a program to send OEM text to another
5209	* program by simulating keyboard input.
5210	* Parameters:
5211	* Variables :
5212	* Result :
5213	* Remark :
5214	* Status : UNTESTED STUB
5215	*
5216	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5217	*****************************************************************************/
5218
5219	DWORD WIN32API OemKeyScan(WORD wOemChar)
5220	{
5221	dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
5222	wOemChar));
5223
5224	return (wOemChar);
5225	}
5226
5227
5228	/*****************************************************************************
5229	* Name : HDESK WIN32API OpenDesktopA
5230	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
5231	* A desktop is a secure object contained within a window station
5232	* object. A desktop has a logical display surface and contains
5233	* windows, menus and hooks.
5234	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5235	* DWORD dwFlags flags to control interaction with other applications
5236	* BOOL fInherit specifies whether returned handle is inheritable
5237	* DWORD dwDesiredAccess specifies access of returned handle
5238	* Variables :
5239	* Result : If the function succeeds, the return value is the handle to the
5240	* opened desktop.
5241	* If the function fails, the return value is NULL. To get extended
5242	* error information, call GetLastError.
5243	* Remark :
5244	* Status : UNTESTED STUB
5245	*
5246	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5247	*****************************************************************************/
5248
5249	HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
5250	DWORD dwFlags,
5251	BOOL fInherit,
5252	DWORD dwDesiredAccess)
5253	{
5254	dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
5255	lpszDesktopName,
5256	dwFlags,
5257	fInherit,
5258	dwDesiredAccess));
5259
5260	return (NULL);
5261	}
5262
5263
5264	/*****************************************************************************
5265	* Name : HDESK WIN32API OpenDesktopW
5266	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
5267	* A desktop is a secure object contained within a window station
5268	* object. A desktop has a logical display surface and contains
5269	* windows, menus and hooks.
5270	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5271	* DWORD dwFlags flags to control interaction with other applications
5272	* BOOL fInherit specifies whether returned handle is inheritable
5273	* DWORD dwDesiredAccess specifies access of returned handle
5274	* Variables :
5275	* Result : If the function succeeds, the return value is the handle to the
5276	* opened desktop.
5277	* If the function fails, the return value is NULL. To get extended
5278	* error information, call GetLastError.
5279	* Remark :
5280	* Status : UNTESTED STUB
5281	*
5282	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5283	*****************************************************************************/
5284
5285	HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
5286	DWORD dwFlags,
5287	BOOL fInherit,
5288	DWORD dwDesiredAccess)
5289	{
5290	dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
5291	lpszDesktopName,
5292	dwFlags,
5293	fInherit,
5294	dwDesiredAccess));
5295
5296	return (NULL);
5297	}
5298
5299
5300	/*****************************************************************************
5301	* Name : HDESK WIN32API OpenInputDesktop
5302	* Purpose : The OpenInputDesktop function returns a handle to the desktop
5303	* that receives user input. The input desktop is a desktop on the
5304	* window station associated with the logged-on user.
5305	* Parameters: DWORD dwFlags flags to control interaction with other applications
5306	* BOOL fInherit specifies whether returned handle is inheritable
5307	* DWORD dwDesiredAccess specifies access of returned handle
5308	* Variables :
5309	* Result : If the function succeeds, the return value is a handle of the
5310	* desktop that receives user input.
5311	* If the function fails, the return value is NULL. To get extended
5312	* error information, call GetLastError.
5313	* Remark :
5314	* Status : UNTESTED STUB
5315	*
5316	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5317	*****************************************************************************/
5318
5319	HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
5320	BOOL fInherit,
5321	DWORD dwDesiredAccess)
5322	{
5323	dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
5324	dwFlags,
5325	fInherit,
5326	dwDesiredAccess));
5327
5328	return (NULL);
5329	}
5330
5331
5332	/*****************************************************************************
5333	* Name : HWINSTA WIN32API OpenWindowStationA
5334	* Purpose : The OpenWindowStation function returns a handle to an existing
5335	* window station.
5336	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
5337	* BOOL fInherit specifies whether returned handle is inheritable
5338	* DWORD dwDesiredAccess specifies access of returned handle
5339	* Variables :
5340	* Result : If the function succeeds, the return value is the handle to the
5341	* specified window station.
5342	* If the function fails, the return value is NULL. To get extended
5343	* error information, call GetLastError.
5344	* Remark :
5345	* Status : UNTESTED STUB
5346	*
5347	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5348	*****************************************************************************/
5349
5350	HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
5351	BOOL fInherit,
5352	DWORD dwDesiredAccess)
5353	{
5354	dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
5355	lpszWinStaName,
5356	fInherit,
5357	dwDesiredAccess));
5358
5359	return (NULL);
5360	}
5361
5362
5363	/*****************************************************************************
5364	* Name : HWINSTA WIN32API OpenWindowStationW
5365	* Purpose : The OpenWindowStation function returns a handle to an existing
5366	* window station.
5367	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
5368	* BOOL fInherit specifies whether returned handle is inheritable
5369	* DWORD dwDesiredAccess specifies access of returned handle
5370	* Variables :
5371	* Result : If the function succeeds, the return value is the handle to the
5372	* specified window station.
5373	* If the function fails, the return value is NULL. To get extended
5374	* error information, call GetLastError.
5375
5376	* Remark :
5377	* Status : UNTESTED STUB
5378	*
5379	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5380	*****************************************************************************/
5381
5382	HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
5383	BOOL fInherit,
5384	DWORD dwDesiredAccess)
5385	{
5386	dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
5387	lpszWinStaName,
5388	fInherit,
5389	dwDesiredAccess));
5390
5391	return (NULL);
5392	}
5393
5394
5395	/*****************************************************************************
5396	* Name : BOOL WIN32API PaintDesktop
5397	* Purpose : The PaintDesktop function fills the clipping region in the
5398	* specified device context with the desktop pattern or wallpaper.
5399	* The function is provided primarily for shell desktops.
5400	* Parameters:
5401	* Variables :
5402	* Result : If the function succeeds, the return value is TRUE.
5403	* If the function fails, the return value is FALSE.
5404	* Remark :
5405	* Status : UNTESTED STUB
5406	*
5407	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5408	*****************************************************************************/
5409
5410	BOOL WIN32API PaintDesktop(HDC hdc)
5411	{
5412	dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
5413	hdc));
5414
5415	return (FALSE);
5416	}
5417
5418
5419	/*****************************************************************************
5420	* Name : BOOL WIN32API SendMessageCallbackA
5421	* Purpose : The SendMessageCallback function sends the specified message to
5422	* a window or windows. The function calls the window procedure for
5423	* the specified window and returns immediately. After the window
5424	* procedure processes the message, the system calls the specified
5425	* callback function, passing the result of the message processing
5426	* and an application-defined value to the callback function.
5427	* Parameters: HWND hwnd handle of destination window
5428	* UINT uMsg message to send
5429	* WPARAM wParam first message parameter
5430	* LPARAM lParam second message parameter
5431	* SENDASYNCPROC lpResultCallBack function to receive message value
5432	* DWORD dwData value to pass to callback function
5433	* Variables :
5434	* Result : If the function succeeds, the return value is TRUE.
5435	* If the function fails, the return value is FALSE. To get extended
5436	* error information, call GetLastError.
5437	* Remark :
5438	* Status : UNTESTED STUB
5439	*
5440	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5441	*****************************************************************************/
5442
5443	BOOL WIN32API SendMessageCallbackA(HWND hWnd,
5444	UINT uMsg,
5445	WPARAM wParam,
5446	LPARAM lParam,
5447	SENDASYNCPROC lpResultCallBack,
5448	DWORD dwData)
5449	{
5450	dprintf(("USER32:SendMessageCallBackA (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5451	hWnd,
5452	uMsg,
5453	wParam,
5454	lParam,
5455	lpResultCallBack,
5456	dwData));
5457
5458	return (FALSE);
5459	}
5460
5461
5462	/*****************************************************************************
5463	* Name : BOOL WIN32API SendMessageCallbackW
5464	* Purpose : The SendMessageCallback function sends the specified message to
5465	* a window or windows. The function calls the window procedure for
5466	* the specified window and returns immediately. After the window
5467	* procedure processes the message, the system calls the specified
5468	* callback function, passing the result of the message processing
5469	* and an application-defined value to the callback function.
5470	* Parameters: HWND hwnd handle of destination window
5471	* UINT uMsg message to send
5472	* WPARAM wParam first message parameter
5473	* LPARAM lParam second message parameter
5474	* SENDASYNCPROC lpResultCallBack function to receive message value
5475	* DWORD dwData value to pass to callback function
5476	* Variables :
5477	* Result : If the function succeeds, the return value is TRUE.
5478	* If the function fails, the return value is FALSE. To get extended
5479	* error information, call GetLastError.
5480	* Remark :
5481	* Status : UNTESTED STUB
5482	*
5483	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5484	*****************************************************************************/
5485
5486	BOOL WIN32API SendMessageCallbackW(HWND hWnd,
5487	UINT uMsg,
5488	WPARAM wParam,
5489	LPARAM lParam,
5490	SENDASYNCPROC lpResultCallBack,
5491	DWORD dwData)
5492	{
5493	dprintf(("USER32:SendMessageCallBackW (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5494	hWnd,
5495	uMsg,
5496	wParam,
5497	lParam,
5498	lpResultCallBack,
5499	dwData));
5500
5501	return (FALSE);
5502	}
5503
5504
5505	/*****************************************************************************
5506	* Name : VOID WIN32API SetDebugErrorLevel
5507	* Purpose : The SetDebugErrorLevel function sets the minimum error level at
5508	* which Windows will generate debugging events and pass them to a debugger.
5509	* Parameters: DWORD dwLevel debugging error level
5510	* Variables :
5511	* Result :
5512	* Remark :
5513	* Status : UNTESTED STUB
5514	*
5515	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5516	*****************************************************************************/
5517
5518	VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
5519	{
5520	dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
5521	dwLevel));
5522	}
5523
5524
5525	/*****************************************************************************
5526	* Name : BOOL WIN32API SetProcessWindowStation
5527	* Purpose : The SetProcessWindowStation function assigns a window station
5528	* to the calling process. This enables the process to access
5529	* objects in the window station such as desktops, the clipboard,
5530	* and global atoms. All subsequent operations on the window station
5531	* use the access rights granted to hWinSta.
5532	* Parameters:
5533	* Variables :
5534	* Result : If the function succeeds, the return value is TRUE.
5535	* If the function fails, the return value is FALSE. To get extended
5536	* error information, call GetLastError.
5537	* Remark :
5538	* Status : UNTESTED STUB
5539	*
5540	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5541	*****************************************************************************/
5542
5543	BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
5544	{
5545	dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
5546	hWinSta));
5547
5548	return (FALSE);
5549	}
5550
5551
5552	/*****************************************************************************
5553	* Name : BOOL WIN32API SetSystemCursor
5554	* Purpose : The SetSystemCursor function replaces the contents of the system
5555	* cursor specified by dwCursorId with the contents of the cursor
5556	* specified by hCursor, and then destroys hCursor. This function
5557	* lets an application customize the system cursors.
5558	* Parameters: HCURSOR hCursor set specified system cursor to this cursor's
5559	* contents, then destroy this
5560	* DWORD dwCursorID system cursor specified by its identifier
5561	* Variables :
5562	* Result : If the function succeeds, the return value is TRUE.
5563	* If the function fails, the return value is FALSE. To get extended
5564	* error information, call GetLastError.
5565	* Remark :
5566	* Status : UNTESTED STUB
5567	*
5568	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5569	*****************************************************************************/
5570
5571	BOOL WIN32API SetSystemCursor(HCURSOR hCursor,
5572	DWORD dwCursorId)
5573	{
5574	dprintf(("USER32:SetSystemCursor (%08xh,%08x) not implemented.\n",
5575	hCursor,
5576	dwCursorId));
5577
5578	return (FALSE);
5579	}
5580
5581
5582	/*****************************************************************************
5583	* Name : BOOL WIN32API SetThreadDesktop
5584	* Purpose : The SetThreadDesktop function assigns a desktop to the calling
5585	* thread. All subsequent operations on the desktop use the access
5586	* rights granted to hDesk.
5587	* Parameters: HDESK hDesk handle of the desktop to assign to this thread
5588	* Variables :
5589	* Result : If the function succeeds, the return value is TRUE.
5590	* If the function fails, the return value is FALSE. To get extended
5591	* error information, call GetLastError.
5592	* Remark :
5593	* Status : UNTESTED STUB
5594	*
5595	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5596	*****************************************************************************/
5597
5598	BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
5599	{
5600	dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
5601	hDesktop));
5602
5603	return (FALSE);
5604	}
5605
5606
5607	/*****************************************************************************
5608	* Name : BOOL WIN32API SetUserObjectInformationA
5609	* Purpose : The SetUserObjectInformation function sets information about a
5610	* window station or desktop object.
5611	* Parameters: HANDLE hObject handle of the object for which to set information
5612	* int nIndex type of information to set
5613	* PVOID lpvInfo points to a buffer that contains the information
5614	* DWORD cbInfo size, in bytes, of lpvInfo buffer
5615	* Variables :
5616	* Result : If the function succeeds, the return value is TRUE.
5617	* If the function fails the return value is FALSE. To get extended
5618	* error information, call GetLastError.
5619	* Remark :
5620	* Status : UNTESTED STUB
5621	*
5622	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5623	*****************************************************************************/
5624
5625	BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
5626	int nIndex,
5627	PVOID lpvInfo,
5628	DWORD cbInfo)
5629	{
5630	dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
5631	hObject,
5632	nIndex,
5633	lpvInfo,
5634	cbInfo));
5635
5636	return (FALSE);
5637	}
5638
5639
5640	/*****************************************************************************
5641	* Name : BOOL WIN32API SetUserObjectInformationW
5642	* Purpose : The SetUserObjectInformation function sets information about a
5643	* window station or desktop object.
5644	* Parameters: HANDLE hObject handle of the object for which to set information
5645	* int nIndex type of information to set
5646	* PVOID lpvInfo points to a buffer that contains the information
5647	* DWORD cbInfo size, in bytes, of lpvInfo buffer
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 SetUserObjectInformationW(HANDLE hObject,
5659	int nIndex,
5660	PVOID lpvInfo,
5661	DWORD cbInfo)
5662	{
5663	dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
5664	hObject,
5665	nIndex,
5666	lpvInfo,
5667	cbInfo));
5668
5669	return (FALSE);
5670	}
5671
5672
5673	/*****************************************************************************
5674	* Name : BOOL WIN32API SetUserObjectSecurity
5675	* Purpose : The SetUserObjectSecurity function sets the security of a user
5676	* object. This can be, for example, a window or a DDE conversation
5677	* Parameters: HANDLE hObject handle of user object
5678	* SECURITY_INFORMATION * psi address of security information
5679	* LPSECURITY_DESCRIPTOR psd address of security descriptor
5680	* Variables :
5681	* Result : If the function succeeds, the return value is TRUE.
5682	* If the function fails, the return value is FALSE. To get extended
5683	* error information, call GetLastError.
5684	* Remark :
5685	* Status : UNTESTED STUB
5686	*
5687	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5688	*****************************************************************************/
5689
5690	BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
5691	SECURITY_INFORMATION * psi,
5692	LPSECURITY_DESCRIPTOR psd)
5693	{
5694	dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
5695	hObject,
5696	psi,
5697	psd));
5698
5699	return (FALSE);
5700	}
5701
5702
5703	/*****************************************************************************
5704	* Name : int WIN32API SetWindowRgn
5705	* Purpose : The SetWindowRgn function sets the window region of a window. The
5706	* window region determines the area within the window where the
5707	* operating system permits drawing. The operating system does not
5708	* display any portion of a window that lies outside of the window region
5709	* Parameters: HWND hWnd handle to window whose window region is to be set
5710	* HRGN hRgn handle to region
5711	* BOOL bRedraw window redraw flag
5712	* Variables :
5713	* Result : If the function succeeds, the return value is non-zero.
5714	* If the function fails, the return value is zero.
5715	* Remark :
5716	* Status : UNTESTED STUB
5717	*
5718	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5719	*****************************************************************************/
5720
5721	int WIN32API SetWindowRgn(HWND hWnd,
5722	HRGN hRgn,
5723	BOOL bRedraw)
5724	{
5725	dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
5726	hWnd,
5727	hRgn,
5728	bRedraw));
5729
5730	return (0);
5731	}
5732
5733
5734	/*****************************************************************************
5735	* Name : BOOL WIN32API SetWindowsHookW
5736	* Purpose : The SetWindowsHook function is not implemented in the Win32 API.
5737	* Win32-based applications should use the SetWindowsHookEx function.
5738	* Parameters:
5739	* Variables :
5740	* Result :
5741	* Remark : ARGH ! MICROSOFT !
5742	* Status : UNTESTED STUB
5743	*
5744	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5745	*****************************************************************************/
5746
5747	HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
5748
5749	{
5750	return (FALSE);
5751	}
5752
5753
5754	/*****************************************************************************
5755	* Name : BOOL WIN32API ShowWindowAsync
5756	* Purpose : The ShowWindowAsync function sets the show state of a window
5757	* created by a different thread.
5758	* Parameters: HWND hwnd handle of window
5759	* int nCmdShow show state of window
5760	* Variables :
5761	* Result : If the window was previously visible, the return value is TRUE.
5762	* If the window was previously hidden, the return value is FALSE.
5763	* Remark :
5764	* Status : UNTESTED STUB
5765	*
5766	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5767	*****************************************************************************/
5768
5769	BOOL WIN32API ShowWindowAsync (HWND hWnd,
5770	int nCmdShow)
5771	{
5772	dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
5773	hWnd,
5774	nCmdShow));
5775
5776	return (FALSE);
5777	}
5778
5779
5780	/*****************************************************************************
5781	* Name : BOOL WIN32API SwitchDesktop
5782	* Purpose : The SwitchDesktop function makes a desktop visible and activates
5783	* it. This enables the desktop to receive input from the user. The
5784	* calling process must have DESKTOP_SWITCHDESKTOP access to the
5785	* desktop for the SwitchDesktop function to succeed.
5786	* Parameters:
5787	* Variables :
5788	* Result : If the function succeeds, the return value is TRUE.
5789	* If the function fails, the return value is FALSE. To get extended
5790	* error information, call GetLastError.
5791	* Remark :
5792	* Status : UNTESTED STUB
5793	*
5794	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5795	*****************************************************************************/
5796
5797	BOOL WIN32API SwitchDesktop(HDESK hDesktop)
5798	{
5799	dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
5800	hDesktop));
5801
5802	return (FALSE);
5803	}
5804
5805
5806	/*****************************************************************************
5807	* Name : WORD WIN32API TileWindows
5808	* Purpose : The TileWindows function tiles the specified windows, or the child
5809	* windows of the specified parent window.
5810	* Parameters: HWND hwndParent handle of parent window
5811	* WORD wFlags types of windows not to arrange
5812	* LPCRECT lpRect rectangle to arrange windows in
5813	* WORD cChildrenb number of windows to arrange
5814	* const HWND *ahwndChildren array of window handles
5815	* Variables :
5816	* Result : If the function succeeds, the return value is the number of
5817	* windows arranged.
5818	* If the function fails, the return value is zero.
5819	* Remark :
5820	* Status : UNTESTED STUB
5821	*
5822	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5823	*****************************************************************************/
5824
5825	WORD WIN32API TileWindows(HWND hwndParent,
5826	UINT wFlags,
5827	const LPRECT lpRect,
5828	UINT cChildrenb,
5829	const HWND *ahwndChildren)
5830	{
5831	dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5832	hwndParent,
5833	wFlags,
5834	lpRect,
5835	cChildrenb,
5836	ahwndChildren));
5837
5838	return (0);
5839	}
5840
5841
5842	/*****************************************************************************
5843	* Name : int WIN32API ToAscii
5844	* Purpose : The ToAscii function translates the specified virtual-key code
5845	* and keyboard state to the corresponding Windows character or characters.
5846	* Parameters: UINT uVirtKey virtual-key code
5847	* UINT uScanCode scan code
5848	* PBYTE lpbKeyState address of key-state array
5849	* LPWORD lpwTransKey buffer for translated key
5850	* UINT fuState active-menu flag
5851	* Variables :
5852	* Result : 0 The specified virtual key has no translation for the current
5853	* state of the keyboard.
5854	* 1 One Windows character was copied to the buffer.
5855	* 2 Two characters were copied to the buffer. This usually happens
5856	* when a dead-key character (accent or diacritic) stored in the
5857	* keyboard layout cannot be composed with the specified virtual
5858	* key to form a single character.
5859	* Remark :
5860	* Status : UNTESTED STUB
5861	*
5862	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5863	*****************************************************************************/
5864
5865	int WIN32API ToAscii(UINT uVirtKey,
5866	UINT uScanCode,
5867	PBYTE lpbKeyState,
5868	LPWORD lpwTransKey,
5869	UINT fuState)
5870	{
5871	dprintf(("USER32:ToAscii (%u,%u,%08xh,%08xh,%u) not implemented.\n",
5872	uVirtKey,
5873	uScanCode,
5874	lpbKeyState,
5875	lpwTransKey,
5876	fuState));
5877
5878	return (0);
5879	}
5880
5881
5882	/*****************************************************************************
5883	* Name : int WIN32API ToAsciiEx
5884	* Purpose : The ToAscii function translates the specified virtual-key code
5885	* and keyboard state to the corresponding Windows character or characters.
5886	* Parameters: UINT uVirtKey virtual-key code
5887	* UINT uScanCode scan code
5888	* PBYTE lpbKeyState address of key-state array
5889	* LPWORD lpwTransKey buffer for translated key
5890	* UINT fuState active-menu flag
5891	* HLK hlk keyboard layout handle
5892	* Variables :
5893	* Result : 0 The specified virtual key has no translation for the current
5894	* state of the keyboard.
5895	* 1 One Windows character was copied to the buffer.
5896	* 2 Two characters were copied to the buffer. This usually happens
5897	* when a dead-key character (accent or diacritic) stored in the
5898	* keyboard layout cannot be composed with the specified virtual
5899	* key to form a single character.
5900	* Remark :
5901	* Status : UNTESTED STUB
5902	*
5903	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5904	*****************************************************************************/
5905
5906	int WIN32API ToAsciiEx(UINT uVirtKey,
5907	UINT uScanCode,
5908	PBYTE lpbKeyState,
5909	LPWORD lpwTransKey,
5910	UINT fuState,
5911	HKL hkl)
5912	{
5913	dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5914	uVirtKey,
5915	uScanCode,
5916	lpbKeyState,
5917	lpwTransKey,
5918	fuState,
5919	hkl));
5920
5921	return (0);
5922	}
5923
5924
5925	/*****************************************************************************
5926	* Name : int WIN32API ToUnicode
5927	* Purpose : The ToUnicode function translates the specified virtual-key code
5928	* and keyboard state to the corresponding Unicode character or characters.
5929	* Parameters: UINT wVirtKey virtual-key code
5930	* UINT wScanCode scan code
5931	* PBYTE lpKeyState address of key-state array
5932	* LPWSTR pwszBuff buffer for translated key
5933	* int cchBuff size of translated key buffer
5934	* UINT wFlags set of function-conditioning flags
5935	* Variables :
5936	* Result : - 1 The specified virtual key is a dead-key character (accent or
5937	* diacritic). This value is returned regardless of the keyboard
5938	* layout, even if several characters have been typed and are
5939	* stored in the keyboard state. If possible, even with Unicode
5940	* keyboard layouts, the function has written a spacing version of
5941	* the dead-key character to the buffer specified by pwszBuffer.
5942	* For example, the function writes the character SPACING ACUTE
5943	* (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
5944	* 0 The specified virtual key has no translation for the current
5945	* state of the keyboard. Nothing was written to the buffer
5946	* specified by pwszBuffer.
5947	* 1 One character was written to the buffer specified by pwszBuffer.
5948	* 2 or more Two or more characters were written to the buffer specified by
5949	* pwszBuff. The most common cause for this is that a dead-key
5950	* character (accent or diacritic) stored in the keyboard layout
5951	* could not be combined with the specified virtual key to form a
5952	* single character.
5953	* Remark :
5954	* Status : UNTESTED STUB
5955	*
5956	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5957	*****************************************************************************/
5958
5959	int WIN32API ToUnicode(UINT uVirtKey,
5960	UINT uScanCode,
5961	PBYTE lpKeyState,
5962	LPWSTR pwszBuff,
5963	int cchBuff,
5964	UINT wFlags)
5965	{
5966	dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5967	uVirtKey,
5968	uScanCode,
5969	lpKeyState,
5970	pwszBuff,
5971	cchBuff,
5972	wFlags));
5973
5974	return (0);
5975	}
5976
5977
5978	/*****************************************************************************
5979	* Name : BOOL WIN32API UnloadKeyboardLayout
5980	* Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
5981	* Parameters: HKL hkl handle of keyboard layout
5982	* Variables :
5983	* Result : If the function succeeds, the return value is the handle of the
5984	* keyboard layout; otherwise, it is NULL. To get extended error
5985	* information, use the GetLastError function.
5986	* Remark :
5987	* Status : UNTESTED STUB
5988	*
5989	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5990	*****************************************************************************/
5991
5992	BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
5993	{
5994	dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
5995	hkl));
5996
5997	return (0);
5998	}
5999
6000
6001	/*****************************************************************************
6002	* Name : SHORT WIN32API VkKeyScanExW
6003	* Purpose : The VkKeyScanEx function translates a character to the
6004	* corresponding virtual-key code and shift state. The function
6005	* translates the character using the input language and physical
6006	* keyboard layout identified by the given keyboard layout handle.
6007	* Parameters: UINT uChar character to translate
6008	* HKL hkl keyboard layout handle
6009	* Variables :
6010	* Result : see docs
6011	* Remark :
6012	* Status : UNTESTED STUB
6013	*
6014	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6015	*****************************************************************************/
6016
6017	WORD WIN32API VkKeyScanExW(WCHAR uChar,
6018	HKL hkl)
6019	{
6020	dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
6021	uChar,
6022	hkl));
6023
6024	return (uChar);
6025	}
6026
6027
6028	/*****************************************************************************
6029	* Name : SHORT WIN32API VkKeyScanExA
6030	* Purpose : The VkKeyScanEx function translates a character to the
6031	* corresponding virtual-key code and shift state. The function
6032	* translates the character using the input language and physical
6033	* keyboard layout identified by the given keyboard layout handle.
6034	* Parameters: UINT uChar character to translate
6035	* HKL hkl keyboard layout handle
6036	* Variables :
6037	* Result : see docs
6038	* Remark :
6039	* Status : UNTESTED STUB
6040	*
6041	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6042	*****************************************************************************/
6043
6044	WORD WIN32API VkKeyScanExA(CHAR uChar,
6045	HKL hkl)
6046	{
6047	dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
6048	uChar,
6049	hkl));
6050
6051	return (uChar);
6052	}
6053
6054
6055	/*****************************************************************************
6056	* Name : VOID WIN32API keybd_event
6057	* Purpose : The keybd_event function synthesizes a keystroke. The system
6058	* can use such a synthesized keystroke to generate a WM_KEYUP or
6059	* WM_KEYDOWN message. The keyboard driver's interrupt handler calls
6060	* the keybd_event function.
6061	* Parameters: BYTE bVk virtual-key code
6062
6063	* BYTE bScan hardware scan code
6064	* DWORD dwFlags flags specifying various function options
6065	* DWORD dwExtraInfo additional data associated with keystroke
6066	* Variables :
6067	* Result :
6068	* Remark :
6069	* Status : UNTESTED STUB
6070	*
6071	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6072	*****************************************************************************/
6073
6074	VOID WIN32API keybd_event (BYTE bVk,
6075	BYTE bScan,
6076	DWORD dwFlags,
6077	DWORD dwExtraInfo)
6078	{
6079	dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
6080	bVk,
6081	bScan,
6082	dwFlags,
6083	dwExtraInfo));
6084	}
6085
6086
6087	/*****************************************************************************
6088	* Name : VOID WIN32API mouse_event
6089	* Purpose : The mouse_event function synthesizes mouse motion and button clicks.
6090	* Parameters: DWORD dwFlags flags specifying various motion/click variants
6091	* DWORD dx horizontal mouse position or position change
6092	* DWORD dy vertical mouse position or position change
6093	* DWORD cButtons unused, reserved for future use, set to zero
6094	* DWORD dwExtraInfo 32 bits of application-defined information
6095	* Variables :
6096	* Result :
6097	* Remark :
6098	* Status : UNTESTED STUB
6099	*
6100	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6101	*****************************************************************************/
6102
6103	VOID WIN32API mouse_event(DWORD dwFlags,
6104	DWORD dx,
6105	DWORD dy,
6106	DWORD cButtons,
6107	DWORD dwExtraInfo)
6108	{
6109	dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
6110	dwFlags,
6111	dx,
6112	dy,
6113	cButtons,
6114	dwExtraInfo));
6115	}
6116
6117
6118	/*****************************************************************************
6119	* Name : BOOL WIN32API SetShellWindow
6120	* Purpose : Unknown
6121	* Parameters: Unknown
6122	* Variables :
6123	* Result :
6124	* Remark :
6125	* Status : UNTESTED UNKNOWN STUB
6126	*
6127	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6128	*****************************************************************************/
6129
6130	BOOL WIN32API SetShellWindow(DWORD x1)
6131	{
6132	dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
6133	x1));
6134
6135	return (FALSE); /* default */
6136	}
6137
6138
6139	/*****************************************************************************
6140	* Name : BOOL WIN32API PlaySoundEvent
6141	* Purpose : Unknown
6142	* Parameters: Unknown
6143	* Variables :
6144	* Result :
6145	* Remark :
6146	* Status : UNTESTED UNKNOWN STUB
6147	*
6148	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6149	*****************************************************************************/
6150
6151	BOOL WIN32API PlaySoundEvent(DWORD x1)
6152	{
6153	dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
6154	x1));
6155
6156	return (FALSE); /* default */
6157	}
6158
6159
6160	/*****************************************************************************
6161	* Name : BOOL WIN32API TileChildWindows
6162	* Purpose : Unknown
6163	* Parameters: Unknown
6164	* Variables :
6165	* Result :
6166	* Remark :
6167	* Status : UNTESTED UNKNOWN STUB
6168	*
6169	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6170	*****************************************************************************/
6171
6172	BOOL WIN32API TileChildWindows(DWORD x1,
6173	DWORD x2)
6174	{
6175	dprintf(("USER32: TileChildWindows(%08xh,%08xh) not implemented.\n",
6176	x1,
6177	x2));
6178
6179	return (FALSE); /* default */
6180	}
6181
6182
6183	/*****************************************************************************
6184	* Name : BOOL WIN32API SetSysColorsTemp
6185	* Purpose : Unknown
6186	* Parameters: Unknown
6187	* Variables :
6188	* Result :
6189	* Remark :
6190	* Status : UNTESTED UNKNOWN STUB
6191	*
6192	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6193	*****************************************************************************/
6194
6195	BOOL WIN32API SetSysColorsTemp(void)
6196	{
6197	dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
6198
6199	return (FALSE); /* default */
6200	}
6201
6202
6203	/*****************************************************************************
6204	* Name : BOOL WIN32API RegisterNetworkCapabilities
6205	* Purpose : Unknown
6206	* Parameters: Unknown
6207	* Variables :
6208	* Result :
6209	* Remark :
6210	* Status : UNTESTED UNKNOWN STUB
6211	*
6212	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6213	*****************************************************************************/
6214
6215	BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
6216	DWORD x2)
6217	{
6218	dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
6219	x1,
6220	x2));
6221
6222	return (FALSE); /* default */
6223	}
6224
6225
6226	/*****************************************************************************
6227	* Name : BOOL WIN32API EndTask
6228	* Purpose : Unknown
6229	* Parameters: Unknown
6230	* Variables :
6231	* Result :
6232	* Remark :
6233	* Status : UNTESTED UNKNOWN STUB
6234	*
6235	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6236	*****************************************************************************/
6237
6238	BOOL WIN32API EndTask(DWORD x1,
6239	DWORD x2,
6240	DWORD x3)
6241	{
6242	dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
6243	x1,
6244	x2,
6245	x3));
6246
6247	return (FALSE); /* default */
6248	}
6249
6250
6251	/*****************************************************************************
6252	* Name : BOOL WIN32API SwitchToThisWindow
6253	* Purpose : Unknown
6254	* Parameters: Unknown
6255	* Variables :
6256	* Result :
6257	* Remark :
6258	* Status : UNTESTED UNKNOWN STUB
6259	*
6260	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6261	*****************************************************************************/
6262
6263	BOOL WIN32API SwitchToThisWindow(HWND hwnd,
6264	BOOL x2)
6265	{
6266	dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
6267	hwnd,
6268	x2));
6269
6270	return (FALSE); /* default */
6271	}
6272
6273
6274	/*****************************************************************************
6275	* Name : BOOL WIN32API GetNextQueueWindow
6276	* Purpose : Unknown
6277	* Parameters: Unknown
6278	* Variables :
6279	* Result :
6280	* Remark :
6281	* Status : UNTESTED UNKNOWN STUB
6282	*
6283	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6284	*****************************************************************************/
6285
6286	BOOL WIN32API GetNextQueueWindow(DWORD x1,
6287	DWORD x2)
6288	{
6289	dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
6290	x1,
6291	x2));
6292
6293	return (FALSE); /* default */
6294	}
6295
6296
6297	/*****************************************************************************
6298	* Name : BOOL WIN32API YieldTask
6299	* Purpose : Unknown
6300	* Parameters: Unknown
6301	* Variables :
6302	* Result :
6303	* Remark :
6304	* Status : UNTESTED UNKNOWN STUB
6305	*
6306	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6307	*****************************************************************************/
6308
6309	BOOL WIN32API YieldTask(void)
6310	{
6311	dprintf(("USER32: YieldTask() not implemented.\n"));
6312
6313	return (FALSE); /* default */
6314	}
6315
6316
6317	/*****************************************************************************
6318	* Name : BOOL WIN32API WinOldAppHackoMatic
6319	* Purpose : Unknown
6320	* Parameters: Unknown
6321	* Variables :
6322	* Result :
6323	* Remark :
6324	* Status : UNTESTED UNKNOWN STUB
6325	*
6326	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6327	*****************************************************************************/
6328
6329	BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
6330	{
6331	dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
6332	x1));
6333
6334	return (FALSE); /* default */
6335	}
6336
6337
6338	/*****************************************************************************
6339	* Name : BOOL WIN32API DragObject
6340	* Purpose : Unknown
6341	* Parameters: Unknown
6342	* Variables :
6343	* Result :
6344	* Remark :
6345	* Status : UNTESTED UNKNOWN STUB
6346	*
6347	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6348	*****************************************************************************/
6349
6350	DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
6351	{
6352	dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6353	x1,
6354	x2,
6355	x3,
6356	x4,
6357	x5));
6358
6359	return (FALSE); /* default */
6360	}
6361
6362
6363	/*****************************************************************************
6364	* Name : BOOL WIN32API CascadeChildWindows
6365	* Purpose : Unknown
6366	* Parameters: Unknown
6367	* Variables :
6368	* Result :
6369	* Remark :
6370	* Status : UNTESTED UNKNOWN STUB
6371	*
6372	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6373	*****************************************************************************/
6374
6375	BOOL WIN32API CascadeChildWindows(DWORD x1,
6376	DWORD x2)
6377	{
6378	dprintf(("USER32: CascadeChildWindows(%08xh,%08xh) not implemented.\n",
6379	x1,
6380	x2));
6381
6382	return (FALSE); /* default */
6383	}
6384
6385
6386	/*****************************************************************************
6387	* Name : BOOL WIN32API RegisterSystemThread
6388	* Purpose : Unknown
6389	* Parameters: Unknown
6390	* Variables :
6391	* Result :
6392	* Remark :
6393	* Status : UNTESTED UNKNOWN STUB
6394	*
6395	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6396	*****************************************************************************/
6397
6398	BOOL WIN32API RegisterSystemThread(DWORD x1,
6399	DWORD x2)
6400	{
6401	dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
6402	x1,
6403	x2));
6404
6405	return (FALSE); /* default */
6406	}
6407
6408
6409	/*****************************************************************************
6410	* Name : BOOL WIN32API IsHungThread
6411	* Purpose : Unknown
6412	* Parameters: Unknown
6413	* Variables :
6414	* Result :
6415	* Remark :
6416	* Status : UNTESTED UNKNOWN STUB
6417	*
6418	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6419	*****************************************************************************/
6420
6421	BOOL WIN32API IsHungThread(DWORD x1)
6422	{
6423	dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
6424	x1));
6425
6426	return (FALSE); /* default */
6427	}
6428
6429
6430	/*****************************************************************************
6431	* Name : BOOL WIN32API SysErrorBox
6432	* Purpose : Unknown
6433	* Parameters: Unknown
6434	* Variables :
6435	* Result :
6436	* Remark : HARDERR like ?
6437	* Status : UNTESTED UNKNOWN STUB
6438	*
6439	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6440	*****************************************************************************/
6441
6442	BOOL WIN32API SysErrorBox(DWORD x1,
6443	DWORD x2,
6444	DWORD x3)
6445	{
6446	dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh) not implemented.\n",
6447	x1,
6448	x2,
6449	x3));
6450
6451	return (FALSE); /* default */
6452	}
6453
6454
6455	/*****************************************************************************
6456	* Name : BOOL WIN32API UserSignalProc
6457	* Purpose : Unknown
6458	* Parameters: Unknown
6459	* Variables :
6460	* Result :
6461	* Remark :
6462	* Status : UNTESTED UNKNOWN STUB
6463	*
6464	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6465	*****************************************************************************/
6466
6467	BOOL WIN32API UserSignalProc(DWORD x1,
6468	DWORD x2,
6469	DWORD x3,
6470	DWORD x4)
6471	{
6472	dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6473	x1,
6474	x2,
6475	x3,
6476	x4));
6477
6478	return (FALSE); /* default */
6479	}
6480
6481
6482	/*****************************************************************************
6483	* Name : BOOL WIN32API GetShellWindow
6484	* Purpose : Unknown
6485	* Parameters: Unknown
6486	* Variables :
6487	* Result :
6488	* Remark :
6489	* Status : UNTESTED UNKNOWN STUB
6490	*
6491	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6492	*****************************************************************************/
6493
6494	HWND WIN32API GetShellWindow(void)
6495	{
6496	dprintf(("USER32: GetShellWindow() not implemented.\n"));
6497
6498	return (0); /* default */
6499	}

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

Download in other formats: