Context Navigation

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

Visit:

Last change on this file since 34 was 34, checked in by cbratschi, 26 years ago
a
File size: 235.8 KB

Line
1	/* $Id: user32.cpp,v 1.3 1999-06-02 15:57:57 cbratschi Exp $ */
2
3	/*
4	* Win32 misc user32 API functions for OS/2
5	*
6	* Copyright 1998 Sander van Leeuwen
7	* Copyright 1998 Patrick Haller
8	* Copyright 1998 Peter Fitzsimmons
9	* Copyright 1999 Christoph Bratschi
10	*
11	*
12	* Project Odin Software License can be found in LICENSE.TXT
13	*
14	*/
15	/*****************************************************************************
16	* Name : USER32.CPP
17	* Purpose : This module maps all Win32 functions contained in USER32.DLL
18	* to their OS/2-specific counterparts as far as possible.
19	*****************************************************************************/
20
21	#include <os2win.h>
22	#include "misc.h"
23
24	#include "user32.h"
25	#include "wndproc.h"
26	#include "wndsubproc.h"
27	#include "wndclass.h"
28	#include "icon.h"
29	#include "usrcall.h"
30	#include "syscolor.h"
31
32	#include <wchar.h>
33	#include <stdlib.h>
34	#include <string.h>
35
36	//undocumented stuff
37	// WIN32API CalcChildScroll
38	// WIN32API CascadeChildWindows
39	// WIN32API ClientThreadConnect
40	// WIN32API DragObject
41	// WIN32API DrawCaptionTempA
42	// WIN32API DrawCaptionTempW
43	// WIN32API DrawFrame
44	// WIN32API EditWndProc
45	// WIN32API EndTask
46	// WIN32API GetInputDesktop
47	// WIN32API GetInternalWindowPos
48	// WIN32API GetNextQueueWindow
49	// WIN32API GetShellWindow
50	// WIN32API InitSharedTable
51	// WIN32API InitTask
52	// WIN32API InternalGetWindowText
53	// WIN32API IsHungThread
54	// WIN32API LockWindowStation
55	// WIN32API ModifyAccess
56	// WIN32API PlaySoundEvent
57	// WIN32API RegisterLogonProcess
58	// WIN32API RegisterNetworkCapabilities
59	// WIN32API RegisterSystemThread
60	// WIN32API RegisterTasklist
61	// WIN32API SetDeskWallpaper
62	// WIN32API SetDesktopBitmap
63	// WIN32API SetInternalWindowPos
64	// WIN32API SetLogonNotifyWindow
65	// WIN32API SetShellWindow
66	// WIN32API SetSysColorsTemp
67	// WIN32API SetWindowFullScreenState
68	// WIN32API SwitchToThisWindow
69	// WIN32API SysErrorBox
70	// WIN32API TileChildWindows
71	// WIN32API UnlockWindowStation
72	// WIN32API UserClientDllInitialize
73	// WIN32API UserSignalProc
74	// WIN32API WinOldAppHackoMatic
75	// WIN32API WNDPROC_CALLBACK
76	// WIN32API YieldTask
77
78
79
80
81	//******************************************************************************
82	//******************************************************************************
83	HWND WIN32API GetActiveWindow()
84	{
85	return(O32_GetActiveWindow());
86	}
87	//******************************************************************************
88	//******************************************************************************
89	int __cdecl wsprintfA(char *lpOut, LPCSTR lpFmt, ...)
90	{
91	int rc;
92	va_list argptr;
93
94	#ifdef DEBUG
95	WriteLog("USER32: wsprintfA\n");
96	WriteLog("USER32: %s\n", lpFmt);
97	#endif
98	va_start(argptr, lpFmt);
99	rc = O32_wvsprintf(lpOut, (char *)lpFmt, argptr);
100	va_end(argptr);
101	#ifdef DEBUG
102	WriteLog("USER32: %s\n", lpOut);
103	#endif
104	return(rc);
105	}
106	//******************************************************************************
107	//******************************************************************************
108	int __cdecl wsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, ...)
109	{
110	int rc;
111	char *lpFmtA;
112	char szOut[512];
113	va_list argptr;
114
115	dprintf(("USER32: wsprintfW(%08xh,%08xh).\n",
116	lpOut,
117	lpFmt));
118
119	lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
120
121	/* @@@PH 98/07/13 transform "%s" to "%ls" does the unicode magic */
122	{
123	PSZ pszTemp;
124	PSZ pszTemp1;
125	ULONG ulStrings;
126	ULONG ulIndex; /* temporary string counter */
127
128	for (ulStrings = 0, /* determine number of placeholders */
129	pszTemp = lpFmtA;
130
131	(pszTemp != NULL) &&
132	(*pszTemp != 0);
133
134	ulStrings++)
135	{
136	pszTemp = strstr(pszTemp,
137	"%s");
138	if (pszTemp != NULL) /* skip 2 characters */
139	{
140	pszTemp++;
141	pszTemp++;
142	}
143	else
144	break; /* leave loop immediately */
145	}
146
147	if (ulStrings != 0) /* transformation required ? */
148	{
149	/* now reallocate lpFmt */
150	ulStrings += strlen(lpFmtA); /* calculate total string length */
151	pszTemp = lpFmtA; /* save string pointer */
152	pszTemp1 = lpFmtA; /* save string pointer */
153
154	/* @@@PH allocation has to be compatible to FreeAsciiString !!! */
155	lpFmtA = (char *)malloc(ulStrings + 1);
156	if (lpFmtA == NULL) /* check proper allocation */
157	return (0); /* raise error condition */
158
159	for (ulIndex = 0;
160	ulIndex <= ulStrings;
161	ulIndex++,
162	pszTemp++)
163	{
164	if ((pszTemp[0] == '%') &&
165	(pszTemp[1] == 's') )
166	{
167	/* replace %s by %ls */
168	lpFmtA[ulIndex++] = '%';
169	lpFmtA[ulIndex ] = 'l';
170	lpFmtA[ulIndex+1] = 's';
171	}
172	else
173	lpFmtA[ulIndex] = pszTemp; / just copy over the character */
174	}
175
176	lpFmtA[ulStrings] = 0; /* string termination */
177
178	FreeAsciiString(pszTemp1); /* the original string is obsolete */
179	}
180	}
181
182	dprintf(("USER32: wsprintfW (%s).\n",
183	lpFmt));
184
185	va_start(argptr,
186	lpFmt);
187
188	rc = O32_wvsprintf(szOut,
189	lpFmtA,
190	argptr);
191
192	AsciiToUnicode(szOut,
193	lpOut);
194
195	FreeAsciiString(lpFmtA);
196	return(rc);
197	}
198	//******************************************************************************
199	//******************************************************************************
200	int WIN32API MessageBoxA(HWND hwndOwner, LPCTSTR lpszText, LPCTSTR lpszTitle, UINT fuStyle)
201	{
202	dprintf(("USER32: MessageBoxA %s %s\n", lpszText, lpszTitle));
203	return(O32_MessageBox(hwndOwner, lpszText, lpszTitle, fuStyle));
204	}
205	//******************************************************************************
206	//******************************************************************************
207	BOOL WIN32API MessageBeep( UINT arg1)
208	{
209	#ifdef DEBUG
210	WriteLog("USER32: MessageBeep\n");
211	#endif
212	return O32_MessageBeep(arg1);
213	}
214	//******************************************************************************
215	//******************************************************************************
216	LONG WIN32API SendDlgItemMessageA( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
217	{
218	#ifdef DEBUG
219	WriteLog("USER32: SendDlgItemMessageA\n");
220	#endif
221	return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
222	}
223	//******************************************************************************
224	//******************************************************************************
225	VOID WIN32API PostQuitMessage( int arg1)
226	{
227	dprintf(("USER32: PostQuitMessage\n"));
228	O32_PostQuitMessage(arg1);
229	}
230	//******************************************************************************
231	// Not implemented by Open32 (31-5-99 Christoph Bratschi)
232	//******************************************************************************
233	BOOL WIN32API IsDlgButtonChecked( HWND arg1, UINT arg2)
234	{
235	#ifdef DEBUG
236	WriteLog("USER32: IsDlgButtonChecked\n");
237	#endif
238	// return O32_IsDlgButtonChecked(arg1, arg2);
239	return (BOOL)SendDlgItemMessageA(arg1,arg2,BM_GETCHECK,0,0);
240	}
241	//******************************************************************************
242	//******************************************************************************
243	int WIN32API GetWindowTextLengthA( HWND arg1)
244	{
245	dprintf(("USER32: GetWindowTextLength\n"));
246	return O32_GetWindowTextLength(arg1);
247	}
248	//******************************************************************************
249	//******************************************************************************
250	int WIN32API GetWindowTextA( HWND arg1, LPSTR arg2, int arg3)
251	{
252	dprintf(("USER32: GetWindowText\n"));
253	return O32_GetWindowText(arg1, arg2, arg3);
254	}
255	//******************************************************************************
256	//******************************************************************************
257	BOOL WIN32API GetWindowRect( HWND arg1, PRECT arg2)
258	{
259	BOOL rc;
260
261	rc = O32_GetWindowRect(arg1, arg2);
262	dprintf(("USER32: GetWindowRect %X returned %d\n", arg1, rc));
263	return(rc);
264	}
265	//******************************************************************************
266	//******************************************************************************
267	HWND WIN32API GetNextDlgTabItem( HWND arg1, HWND arg2, BOOL arg3)
268	{
269	dprintf(("USER32: GetNextDlgTabItem\n"));
270	return O32_GetNextDlgTabItem(arg1, arg2, arg3);
271	}
272	//******************************************************************************
273	//******************************************************************************
274	BOOL WIN32API GetMessageA( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
275	{
276	//// dprintf(("USER32: GetMessage\n"));
277	return O32_GetMessage(arg1, arg2, arg3, arg4);
278	}
279	//******************************************************************************
280	//******************************************************************************
281	HWND WIN32API GetFocus(void)
282	{
283	dprintf(("USER32: GetFocus\n"));
284	return O32_GetFocus();
285	}
286	//******************************************************************************
287	//******************************************************************************
288	HWND WIN32API GetDlgItem(HWND arg1, int arg2)
289	{
290	HWND rc;
291
292	rc = O32_GetDlgItem(arg1, arg2);
293	dprintf(("USER32: GetDlgItem %d returned %d\n", arg2, rc));
294	return(rc);
295	}
296	//******************************************************************************
297	//******************************************************************************
298	int WIN32API GetDlgCtrlID( HWND arg1)
299	{
300	dprintf(("USER32: GetDlgCtrlID\n"));
301	return O32_GetDlgCtrlID(arg1);
302	}
303	//******************************************************************************
304	//******************************************************************************
305	HWND WIN32API GetDesktopWindow(void)
306	{
307	dprintf(("USER32: GetDesktopWindow\n"));
308	return O32_GetDesktopWindow();
309	}
310	//******************************************************************************
311	//******************************************************************************
312	BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
313	{
314	BOOL rc;
315	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
316
317	dprintf(("USER32: EnumThreadWindows\n"));
318	rc = O32_EnumThreadWindows(dwThreadId, callback->GetOS2Callback(), (LPARAM)callback);
319	if(callback)
320	delete callback;
321	return(rc);
322	}
323	//******************************************************************************
324	//******************************************************************************
325	BOOL WIN32API EndDialog( HWND arg1, int arg2)
326	{
327	BOOL rc;
328
329	dprintf(("USER32: EndDialog\n"));
330	rc = O32_EndDialog(arg1, arg2);
331	return(rc);
332	}
333	//******************************************************************************
334	//******************************************************************************
335	LONG WIN32API DispatchMessageA( const MSG * arg1)
336	{
337	//// dprintf(("USER32: DispatchMessage\n"));
338	return O32_DispatchMessage(arg1);
339	}
340	//******************************************************************************
341	//******************************************************************************
342	BOOL WIN32API OffsetRect( PRECT arg1, int arg2, int arg3)
343	{
344	#ifdef DEBUG
345	//// WriteLog("USER32: OffsetRect\n");
346	#endif
347	return O32_OffsetRect(arg1, arg2, arg3);
348	}
349	//******************************************************************************
350	//******************************************************************************
351	BOOL WIN32API CopyRect( PRECT arg1, const RECT * arg2)
352	{
353	// ddprintf(("USER32: CopyRect\n"));
354	return O32_CopyRect(arg1, arg2);
355	}
356	//******************************************************************************
357	// Not implemented by Open32 (5-31-99 Christoph Bratschi)
358	//******************************************************************************
359	BOOL WIN32API CheckDlgButton( HWND arg1, int arg2, UINT arg3)
360	{
361	#ifdef DEBUG
362	WriteLog("USER32: CheckDlgButton\n");
363	#endif
364	// return O32_CheckDlgButton(arg1, arg2, arg3);
365	return (BOOL)SendDlgItemMessageA(arg1,arg2,BM_SETCHECK,arg3,0);
366	}
367	//******************************************************************************
368	//******************************************************************************
369	HWND WIN32API SetFocus( HWND arg1)
370	{
371	dprintf(("USER32: SetFocus\n"));
372	return O32_SetFocus(arg1);
373	}
374	//******************************************************************************
375	//******************************************************************************
376	BOOL WIN32API TranslateMessage( const MSG * arg1)
377	{
378	#ifdef DEBUG
379	//// WriteLog("USER32: TranslateMessage\n");
380	#endif
381	return O32_TranslateMessage(arg1);
382	}
383	//******************************************************************************
384	//******************************************************************************
385	BOOL WIN32API SetWindowPos( HWND arg1, HWND arg2, int arg3, int arg4, int arg5, int arg6, UINT arg7)
386	{
387	#ifdef DEBUG
388	WriteLog("USER32: SetWindowPos\n");
389	#endif
390	return O32_SetWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
391	}
392	//******************************************************************************
393	//******************************************************************************
394	BOOL WIN32API ShowWindow(HWND arg1, int arg2)
395	{
396	#ifdef DEBUG
397	WriteLog("USER32: ShowWindow %X %d\n", arg1, arg2);
398	#endif
399	return O32_ShowWindow(arg1, arg2);
400	}
401	//******************************************************************************
402	//******************************************************************************
403	BOOL WIN32API SetWindowTextA(HWND arg1, LPCSTR arg2)
404	{
405	#ifdef DEBUG
406	WriteLog("USER32: SetWindowText %s\n", arg2);
407	#endif
408	return O32_SetWindowText(arg1, arg2);
409	}
410	//******************************************************************************
411	//******************************************************************************
412	BOOL WIN32API SetForegroundWindow(HWND arg1)
413	{
414	#ifdef DEBUG
415	WriteLog("USER32: SetForegroundWindow\n");
416	#endif
417	return O32_SetForegroundWindow(arg1);
418	}
419	//******************************************************************************
420	//******************************************************************************
421	int WIN32API ReleaseDC( HWND arg1, HDC arg2)
422	{
423	#ifdef DEBUG
424	WriteLog("USER32: ReleaseDC\n");
425	#endif
426	return O32_ReleaseDC(arg1, arg2);
427	}
428	//******************************************************************************
429	//******************************************************************************
430	BOOL WIN32API InvalidateRect(HWND arg1, const RECT *arg2, BOOL arg3)
431	{
432	#ifdef DEBUG
433	if(arg2)
434	WriteLog("USER32: InvalidateRect for window %X (%d,%d)(%d,%d) %d\n", arg1, arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
435	else WriteLog("USER32: InvalidateRect for window %X NULL, %d\n", arg1, arg3);
436	#endif
437	return O32_InvalidateRect(arg1, arg2, arg3);
438	}
439	//******************************************************************************
440	//******************************************************************************
441	BOOL WIN32API GetUpdateRect( HWND arg1, PRECT arg2, BOOL arg3)
442	{
443	#ifdef DEBUG
444	WriteLog("USER32: GetUpdateRect\n");
445	#endif
446	return O32_GetUpdateRect(arg1, arg2, arg3);
447	}
448	//******************************************************************************
449	//******************************************************************************
450	HDC WIN32API GetDC( HWND arg1)
451	{
452	HDC hdc;
453
454	hdc = O32_GetDC(arg1);
455	#ifdef DEBUG
456	WriteLog("USER32: GetDC of %X returns %X\n", arg1, hdc);
457	#endif
458	return(hdc);
459	}
460	//******************************************************************************
461	//******************************************************************************
462	HDC WIN32API GetDCEx(HWND arg1, HRGN arg2, DWORD arg3)
463	{
464	#ifdef DEBUG
465	WriteLog("USER32: GetDCEx\n");
466	#endif
467	return O32_GetDCEx(arg1, arg2, arg3);
468	}
469	//******************************************************************************
470	//******************************************************************************
471	BOOL WIN32API GetClientRect( HWND arg1, PRECT arg2)
472	{
473	#ifdef DEBUG
474	WriteLog("USER32: GetClientRect of %X\n", arg1);
475	#endif
476
477	return O32_GetClientRect(arg1, arg2);
478	}
479	//******************************************************************************
480	//******************************************************************************
481	HWND WIN32API FindWindowA(LPCSTR arg1, LPCSTR arg2)
482	{
483	#ifdef DEBUG
484	WriteLog("USER32: FindWindow\n");
485	#endif
486	return O32_FindWindow(arg1, arg2);
487	}
488	//******************************************************************************
489	//******************************************************************************
490	HWND WIN32API FindWindowExA(HWND arg1, HWND arg2, LPCSTR arg3, LPCSTR arg4)
491	{
492	#ifdef DEBUG
493	WriteLog("USER32: FindWindowExA, not completely implemented\n");
494	#endif
495	return O32_FindWindow(arg3, arg4);
496	}
497	//******************************************************************************
498	//******************************************************************************
499	BOOL WIN32API FlashWindow( HWND arg1, BOOL arg2)
500	{
501	#ifdef DEBUG
502	WriteLog("USER32: FlashWindow\n");
503	#endif
504	return O32_FlashWindow(arg1, arg2);
505	}
506	//******************************************************************************
507	//******************************************************************************
508	BOOL WIN32API EndPaint( HWND arg1, const PAINTSTRUCT * arg2)
509	{
510	#ifdef DEBUG
511	WriteLog("USER32: EndPaint\n");
512	#endif
513	return O32_EndPaint(arg1, arg2);
514	}
515	//******************************************************************************
516	//******************************************************************************
517	BOOL WIN32API MoveWindow(HWND arg1, int arg2, int arg3, int arg4, int arg5, BOOL arg6)
518	{
519	BOOL rc;
520
521	rc = O32_MoveWindow(arg1, arg2, arg3, arg4, arg5, arg6);
522	dprintf(("USER32: MoveWindow %X to (%d,%d) size (%d,%d), repaint = %d returned %d\n", arg1, arg2, arg3, arg4, arg5, arg6, rc));
523	return(rc);
524	}
525	//******************************************************************************
526	//******************************************************************************
527	HWND WIN32API CreateWindowExA(DWORD dwExStyle,
528	LPCSTR arg2,
529	LPCSTR arg3,
530	DWORD dwStyle,
531	int x,
532	int y,
533	int nWidth,
534	int nHeight,
535	HWND arg9,
536	HMENU arg10,
537	HINSTANCE arg11,
538	PVOID arg12)
539	{
540	HWND hwnd;
541	Win32WindowProc *window = NULL;
542
543	/* @@@PH 98/06/12 CreateWindow crashes somewhere in Open32 */
544	if(arg3 == NULL)
545	arg3 = (LPCSTR)"CRASH, CRASH";
546
547	//SvL: This break generic.exe & notepad.exe (probably many others too)
548	//These parameters can be CW_USEDEFAULT, which is 0x80000000
549	#if 0
550	if (nWidth < 0) nWidth = 0;
551	if (x < 0) x = 0;
552	if (nHeight< 0) nHeight = 0;
553	if (y < 0) y = 0;
554	#endif
555
556	//SvL: Breaks applications
557	#if 0
558	/* @@@PH 98/06/21 redraw problems disappear when WS_SYNCPAINT is on */
559	#ifndef WS_VISIBLE
560	#define WS_VISIBLE 0x80000000L
561	#endif
562
563	#ifndef WS_SYNCPAINT
564	#define WS_SYNCPAINT 0x02000000L
565	#endif
566
567	#ifndef WS_CLIPSYBLINGS
568	#define WS_CLIPSYBLINGS 0x10000000L
569	#endif
570
571	dwStyle \|= WS_SYNCPAINT;
572
573	/* @@@PH 98/06/21 experimental fix for WinHlp32 */
574	// SOL.EXE crashes here, but WINHLP32 does not display the
575	// navigation buttons otherwise.
576	dwStyle \|= WS_VISIBLE;
577	#endif
578
579	#ifdef DEBUG
580	WriteLog("USER32: CreateWindow: dwExStyle = %X\n", dwExStyle);
581	if((int)arg2 >> 16 != 0)
582	WriteLog("USER32: CreateWindow: classname = %s\n", arg2);
583	else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
584	WriteLog("USER32: CreateWindow: windowname= %s\n", arg3);
585	WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
586	WriteLog("USER32: CreateWindow: x = %d\n", x);
587	WriteLog("USER32: CreateWindow: y = %d\n", y);
588	WriteLog("USER32: CreateWindow: nWidth = %d\n", nWidth);
589	WriteLog("USER32: CreateWindow: nHeight = %d\n", nHeight);
590	WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
591	WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
592	WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
593	WriteLog("USER32: CreateWindow: param = %X\n", arg12);
594	#endif
595
596	if((int) arg2 >> 16 != 0 && strcmp(arg2, "COMBOBOX") == 0)
597	{
598	dprintf(("COMBOBOX creation"));
599	//TODO: #%@#%$ Open32 doesn't support this
600	dwStyle &= ~(CBS_OWNERDRAWFIXED \| CBS_OWNERDRAWVARIABLE);
601
602	/* @@@PH 98/06/12 drop down combos are problematic too */
603	/* so we translate the styles to OS/2 style */
604	dwStyle \|= CBS_DROPDOWN \| CBS_DROPDOWNLIST;
605	}
606
607	//Classname might be name of system class, in which case we don't
608	//need to use our own callback
609	// if(Win32WindowClass::FindClass((LPSTR)arg2) != NULL) {
610	window = new Win32WindowProc(arg11, arg2);
611	// }
612
613	hwnd = O32_CreateWindowEx(dwExStyle,
614	arg2,
615	arg3,
616	dwStyle,
617	x,
618	y,
619	nWidth,
620	nHeight,
621	arg9,
622	arg10,
623	arg11,
624	arg12);
625
626	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
627	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
628	delete(window);
629	window = 0;
630	}
631	if(window) {
632	window->SetWindowHandle(hwnd);
633	}
634	dprintf(("USER32: ************CreateWindowExA %s (%d,%d,%d,%d), hwnd = %X\n", arg2, x, y, nWidth, nHeight, hwnd));
635	return(hwnd);
636	}
637	//******************************************************************************
638	//******************************************************************************
639	LRESULT WIN32API SendMessageA(HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
640	{
641	LRESULT rc;
642
643	#ifdef DEBUG
644	WriteLog("USER32: SendMessage....\n");
645	#endif
646	rc = O32_SendMessage(arg1, arg2, arg3, arg4);
647	#ifdef DEBUG
648	WriteLog("USER32: *****SendMessage %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
649	#endif
650	return(rc);
651	}
652	//******************************************************************************
653	//******************************************************************************
654	HWND WIN32API SetActiveWindow( HWND arg1)
655	{
656	#ifdef DEBUG
657	WriteLog("USER32: SetActiveWindow\n");
658	#endif
659	return O32_SetActiveWindow(arg1);
660	}
661	//******************************************************************************
662	//******************************************************************************
663	HDC WIN32API BeginPaint(HWND arg1, PPAINTSTRUCT arg2)
664	{
665	dprintf(("USER32: BeginPaint %X\n", arg2));
666	return O32_BeginPaint(arg1, arg2);
667	}
668	//******************************************************************************
669	//******************************************************************************
670	BOOL WIN32API IsDialogMessageA( HWND arg1, LPMSG arg2)
671	{
672	#ifdef DEBUG
673	//// WriteLog("USER32: IsDialogMessage\n");
674	#endif
675	return O32_IsDialogMessage(arg1, arg2);
676	}
677	//******************************************************************************
678	//******************************************************************************
679	int WIN32API DrawTextA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5)
680	{
681	#ifdef DEBUG
682	WriteLog("USER32: DrawTextA %s", arg2);
683	#endif
684	return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
685	}
686	//******************************************************************************
687	//******************************************************************************
688	int WIN32API DrawTextExA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
689	{
690	#ifdef DEBUG
691	WriteLog("USER32: DrawTextExA (not completely implemented) %s", arg2);
692	#endif
693	return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
694	}
695	//******************************************************************************
696	//******************************************************************************
697	int WIN32API GetSystemMetrics(int arg1)
698	{
699	int rc;
700
701	switch(arg1) {
702	case SM_CXICONSPACING: //TODO: size of grid cell for large icons
703	rc = O32_GetSystemMetrics(SM_CXICON);
704	break;
705	case SM_CYICONSPACING:
706	rc = O32_GetSystemMetrics(SM_CYICON);
707	break;
708	case SM_PENWINDOWS:
709	rc = FALSE;
710	break;
711	case SM_DBCSENABLED:
712	rc = FALSE;
713	break;
714	case SM_CXEDGE: //size of 3D window edge (not supported)
715	rc = 1;
716	break;
717	case SM_CYEDGE:
718	rc = 1;
719	break;
720	case SM_CXMINSPACING: //can be SM_CXMINIMIZED or larger
721	rc = O32_GetSystemMetrics(SM_CXMINIMIZED);
722	break;
723	case SM_CYMINSPACING:
724	rc = GetSystemMetrics(SM_CYMINIMIZED);
725	break;
726	case SM_CXSMICON: //recommended size of small icons (TODO: adjust to screen res.)
727	rc = 16;
728	break;
729	case SM_CYSMICON:
730	rc = 16;
731	break;
732	case SM_CYSMCAPTION: //size in pixels of a small caption (TODO: ????)
733	rc = 8;
734	break;
735	case SM_CXSMSIZE: //size of small caption buttons (pixels) (TODO: implement properly)
736	rc = 16;
737	break;
738	case SM_CYSMSIZE:
739	rc = 16;
740	break;
741	case SM_CXMENUSIZE: //TODO: size of menu bar buttons (such as MDI window close)
742	rc = 16;
743	break;
744	case SM_CYMENUSIZE:
745	rc = 16;
746	break;
747	case SM_ARRANGE:
748	rc = ARW_BOTTOMLEFT \| ARW_LEFT;
749	break;
750	case SM_CXMINIMIZED:
751	break;
752	case SM_CYMINIMIZED:
753	break;
754	case SM_CXMAXTRACK: //max window size
755	case SM_CXMAXIMIZED: //max toplevel window size
756	rc = O32_GetSystemMetrics(SM_CXSCREEN);
757	break;
758	case SM_CYMAXTRACK:
759	case SM_CYMAXIMIZED:
760	rc = O32_GetSystemMetrics(SM_CYSCREEN);
761	break;
762	case SM_NETWORK:
763	rc = 0x01; //TODO: default = yes
764	break;
765	case SM_CLEANBOOT:
766	rc = 0; //normal boot
767	break;
768	case SM_CXDRAG: //nr of pixels before drag becomes a real one
769	rc = 2;
770	break;
771	case SM_CYDRAG:
772	rc = 2;
773	break;
774	case SM_SHOWSOUNDS: //show instead of play sound
775	rc = FALSE;
776	break;
777	case SM_CXMENUCHECK:
778	rc = 4; //TODO
779	break;
780	case SM_CYMENUCHECK:
781	rc = O32_GetSystemMetrics(SM_CYMENU);
782	break;
783	case SM_SLOWMACHINE:
784	rc = FALSE; //even a slow machine is fast with OS/2 :)
785	break;
786	case SM_MIDEASTENABLED:
787	rc = FALSE;
788	break;
789	case SM_CMETRICS:
790	rc = O32_GetSystemMetrics(44); //Open32 changed this one
791	break;
792	default:
793	rc = O32_GetSystemMetrics(arg1);
794	break;
795	}
796	#ifdef DEBUG
797	WriteLog("USER32: GetSystemMetrics %d returned %d\n", arg1, rc);
798	#endif
799	return(rc);
800	}
801	//******************************************************************************
802	//******************************************************************************
803	UINT WIN32API SetTimer( HWND arg1, UINT arg2, UINT arg3, TIMERPROC arg4)
804	{
805	#ifdef DEBUG
806	WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
807	#endif
808	//SvL: Write callback handler class for this one
809	return O32_SetTimer(arg1, arg2, arg3, (TIMERPROC_O32)arg4);
810	}
811	//******************************************************************************
812	//******************************************************************************
813	BOOL WIN32API KillTimer(HWND arg1, UINT arg2)
814	{
815	#ifdef DEBUG
816	WriteLog("USER32: KillTimer\n");
817	#endif
818	return O32_KillTimer(arg1, arg2);
819	}
820	//******************************************************************************
821	//******************************************************************************
822	BOOL WIN32API DestroyWindow(HWND arg1)
823	{
824	#ifdef DEBUG
825	WriteLog("USER32: DestroyWindow\n");
826	#endif
827	return O32_DestroyWindow(arg1);
828	}
829	//******************************************************************************
830	//******************************************************************************
831	BOOL WIN32API PostMessageA( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
832	{
833	#ifdef DEBUG
834	WriteLog("USER32: PostMessageA %X %X %X %X\n", arg1, arg2, arg3, arg4);
835	#endif
836	return O32_PostMessage(arg1, arg2, arg3, arg4);
837	}
838	//******************************************************************************
839	//******************************************************************************
840	BOOL WIN32API InflateRect( PRECT arg1, int arg2, int arg3)
841	{
842	#ifdef DEBUG
843	WriteLog("USER32: InflateRect\n");
844	#endif
845	return O32_InflateRect(arg1, arg2, arg3);
846	}
847	//******************************************************************************
848	//TODO:How can we emulate this one in OS/2???
849	//******************************************************************************
850	DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
851	{
852	#ifdef DEBUG
853	WriteLog("USER32: WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
854	#endif
855
856	if(dwTimeOut == INFINITE) return(0);
857
858	// DosSleep(dwTimeOut/16);
859	return(0);
860	}
861	//******************************************************************************
862	//******************************************************************************
863	UINT WIN32API GetDlgItemTextA(HWND arg1, int arg2, LPSTR arg3, UINT arg4)
864	{
865	UINT rc;
866
867	rc = O32_GetDlgItemText(arg1, arg2, arg3, arg4);
868	#ifdef DEBUG
869	if(rc)
870	WriteLog("USER32: GetDlgItemTextA returned %s\n", arg3);
871	else WriteLog("USER32: GetDlgItemTextA returned 0 (%d)\n", GetLastError());
872	#endif
873	return(rc);
874	}
875	//******************************************************************************
876	//******************************************************************************
877	BOOL WIN32API PeekMessageA(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
878	{
879	#ifdef DEBUG
880	// WriteLog("USER32: PeekMessage\n");
881	#endif
882	return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
883	}
884	//******************************************************************************
885	//******************************************************************************
886	int WIN32API ShowCursor( BOOL arg1)
887	{
888	#ifdef DEBUG
889	WriteLog("USER32: ShowCursor\n");
890	#endif
891	return O32_ShowCursor(arg1);
892	}
893	//******************************************************************************
894	//BUGBUG: UpdateWindow sends a WM_ERASEBKGRND when it shouldn't!
895	// So we just do it manually
896	//******************************************************************************
897	BOOL WIN32API UpdateWindow(HWND hwnd)
898	{
899	RECT rect;
900
901	#ifdef DEBUG
902	WriteLog("USER32: UpdateWindow\n");
903	#endif
904	if(O32_GetUpdateRect(hwnd, &rect, FALSE) != FALSE) {//update region empty?
905	WndCallback(hwnd, WM_PAINT, 0, 0);
906	// O32_PostMessage(hwnd, WM_PAINT, 0, 0);
907	}
908	#ifdef DEBUG
909	else WriteLog("USER32: Update region empty!\n");
910	#endif
911	return(TRUE);
912	}
913	//******************************************************************************
914	//******************************************************************************
915	BOOL WIN32API AdjustWindowRect( PRECT arg1, DWORD arg2, BOOL arg3)
916	{
917	#ifdef DEBUG
918	WriteLog("USER32: AdjustWindowRect\n");
919	#endif
920	return O32_AdjustWindowRect(arg1, arg2, arg3);
921	}
922	//******************************************************************************
923	//******************************************************************************
924	BOOL WIN32API AdjustWindowRectEx( PRECT arg1, DWORD arg2, BOOL arg3, DWORD arg4)
925	{
926	#ifdef DEBUG
927	WriteLog("USER32: AdjustWindowRectEx\n");
928	#endif
929	return O32_AdjustWindowRectEx(arg1, arg2, arg3, arg4);
930	}
931	//******************************************************************************
932	//******************************************************************************
933	BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
934	{
935	#ifdef DEBUG
936	//// WriteLog("USER32: ClientToScreen\n");
937	#endif
938	return O32_ClientToScreen(arg1, arg2);
939	}
940	//******************************************************************************
941	//******************************************************************************
942	BOOL WIN32API SetRect( PRECT arg1, int arg2, int arg3, int arg4, int arg5)
943	{
944	#ifdef DEBUG
945	WriteLog("USER32: SetRect\n");
946	#endif
947	return O32_SetRect(arg1, arg2, arg3, arg4, arg5);
948	}
949	//******************************************************************************
950	//******************************************************************************
951	LONG WIN32API GetWindowLongA(HWND hwnd, int nIndex)
952	{
953	LONG rc;
954
955	#ifdef DEBUG
956	WriteLog("USER32: GetWindowLong %X %d\n", hwnd, nIndex);
957	#endif
958	if(nIndex == GWL_WNDPROC \|\| nIndex == DWL_DLGPROC) {
959	Win32WindowProc *window = Win32WindowProc::FindProc(hwnd);
960	if(window && !(nIndex == DWL_DLGPROC && window->IsWindow() == TRUE)) {
961	return (LONG)window->GetWin32Callback();
962	}
963	}
964	rc = O32_GetWindowLong(hwnd, nIndex);
965	#ifdef DEBUG
966	WriteLog("USER32: GetWindowLong returned %X\n", rc);
967	#endif
968	return(rc);
969	}
970	//******************************************************************************
971	//******************************************************************************
972	BOOL WIN32API SetDlgItemInt( HWND arg1, int arg2, UINT arg3, BOOL arg4)
973	{
974	#ifdef DEBUG
975	WriteLog("USER32: SetDlgItemInt\n");
976	#endif
977	return O32_SetDlgItemInt(arg1, arg2, arg3, arg4);
978	}
979	//******************************************************************************
980	//******************************************************************************
981	BOOL WIN32API SetDlgItemTextA( HWND arg1, int arg2, LPCSTR arg3)
982	{
983	#ifdef DEBUG
984	WriteLog("USER32: SetDlgItemText to %s\n", arg3);
985	#endif
986	return O32_SetDlgItemText(arg1, arg2, arg3);
987	}
988	//******************************************************************************
989	//******************************************************************************
990	BOOL WIN32API WinHelpA( HWND arg1, LPCSTR arg2, UINT arg3, DWORD arg4)
991	{
992	#ifdef DEBUG
993	WriteLog("USER32: WinHelp not implemented %s\n", arg2);
994	#endif
995	// return O32_WinHelp(arg1, arg2, arg3, arg4);
996	return(TRUE);
997	}
998	//******************************************************************************
999	//******************************************************************************
1000	BOOL WIN32API IsIconic( HWND arg1)
1001	{
1002	#ifdef DEBUG
1003	WriteLog("USER32: IsIconic\n");
1004	#endif
1005	return O32_IsIconic(arg1);
1006	}
1007	//******************************************************************************
1008	//******************************************************************************
1009	int WIN32API TranslateAcceleratorA(HWND arg1, HACCEL arg2, LPMSG arg3)
1010	{
1011	#ifdef DEBUG
1012	//// WriteLog("USER32: TranslateAccelerator\n");
1013	#endif
1014	return O32_TranslateAccelerator(arg1, arg2, arg3);
1015	}
1016	//******************************************************************************
1017	//******************************************************************************
1018	HWND WIN32API GetWindow(HWND arg1, UINT arg2)
1019	{
1020	HWND rc;
1021
1022	rc = O32_GetWindow(arg1, arg2);
1023	#ifdef DEBUG
1024	WriteLog("USER32: GetWindow %X %d returned %d\n", arg1, arg2, rc);
1025	#endif
1026	return(rc);
1027	}
1028	//******************************************************************************
1029	//******************************************************************************
1030	HDC WIN32API GetWindowDC(HWND arg1)
1031	{
1032	#ifdef DEBUG
1033	WriteLog("USER32: GetWindowDC\n");
1034	#endif
1035	return O32_GetWindowDC(arg1);
1036	}
1037	//******************************************************************************
1038	//******************************************************************************
1039	BOOL WIN32API SubtractRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
1040	{
1041	#ifdef DEBUG
1042	WriteLog("USER32: SubtractRect");
1043	#endif
1044	return O32_SubtractRect(arg1, arg2, arg3);
1045	}
1046	//******************************************************************************
1047	//SvL: 24-6-'97 - Added
1048	//******************************************************************************
1049	BOOL WIN32API ClipCursor(const RECT * arg1)
1050	{
1051	#ifdef DEBUG
1052	WriteLog("USER32: ClipCursor\n");
1053	#endif
1054	return O32_ClipCursor(arg1);
1055	}
1056	//******************************************************************************
1057	//SvL: 24-6-'97 - Added
1058	//TODO: Not implemented
1059	//******************************************************************************
1060	WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1061	{
1062	#ifdef DEBUG
1063	//// WriteLog("USER32: GetAsyncKeyState Not implemented\n");
1064	#endif
1065	return 0;
1066	}
1067	//******************************************************************************
1068	//SvL: 24-6-'97 - Added
1069	//******************************************************************************
1070	HCURSOR WIN32API GetCursor(void)
1071	{
1072	#ifdef DEBUG
1073	//// WriteLog("USER32: GetCursor\n");
1074	#endif
1075	return O32_GetCursor();
1076	}
1077	//******************************************************************************
1078	//SvL: 24-6-'97 - Added
1079	//******************************************************************************
1080	BOOL WIN32API GetCursorPos( PPOINT arg1)
1081	{
1082	#ifdef DEBUG
1083	//// WriteLog("USER32: GetCursorPos\n");
1084	#endif
1085	return O32_GetCursorPos(arg1);
1086	}
1087	//******************************************************************************
1088	//SvL: 24-6-'97 - Added
1089	//******************************************************************************
1090	UINT WIN32API RegisterWindowMessageA(LPCSTR arg1)
1091	{
1092	UINT rc;
1093
1094	rc = O32_RegisterWindowMessage(arg1);
1095	#ifdef DEBUG
1096	WriteLog("USER32: RegisterWindowMessageA %s returned %X\n", arg1, rc);
1097	#endif
1098	return(rc);
1099	}
1100	//******************************************************************************
1101	//SvL: 24-6-'97 - Added
1102	//******************************************************************************
1103	WORD WIN32API VkKeyScanA( char arg1)
1104	{
1105	#ifdef DEBUG
1106	WriteLog("USER32: VkKeyScanA\n");
1107	#endif
1108	return O32_VkKeyScan(arg1);
1109	}
1110	//******************************************************************************
1111	//SvL: 24-6-'97 - Added
1112	//******************************************************************************
1113	SHORT WIN32API GetKeyState( int arg1)
1114	{
1115	#ifdef DEBUG
1116	WriteLog("USER32: GetKeyState %d\n", arg1);
1117	#endif
1118	return O32_GetKeyState(arg1);
1119	}
1120	//******************************************************************************
1121	//******************************************************************************
1122	HCURSOR WIN32API SetCursor( HCURSOR arg1)
1123	{
1124	#ifdef DEBUG
1125	WriteLog("USER32: SetCursor\n");
1126	#endif
1127	return O32_SetCursor(arg1);
1128	}
1129	//******************************************************************************
1130	//******************************************************************************
1131	BOOL WIN32API SetCursorPos( int arg1, int arg2)
1132	{
1133	#ifdef DEBUG
1134	WriteLog("USER32: SetCursorPos\n");
1135	#endif
1136	return O32_SetCursorPos(arg1, arg2);
1137	}
1138	//******************************************************************************
1139	//******************************************************************************
1140	BOOL WIN32API EnableScrollBar( HWND arg1, INT arg2, UINT arg3)
1141	{
1142	#ifdef DEBUG
1143	WriteLog("USER32: EnableScrollBar\n");
1144	#endif
1145	return O32_EnableScrollBar(arg1, arg2, arg3);
1146	}
1147	//******************************************************************************
1148	//******************************************************************************
1149	BOOL WIN32API EnableWindow( HWND arg1, BOOL arg2)
1150	{
1151	#ifdef DEBUG
1152	WriteLog("USER32: EnableWindow\n");
1153	#endif
1154	return O32_EnableWindow(arg1, arg2);
1155	}
1156	//******************************************************************************
1157	//******************************************************************************
1158	HWND WIN32API SetCapture( HWND arg1)
1159	{
1160	#ifdef DEBUG
1161	WriteLog("USER32: SetCapture\n");
1162	#endif
1163	return O32_SetCapture(arg1);
1164	}
1165	//******************************************************************************
1166	//******************************************************************************
1167	BOOL WIN32API ReleaseCapture(void)
1168	{
1169	#ifdef DEBUG
1170	WriteLog("USER32: ReleaseCapture\n");
1171	#endif
1172	return O32_ReleaseCapture();
1173	}
1174	//******************************************************************************
1175	//******************************************************************************
1176	DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD arg5)
1177	{
1178	#ifdef DEBUG
1179	WriteLog("USER32: MsgWaitForMultipleObjects\n");
1180	#endif
1181	return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
1182	}
1183	//******************************************************************************
1184	//******************************************************************************
1185	HDWP WIN32API BeginDeferWindowPos( int arg1)
1186	{
1187	#ifdef DEBUG
1188	WriteLog("USER32: BeginDeferWindowPos\n");
1189	#endif
1190	return O32_BeginDeferWindowPos(arg1);
1191	}
1192	//******************************************************************************
1193	//******************************************************************************
1194	BOOL WIN32API BringWindowToTop( HWND arg1)
1195	{
1196	#ifdef DEBUG
1197	WriteLog("USER32: BringWindowToTop\n");
1198	#endif
1199	return O32_BringWindowToTop(arg1);
1200	}
1201	//******************************************************************************
1202	//******************************************************************************
1203	BOOL WIN32API CallMsgFilterA( LPMSG arg1, int arg2)
1204	{
1205	#ifdef DEBUG
1206	WriteLog("USER32: CallMsgFilterA\n");
1207	#endif
1208	return O32_CallMsgFilter(arg1, arg2);
1209	}
1210	//******************************************************************************
1211	//******************************************************************************
1212	BOOL WIN32API CallMsgFilterW( LPMSG arg1, int arg2)
1213	{
1214	#ifdef DEBUG
1215	WriteLog("USER32: CallMsgFilterW\n");
1216	#endif
1217	// NOTE: This will not work as is (needs UNICODE support)
1218	return O32_CallMsgFilter(arg1, arg2);
1219	}
1220	//******************************************************************************
1221	//******************************************************************************
1222	LRESULT WIN32API CallWindowProcA(WNDPROC wndprcPrev,
1223	HWND arg2,
1224	UINT arg3,
1225	WPARAM arg4,
1226	LPARAM arg5)
1227	{
1228	#ifdef DEBUG
1229	//// WriteLog("USER32: CallWindowProcA %X hwnd=%X, msg = %X\n", wndprcPrev, arg2, arg3);
1230	#endif
1231
1232	if(Win32WindowSubProc::FindSubProc((WNDPROC_O32)wndprcPrev) != NULL) {
1233	WNDPROC_O32 orgprc = (WNDPROC_O32)wndprcPrev; //is original Open32 system class callback (_System)
1234	return orgprc(arg2, arg3, arg4, arg5);
1235	}
1236	else return wndprcPrev(arg2, arg3, arg4, arg5); //win32 callback (__stdcall)
1237	}
1238	//******************************************************************************
1239	//******************************************************************************
1240	LRESULT WIN32API CallWindowProcW(WNDPROC arg1,
1241	HWND arg2,
1242	UINT arg3,
1243	WPARAM arg4,
1244	LPARAM arg5)
1245	{
1246	dprintf(("USER32: CallWindowProcW(%08xh,%08xh,%08xh,%08xh,%08xh) not properly implemented.\n",
1247	arg1,
1248	arg2,
1249	arg3,
1250	arg4,
1251	arg5));
1252
1253	return CallWindowProcA(arg1,
1254	arg2,
1255	arg3,
1256	arg4,
1257	arg5);
1258	}
1259	//******************************************************************************
1260	//******************************************************************************
1261	BOOL WIN32API ChangeClipboardChain( HWND arg1, HWND arg2)
1262	{
1263	#ifdef DEBUG
1264	WriteLog("USER32: ChangeClipboardChain\n");
1265	#endif
1266	return O32_ChangeClipboardChain(arg1, arg2);
1267	}
1268	//******************************************************************************
1269	//******************************************************************************
1270	UINT WIN32API ArrangeIconicWindows( HWND arg1)
1271	{
1272	#ifdef DEBUG
1273	WriteLog("USER32: ArrangeIconicWindows\n");
1274	#endif
1275	return O32_ArrangeIconicWindows(arg1);
1276	}
1277	//******************************************************************************
1278	// Not implemented by Open32 (5-31-99 Christoph Bratschi)
1279	// Quick and dirty implementation
1280	//******************************************************************************
1281	BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT arg4)
1282	{
1283	#ifdef DEBUG
1284	WriteLog("USER32: CheckRadioButton\n");
1285	#endif
1286	// return O32_CheckRadioButton(arg1, arg2, arg3, arg4);
1287	if (arg2 > arg3) return (FALSE);
1288	for (UINT x=arg2;x <= arg3;x++)
1289	{
1290	SendDlgItemMessageA(arg1,x,BM_SETCHECK,(x == arg4) ? BST_CHECKED : BST_UNCHECKED,0);
1291	}
1292	return (TRUE);
1293	}
1294	//******************************************************************************
1295	//******************************************************************************
1296	HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
1297	{
1298	#ifdef DEBUG
1299	WriteLog("USER32: ChildWindowFromPoint\n");
1300	#endif
1301	return O32_ChildWindowFromPoint(arg1, arg2);
1302	}
1303	//******************************************************************************
1304	//******************************************************************************
1305	HWND WIN32API ChildWindowFromPointEx(HWND arg1, POINT arg2, UINT uFlags)
1306	{
1307	#ifdef DEBUG
1308	WriteLog("USER32: ChildWindowFromPointEx, not completely supported!\n");
1309	#endif
1310	return O32_ChildWindowFromPoint(arg1, arg2);
1311	}
1312	//******************************************************************************
1313	//******************************************************************************
1314	BOOL WIN32API CloseClipboard(void)
1315	{
1316	#ifdef DEBUG
1317	WriteLog("USER32: CloseClipboard\n");
1318	#endif
1319	return O32_CloseClipboard();
1320	}
1321	//******************************************************************************
1322	//******************************************************************************
1323	BOOL WIN32API CloseWindow( HWND arg1)
1324	{
1325	#ifdef DEBUG
1326	WriteLog("USER32: CloseWindow\n");
1327	#endif
1328	return O32_CloseWindow(arg1);
1329	}
1330	//******************************************************************************
1331	//******************************************************************************
1332	HICON WIN32API CopyIcon( HICON arg1)
1333	{
1334	#ifdef DEBUG
1335	WriteLog("USER32: CopyIcon\n");
1336	#endif
1337	return O32_CopyIcon(arg1);
1338	}
1339	//******************************************************************************
1340	//******************************************************************************
1341	int WIN32API CountClipboardFormats(void)
1342	{
1343	#ifdef DEBUG
1344	WriteLog("USER32: CountClipboardFormats\n");
1345	#endif
1346	return O32_CountClipboardFormats();
1347	}
1348	//******************************************************************************
1349	//******************************************************************************
1350	HACCEL WIN32API CreateAcceleratorTableA( LPACCEL arg1, int arg2)
1351	{
1352	#ifdef DEBUG
1353	WriteLog("USER32: CreateAcceleratorTableA\n");
1354	#endif
1355	return O32_CreateAcceleratorTable(arg1, arg2);
1356	}
1357	//******************************************************************************
1358	//******************************************************************************
1359	HACCEL WIN32API CreateAcceleratorTableW( LPACCEL arg1, int arg2)
1360	{
1361	#ifdef DEBUG
1362	WriteLog("USER32: CreateAcceleratorTableW\n");
1363	#endif
1364	// NOTE: This will not work as is (needs UNICODE support)
1365	return O32_CreateAcceleratorTable(arg1, arg2);
1366	}
1367	//******************************************************************************
1368	//******************************************************************************
1369	BOOL WIN32API CreateCaret( HWND arg1, HBITMAP arg2, int arg3, int arg4)
1370	{
1371	#ifdef DEBUG
1372	WriteLog("USER32: CreateCaret\n");
1373	#endif
1374	return O32_CreateCaret(arg1, arg2, arg3, arg4);
1375	}
1376	//******************************************************************************
1377	//******************************************************************************
1378	HCURSOR WIN32API CreateCursor( HINSTANCE arg1, int arg2, int arg3, int arg4, int arg5, const VOID * arg6, const VOID * arg7)
1379	{
1380	#ifdef DEBUG
1381	WriteLog("USER32: CreateCursor\n");
1382	#endif
1383	return O32_CreateCursor(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1384	}
1385	//******************************************************************************
1386	//******************************************************************************
1387	HICON WIN32API CreateIcon( HINSTANCE arg1, INT arg2, INT arg3, BYTE arg4, BYTE arg5, LPCVOID arg6, LPCVOID arg7)
1388	{
1389	#ifdef DEBUG
1390	WriteLog("USER32: CreateIcon\n");
1391	#endif
1392	return O32_CreateIcon(arg1, arg2, arg3, arg4, arg5, (const BYTE )arg6, (const BYTE )arg7);
1393	}
1394	//******************************************************************************
1395	//ASSERT dwVer == win31 (ok according to SDK docs)
1396	//******************************************************************************
1397	HICON WIN32API CreateIconFromResource(PBYTE presbits, UINT dwResSize,
1398	BOOL fIcon, DWORD dwVer)
1399	{
1400	HICON hicon;
1401	DWORD OS2ResSize = 0;
1402	PBYTE OS2Icon = ConvertWin32Icon(presbits, dwResSize, &OS2ResSize);
1403
1404	hicon = O32_CreateIconFromResource(OS2Icon, OS2ResSize, fIcon, dwVer);
1405	#ifdef DEBUG
1406	WriteLog("USER32: CreateIconFromResource returned %X (%X)\n", hicon, GetLastError());
1407	#endif
1408	if(OS2Icon)
1409	FreeIcon(OS2Icon);
1410
1411	return(hicon);
1412	}
1413	//******************************************************************************
1414	//******************************************************************************
1415	HICON WIN32API CreateIconFromResourceEx(PBYTE presbits, UINT dwResSize,
1416	BOOL fIcon, DWORD dwVer,
1417	int cxDesired, int cyDesired,
1418	UINT Flags)
1419	{
1420	#ifdef DEBUG
1421	WriteLog("USER32: CreateIconFromResourceEx %X %d %d %X %d %d %X, not completely supported!\n", presbits, dwResSize, fIcon, dwVer, cxDesired, cyDesired, Flags);
1422	#endif
1423	return CreateIconFromResource(presbits, dwResSize, fIcon, dwVer);
1424	}
1425	//******************************************************************************
1426	//******************************************************************************
1427	HICON WIN32API CreateIconIndirect(LPICONINFO arg1)
1428	{
1429	#ifdef DEBUG
1430	WriteLog("USER32: CreateIconIndirect\n");
1431	#endif
1432	return O32_CreateIconIndirect(arg1);
1433	}
1434	//******************************************************************************
1435	//******************************************************************************
1436	HWND WIN32API CreateMDIWindowA(LPCSTR arg1, LPCSTR arg2, DWORD arg3,
1437	int arg4, int arg5, int arg6, int arg7,
1438	HWND arg8, HINSTANCE arg9, LPARAM arg10)
1439	{
1440	HWND hwnd;
1441
1442	#ifdef DEBUG
1443	WriteLog("USER32: CreateMDIWindowA\n");
1444	#endif
1445	Win32WindowProc *window = new Win32WindowProc(arg9, arg1);
1446	hwnd = O32_CreateMDIWindow((LPSTR)arg1, (LPSTR)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1447	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1448	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1449	delete(window);
1450	window = 0;
1451	}
1452
1453	#ifdef DEBUG
1454	WriteLog("USER32: CreateMDIWindowA returned %X\n", hwnd);
1455	#endif
1456	return hwnd;
1457	}
1458	//******************************************************************************
1459	//******************************************************************************
1460	HWND WIN32API CreateMDIWindowW(LPCWSTR arg1, LPCWSTR arg2, DWORD arg3, int arg4,
1461	int arg5, int arg6, int arg7, HWND arg8, HINSTANCE arg9,
1462	LPARAM arg10)
1463	{
1464	HWND hwnd;
1465	char astring1 = NULL, astring2 = NULL;
1466	Win32WindowProc *window = NULL;
1467
1468	if((int)arg1 >> 16 != 0) {
1469	astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1470	}
1471	else astring1 = (char *)arg2;
1472
1473	astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1474
1475	//Classname might be name of system class, in which case we don't
1476	//need to use our own callback
1477	// if(Win32WindowClass::FindClass((LPSTR)astring1) != NULL) {
1478	window = new Win32WindowProc(arg9, astring1);
1479	// }
1480	hwnd = O32_CreateMDIWindow(astring1, astring2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1481	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1482	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1483	delete(window);
1484	window = 0;
1485	}
1486	if(window) {
1487	window->SetWindowHandle(hwnd);
1488	}
1489
1490	if(astring1) FreeAsciiString(astring1);
1491	FreeAsciiString(astring2);
1492	#ifdef DEBUG
1493	WriteLog("USER32: CreateMDIWindowW hwnd = %X\n", hwnd);
1494	#endif
1495	return(hwnd);
1496	}
1497	//******************************************************************************
1498	//******************************************************************************
1499	HWND WIN32API CreateWindowExW(DWORD arg1,
1500	LPCWSTR arg2,
1501	LPCWSTR arg3,
1502	DWORD dwStyle,
1503	int arg5,
1504	int arg6,
1505	int arg7,
1506	int arg8,
1507	HWND arg9,
1508	HMENU arg10,
1509	HINSTANCE arg11,
1510	PVOID arg12)
1511	{
1512	HWND hwnd;
1513	char *astring1 = NULL,
1514	*astring2 = NULL;
1515	Win32WindowProc *window = NULL;
1516
1517	/* @@@PH 98/06/21 changed to call OS2CreateWindowExA */
1518	if((int)arg2 >> 16 != 0)
1519	astring1 = UnicodeToAsciiString((LPWSTR)arg2);
1520	else
1521	astring1 = (char *)arg2;
1522
1523	astring2 = UnicodeToAsciiString((LPWSTR)arg3);
1524
1525	#ifdef DEBUG
1526	WriteLog("USER32: CreateWindowExW: dwExStyle = %X\n", arg1);
1527	if((int)arg2 >> 16 != 0)
1528	WriteLog("USER32: CreateWindow: classname = %s\n", astring1);
1529	else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
1530	WriteLog("USER32: CreateWindow: windowname= %s\n", astring2);
1531	WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
1532	WriteLog("USER32: CreateWindow: x = %d\n", arg5);
1533	WriteLog("USER32: CreateWindow: y = %d\n", arg6);
1534	WriteLog("USER32: CreateWindow: nWidth = %d\n", arg7);
1535	WriteLog("USER32: CreateWindow: nHeight = %d\n", arg8);
1536	WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
1537	WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
1538	WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
1539	WriteLog("USER32: CreateWindow: param = %X\n", arg12);
1540	#endif
1541
1542	hwnd = CreateWindowExA(arg1,
1543	astring1,
1544	astring2,
1545	dwStyle,
1546	arg5,
1547	arg6,
1548	arg7,
1549	arg8,
1550	arg9,
1551	arg10,
1552	arg11,
1553	arg12);
1554
1555	if(astring1)
1556	FreeAsciiString(astring1);
1557
1558	FreeAsciiString(astring2);
1559
1560	#ifdef DEBUG
1561	WriteLog("USER32: ************CreateWindowExW hwnd = %X (%X)\n", hwnd, GetLastError());
1562	#endif
1563	return(hwnd);
1564	}
1565	//******************************************************************************
1566	//******************************************************************************
1567	HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
1568	{
1569	#ifdef DEBUG
1570	WriteLog("USER32: DeferWindowPos\n");
1571	#endif
1572	return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1573	}
1574	//******************************************************************************
1575	//******************************************************************************
1576	BOOL WIN32API DestroyAcceleratorTable( HACCEL arg1)
1577	{
1578	#ifdef DEBUG
1579	WriteLog("USER32: DestroyAcceleratorTable\n");
1580	#endif
1581	return O32_DestroyAcceleratorTable(arg1);
1582	}
1583	//******************************************************************************
1584	//******************************************************************************
1585	BOOL WIN32API DestroyCaret(void)
1586	{
1587	#ifdef DEBUG
1588	WriteLog("USER32: DestroyCaret\n");
1589	#endif
1590	return O32_DestroyCaret();
1591	}
1592	//******************************************************************************
1593	//******************************************************************************
1594	BOOL WIN32API DestroyCursor( HCURSOR arg1)
1595	{
1596	#ifdef DEBUG
1597	WriteLog("USER32: DestroyCursor\n");
1598	#endif
1599	return O32_DestroyCursor(arg1);
1600	}
1601	//******************************************************************************
1602	//******************************************************************************
1603	BOOL WIN32API DestroyIcon( HICON arg1)
1604	{
1605	#ifdef DEBUG
1606	WriteLog("USER32: DestroyIcon\n");
1607	#endif
1608	return O32_DestroyIcon(arg1);
1609	}
1610	//******************************************************************************
1611	//******************************************************************************
1612	LONG WIN32API DispatchMessageW( const MSG * arg1)
1613	{
1614	#ifdef DEBUG
1615	WriteLog("USER32: DispatchMessageW\n");
1616	#endif
1617	// NOTE: This will not work as is (needs UNICODE support)
1618	return O32_DispatchMessage(arg1);
1619	}
1620	//******************************************************************************
1621	//******************************************************************************
1622	int WIN32API DlgDirListA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1623	{
1624	#ifdef DEBUG
1625	WriteLog("USER32: DlgDirListA\n");
1626	#endif
1627	return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1628	}
1629	//******************************************************************************
1630	//******************************************************************************
1631	int WIN32API DlgDirListComboBoxA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1632	{
1633	#ifdef DEBUG
1634	WriteLog("USER32: DlgDirListComboBoxA\n");
1635	#endif
1636	return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1637	}
1638	//******************************************************************************
1639	//******************************************************************************
1640	int WIN32API DlgDirListComboBoxW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1641	{
1642	#ifdef DEBUG
1643	WriteLog("USER32: DlgDirListComboBoxW NOT WORKING\n");
1644	#endif
1645	// NOTE: This will not work as is (needs UNICODE support)
1646	return 0;
1647	// return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1648	}
1649	//******************************************************************************
1650	//******************************************************************************
1651	int WIN32API DlgDirListW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1652	{
1653	#ifdef DEBUG
1654	WriteLog("USER32: DlgDirListW NOT WORKING\n");
1655	#endif
1656	// NOTE: This will not work as is (needs UNICODE support)
1657	return 0;
1658	// return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1659	}
1660	//******************************************************************************
1661	//******************************************************************************
1662	BOOL WIN32API DlgDirSelectComboBoxExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1663	{
1664	#ifdef DEBUG
1665	WriteLog("USER32: DlgDirSelectComboBoxExA\n");
1666	#endif
1667	return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1668	}
1669	//******************************************************************************
1670	//******************************************************************************
1671	BOOL WIN32API DlgDirSelectComboBoxExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1672	{
1673	#ifdef DEBUG
1674	WriteLog("USER32: DlgDirSelectComboBoxExW NOT WORKING\n");
1675	#endif
1676	// NOTE: This will not work as is (needs UNICODE support)
1677	return 0;
1678	// return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1679	}
1680	//******************************************************************************
1681	//******************************************************************************
1682	BOOL WIN32API DlgDirSelectExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1683	{
1684	#ifdef DEBUG
1685	WriteLog("USER32: DlgDirSelectExA\n");
1686	#endif
1687	return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1688	}
1689	//******************************************************************************
1690	//******************************************************************************
1691	BOOL WIN32API DlgDirSelectExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1692	{
1693	#ifdef DEBUG
1694	WriteLog("USER32: DlgDirSelectExW NOT WORKING\n");
1695	#endif
1696	// NOTE: This will not work as is (needs UNICODE support)
1697	return 0;
1698	// return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1699	}
1700	//******************************************************************************
1701	//******************************************************************************
1702	BOOL WIN32API DrawFocusRect( HDC arg1, const RECT * arg2)
1703	{
1704	#ifdef DEBUG
1705	WriteLog("USER32: DrawFocusRect\n");
1706	#endif
1707	return O32_DrawFocusRect(arg1, arg2);
1708	}
1709	//******************************************************************************
1710	//******************************************************************************
1711	BOOL WIN32API DrawIcon( HDC arg1, int arg2, int arg3, HICON arg4)
1712	{
1713	#ifdef DEBUG
1714	WriteLog("USER32: DrawIcon\n");
1715	#endif
1716	return O32_DrawIcon(arg1, arg2, arg3, arg4);
1717	}
1718	//******************************************************************************
1719	//******************************************************************************
1720	BOOL WIN32API DrawIconEx(HDC hdc, int xLeft, int xRight, HICON hIcon,
1721	int cxWidth, int cyWidth, UINT istepIfAniCur,
1722	HBRUSH hbrFlickerFreeDraw, UINT diFlags)
1723	{
1724	#ifdef DEBUG
1725	WriteLog("USER32: DrawIcon, partially implemented\n");
1726	#endif
1727	return O32_DrawIcon(hdc, xLeft, xRight, hIcon);
1728	}
1729	//******************************************************************************
1730	//******************************************************************************
1731	BOOL WIN32API DrawMenuBar( HWND arg1)
1732	{
1733	#ifdef DEBUG
1734	WriteLog("USER32: DrawMenuBar\n");
1735	#endif
1736	return O32_DrawMenuBar(arg1);
1737	}
1738	//******************************************************************************
1739	//******************************************************************************
1740	int WIN32API DrawTextW( HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5)
1741	{
1742	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1743	int rc;
1744
1745	#ifdef DEBUG
1746	WriteLog("USER32: DrawTextW %s\n", astring);
1747	#endif
1748	rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1749	FreeAsciiString(astring);
1750	return(rc);
1751	}
1752	//******************************************************************************
1753	//******************************************************************************
1754	int WIN32API DrawTextExW(HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
1755	{
1756	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1757	int rc;
1758
1759	#ifdef DEBUG
1760	WriteLog("USER32: DrawTextExW (not completely supported) %s\n", astring);
1761	#endif
1762	rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1763	FreeAsciiString(astring);
1764	return(rc);
1765	}
1766	//******************************************************************************
1767	//******************************************************************************
1768	BOOL WIN32API EmptyClipboard(void)
1769	{
1770	#ifdef DEBUG
1771	WriteLog("USER32: EmptyClipboard\n");
1772	#endif
1773	return O32_EmptyClipboard();
1774	}
1775	//******************************************************************************
1776	//******************************************************************************
1777	BOOL WIN32API EndDeferWindowPos( HDWP arg1)
1778	{
1779	#ifdef DEBUG
1780	WriteLog("USER32: EndDeferWindowPos\n");
1781	#endif
1782	return O32_EndDeferWindowPos(arg1);
1783	}
1784	//******************************************************************************
1785	//******************************************************************************
1786	BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1787	{
1788	BOOL rc;
1789	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1790
1791	#ifdef DEBUG
1792	WriteLog("USER32: EnumChildWindows\n");
1793	#endif
1794	rc = O32_EnumChildWindows(hwnd, callback->GetOS2Callback(), (LPARAM)callback);
1795	if(callback)
1796	delete callback;
1797	return(rc);
1798	}
1799	//******************************************************************************
1800	//******************************************************************************
1801	UINT WIN32API EnumClipboardFormats(UINT arg1)
1802	{
1803	#ifdef DEBUG
1804	WriteLog("USER32: EnumClipboardFormats\n");
1805	#endif
1806	return O32_EnumClipboardFormats(arg1);
1807	}
1808	//******************************************************************************
1809	//******************************************************************************
1810	int WIN32API EnumPropsA(HWND arg1, PROPENUMPROCA arg2)
1811	{
1812	#ifdef DEBUG
1813	WriteLog("USER32: EnumPropsA DOES NOT WORK\n");
1814	#endif
1815	//calling convention problems
1816	return 0;
1817	// return O32_EnumProps(arg1, (PROPENUMPROC_O32)arg2);
1818	}
1819	//******************************************************************************
1820	//******************************************************************************
1821	int WIN32API EnumPropsExA( HWND arg1, PROPENUMPROCEXA arg2, LPARAM arg3)
1822	{
1823	#ifdef DEBUG
1824	WriteLog("USER32: EnumPropsExA DOES NOT WORK\n");
1825	#endif
1826	//calling convention problems
1827	return 0;
1828	// return O32_EnumPropsEx(arg1, arg2, (PROPENUMPROCEX_O32)arg3);
1829	}
1830	//******************************************************************************
1831	//******************************************************************************
1832	int WIN32API EnumPropsExW( HWND arg1, PROPENUMPROCEXW arg2, LPARAM arg3)
1833	{
1834	#ifdef DEBUG
1835	WriteLog("USER32: EnumPropsExW\n");
1836	#endif
1837	// NOTE: This will not work as is (needs UNICODE support)
1838	//calling convention problems
1839	return 0;
1840	// return O32_EnumPropsEx(arg1, arg2, arg3);
1841	}
1842	//******************************************************************************
1843	//******************************************************************************
1844	int WIN32API EnumPropsW( HWND arg1, PROPENUMPROCW arg2)
1845	{
1846	#ifdef DEBUG
1847	WriteLog("USER32: EnumPropsW\n");
1848	#endif
1849	// NOTE: This will not work as is (needs UNICODE support)
1850	//calling convention problems
1851	return 0;
1852	// return O32_EnumProps(arg1, arg2);
1853	}
1854	//******************************************************************************
1855	//******************************************************************************
1856	BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1857	{
1858	BOOL rc;
1859	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1860
1861	#ifdef DEBUG
1862	WriteLog("USER32: EnumWindows\n");
1863	#endif
1864	rc = O32_EnumWindows(callback->GetOS2Callback(), (LPARAM)callback);
1865	if(callback)
1866	delete callback;
1867	return(rc);
1868	}
1869	//******************************************************************************
1870	//******************************************************************************
1871	BOOL WIN32API EqualRect( const RECT * arg1, const RECT * arg2)
1872	{
1873	#ifdef DEBUG
1874	WriteLog("USER32: EqualRect\n");
1875	#endif
1876	return O32_EqualRect(arg1, arg2);
1877	}
1878	//******************************************************************************
1879	//******************************************************************************
1880	BOOL WIN32API ExcludeUpdateRgn( HDC arg1, HWND arg2)
1881	{
1882	#ifdef DEBUG
1883	WriteLog("USER32: ExcludeUpdateRgn\n");
1884	#endif
1885	return O32_ExcludeUpdateRgn(arg1, arg2);
1886	}
1887	//******************************************************************************
1888	//******************************************************************************
1889	BOOL WIN32API ExitWindowsEx( UINT arg1, DWORD arg2)
1890	{
1891	#ifdef DEBUG
1892	WriteLog("USER32: ExitWindowsEx\n");
1893	#endif
1894	return O32_ExitWindowsEx(arg1, arg2);
1895	}
1896	//******************************************************************************
1897	//******************************************************************************
1898	int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
1899	{
1900	#ifdef DEBUG
1901	WriteLog("USER32: FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
1902	#endif
1903	return O32_FillRect(arg1, arg2, arg3);
1904	}
1905	//******************************************************************************
1906	//******************************************************************************
1907	HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
1908	{
1909	char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1910	char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1911	HWND rc;
1912
1913	#ifdef DEBUG
1914	WriteLog("USER32: FindWindowW\n");
1915	#endif
1916	rc = O32_FindWindow(astring1, astring2);
1917	FreeAsciiString(astring1);
1918	FreeAsciiString(astring2);
1919	return rc;
1920	}
1921	//******************************************************************************
1922	//******************************************************************************
1923	int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH arg3)
1924	{
1925	#ifdef DEBUG
1926	WriteLog("USER32: FrameRect\n");
1927	#endif
1928	return O32_FrameRect(arg1, arg2, arg3);
1929	}
1930	//******************************************************************************
1931	//******************************************************************************
1932	HWND WIN32API GetCapture(void)
1933	{
1934	#ifdef DEBUG
1935	WriteLog("USER32: GetCapture\n");
1936	#endif
1937	return O32_GetCapture();
1938	}
1939	//******************************************************************************
1940	//******************************************************************************
1941	UINT WIN32API GetCaretBlinkTime(void)
1942	{
1943	#ifdef DEBUG
1944	WriteLog("USER32: GetCaretBlinkTime\n");
1945	#endif
1946	return O32_GetCaretBlinkTime();
1947	}
1948	//******************************************************************************
1949	//******************************************************************************
1950	BOOL WIN32API GetCaretPos( PPOINT arg1)
1951	{
1952	#ifdef DEBUG
1953	WriteLog("USER32: GetCaretPos\n");
1954	#endif
1955	return O32_GetCaretPos(arg1);
1956	}
1957	//******************************************************************************
1958	//******************************************************************************
1959	BOOL WIN32API GetClipCursor( PRECT arg1)
1960	{
1961	#ifdef DEBUG
1962	WriteLog("USER32: GetClipCursor\n");
1963	#endif
1964	return O32_GetClipCursor(arg1);
1965	}
1966	//******************************************************************************
1967	//******************************************************************************
1968	HANDLE WIN32API GetClipboardData( UINT arg1)
1969	{
1970	#ifdef DEBUG
1971	WriteLog("USER32: GetClipboardData\n");
1972	#endif
1973	return O32_GetClipboardData(arg1);
1974	}
1975	//******************************************************************************
1976	//******************************************************************************
1977	int WIN32API GetClipboardFormatNameA( UINT arg1, LPSTR arg2, int arg3)
1978	{
1979	#ifdef DEBUG
1980	WriteLog("USER32: GetClipboardFormatNameA %s\n", arg2);
1981	#endif
1982	return O32_GetClipboardFormatName(arg1, arg2, arg3);
1983	}
1984	//******************************************************************************
1985	//******************************************************************************
1986	int WIN32API GetClipboardFormatNameW(UINT arg1, LPWSTR arg2, int arg3)
1987	{
1988	int rc;
1989	char *astring = UnicodeToAsciiString(arg2);
1990
1991	#ifdef DEBUG
1992	WriteLog("USER32: GetClipboardFormatNameW %s\n", astring);
1993	#endif
1994	rc = O32_GetClipboardFormatName(arg1, astring, arg3);
1995	FreeAsciiString(astring);
1996	return(rc);
1997	}
1998	//******************************************************************************
1999	//******************************************************************************
2000	HWND WIN32API GetClipboardOwner(void)
2001	{
2002	#ifdef DEBUG
2003	WriteLog("USER32: GetClipboardOwner\n");
2004	#endif
2005	return O32_GetClipboardOwner();
2006	}
2007	//******************************************************************************
2008	//******************************************************************************
2009	HWND WIN32API GetClipboardViewer(void)
2010	{
2011	#ifdef DEBUG
2012	WriteLog("USER32: GetClipboardViewer\n");
2013	#endif
2014	return O32_GetClipboardViewer();
2015	}
2016	//******************************************************************************
2017	//******************************************************************************
2018	DWORD WIN32API GetDialogBaseUnits(void)
2019	{
2020	#ifdef DEBUG
2021	WriteLog("USER32: GetDialogBaseUnits\n");
2022	#endif
2023	return O32_GetDialogBaseUnits();
2024	}
2025	//******************************************************************************
2026	//******************************************************************************
2027	UINT WIN32API GetDlgItemInt( HWND arg1, int arg2, PBOOL arg3, BOOL arg4)
2028	{
2029	#ifdef DEBUG
2030	WriteLog("USER32: GetDlgItemInt\n");
2031	#endif
2032	return O32_GetDlgItemInt(arg1, arg2, arg3, arg4);
2033	}
2034	//******************************************************************************
2035	//******************************************************************************
2036	UINT WIN32API GetDlgItemTextW( HWND arg1, int arg2, LPWSTR arg3, UINT arg4)
2037	{
2038	#ifdef DEBUG
2039	WriteLog("USER32: GetDlgItemTextW NOT WORKING\n");
2040	#endif
2041	// NOTE: This will not work as is (needs UNICODE support)
2042	return 0;
2043	// return O32_GetDlgItemText(arg1, arg2, arg3, arg4);
2044	}
2045	//******************************************************************************
2046	//******************************************************************************
2047	UINT WIN32API GetDoubleClickTime(void)
2048	{
2049	#ifdef DEBUG
2050	WriteLog("USER32: GetDoubleClickTime\n");
2051	#endif
2052	return O32_GetDoubleClickTime();
2053	}
2054	//******************************************************************************
2055	//******************************************************************************
2056	HWND WIN32API GetForegroundWindow(void)
2057	{
2058	#ifdef DEBUG
2059	WriteLog("USER32: GetForegroundWindow\n");
2060	#endif
2061	return O32_GetForegroundWindow();
2062	}
2063	//******************************************************************************
2064	//******************************************************************************
2065	BOOL WIN32API GetIconInfo( HICON arg1, LPICONINFO arg2)
2066	{
2067	#ifdef DEBUG
2068	WriteLog("USER32: GetIconInfo\n");
2069	#endif
2070	return O32_GetIconInfo(arg1, arg2);
2071	}
2072	//******************************************************************************
2073	//******************************************************************************
2074	int WIN32API GetKeyNameTextA( LPARAM arg1, LPSTR arg2, int arg3)
2075	{
2076	#ifdef DEBUG
2077	WriteLog("USER32: GetKeyNameTextA\n");
2078	#endif
2079	return O32_GetKeyNameText(arg1, arg2, arg3);
2080	}
2081	//******************************************************************************
2082	//******************************************************************************
2083	int WIN32API GetKeyNameTextW( LPARAM arg1, LPWSTR arg2, int arg3)
2084	{
2085	#ifdef DEBUG
2086	WriteLog("USER32: GetKeyNameTextW DOES NOT WORK\n");
2087	#endif
2088	// NOTE: This will not work as is (needs UNICODE support)
2089	return 0;
2090	// return O32_GetKeyNameText(arg1, arg2, arg3);
2091	}
2092	//******************************************************************************
2093	//******************************************************************************
2094	int WIN32API GetKeyboardType( int arg1)
2095	{
2096	#ifdef DEBUG
2097	WriteLog("USER32: GetKeyboardType\n");
2098	#endif
2099	return O32_GetKeyboardType(arg1);
2100	}
2101	//******************************************************************************
2102	//******************************************************************************
2103	HWND WIN32API GetLastActivePopup( HWND arg1)
2104	{
2105	#ifdef DEBUG
2106	WriteLog("USER32: GetLastActivePopup\n");
2107	#endif
2108	return O32_GetLastActivePopup(arg1);
2109	}
2110	//******************************************************************************
2111	//******************************************************************************
2112	LONG WIN32API GetMessageExtraInfo(void)
2113	{
2114	dprintf(("USER32: GetMessageExtraInfo\n"));
2115	return O32_GetMessageExtraInfo();
2116	}
2117	//******************************************************************************
2118	//******************************************************************************
2119	DWORD WIN32API GetMessagePos(void)
2120	{
2121	dprintf(("USER32: GetMessagePos\n"));
2122	return O32_GetMessagePos();
2123	}
2124	//******************************************************************************
2125	//******************************************************************************
2126	LONG WIN32API GetMessageTime(void)
2127	{
2128	dprintf(("USER32: GetMessageTime\n"));
2129	return O32_GetMessageTime();
2130	}
2131	//******************************************************************************
2132	//******************************************************************************
2133	BOOL WIN32API GetMessageW(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
2134	{
2135	BOOL rc;
2136
2137	// NOTE: This will not work as is (needs UNICODE support)
2138	rc = O32_GetMessage(arg1, arg2, arg3, arg4);
2139	dprintf(("USER32: GetMessageW %X returned %d\n", arg2, rc));
2140	return(rc);
2141	}
2142	//******************************************************************************
2143	//******************************************************************************
2144	HWND WIN32API GetNextDlgGroupItem( HWND arg1, HWND arg2, BOOL arg3)
2145	{
2146	#ifdef DEBUG
2147	WriteLog("USER32: GetNextDlgGroupItem\n");
2148	#endif
2149	return O32_GetNextDlgGroupItem(arg1, arg2, arg3);
2150	}
2151	//******************************************************************************
2152	//******************************************************************************
2153	HWND WIN32API GetOpenClipboardWindow(void)
2154	{
2155	#ifdef DEBUG
2156	WriteLog("USER32: GetOpenClipboardWindow\n");
2157	#endif
2158	return O32_GetOpenClipboardWindow();
2159	}
2160	//******************************************************************************
2161	//******************************************************************************
2162	HWND WIN32API GetParent( HWND arg1)
2163	{
2164	#ifdef DEBUG
2165	//// WriteLog("USER32: GetParent\n");
2166	#endif
2167	return O32_GetParent(arg1);
2168	}
2169	//******************************************************************************
2170	//******************************************************************************
2171	int WIN32API GetPriorityClipboardFormat( PUINT arg1, int arg2)
2172	{
2173	#ifdef DEBUG
2174	WriteLog("USER32: GetPriorityClipboardFormat\n");
2175	#endif
2176	return O32_GetPriorityClipboardFormat(arg1, arg2);
2177	}
2178	//******************************************************************************
2179	//******************************************************************************
2180	HANDLE WIN32API GetPropA( HWND arg1, LPCSTR arg2)
2181	{
2182	#ifdef DEBUG
2183	if((int)arg2 >> 16 != 0)
2184	WriteLog("USER32: GetPropA %s\n", arg2);
2185	else WriteLog("USER32: GetPropA %X\n", arg2);
2186	#endif
2187	return O32_GetProp(arg1, arg2);
2188	}
2189	//******************************************************************************
2190	//******************************************************************************
2191	HANDLE WIN32API GetPropW(HWND arg1, LPCWSTR arg2)
2192	{
2193	BOOL handle;
2194	char *astring;
2195
2196	if((int)arg2 >> 16 != 0)
2197	astring = UnicodeToAsciiString((LPWSTR)arg2);
2198	else astring = (char *)arg2;
2199	#ifdef DEBUG
2200	if((int)arg2 >> 16 != 0)
2201	WriteLog("USER32: GetPropW %s\n", astring);
2202	else WriteLog("USER32: GetPropW %X\n", astring);
2203	#endif
2204	handle = GetPropA(arg1, (LPCSTR)astring);
2205	if((int)arg2 >> 16 != 0)
2206	FreeAsciiString(astring);
2207
2208	return(handle);
2209	}
2210	//******************************************************************************
2211	//******************************************************************************
2212	DWORD WIN32API GetQueueStatus( UINT arg1)
2213	{
2214	#ifdef DEBUG
2215	WriteLog("USER32: GetQueueStatus\n");
2216	#endif
2217	return O32_GetQueueStatus(arg1);
2218	}
2219	//******************************************************************************
2220	//******************************************************************************
2221	int WIN32API GetScrollPos(HWND hwnd, int fnBar)
2222	{
2223	int pos;
2224
2225	pos = GetScrollPos(hwnd, fnBar);
2226	#ifdef DEBUG
2227	WriteLog("USER32: GetScrollPos of %X type %d returned %d\n", hwnd, fnBar, pos);
2228	#endif
2229	return(pos);
2230	}
2231	//******************************************************************************
2232	//******************************************************************************
2233	BOOL WIN32API GetScrollRange( HWND arg1, int arg2, int * arg3, int * arg4)
2234	{
2235	#ifdef DEBUG
2236	WriteLog("USER32: GetScrollRange\n");
2237	#endif
2238	return O32_GetScrollRange(arg1, arg2, arg3, arg4);
2239	}
2240	//******************************************************************************
2241	//******************************************************************************
2242	DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
2243	{
2244	#ifdef DEBUG
2245	WriteLog("USER32: GetTabbedTextExtentA\n");
2246	#endif
2247	return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
2248	}
2249	//******************************************************************************
2250	//******************************************************************************
2251	DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
2252	{
2253	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2254	DWORD rc;
2255
2256	#ifdef DEBUG
2257	WriteLog("USER32: GetTabbedTextExtentW\n");
2258	#endif
2259	rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
2260	FreeAsciiString(astring);
2261	return rc;
2262	}
2263	//******************************************************************************
2264	//******************************************************************************
2265	HWND WIN32API GetTopWindow( HWND arg1)
2266	{
2267	#ifdef DEBUG
2268	//// WriteLog("USER32: GetTopWindow\n");
2269	#endif
2270	return O32_GetTopWindow(arg1);
2271	}
2272	//******************************************************************************
2273	//******************************************************************************
2274	int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2275	{
2276	#ifdef DEBUG
2277	WriteLog("USER32: GetUpdateRgn\n");
2278	#endif
2279	return O32_GetUpdateRgn(arg1, arg2, arg3);
2280	}
2281	//******************************************************************************
2282	//******************************************************************************
2283	LONG WIN32API GetWindowLongW( HWND arg1, int arg2)
2284	{
2285	#ifdef DEBUG
2286	WriteLog("USER32: GetWindowLongW\n");
2287	#endif
2288	return GetWindowLongA(arg1, arg2); //class procedures..
2289	}
2290	//******************************************************************************
2291	//******************************************************************************
2292	BOOL WIN32API GetWindowPlacement( HWND arg1, LPWINDOWPLACEMENT arg2)
2293	{
2294	#ifdef DEBUG
2295	WriteLog("USER32: GetWindowPlacement\n");
2296	#endif
2297	return O32_GetWindowPlacement(arg1, arg2);
2298	}
2299	//******************************************************************************
2300	//******************************************************************************
2301	int WIN32API GetWindowTextLengthW( HWND arg1)
2302	{
2303	#ifdef DEBUG
2304	WriteLog("USER32: GetWindowTextLengthW\n");
2305	#endif
2306	return O32_GetWindowTextLength(arg1);
2307	}
2308	//******************************************************************************
2309	//******************************************************************************
2310	int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
2311	{
2312	char title[128];
2313	int rc;
2314
2315	rc = O32_GetWindowText(hwnd, title, sizeof(title));
2316	#ifdef DEBUG
2317	WriteLog("USER32: GetWindowTextW returned %s\n", title);
2318	#endif
2319	if(rc > cch) {
2320	title[cch-1] = 0;
2321	rc = cch;
2322	}
2323	AsciiToUnicode(title, lpsz);
2324	return(rc);
2325	}
2326	//******************************************************************************
2327	//******************************************************************************
2328	DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD arg2)
2329	{
2330	#ifdef DEBUG
2331	WriteLog("USER32: GetWindowThreadProcessId\n");
2332	#endif
2333	return O32_GetWindowThreadProcessId(arg1, arg2);
2334	}
2335	//******************************************************************************
2336	//******************************************************************************
2337	WORD WIN32API GetWindowWord( HWND arg1, int arg2)
2338	{
2339	#ifdef DEBUG
2340	WriteLog("USER32: GetWindowWord\n");
2341	#endif
2342	return O32_GetWindowWord(arg1, arg2);
2343	}
2344	//******************************************************************************
2345	//******************************************************************************
2346	BOOL WIN32API HideCaret( HWND arg1)
2347	{
2348	#ifdef DEBUG
2349	WriteLog("USER32: HideCaret\n");
2350	#endif
2351	return O32_HideCaret(arg1);
2352	}
2353	//******************************************************************************
2354	//******************************************************************************
2355	BOOL WIN32API InSendMessage(void)
2356	{
2357	#ifdef DEBUG
2358	WriteLog("USER32: InSendMessage\n");
2359	#endif
2360	return O32_InSendMessage();
2361	}
2362	//******************************************************************************
2363	//******************************************************************************
2364	BOOL WIN32API IntersectRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
2365	{
2366	#ifdef DEBUG
2367	//// WriteLog("USER32: IntersectRect\n");
2368	#endif
2369	return O32_IntersectRect(arg1, arg2, arg3);
2370	}
2371	//******************************************************************************
2372	//******************************************************************************
2373	BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2374	{
2375	#ifdef DEBUG
2376	WriteLog("USER32: InvalidateRgn\n");
2377	#endif
2378	return O32_InvalidateRgn(arg1, arg2, arg3);
2379	}
2380	//******************************************************************************
2381	//******************************************************************************
2382	BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
2383	{
2384	#ifdef DEBUG
2385	WriteLog("USER32: InvertRect\n");
2386	#endif
2387	return O32_InvertRect(arg1, arg2);
2388	}
2389	//******************************************************************************
2390	//******************************************************************************
2391	BOOL WIN32API IsChild( HWND arg1, HWND arg2)
2392	{
2393	#ifdef DEBUG
2394	WriteLog("USER32: IsChild\n");
2395	#endif
2396	return O32_IsChild(arg1, arg2);
2397	}
2398	//******************************************************************************
2399	//******************************************************************************
2400	BOOL WIN32API IsClipboardFormatAvailable( UINT arg1)
2401	{
2402	#ifdef DEBUG
2403	WriteLog("USER32: IsClipboardFormatAvailable\n");
2404	#endif
2405	return O32_IsClipboardFormatAvailable(arg1);
2406	}
2407	//******************************************************************************
2408	//******************************************************************************
2409	BOOL WIN32API IsDialogMessageW( HWND arg1, LPMSG arg2)
2410	{
2411	#ifdef DEBUG
2412	WriteLog("USER32: IsDialogMessageW\n");
2413	#endif
2414	// NOTE: This will not work as is (needs UNICODE support)
2415	return O32_IsDialogMessage(arg1, arg2);
2416	}
2417	//******************************************************************************
2418	//******************************************************************************
2419	BOOL WIN32API IsRectEmpty( const RECT * arg1)
2420	{
2421	#ifdef DEBUG
2422	WriteLog("USER32: IsRectEmpty\n");
2423	#endif
2424	return O32_IsRectEmpty(arg1);
2425	}
2426	//******************************************************************************
2427	//******************************************************************************
2428	BOOL WIN32API IsWindow( HWND arg1)
2429	{
2430	#ifdef DEBUG
2431	WriteLog("USER32: IsWindow\n");
2432	#endif
2433	return O32_IsWindow(arg1);
2434	}
2435	//******************************************************************************
2436	//******************************************************************************
2437	BOOL WIN32API IsWindowEnabled( HWND arg1)
2438	{
2439	#ifdef DEBUG
2440	WriteLog("USER32: IsWindowEnabled\n");
2441	#endif
2442	return O32_IsWindowEnabled(arg1);
2443	}
2444	//******************************************************************************
2445	//******************************************************************************
2446	BOOL WIN32API IsWindowVisible( HWND arg1)
2447	{
2448	#ifdef DEBUG
2449	WriteLog("USER32: IsWindowVisible\n");
2450	#endif
2451	return O32_IsWindowVisible(arg1);
2452	}
2453	//******************************************************************************
2454	//******************************************************************************
2455	BOOL WIN32API IsZoomed( HWND arg1)
2456	{
2457	#ifdef DEBUG
2458	WriteLog("USER32: IsZoomed\n");
2459	#endif
2460	return O32_IsZoomed(arg1);
2461	}
2462	//******************************************************************************
2463	//******************************************************************************
2464	BOOL WIN32API LockWindowUpdate( HWND arg1)
2465	{
2466	#ifdef DEBUG
2467	WriteLog("USER32: LockWindowUpdate\n");
2468	#endif
2469	return O32_LockWindowUpdate(arg1);
2470	}
2471	//******************************************************************************
2472	//******************************************************************************
2473	BOOL WIN32API MapDialogRect( HWND arg1, PRECT arg2)
2474	{
2475	#ifdef DEBUG
2476	WriteLog("USER32: MapDialogRect\n");
2477	#endif
2478	return O32_MapDialogRect(arg1, arg2);
2479	}
2480	//******************************************************************************
2481	//******************************************************************************
2482	UINT WIN32API MapVirtualKeyA( UINT arg1, UINT arg2)
2483	{
2484	#ifdef DEBUG
2485	WriteLog("USER32: MapVirtualKeyA\n");
2486	#endif
2487	return O32_MapVirtualKey(arg1, arg2);
2488	}
2489	//******************************************************************************
2490	//******************************************************************************
2491	UINT WIN32API MapVirtualKeyW( UINT arg1, UINT arg2)
2492	{
2493	#ifdef DEBUG
2494	WriteLog("USER32: MapVirtualKeyW\n");
2495	#endif
2496	// NOTE: This will not work as is (needs UNICODE support)
2497	return O32_MapVirtualKey(arg1, arg2);
2498	}
2499	//******************************************************************************
2500	//******************************************************************************
2501	int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
2502	{
2503	#ifdef DEBUG
2504	WriteLog("USER32: MapWindowPoints\n");
2505	#endif
2506	return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
2507	}
2508	//******************************************************************************
2509	//******************************************************************************
2510	int WIN32API MessageBoxW(HWND arg1, LPCWSTR arg2, LPCWSTR arg3, UINT arg4)
2511	{
2512	char astring1, astring2;
2513	int rc;
2514
2515	astring1 = UnicodeToAsciiString((LPWSTR)arg2);
2516	astring2 = UnicodeToAsciiString((LPWSTR)arg3);
2517	#ifdef DEBUG
2518	WriteLog("USER32: MessageBoxW %s %s\n", astring1, astring2);
2519	#endif
2520	rc = O32_MessageBox(arg1, astring1, astring2, arg4);
2521	FreeAsciiString(astring1);
2522	FreeAsciiString(astring2);
2523	return(rc);
2524	}
2525	//******************************************************************************
2526	//******************************************************************************
2527	BOOL WIN32API OpenClipboard( HWND arg1)
2528	{
2529	#ifdef DEBUG
2530	WriteLog("USER32: OpenClipboard\n");
2531	#endif
2532	return O32_OpenClipboard(arg1);
2533	}
2534	//******************************************************************************
2535	//******************************************************************************
2536	BOOL WIN32API PeekMessageW( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
2537	{
2538	#ifdef DEBUG
2539	WriteLog("USER32: PeekMessageW\n");
2540	#endif
2541	// NOTE: This will not work as is (needs UNICODE support)
2542	return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
2543	}
2544	//******************************************************************************
2545	//******************************************************************************
2546	// NOTE: Open32 function doesn't have the 'W'.
2547	BOOL WIN32API PostMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2548	{
2549	#ifdef DEBUG
2550	WriteLog("USER32: PostMessageW\n");
2551	#endif
2552	// NOTE: This will not work as is (needs UNICODE support)
2553	return O32_PostMessage(arg1, arg2, arg3, arg4);
2554	}
2555	//******************************************************************************
2556	//******************************************************************************
2557	BOOL WIN32API PostThreadMessageA( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2558	{
2559	#ifdef DEBUG
2560	WriteLog("USER32: PostThreadMessageA\n");
2561	#endif
2562	return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2563	}
2564	//******************************************************************************
2565	//******************************************************************************
2566	BOOL WIN32API PostThreadMessageW( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2567	{
2568	#ifdef DEBUG
2569	WriteLog("USER32: PostThreadMessageW\n");
2570	#endif
2571	// NOTE: This will not work as is (needs UNICODE support)
2572	return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2573	}
2574	//******************************************************************************
2575	//******************************************************************************
2576	BOOL WIN32API PtInRect( const RECT * arg1, POINT arg2)
2577	{
2578	#ifdef DEBUG
2579	WriteLog("USER32: PtInRect\n");
2580	#endif
2581	return O32_PtInRect(arg1, arg2);
2582	}
2583	//******************************************************************************
2584	//******************************************************************************
2585	BOOL WIN32API RedrawWindow( HWND arg1, const RECT * arg2, HRGN arg3, UINT arg4)
2586	{
2587	BOOL rc;
2588
2589	rc = O32_RedrawWindow(arg1, arg2, arg3, arg4);
2590	#ifdef DEBUG
2591	WriteLog("USER32: RedrawWindow %X , %X, %X, %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2592	#endif
2593	InvalidateRect(arg1, arg2, TRUE);
2594	UpdateWindow(arg1);
2595	SendMessageA(arg1, WM_PAINT, 0, 0);
2596	return(rc);
2597	}
2598	//******************************************************************************
2599	//******************************************************************************
2600	UINT WIN32API RegisterClipboardFormatA( LPCSTR arg1)
2601	{
2602	#ifdef DEBUG
2603	WriteLog("USER32: RegisterClipboardFormatA\n");
2604	#endif
2605	return O32_RegisterClipboardFormat(arg1);
2606	}
2607	//******************************************************************************
2608	//******************************************************************************
2609	UINT WIN32API RegisterClipboardFormatW(LPCWSTR arg1)
2610	{
2611	UINT rc;
2612	char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2613
2614	#ifdef DEBUG
2615	WriteLog("USER32: RegisterClipboardFormatW %s\n", astring);
2616	#endif
2617	rc = O32_RegisterClipboardFormat(astring);
2618	FreeAsciiString(astring);
2619	#ifdef DEBUG
2620	WriteLog("USER32: RegisterClipboardFormatW returned %d\n", rc);
2621	#endif
2622	return(rc);
2623	}
2624	//******************************************************************************
2625	//******************************************************************************
2626	UINT WIN32API RegisterWindowMessageW( LPCWSTR arg1)
2627	{
2628	char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2629	UINT rc;
2630
2631	#ifdef DEBUG
2632	WriteLog("USER32: RegisterWindowMessageW\n");
2633	#endif
2634	rc = O32_RegisterWindowMessage(astring);
2635	FreeAsciiString(astring);
2636	return rc;
2637	}
2638	//******************************************************************************
2639	//******************************************************************************
2640	HANDLE WIN32API RemovePropA( HWND arg1, LPCSTR arg2)
2641	{
2642	#ifdef DEBUG
2643	WriteLog("USER32: RemovePropA\n");
2644	#endif
2645	return O32_RemoveProp(arg1, arg2);
2646	}
2647	//******************************************************************************
2648	//******************************************************************************
2649	HANDLE WIN32API RemovePropW( HWND arg1, LPCWSTR arg2)
2650	{
2651	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2652	HANDLE rc;
2653
2654	#ifdef DEBUG
2655	WriteLog("USER32: RemovePropW\n");
2656	#endif
2657	rc = O32_RemoveProp(arg1, astring);
2658	FreeAsciiString(astring);
2659	return rc;
2660	}
2661	//******************************************************************************
2662	//******************************************************************************
2663	BOOL WIN32API ReplyMessage( LRESULT arg1)
2664	{
2665	#ifdef DEBUG
2666	WriteLog("USER32: ReplyMessage\n");
2667	#endif
2668	return O32_ReplyMessage(arg1);
2669	}
2670	//******************************************************************************
2671	//******************************************************************************
2672	BOOL WIN32API ScreenToClient( HWND arg1, LPPOINT arg2)
2673	{
2674	#ifdef DEBUG
2675	WriteLog("USER32: ScreenToClient\n");
2676	#endif
2677	return O32_ScreenToClient(arg1, arg2);
2678	}
2679	//******************************************************************************
2680	//******************************************************************************
2681	BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7)
2682	{
2683	#ifdef DEBUG
2684	WriteLog("USER32: ScrollDC\n");
2685	#endif
2686	return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2687	}
2688	//******************************************************************************
2689	//******************************************************************************
2690	BOOL WIN32API ScrollWindow( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5)
2691	{
2692	#ifdef DEBUG
2693	WriteLog("USER32: ScrollWindow\n");
2694	#endif
2695	return O32_ScrollWindow(arg1, arg2, arg3, arg4, arg5);
2696	}
2697	//******************************************************************************
2698	//******************************************************************************
2699	BOOL WIN32API ScrollWindowEx( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7, UINT arg8)
2700	{
2701	#ifdef DEBUG
2702	WriteLog("USER32: ScrollWindowEx\n");
2703	#endif
2704	return O32_ScrollWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2705	}
2706	//******************************************************************************
2707	//******************************************************************************
2708	LONG WIN32API SendDlgItemMessageW( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
2709	{
2710	#ifdef DEBUG
2711	WriteLog("USER32: SendDlgItemMessageW\n");
2712	#endif
2713	return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
2714	}
2715	//******************************************************************************
2716	//******************************************************************************
2717	LRESULT WIN32API SendMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2718	{
2719	LRESULT rc;
2720
2721	#ifdef DEBUG
2722	WriteLog("USER32: SendMessageW....\n");
2723	#endif
2724	rc = O32_SendMessage(arg1, arg2, arg3, arg4);
2725	#ifdef DEBUG
2726	WriteLog("USER32: SendMessageW %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2727	#endif
2728	return(rc);
2729	}
2730	//******************************************************************************
2731	//******************************************************************************
2732	BOOL WIN32API SetCaretBlinkTime( UINT arg1)
2733	{
2734	#ifdef DEBUG
2735	WriteLog("USER32: SetCaretBlinkTime\n");
2736	#endif
2737	return O32_SetCaretBlinkTime(arg1);
2738	}
2739	//******************************************************************************
2740	//******************************************************************************
2741	BOOL WIN32API SetCaretPos( int arg1, int arg2)
2742	{
2743	dprintf(("USER32: SetCaretPos\n"));
2744	return O32_SetCaretPos(arg1, arg2);
2745	}
2746	//******************************************************************************
2747	//******************************************************************************
2748	HANDLE WIN32API SetClipboardData( UINT arg1, HANDLE arg2)
2749	{
2750	dprintf(("USER32: SetClipboardData\n"));
2751	return O32_SetClipboardData(arg1, arg2);
2752	}
2753	//******************************************************************************
2754	//******************************************************************************
2755	HWND WIN32API SetClipboardViewer( HWND arg1)
2756	{
2757	dprintf(("USER32: SetClipboardViewer\n"));
2758	return O32_SetClipboardViewer(arg1);
2759	}
2760	//******************************************************************************
2761	//******************************************************************************
2762	BOOL WIN32API SetDlgItemTextW( HWND arg1, int arg2, LPCWSTR arg3)
2763	{
2764	char *astring = UnicodeToAsciiString((LPWSTR)arg3);
2765	BOOL rc;
2766
2767	#ifdef DEBUG
2768	WriteLog("USER32: SetDlgItemTextW\n");
2769	#endif
2770	// NOTE: This will not work as is (needs UNICODE support)
2771	rc = O32_SetDlgItemText(arg1, arg2, astring);
2772	FreeAsciiString(astring);
2773	return rc;
2774	}
2775	//******************************************************************************
2776	//******************************************************************************
2777	BOOL WIN32API SetDoubleClickTime( UINT arg1)
2778	{
2779	#ifdef DEBUG
2780	WriteLog("USER32: SetDoubleClickTime\n");
2781	#endif
2782	return O32_SetDoubleClickTime(arg1);
2783	}
2784	//******************************************************************************
2785	//******************************************************************************
2786	HWND WIN32API SetParent( HWND arg1, HWND arg2)
2787	{
2788	#ifdef DEBUG
2789	WriteLog("USER32: SetParent\n");
2790	#endif
2791	return O32_SetParent(arg1, arg2);
2792	}
2793	//******************************************************************************
2794	//******************************************************************************
2795	BOOL WIN32API SetPropA( HWND arg1, LPCSTR arg2, HANDLE arg3)
2796	{
2797	#ifdef DEBUG
2798	if((int)arg2 >> 16 != 0)
2799	WriteLog("USER32: SetPropA %S\n", arg2);
2800	else WriteLog("USER32: SetPropA %X\n", arg2);
2801	#endif
2802	return O32_SetProp(arg1, arg2, arg3);
2803	}
2804	//******************************************************************************
2805	//******************************************************************************
2806	BOOL WIN32API SetPropW(HWND arg1, LPCWSTR arg2, HANDLE arg3)
2807	{
2808	BOOL rc;
2809	char *astring;
2810
2811	if((int)arg2 >> 16 != 0)
2812	astring = UnicodeToAsciiString((LPWSTR)arg2);
2813	else astring = (char *)arg2;
2814
2815	#ifdef DEBUG
2816	if((int)arg2 >> 16 != 0)
2817	WriteLog("USER32: SetPropW %S\n", astring);
2818	else WriteLog("USER32: SetPropW %X\n", astring);
2819	#endif
2820	rc = O32_SetProp(arg1, astring, arg3);
2821	if((int)astring >> 16 != 0)
2822	FreeAsciiString(astring);
2823	return(rc);
2824	}
2825	//******************************************************************************
2826	//******************************************************************************
2827	BOOL WIN32API SetRectEmpty( PRECT arg1)
2828	{
2829	#ifdef DEBUG
2830	WriteLog("USER32: SetRectEmpty\n");
2831	#endif
2832	return O32_SetRectEmpty(arg1);
2833	}
2834	//******************************************************************************
2835	//******************************************************************************
2836	int WIN32API SetScrollPos( HWND arg1, int arg2, int arg3, BOOL arg4)
2837	{
2838	#ifdef DEBUG
2839	WriteLog("USER32: SetScrollPos\n");
2840	#endif
2841	return O32_SetScrollPos(arg1, arg2, arg3, arg4);
2842	}
2843	//******************************************************************************
2844	//******************************************************************************
2845	BOOL WIN32API SetScrollRange( HWND arg1, int arg2, int arg3, int arg4, BOOL arg5)
2846	{
2847	#ifdef DEBUG
2848	WriteLog("USER32: SetScrollRange\n");
2849	#endif
2850	return O32_SetScrollRange(arg1, arg2, arg3, arg4, arg5);
2851	}
2852	//******************************************************************************
2853	//******************************************************************************
2854	LONG WIN32API SetWindowLongA(HWND hwnd, int nIndex, LONG arg3)
2855	{
2856	LONG rc;
2857
2858	dprintf(("USER32: SetWindowLongA %X %d %X\n", hwnd, nIndex, arg3));
2859	if(nIndex == GWL_WNDPROC \|\| nIndex == DWL_DLGPROC) {
2860	Win32WindowProc *wndproc = Win32WindowProc::FindProc(hwnd);
2861	if(wndproc == NULL) {//created with system class and app wants to change the handler
2862	dprintf(("USER32: SetWindowLong new WindowProc for system class\n"));
2863	wndproc = new Win32WindowProc((WNDPROC)arg3);
2864	wndproc->SetWindowHandle(hwnd);
2865	rc = O32_GetWindowLong(hwnd, nIndex);
2866	Win32WindowSubProc *subwndproc = new Win32WindowSubProc(hwnd, (WNDPROC_O32)rc);
2867	O32_SetWindowLong(hwnd, nIndex, (LONG)wndproc->GetOS2Callback());
2868	return((LONG)subwndproc->GetWin32Callback());
2869	}
2870	else {
2871	if(!(nIndex == DWL_DLGPROC && wndproc->IsWindow() == TRUE)) {
2872	rc = (LONG)wndproc->GetWin32Callback();
2873	dprintf(("USER32: SetWindowLong change WindowProc %X to %X\n", rc, arg3));
2874	wndproc->SetWin32Callback((WNDPROC)arg3);
2875	return(rc);
2876	}
2877	//else window that accesses it's normal window data
2878	}
2879	}
2880	return O32_SetWindowLong(hwnd, nIndex, arg3);
2881	}
2882	//******************************************************************************
2883	//TODO: Is this always correct? (GWL_ID: window identifier??)
2884	//******************************************************************************
2885	LONG WIN32API SetWindowLongW(HWND arg1, int arg2, LONG arg3)
2886	{
2887	dprintf(("USER32: SetWindowLongW %X %d %X\n", arg1, arg2, arg3));
2888	return SetWindowLongA(arg1, arg2, arg3);
2889	}
2890	//******************************************************************************
2891	//******************************************************************************
2892	BOOL WIN32API SetWindowPlacement( HWND arg1, const WINDOWPLACEMENT * arg2)
2893	{
2894	dprintf(("USER32: SetWindowPlacement\n"));
2895	return O32_SetWindowPlacement(arg1, arg2);
2896	}
2897	//******************************************************************************
2898	//******************************************************************************
2899	BOOL WIN32API SetWindowTextW( HWND arg1, LPCWSTR arg2)
2900	{
2901	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2902	BOOL rc;
2903
2904	rc = SetWindowTextA(arg1, (LPCSTR)astring);
2905	dprintf(("USER32: SetWindowTextW %X %s returned %d\n", arg1, astring, rc));
2906	FreeAsciiString(astring);
2907	return(rc);
2908	}
2909	//******************************************************************************
2910	//******************************************************************************
2911	WORD WIN32API SetWindowWord( HWND arg1, int arg2, WORD arg3)
2912	{
2913	dprintf(("USER32: SetWindowWord\n"));
2914	return O32_SetWindowWord(arg1, arg2, arg3);
2915	}
2916	//******************************************************************************
2917	//******************************************************************************
2918	BOOL WIN32API ShowCaret( HWND arg1)
2919	{
2920	dprintf(("USER32: ShowCaret\n"));
2921	return O32_ShowCaret(arg1);
2922	}
2923	//******************************************************************************
2924	//******************************************************************************
2925	BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
2926	{
2927	dprintf(("USER32: ShowOwnedPopups\n"));
2928	return O32_ShowOwnedPopups(arg1, arg2);
2929	}
2930	//******************************************************************************
2931	//******************************************************************************
2932	BOOL WIN32API ShowScrollBar( HWND arg1, int arg2, BOOL arg3)
2933	{
2934	#ifdef DEBUG
2935	WriteLog("USER32: ShowScrollBar\n");
2936	#endif
2937	return O32_ShowScrollBar(arg1, arg2, arg3);
2938	}
2939	//******************************************************************************
2940	//******************************************************************************
2941	BOOL WIN32API SwapMouseButton( BOOL arg1)
2942	{
2943	#ifdef DEBUG
2944	WriteLog("USER32: SwapMouseButton\n");
2945	#endif
2946	return O32_SwapMouseButton(arg1);
2947	}
2948	//******************************************************************************
2949	//******************************************************************************
2950	BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
2951	{
2952	BOOL rc;
2953	NONCLIENTMETRICSA cmetric = (NONCLIENTMETRICSA )pvParam;
2954
2955	switch(uiAction) {
2956	case SPI_SCREENSAVERRUNNING:
2957	(BOOL )pvParam = FALSE;
2958	rc = TRUE;
2959	break;
2960	case SPI_GETDRAGFULLWINDOWS:
2961	(BOOL )pvParam = FALSE;
2962	rc = TRUE;
2963	break;
2964	case SPI_GETNONCLIENTMETRICS:
2965	memset(cmetric, 0, sizeof(NONCLIENTMETRICSA));
2966	cmetric->cbSize = sizeof(NONCLIENTMETRICSA);
2967	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfCaptionFont),0);
2968	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMenuFont),0);
2969	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfStatusFont),0);
2970	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMessageFont),0);
2971	cmetric->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
2972	cmetric->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
2973	cmetric->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
2974	cmetric->iCaptionWidth = 32; //TODO
2975	cmetric->iCaptionHeight = 16; //TODO
2976	cmetric->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
2977	cmetric->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
2978	cmetric->iMenuWidth = 32; //TODO
2979	cmetric->iMenuHeight = GetSystemMetrics(SM_CYMENU);
2980	rc = TRUE;
2981	break;
2982	case 104: //TODO: Undocumented
2983	rc = 16;
2984	break;
2985	default:
2986	rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
2987	break;
2988	}
2989	#ifdef DEBUG
2990	WriteLog("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc);
2991	#endif
2992	return(rc);
2993	}
2994	//******************************************************************************
2995	//TODO: Check for more options that have different structs for Unicode!!!!
2996	//******************************************************************************
2997	BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
2998	{
2999	BOOL rc;
3000	NONCLIENTMETRICSW clientMetricsW = (NONCLIENTMETRICSW )pvParam;
3001	NONCLIENTMETRICSA clientMetricsA = {0};
3002	PVOID pvParamA;
3003	UINT uiParamA;
3004
3005	switch(uiAction) {
3006	case SPI_SETNONCLIENTMETRICS:
3007	clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
3008	clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
3009	clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
3010	clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
3011	clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
3012	clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
3013	ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
3014	clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
3015	clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
3016	ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
3017	clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
3018	clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
3019	ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
3020	ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
3021	ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
3022	//no break
3023	case SPI_GETNONCLIENTMETRICS:
3024	uiParamA = sizeof(NONCLIENTMETRICSA);
3025	pvParamA = &clientMetricsA;
3026	break;
3027	default:
3028	pvParamA = pvParam;
3029	uiParamA = uiParam;
3030	break;
3031	}
3032	rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
3033
3034	switch(uiAction) {
3035	case SPI_GETNONCLIENTMETRICS:
3036	clientMetricsW->cbSize = sizeof(*clientMetricsW);
3037	clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
3038	clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
3039	clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
3040	clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
3041	clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
3042	ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
3043
3044	clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
3045	clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
3046	ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
3047
3048	clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
3049	clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
3050	ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
3051	ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
3052	ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
3053	break;
3054	}
3055	#ifdef DEBUG
3056	WriteLog("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc);
3057	#endif
3058	return(rc);
3059	}
3060	//******************************************************************************
3061	//******************************************************************************
3062	LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3063	{
3064	#ifdef DEBUG
3065	WriteLog("USER32: TabbedTextOutA\n");
3066	#endif
3067	return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
3068	}
3069	//******************************************************************************
3070	//******************************************************************************
3071	LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3072	{
3073	char *astring = UnicodeToAsciiString((LPWSTR)arg4);
3074	LONG rc;
3075
3076	#ifdef DEBUG
3077	WriteLog("USER32: TabbedTextOutW\n");
3078	#endif
3079	rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
3080	FreeAsciiString(astring);
3081	return rc;
3082	}
3083	//******************************************************************************
3084	//******************************************************************************
3085	int WIN32API TranslateAccelerator( HWND arg1, HACCEL arg2, LPMSG arg3)
3086	{
3087	#ifdef DEBUG
3088	WriteLog("USER32: TranslateAccelerator\n");
3089	#endif
3090	return O32_TranslateAccelerator(arg1, arg2, arg3);
3091	}
3092	//******************************************************************************
3093	//******************************************************************************
3094	int WIN32API TranslateAcceleratorW( HWND arg1, HACCEL arg2, LPMSG arg3)
3095	{
3096	#ifdef DEBUG
3097	WriteLog("USER32: TranslateAcceleratorW\n");
3098	#endif
3099	// NOTE: This will not work as is (needs UNICODE support)
3100	return O32_TranslateAccelerator(arg1, arg2, arg3);
3101	}
3102	//******************************************************************************
3103	//******************************************************************************
3104	BOOL WIN32API TranslateMDISysAccel( HWND arg1, LPMSG arg2)
3105	{
3106	#ifdef DEBUG
3107	//// WriteLog("USER32: TranslateMDISysAccel\n");
3108	#endif
3109	return O32_TranslateMDISysAccel(arg1, arg2);
3110	}
3111	//******************************************************************************
3112	//******************************************************************************
3113	BOOL WIN32API UnionRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
3114	{
3115	#ifdef DEBUG
3116	WriteLog("USER32: UnionRect\n");
3117	#endif
3118	return O32_UnionRect(arg1, arg2, arg3);
3119	}
3120	//******************************************************************************
3121	//******************************************************************************
3122	BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
3123	{
3124	#ifdef DEBUG
3125	WriteLog("USER32: ValidateRect\n");
3126	#endif
3127	return O32_ValidateRect(arg1, arg2);
3128	}
3129	//******************************************************************************
3130	//******************************************************************************
3131	BOOL WIN32API ValidateRgn( HWND arg1, HRGN arg2)
3132	{
3133	#ifdef DEBUG
3134	WriteLog("USER32: ValidateRgn\n");
3135	#endif
3136	return O32_ValidateRgn(arg1, arg2);
3137	}
3138	//******************************************************************************
3139	//******************************************************************************
3140	WORD WIN32API VkKeyScanW( WCHAR arg1)
3141	{
3142	#ifdef DEBUG
3143	WriteLog("USER32: VkKeyScanW\n");
3144	#endif
3145	// NOTE: This will not work as is (needs UNICODE support)
3146	return O32_VkKeyScan((char)arg1);
3147	}
3148	//******************************************************************************
3149	//******************************************************************************
3150	BOOL WIN32API WaitMessage(void)
3151	{
3152	#ifdef DEBUG
3153	WriteLog("USER32: WaitMessage\n");
3154	#endif
3155	return O32_WaitMessage();
3156	}
3157	//******************************************************************************
3158	//******************************************************************************
3159	BOOL WIN32API WinHelpW( HWND arg1, LPCWSTR arg2, UINT arg3, DWORD arg4)
3160	{
3161	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
3162	BOOL rc;
3163
3164	#ifdef DEBUG
3165	WriteLog("USER32: WinHelpW\n");
3166	#endif
3167	rc = WinHelpA(arg1, astring, arg3, arg4);
3168	FreeAsciiString(astring);
3169	return rc;
3170	}
3171	//******************************************************************************
3172	//******************************************************************************
3173	HWND WIN32API WindowFromDC( HDC arg1)
3174	{
3175	#ifdef DEBUG
3176	WriteLog("USER32: WindowFromDC\n");
3177	#endif
3178	return O32_WindowFromDC(arg1);
3179	}
3180	//******************************************************************************
3181	//******************************************************************************
3182	HWND WIN32API WindowFromPoint( POINT arg1)
3183	{
3184	#ifdef DEBUG
3185	WriteLog("USER32: WindowFromPoint\n");
3186	#endif
3187	return O32_WindowFromPoint(arg1);
3188	}
3189	//******************************************************************************
3190	//******************************************************************************
3191	int WIN32API wvsprintfA( LPSTR arg1, LPCSTR arg2, va_list arg3)
3192	{
3193	#ifdef DEBUG
3194	WriteLog("USER32: wvsprintfA\n");
3195	#endif
3196	return O32_wvsprintf(arg1, arg2, (LPCVOID *)arg3);
3197	}
3198	//******************************************************************************
3199	//******************************************************************************
3200	int WIN32API wvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, va_list argptr)
3201	{
3202	int rc;
3203	char szOut[256];
3204	char *lpFmtA;
3205
3206	lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
3207	#ifdef DEBUG
3208	WriteLog("USER32: wvsprintfW, DOES NOT HANDLE UNICODE STRINGS!\n");
3209	WriteLog("USER32: %s\n", lpFmt);
3210	#endif
3211	rc = O32_wvsprintf(szOut, lpFmtA, (LPCVOID)argptr);
3212
3213	AsciiToUnicode(szOut, lpOut);
3214	#ifdef DEBUG
3215	WriteLog("USER32: %s\n", lpOut);
3216	#endif
3217	FreeAsciiString(lpFmtA);
3218	return(rc);
3219	}
3220	//******************************************************************************
3221	//No need to support this
3222	//******************************************************************************
3223	BOOL WIN32API SetMessageQueue(int cMessagesMax)
3224	{
3225	#ifdef DEBUG
3226	WriteLog("USER32: SetMessageQueue\n");
3227	#endif
3228	return(TRUE);
3229	}
3230	//******************************************************************************
3231	//TODO: Not complete
3232	//******************************************************************************
3233	BOOL WIN32API GetScrollInfo(HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
3234	{
3235	#ifdef DEBUG
3236	WriteLog("USER32: GetScrollInfo\n");
3237	#endif
3238	if(lpsi == NULL)
3239	return(FALSE);
3240
3241	if(lpsi->fMask & SIF_POS)
3242	lpsi->nPos = GetScrollPos(hwnd, fnBar);
3243	if(lpsi->fMask & SIF_RANGE)
3244	GetScrollRange(hwnd, fnBar, &lpsi->nMin, &lpsi->nMax);
3245	if(lpsi->fMask & SIF_PAGE) {
3246	#ifdef DEBUG
3247	WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3248	#endif
3249	lpsi->nPage = 25;
3250	}
3251	return(TRUE);
3252	}
3253	//******************************************************************************
3254	//TODO: Not complete
3255	//******************************************************************************
3256	INT WIN32API SetScrollInfo(HWND hwnd, INT fnBar, const SCROLLINFO *lpsi, BOOL fRedraw)
3257	{
3258	int smin, smax;
3259
3260	#ifdef DEBUG
3261	WriteLog("USER32: SetScrollInfo\n");
3262	#endif
3263	if(lpsi == NULL)
3264	return(FALSE);
3265
3266	if(lpsi->fMask & SIF_POS)
3267	SetScrollPos(hwnd, fnBar, lpsi->nPos, fRedraw);
3268	if(lpsi->fMask & SIF_RANGE)
3269	SetScrollRange(hwnd, fnBar, lpsi->nMin, lpsi->nMax, fRedraw);
3270	if(lpsi->fMask & SIF_PAGE) {
3271	#ifdef DEBUG
3272	WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3273	#endif
3274	}
3275	if(lpsi->fMask & SIF_DISABLENOSCROLL) {
3276	#ifdef DEBUG
3277	WriteLog("USER32: GetScrollInfo, disable scrollbar not yet implemented\n");
3278	#endif
3279	}
3280	return(TRUE);
3281	}
3282	//******************************************************************************
3283	//******************************************************************************
3284	BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3285	LPARAM lpData, int nCount, int X, int Y, int nWidth,
3286	int nHeight)
3287	{
3288	BOOL rc;
3289	COLORREF curclr;
3290
3291	#ifdef DEBUG
3292	WriteLog("USER32: GrayStringA, not completely implemented\n");
3293	#endif
3294	if(lpOutputFunc == NULL && lpData == NULL) {
3295	#ifdef DEBUG
3296	WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3297	#endif
3298	return(FALSE);
3299	}
3300	if(lpOutputFunc) {
3301	return(lpOutputFunc(hdc, lpData, nCount));
3302	}
3303	curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3304	rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
3305	SetTextColor(hdc, curclr);
3306
3307	return(rc);
3308	}
3309	//******************************************************************************
3310	//******************************************************************************
3311	BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3312	LPARAM lpData, int nCount, int X, int Y, int nWidth,
3313	int nHeight)
3314	{
3315	BOOL rc;
3316	char *astring;
3317	COLORREF curclr;
3318
3319	#ifdef DEBUG
3320	WriteLog("USER32: GrayStringW, not completely implemented\n");
3321	#endif
3322
3323	if(lpOutputFunc == NULL && lpData == NULL) {
3324	#ifdef DEBUG
3325	WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3326	#endif
3327	return(FALSE);
3328	}
3329	if(nCount == 0)
3330	nCount = UniStrlen((UniChar*)lpData);
3331
3332	if(lpOutputFunc) {
3333	return(lpOutputFunc(hdc, lpData, nCount));
3334	}
3335	astring = UnicodeToAsciiString((LPWSTR)lpData);
3336
3337	curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3338	rc = TextOutA(hdc, X, Y, astring, nCount);
3339	SetTextColor(hdc, curclr);
3340
3341	FreeAsciiString(astring);
3342	return(rc);
3343	}
3344	//******************************************************************************
3345	//TODO:
3346	//******************************************************************************
3347	int WIN32API CopyAcceleratorTableA(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3348	int cAccelEntries)
3349	{
3350	#ifdef DEBUG
3351	WriteLog("USER32: CopyAcceleratorTableA, not implemented\n");
3352	#endif
3353	return(0);
3354	}
3355	//******************************************************************************
3356	//TODO:
3357	//******************************************************************************
3358	int WIN32API CopyAcceleratorTableW(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3359	int cAccelEntries)
3360	{
3361	#ifdef DEBUG
3362	WriteLog("USER32: CopyAcceleratorTableW, not implemented\n");
3363	#endif
3364	return(0);
3365	}
3366	//******************************************************************************
3367	//Stolen from Wine (controls\uitools.c)
3368	//******************************************************************************
3369	BOOL DrawEdgeDiag(HDC hdc, RECT *rect, UINT edge, UINT flags)
3370	{
3371	HPEN facePen, shadowPen, lightPen, blackPen, grayPen, nullPen;
3372	HPEN iPen, oPen, oldPen;
3373	HBRUSH oldBrush, faceBrush;
3374	int cl, cr, ct, cb;
3375	BOOL mainDiag;
3376	POINT tp;
3377	RECT r;
3378
3379	/* If both rasied and sunken is specified, they anihilate one another */
3380	if( !((flags & BF_MONO) \|\| (flags & BF_FLAT)) ){
3381	if( (edge & BDR_RAISEDOUTER) && (edge & BDR_SUNKENOUTER) )
3382	return FALSE;
3383	if( (edge & BDR_RAISEDINNER) && (edge & BDR_SUNKENINNER) )
3384	return FALSE;
3385	}
3386
3387	/* Create/get the tools of the trade... */
3388	facePen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNFACE));
3389	shadowPen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNSHADOW));
3390	lightPen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNHILIGHT));
3391	grayPen = CreatePen(PS_SOLID, 0, RGB(168, 152, 144));
3392	blackPen = GetStockObject(BLACK_PEN);
3393	nullPen = GetStockObject(NULL_PEN);
3394	faceBrush = GetSysColorBrush(COLOR_BTNFACE);
3395	oldPen = SelectObject(hdc, nullPen);
3396	oldBrush = SelectObject(hdc, faceBrush);
3397
3398	/* this is my working rectangle */
3399	r = *rect;
3400
3401	if(flags & BF_MONO){
3402	oPen = blackPen;
3403	iPen = nullPen;
3404	}else if(flags & BF_FLAT){
3405	oPen = shadowPen;
3406	iPen = facePen;
3407	}else {
3408	if(flags & BF_SOFT){
3409	if(flags & BF_BOTTOM){
3410	oPen = (edge & BDR_RAISEDOUTER) ? blackPen : lightPen;
3411	iPen = (edge & BDR_RAISEDINNER) ? shadowPen : grayPen;
3412	}
3413	else{
3414	oPen = (edge & BDR_RAISEDOUTER) ? lightPen : blackPen;
3415	iPen = (edge & BDR_RAISEDINNER) ? grayPen : shadowPen;
3416	}
3417	}
3418	else{
3419	if(flags & BF_BOTTOM){
3420	oPen = (edge & BDR_RAISEDOUTER) ? blackPen : lightPen;
3421	iPen = (edge & BDR_RAISEDINNER) ? shadowPen : grayPen;
3422	}
3423	else{
3424	oPen = (edge & BDR_RAISEDOUTER) ? grayPen : shadowPen;
3425	iPen = (edge & BDR_RAISEDINNER) ? lightPen : blackPen;
3426	}
3427	}
3428	}
3429
3430	if(flags & BF_BOTTOM){
3431	if(flags & BF_LEFT){
3432	cr = -1; cl = 0;
3433	ct = 0; cb = -1;
3434	mainDiag = TRUE;
3435	tp.x = r.left; tp.y = r.top;
3436	}
3437	else{ /* RIGHT */
3438	cr = -1; cl = 0;
3439	ct = 1; cb = 0;
3440	tp.x = r.left; tp.y = r.bottom-1;
3441	mainDiag = FALSE;
3442	}
3443	}
3444	else{ /* TOP */
3445	if(flags & BF_LEFT){
3446	cr = 0; cl = 1;
3447	ct = 0; cb = -1;
3448	mainDiag = FALSE;
3449	tp.x = r.right; tp.y = r.top;
3450	}
3451	else{ /* RIGHT */
3452	cr = 0; cl = 1;
3453	ct = 1; cb = 0;
3454	tp.x = r.right; tp.y = r.bottom-1;
3455	mainDiag = TRUE;
3456	}
3457	}
3458
3459	/* if it has external edge, draw it */
3460	if(edge & BDR_OUTER){
3461	SelectObject(hdc, oPen);
3462	MoveToEx(hdc, r.left, mainDiag ? r.bottom-1 : r.top, 0);
3463	LineTo(hdc, r.right, mainDiag ? r.top-1 : r.bottom);
3464	r.left += cl; r.right += cr; r.top += ct; r.bottom += cb;
3465	}
3466
3467	/* if it has internal edge, draw it */
3468	if(edge & BDR_INNER){
3469	SelectObject(hdc, iPen);
3470	MoveToEx(hdc, r.left, mainDiag ? r.bottom-1 : r.top, 0);
3471	LineTo(hdc, r.right, mainDiag ? r.top-1 : r.bottom);
3472	r.left += cl; r.right += cr; r.top += ct; r.bottom += cb;
3473	}
3474
3475	if((flags & BF_MIDDLE) && !(flags & BF_MONO)){
3476	POINT p[3];
3477	p[0].x = mainDiag ? r.right: r.left;
3478	p[0].y = r.top;
3479	p[1].x = mainDiag ? r.left : r.right;
3480	p[1].y = r.bottom;
3481	p[2].x = tp.x;
3482	p[2].y = tp.y;
3483	SelectObject(hdc, nullPen);
3484	SelectObject(hdc, faceBrush);
3485	Polygon(hdc, p, 3);
3486	}
3487
3488	if(flags & BF_ADJUST)
3489	*rect = r;
3490
3491	/* Restore the DC */
3492	SelectObject(hdc, oldPen);
3493	SelectObject(hdc, oldBrush);
3494
3495	/* Clean-up */
3496	DeleteObject(facePen);
3497	DeleteObject(shadowPen);
3498	DeleteObject(lightPen);
3499	DeleteObject(grayPen);
3500
3501	return TRUE;
3502	}
3503	//******************************************************************************
3504	//Stolen from Wine (controls\uitools.c)
3505	//******************************************************************************
3506	BOOL WIN32API DrawEdge(HDC hdc, LPRECT rect, UINT edge, UINT flags)
3507	{
3508	HBRUSH faceBrush, shadowBrush, lightBrush, blackBrush, grayBrush, nullBrush;
3509	HBRUSH iNBrush, iSBrush, iEBrush, iWBrush;
3510	HBRUSH oNBrush, oSBrush, oEBrush, oWBrush;
3511	HBRUSH oldBrush;
3512	POINT point[2];
3513	RECT r;
3514
3515	#ifdef DEBUG
3516	WriteLog("USER32: DrawEdge %X %X, partially implemented\n", edge, flags);
3517	WriteLog("USER32: DrawEdge (%d,%d) (%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom);
3518	#endif
3519
3520	if(flags & BF_DIAGONAL) {
3521	return DrawEdgeDiag(hdc, rect, edge, flags);
3522	}
3523	/* If both rasied and sunken is specified, they anihilate one another */
3524	if( !((flags & BF_MONO) \|\| (flags & BF_FLAT)) ){
3525	if( (edge & BDR_RAISEDOUTER) && (edge & BDR_SUNKENOUTER) )
3526	return FALSE;
3527	if( (edge & BDR_RAISEDINNER) && (edge & BDR_SUNKENINNER) )
3528	return FALSE;
3529	}
3530
3531	faceBrush = GetSysColorBrush(COLOR_BTNFACE);
3532	shadowBrush = GetSysColorBrush(COLOR_BTNSHADOW);
3533	lightBrush = GetSysColorBrush(COLOR_BTNHILIGHT);
3534	blackBrush = GetStockObject(BLACK_BRUSH);
3535	grayBrush = GetStockObject(LTGRAY_BRUSH);
3536	nullBrush = GetStockObject(NULL_BRUSH);
3537	oldBrush = SelectObject(hdc, nullBrush);
3538
3539	/* this is my working rectangle */
3540	r = *rect;
3541
3542	if(flags & BF_MONO){
3543	oNBrush = oSBrush = oEBrush = oWBrush = blackBrush;
3544	iNBrush = iSBrush = iEBrush = iWBrush = nullBrush;
3545	}else if(flags & BF_FLAT){
3546	oNBrush = oSBrush = oEBrush = oWBrush = shadowBrush;
3547	iNBrush = iSBrush = iEBrush = iWBrush = faceBrush;
3548	}else {
3549	if(flags & BF_SOFT){
3550	oNBrush = oWBrush = (edge & BDR_RAISEDOUTER) ? lightBrush : blackBrush;
3551	oSBrush = oEBrush = (edge & BDR_RAISEDOUTER) ? blackBrush : lightBrush;
3552	iNBrush = iWBrush = (edge & BDR_RAISEDINNER) ? grayBrush : shadowBrush;
3553	iSBrush = iEBrush = (edge & BDR_RAISEDINNER) ? shadowBrush : grayBrush;
3554	}
3555	else{
3556	oNBrush = oWBrush = (edge & BDR_RAISEDOUTER) ? grayBrush : shadowBrush;
3557	oSBrush = oEBrush = (edge & BDR_RAISEDOUTER) ? blackBrush : lightBrush;
3558	iNBrush = iWBrush = (edge & BDR_RAISEDINNER) ? lightBrush : blackBrush;
3559	iSBrush = iEBrush = (edge & BDR_RAISEDINNER) ? shadowBrush : grayBrush;
3560	}
3561	}
3562
3563	/* if it has external edge, draw it */
3564	if(edge & BDR_OUTER){
3565	if(flags & BF_RIGHT){
3566	SelectObject(hdc, oEBrush);
3567	PatBlt(hdc, r.right-1, r.top, 1, r.bottom - r.top, PATCOPY);
3568	r.right--;
3569	}
3570	if(flags & BF_BOTTOM){
3571	SelectObject(hdc, oSBrush);
3572	PatBlt(hdc, r.left, r.bottom-1, r.right-r.left, 1, PATCOPY);
3573	r.bottom--;
3574	}
3575	if(flags & BF_LEFT){
3576	SelectObject(hdc, oWBrush);
3577	PatBlt(hdc, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
3578	r.left++;
3579	}
3580	if(flags & BF_TOP){
3581	SelectObject(hdc, oNBrush);
3582	PatBlt(hdc, r.left, r.top, r.right-r.left, 1, PATCOPY);
3583	r.top++;
3584	}
3585	}
3586
3587	/* if it has internal edge, draw it */
3588	if(edge & BDR_INNER){
3589	if(flags & BF_RIGHT){
3590	SelectObject(hdc, iEBrush);
3591	PatBlt(hdc, r.right-1, r.top, 1, r.bottom - r.top, PATCOPY);
3592	r.right--;
3593	}
3594	if(flags & BF_BOTTOM){
3595	SelectObject(hdc, iSBrush);
3596	PatBlt(hdc, r.left, r.bottom-1, r.right-r.left, 1, PATCOPY);
3597	r.bottom--;
3598	}
3599	if(flags & BF_LEFT){
3600	SelectObject(hdc, iWBrush);
3601	PatBlt(hdc, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
3602	r.left++;
3603	}
3604	if(flags & BF_TOP){
3605	SelectObject(hdc, iNBrush);
3606	PatBlt(hdc, r.left, r.top, r.right-r.left, 1, PATCOPY);
3607	r.top++;
3608	}
3609	}
3610
3611	/* if we got to fill the middle, to it now */
3612	if((flags & BF_MIDDLE) && !(flags & BF_MONO))
3613	FillRect(hdc, &r, faceBrush);
3614
3615	/* adjust the rectangle if required */
3616	if(flags & BF_ADJUST)
3617	*rect = r;
3618
3619	/* Restore the DC */
3620	SelectObject(hdc, oldBrush);
3621
3622	return TRUE;
3623	}
3624	//******************************************************************************
3625	//******************************************************************************
3626	LRESULT WIN32API SendMessageTimeoutA(HWND hwnd, UINT Msg, WPARAM wParam,
3627	LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3628	LPDWORD lpdwResult)
3629	{
3630	#ifdef DEBUG
3631	WriteLog("USER32: SendMessageTimeoutA, partially implemented\n");
3632	#endif
3633	//ignore fuFlags & wTimeOut
3634	*lpdwResult = SendMessageA(hwnd, Msg, wParam, lParam);
3635	return(TRUE);
3636	}
3637	//******************************************************************************
3638	//******************************************************************************
3639	LRESULT WIN32API SendMessageTimeoutW(HWND hwnd, UINT Msg, WPARAM wParam,
3640	LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3641	LPDWORD lpdwResult)
3642	{
3643	#ifdef DEBUG
3644	WriteLog("USER32: SendMessageTimeoutW, partially implemented\n");
3645	#endif
3646	return(SendMessageTimeoutA(hwnd, Msg, wParam, lParam, fuFlags, uTimeOut, lpdwResult));
3647	}
3648	//******************************************************************************
3649	//******************************************************************************
3650	HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
3651	{
3652	#ifdef DEBUG
3653	WriteLog("USER32: CopyImage, not implemented\n");
3654	#endif
3655	switch(uType) {
3656	case IMAGE_BITMAP:
3657	case IMAGE_CURSOR:
3658	case IMAGE_ICON:
3659	default:
3660	#ifdef DEBUG
3661	WriteLog("USER32: CopyImage, unknown type\n");
3662	#endif
3663	return(NULL);
3664	}
3665	return(NULL);
3666	}
3667	//******************************************************************************
3668	//******************************************************************************
3669	BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
3670	{
3671	#ifdef DEBUG
3672	WriteLog("USER32: GetKeyboardState, not properly implemented\n");
3673	#endif
3674	memset(lpKeyState, 0, 256);
3675	return(TRUE);
3676	}
3677	//******************************************************************************
3678	//******************************************************************************
3679	BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
3680	{
3681	#ifdef DEBUG
3682	WriteLog("USER32: SetKeyboardState, not implemented\n");
3683	#endif
3684	return(TRUE);
3685	}
3686	//******************************************************************************
3687	//******************************************************************************
3688	BOOL WIN32API DrawFrameControl(HDC hdc, LPRECT lprc, UINT uType, UINT uState)
3689	{
3690	#ifdef DEBUG
3691	WriteLog("USER32: DrawFrameControl, not implemented\n");
3692	#endif
3693	return(TRUE);
3694	}
3695	//******************************************************************************
3696	//******************************************************************************
3697	BOOL WIN32API SendNotifyMessageA(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3698	{
3699	#ifdef DEBUG
3700	WriteLog("USER32: SendNotifyMessageA, not completely implemented\n");
3701	#endif
3702	return(SendMessageA(hwnd, Msg, wParam, lParam));
3703	}
3704	//******************************************************************************
3705	//******************************************************************************
3706	BOOL WIN32API SendNotifyMessageW(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3707	{
3708	#ifdef DEBUG
3709	WriteLog("USER32: SendNotifyMessageW, not completely implemented\n");
3710	#endif
3711	return(SendMessageA(hwnd, Msg, wParam, lParam));
3712	}
3713	//******************************************************************************
3714	//2nd parameter not used according to SDK (yet?)
3715	//******************************************************************************
3716	VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
3717	{
3718	#ifdef DEBUG
3719	WriteLog("USER32: SetLastErrorEx\n");
3720	#endif
3721	SetLastError(dwErrCode);
3722	}
3723	//******************************************************************************
3724	//******************************************************************************
3725	LPARAM WIN32API SetMessageExtraInfo(LPARAM lParam)
3726	{
3727	#ifdef DEBUG
3728	WriteLog("USER32: SetMessageExtraInfo, not implemented\n");
3729	#endif
3730	return(0);
3731	}
3732	//******************************************************************************
3733	//******************************************************************************
3734	BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
3735	{
3736	#ifdef DEBUG
3737	WriteLog("USER32: ActivateKeyboardLayout, not implemented\n");
3738	#endif
3739	return(TRUE);
3740	}
3741	//******************************************************************************
3742	//******************************************************************************
3743	int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
3744	{
3745	#ifdef DEBUG
3746	WriteLog("USER32: GetKeyboardLayoutList, not implemented\n");
3747	#endif
3748	return(0);
3749	}
3750	//******************************************************************************
3751	//******************************************************************************
3752	HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
3753	{
3754	#ifdef DEBUG
3755	WriteLog("USER32: GetKeyboardLayout, not implemented\n");
3756	#endif
3757	return(0);
3758	}
3759	//******************************************************************************
3760	//******************************************************************************
3761	int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
3762	{
3763	#ifdef DEBUG
3764	WriteLog("USER32: LookupIconIdFromDirectory, not implemented\n");
3765	#endif
3766	return(0);
3767	}
3768	//******************************************************************************
3769	//******************************************************************************
3770	int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL fIcon,
3771	int cxDesired, int cyDesired,
3772	UINT Flags)
3773	{
3774	#ifdef DEBUG
3775	WriteLog("USER32: LookupIconIdFromDirectoryEx, not implemented\n");
3776	#endif
3777	return(0);
3778	}
3779	//******************************************************************************
3780	//DWORD idAttach; /* thread to attach */
3781	//DWORD idAttachTo; /* thread to attach to */
3782	//BOOL fAttach; /* attach or detach */
3783	//******************************************************************************
3784	BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
3785	{
3786	#ifdef DEBUG
3787	WriteLog("USER32: AttachThreadInput, not implemented\n");
3788	#endif
3789	return(TRUE);
3790	}
3791	//******************************************************************************
3792	//******************************************************************************
3793	BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
3794	{
3795	#ifdef DEBUG
3796	WriteLog("USER32: RegisterHotKey, not implemented\n");
3797	#endif
3798	return(TRUE);
3799	}
3800	//******************************************************************************
3801	//******************************************************************************
3802	BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
3803	{
3804	#ifdef DEBUG
3805	WriteLog("USER32: UnregisterHotKey, not implemented\n");
3806	#endif
3807	return(TRUE);
3808	}
3809	//******************************************************************************
3810	//******************************************************************************
3811	BOOL WIN32API DrawStateA(HDC hdc, HBRUSH hbc, DRAWSTATEPROC lpOutputFunc,
3812	LPARAM lData, WPARAM wData, int x, int y, int cx,
3813	int cy, UINT fuFlags)
3814	{
3815	#ifdef DEBUG
3816	WriteLog("USER32: DrawStateA, not implemented\n");
3817	#endif
3818	return(TRUE);
3819	}
3820	//******************************************************************************
3821	//******************************************************************************
3822	//******************************************************************************
3823	//******************************************************************************
3824	BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
3825	{
3826	#ifdef DEBUG
3827	WriteLog("USER32: SetWindowContextHelpId, not implemented\n");
3828	#endif
3829	return(TRUE);
3830	}
3831	//******************************************************************************
3832	//******************************************************************************
3833	DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
3834	{
3835	#ifdef DEBUG
3836	WriteLog("USER32: GetWindowContextHelpId, not implemented\n");
3837	#endif
3838	return(0);
3839	}
3840	//******************************************************************************
3841	//restores iconized window to previous size/position
3842	//******************************************************************************
3843	BOOL WIN32API OpenIcon(HWND hwnd)
3844	{
3845	#ifdef DEBUG
3846	WriteLog("USER32: OpenIcon\n");
3847	#endif
3848	if(!IsIconic(hwnd))
3849	return FALSE;
3850	ShowWindow(hwnd, SW_SHOWNORMAL);
3851	return TRUE;
3852	}
3853	//******************************************************************************
3854	//******************************************************************************
3855	BOOL WIN32API IsWindowUnicode(HWND hwnd)
3856	{
3857	#ifdef DEBUG
3858	WriteLog("USER32: IsWindowUnicode, not implemented\n");
3859	#endif
3860	return(FALSE);
3861	}
3862	//******************************************************************************
3863	//******************************************************************************
3864	BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
3865	{
3866	#ifdef DEBUG
3867	WriteLog("USER32: GetMonitorInfoA not supported!!\n");
3868	#endif
3869	return(FALSE);
3870	}
3871	//******************************************************************************
3872	//******************************************************************************
3873	BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
3874	{
3875	#ifdef DEBUG
3876	WriteLog("USER32: GetMonitorInfoW not supported!!\n");
3877	#endif
3878	return(FALSE);
3879	}
3880	//******************************************************************************
3881	//******************************************************************************
3882	HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
3883	{
3884	#ifdef DEBUG
3885	WriteLog("USER32: MonitorFromWindow not correctly supported??\n");
3886	#endif
3887	return(0);
3888	}
3889	//******************************************************************************
3890	//******************************************************************************
3891	HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
3892	{
3893	#ifdef DEBUG
3894	WriteLog("USER32: MonitorFromRect not correctly supported??\n");
3895	#endif
3896	return(0);
3897	}
3898	//******************************************************************************
3899	//******************************************************************************
3900	HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
3901	{
3902	#ifdef DEBUG
3903	WriteLog("USER32: MonitorFromPoint not correctly supported??\n");
3904	#endif
3905	return(0);
3906	}
3907	//******************************************************************************
3908	//******************************************************************************
3909	BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
3910	{
3911	#ifdef DEBUG
3912	WriteLog("USER32: EnumDisplayMonitors not supported??\n");
3913	#endif
3914	return(FALSE);
3915	}
3916	//******************************************************************************
3917	//******************************************************************************
3918	BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
3919	LPDEVMODEA lpDevMode)
3920	{
3921	#ifdef DEBUG
3922	WriteLog("USER32: EnumDisplaySettingsA FAKED\n");
3923	#endif
3924	switch(iModeNum) {
3925	case 0:
3926	lpDevMode->dmBitsPerPel = 16;
3927	lpDevMode->dmPelsWidth = 768;
3928	lpDevMode->dmPelsHeight = 1024;
3929	lpDevMode->dmDisplayFlags = 0;
3930	lpDevMode->dmDisplayFrequency = 70;
3931	break;
3932	case 1:
3933	lpDevMode->dmBitsPerPel = 16;
3934	lpDevMode->dmPelsWidth = 640;
3935	lpDevMode->dmPelsHeight = 480;
3936	lpDevMode->dmDisplayFlags = 0;
3937	lpDevMode->dmDisplayFrequency = 70;
3938	break;
3939	default:
3940	return(FALSE);
3941	}
3942	return(TRUE);
3943	}
3944	//******************************************************************************
3945	//******************************************************************************
3946	LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA lpDevMode, DWORD dwFlags)
3947	{
3948	#ifdef DEBUG
3949	if(lpDevMode) {
3950	WriteLog("USER32: ChangeDisplaySettingsA FAKED %X\n", dwFlags);
3951	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
3952	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsWidth %d\n", lpDevMode->dmPelsWidth);
3953	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
3954	}
3955	#endif
3956	return(DISP_CHANGE_SUCCESSFUL);
3957	}
3958	//******************************************************************************
3959	//******************************************************************************
3960
3961
3962	/*****************************************************************************
3963	* Name : BOOL WIN32API AnyPopup
3964	* Purpose : The AnyPopup function indicates whether an owned, visible,
3965	* top-level pop-up, or overlapped window exists on the screen. The
3966	* function searches the entire Windows screen, not just the calling
3967	* application's client area.
3968	* Parameters: VOID
3969	* Variables :
3970	* Result : If a pop-up window exists, the return value is TRUE even if the
3971	* pop-up window is completely covered by other windows. Otherwise,
3972	* it is FALSE.
3973	* Remark : AnyPopup is a Windows version 1.x function and is retained for
3974	* compatibility purposes. It is generally not useful.
3975	* Status : UNTESTED STUB
3976	*
3977	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3978	*****************************************************************************/
3979
3980	BOOL WIN32API AnyPopup(VOID)
3981	{
3982	dprintf(("USER32:AnyPopup() not implemented.\n"));
3983
3984	return (FALSE);
3985	}
3986
3987
3988	/*****************************************************************************
3989	* Name : long WIN32API BroadcastSystemMessage
3990	* Purpose : The BroadcastSystemMessage function sends a message to the given
3991	* recipients. The recipients can be applications, installable
3992	* drivers, Windows-based network drivers, system-level device
3993	* drivers, or any combination of these system components.
3994	* Parameters: DWORD dwFlags,
3995	LPDWORD lpdwRecipients,
3996	UINT uiMessage,
3997	WPARAM wParam,
3998	LPARAM lParam
3999	* Variables :
4000	* Result : If the function succeeds, the return value is a positive value.
4001	* If the function is unable to broadcast the message, the return value is -1.
4002	* If the dwFlags parameter is BSF_QUERY and at least one recipient returned FALSE to the corresponding message, the return value is zero.
4003	* Remark :
4004	* Status : UNTESTED STUB
4005	*
4006	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4007	*****************************************************************************/
4008
4009	long WIN32API BroadcastSystemMessage(DWORD dwFlags,
4010	LPDWORD lpdwRecipients,
4011	UINT uiMessage,
4012	WPARAM wParam,
4013	LPARAM lParam)
4014	{
4015	dprintf(("USER32:BroadcastSystemMessage(%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4016	dwFlags,
4017	lpdwRecipients,
4018	uiMessage,
4019	wParam,
4020	lParam));
4021
4022	return (-1);
4023	}
4024
4025
4026	/*****************************************************************************
4027	* Name : WORD WIN32API CascadeWindows
4028	* Purpose : The CascadeWindows function cascades the specified windows or
4029	* the child windows of the specified parent window.
4030	* Parameters: HWND hwndParent handle of parent window
4031	* UINT wHow types of windows not to arrange
4032	* CONST RECT * lpRect rectangle to arrange windows in
4033	* UINT cKids number of windows to arrange
4034	* const HWND FAR * lpKids array of window handles
4035	* Variables :
4036	* Result : If the function succeeds, the return value is the number of windows arranged.
4037	* If the function fails, the return value is zero.
4038	* Remark :
4039	* Status : UNTESTED STUB
4040	*
4041	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4042	*****************************************************************************/
4043
4044	WORD WIN32API CascadeWindows(HWND hwndParent,
4045	UINT wHow,
4046	CONST LPRECT lpRect,
4047	UINT cKids,
4048	const HWND *lpKids)
4049	{
4050	dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
4051	hwndParent,
4052	wHow,
4053	lpRect,
4054	cKids,
4055	lpKids));
4056
4057	return (0);
4058	}
4059
4060
4061	/*****************************************************************************
4062	* Name : LONG WIN32API ChangeDisplaySettingsW
4063	* Purpose : The ChangeDisplaySettings function changes the display settings
4064	* to the specified graphics mode.
4065	* Parameters: LPDEVMODEW lpDevModeW
4066	* DWORD dwFlags
4067	* Variables :
4068	* Result : DISP_CHANGE_SUCCESSFUL The settings change was successful.
4069	* DISP_CHANGE_RESTART The computer must be restarted in order for the graphics mode to work.
4070	* DISP_CHANGE_BADFLAGS An invalid set of flags was passed in.
4071	* DISP_CHANGE_FAILED The display driver failed the specified graphics mode.
4072	* DISP_CHANGE_BADMODE The graphics mode is not supported.
4073	* DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
4074	* Remark :
4075	* Status : UNTESTED STUB
4076	*
4077	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4078	*****************************************************************************/
4079
4080	LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
4081	DWORD dwFlags)
4082	{
4083	dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
4084	lpDevMode,
4085	dwFlags));
4086
4087	return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
4088	dwFlags));
4089	}
4090
4091	/*****************************************************************************
4092	* Name : BOOL WIN32API CloseDesktop
4093	* Purpose : The CloseDesktop function closes an open handle of a desktop
4094	* object. A desktop is a secure object contained within a window
4095	* station object. A desktop has a logical display surface and
4096	* contains windows, menus and hooks.
4097	* Parameters: HDESK hDesktop
4098	* Variables :
4099	* Result : If the function succeeds, the return value is TRUE.
4100	* If the functions fails, the return value is FALSE. To get
4101	* extended error information, call GetLastError.
4102	* Remark :
4103	* Status : UNTESTED STUB
4104	*
4105	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4106	*****************************************************************************/
4107
4108	BOOL WIN32API CloseDesktop(HDESK hDesktop)
4109	{
4110	dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
4111	hDesktop));
4112
4113	return (FALSE);
4114	}
4115
4116
4117	/*****************************************************************************
4118	* Name : BOOL WIN32API CloseWindowStation
4119	* Purpose : The CloseWindowStation function closes an open window station handle.
4120	* Parameters: HWINSTA hWinSta
4121	* Variables :
4122	* Result :
4123	* Remark : If the function succeeds, the return value is TRUE.
4124	* If the functions fails, the return value is FALSE. To get
4125	* extended error information, call GetLastError.
4126	* Status : UNTESTED STUB
4127	*
4128	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4129	*****************************************************************************/
4130
4131	BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
4132	{
4133	dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
4134	hWinSta));
4135
4136	return (FALSE);
4137	}
4138
4139
4140	/*****************************************************************************
4141	* Name : HDESK WIN32API CreateDesktopA
4142	* Purpose : The CreateDesktop function creates a new desktop on the window
4143	* station associated with the calling process.
4144	* Parameters: LPCTSTR lpszDesktop name of the new desktop
4145	* LPCTSTR lpszDevice name of display device to assign to the desktop
4146	* LPDEVMODE pDevMode reserved; must be NULL
4147	* DWORD dwFlags flags to control interaction with other applications
4148	* DWORD dwDesiredAccess specifies access of returned handle
4149	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
4150	* Variables :
4151	* Result : If the function succeeds, the return value is a handle of the
4152	* newly created desktop.
4153	* If the function fails, the return value is NULL. To get extended
4154	* error information, call GetLastError.
4155	* Remark :
4156	* Status : UNTESTED STUB
4157	*
4158	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4159	*****************************************************************************/
4160
4161	HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
4162	LPCTSTR lpszDevice,
4163	LPDEVMODEA pDevMode,
4164	DWORD dwFlags,
4165	DWORD dwDesiredAccess,
4166	LPSECURITY_ATTRIBUTES lpsa)
4167	{
4168	dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4169	lpszDesktop,
4170	lpszDevice,
4171	pDevMode,
4172	dwFlags,
4173	dwDesiredAccess,
4174	lpsa));
4175
4176	return (NULL);
4177	}
4178
4179
4180	/*****************************************************************************
4181	* Name : HDESK WIN32API CreateDesktopW
4182	* Purpose : The CreateDesktop function creates a new desktop on the window
4183	* station associated with the calling process.
4184	* Parameters: LPCTSTR lpszDesktop name of the new desktop
4185	* LPCTSTR lpszDevice name of display device to assign to the desktop
4186	* LPDEVMODE pDevMode reserved; must be NULL
4187	* DWORD dwFlags flags to control interaction with other applications
4188	* DWORD dwDesiredAccess specifies access of returned handle
4189	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
4190	* Variables :
4191	* Result : If the function succeeds, the return value is a handle of the
4192	* newly created desktop.
4193	* If the function fails, the return value is NULL. To get extended
4194	* error information, call GetLastError.
4195	* Remark :
4196	* Status : UNTESTED STUB
4197	*
4198	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4199	*****************************************************************************/
4200
4201	HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
4202	LPCTSTR lpszDevice,
4203	LPDEVMODEW pDevMode,
4204	DWORD dwFlags,
4205	DWORD dwDesiredAccess,
4206	LPSECURITY_ATTRIBUTES lpsa)
4207	{
4208	dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4209	lpszDesktop,
4210	lpszDevice,
4211	pDevMode,
4212	dwFlags,
4213	dwDesiredAccess,
4214	lpsa));
4215
4216	return (NULL);
4217	}
4218
4219
4220	/*****************************************************************************
4221	* Name : HWINSTA WIN32API CreateWindowStationA
4222	* Purpose : The CreateWindowStation function creates a window station object.
4223	* It returns a handle that can be used to access the window station.
4224	* A window station is a secure object that contains a set of global
4225	* atoms, a clipboard, and a set of desktop objects.
4226	* Parameters: LPTSTR lpwinsta name of the new window station
4227	* DWORD dwReserved reserved; must be NULL
4228	* DWORD dwDesiredAccess specifies access of returned handle
4229	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4230	* Variables :
4231	* Result : If the function succeeds, the return value is the handle to the
4232	* newly created window station.
4233	* If the function fails, the return value is NULL. To get extended
4234	* error information, call GetLastError.
4235	* Remark :
4236	* Status : UNTESTED STUB
4237	*
4238	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4239	*****************************************************************************/
4240
4241	HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
4242	DWORD dwReserved,
4243	DWORD dwDesiredAccess,
4244	LPSECURITY_ATTRIBUTES lpsa)
4245	{
4246	dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
4247	lpWinSta,
4248	dwReserved,
4249	dwDesiredAccess,
4250	lpsa));
4251
4252	return (NULL);
4253	}
4254
4255
4256	/*****************************************************************************
4257	* Name : HWINSTA WIN32API CreateWindowStationW
4258	* Purpose : The CreateWindowStation function creates a window station object.
4259	* It returns a handle that can be used to access the window station.
4260	* A window station is a secure object that contains a set of global
4261	* atoms, a clipboard, and a set of desktop objects.
4262	* Parameters: LPTSTR lpwinsta name of the new window station
4263	* DWORD dwReserved reserved; must be NULL
4264	* DWORD dwDesiredAccess specifies access of returned handle
4265	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4266	* Variables :
4267	* Result : If the function succeeds, the return value is the handle to the
4268	* newly created window station.
4269	* If the function fails, the return value is NULL. To get extended
4270	* error information, call GetLastError.
4271	* Remark :
4272	* Status : UNTESTED STUB
4273	*
4274	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4275	*****************************************************************************/
4276
4277	HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
4278	DWORD dwReserved,
4279	DWORD dwDesiredAccess,
4280	LPSECURITY_ATTRIBUTES lpsa)
4281	{
4282	dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
4283	lpWinSta,
4284	dwReserved,
4285	dwDesiredAccess,
4286	lpsa));
4287
4288	return (NULL);
4289	}
4290
4291	/*****************************************************************************
4292	* Name : BOOL WIN32API DragDetect
4293	* Purpose : The DragDetect function captures the mouse and tracks its movement
4294	* Parameters: HWND hwnd
4295	* POINT pt
4296	* Variables :
4297	* Result : If the user moved the mouse outside of the drag rectangle while
4298	* holding the left button down, the return value is TRUE.
4299	* If the user did not move the mouse outside of the drag rectangle
4300	* while holding the left button down, the return value is FALSE.
4301	* Remark :
4302	* Status : UNTESTED STUB
4303	*
4304	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4305	*****************************************************************************/
4306
4307	BOOL WIN32API DragDetect(HWND hwnd,
4308	POINT pt)
4309	{
4310	dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
4311	hwnd));
4312
4313	return (FALSE);
4314	}
4315
4316
4317	/*****************************************************************************
4318	* Name : BOOL WIN32API DrawAnimatedRects
4319	* Purpose : The DrawAnimatedRects function draws a wire-frame rectangle
4320	* and animates it to indicate the opening of an icon or the
4321	* minimizing or maximizing of a window.
4322	* Parameters: HWND hwnd handle of clipping window
4323	* int idAni type of animation
4324	* CONST RECT * lprcFrom address of rectangle coordinates (minimized)
4325	* CONST RECT * lprcTo address of rectangle coordinates (restored)
4326	* Variables :
4327	* Result : If the function succeeds, the return value is TRUE.
4328	* If the function fails, the return value is FALSE.
4329	* Remark :
4330	* Status : UNTESTED STUB
4331	*
4332	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4333	*****************************************************************************/
4334
4335	BOOL WIN32API DrawAnimatedRects(HWND hwnd,
4336	int idAni,
4337	CONST RECT *lprcFrom,
4338	CONST RECT *lprcTo)
4339	{
4340	dprintf(("USER32:DrawAnimatedRects (%08xh,%u,%08xh,%08x) not implemented.\n",
4341	hwnd,
4342	idAni,
4343	lprcFrom,
4344	lprcTo));
4345
4346	return (TRUE);
4347	}
4348
4349
4350	/*****************************************************************************
4351	* Name : VOID WIN32API DrawCaption
4352	* Purpose : The DrawCaption function draws a window caption.
4353	* Parameters: HDC hdc handle of device context
4354	* LPRECT lprc address of bounding rectangle coordinates
4355	* HFONT hfont handle of font for caption
4356	* HICON hicon handle of icon in caption
4357	* LPSTR lpszText address of caption string
4358	* WORD wFlags drawing options
4359	* Variables :
4360	* Result :
4361	* Remark :
4362	* Status : UNTESTED STUB
4363	*
4364	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4365	*****************************************************************************/
4366
4367	BOOL WIN32API DrawCaption (HWND hwnd,
4368	HDC hdc,
4369	const RECT *lprc,
4370	UINT wFlags)
4371	{
4372	dprintf(("USER32:DrawCaption (%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4373	hwnd,
4374	hdc,
4375	lprc,
4376	wFlags));
4377
4378	return FALSE;
4379	}
4380
4381
4382	/*****************************************************************************
4383	* Name :
4384	* Purpose :
4385	* Parameters:
4386	* Variables :
4387	* Result :
4388	* Remark :
4389	* Status : UNTESTED STUB
4390	*
4391	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4392	*****************************************************************************/
4393
4394	BOOL WIN32API DrawStateW(HDC hdc,
4395	HBRUSH hBrush,
4396	DRAWSTATEPROC lpOutputFunc,
4397	LPARAM lParam,
4398	WPARAM wParam,
4399	int x,
4400	int y,
4401	int cx,
4402	int cy,
4403	UINT fuFlags)
4404	{
4405	dprintf(("USER32:DrawStateW (%08xh,%08xh,%08xh,%08xh,%08xh,%d,%d,%d,%d,%08x) not implemented.\n",
4406	hdc,
4407	hBrush,
4408	lpOutputFunc,
4409	lParam,
4410	wParam,
4411	x,
4412	y,
4413	cx,
4414	cy,
4415	fuFlags));
4416
4417	return(DrawStateA(hdc,
4418	hBrush,
4419	lpOutputFunc,
4420	lParam,
4421	wParam,
4422	x,
4423	y,
4424	cx,
4425	cy,
4426	fuFlags));
4427	}
4428
4429
4430	/*****************************************************************************
4431	* Name : BOOL WIN32API EnumDesktopWindows
4432	* Purpose : The EnumDesktopWindows function enumerates all windows in a
4433	* desktop by passing the handle of each window, in turn, to an
4434	* application-defined callback function.
4435	* Parameters: HDESK hDesktop handle of desktop to enumerate
4436	* WNDENUMPROC lpfn points to application's callback function
4437	* LPARAM lParam 32-bit value to pass to the callback function
4438	* Variables :
4439	* Result : If the function succeeds, the return value is TRUE.
4440	* If the function fails, the return value is FALSE. To get
4441	* extended error information, call GetLastError.
4442	* Remark :
4443	* Status : UNTESTED STUB
4444	*
4445	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4446	*****************************************************************************/
4447
4448	BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
4449	WNDENUMPROC lpfn,
4450	LPARAM lParam)
4451	{
4452	dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
4453	hDesktop,
4454	lpfn,
4455	lParam));
4456
4457	return (FALSE);
4458	}
4459
4460
4461	/*****************************************************************************
4462	* Name : BOOL WIN32API EnumDesktopsA
4463	* Purpose : The EnumDesktops function enumerates all desktops in the window
4464	* station assigned to the calling process. The function does so by
4465	* passing the name of each desktop, in turn, to an application-
4466	* defined callback function.
4467	* Parameters: HWINSTA hwinsta handle of window station to enumerate
4468	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
4469	* LPARAM lParam 32-bit value to pass to the callback function
4470	* Variables :
4471	* Result : If the function succeeds, the return value is TRUE.
4472	* If the function fails, the return value is FALSE. To get extended
4473	* error information, call GetLastError.
4474	* Remark :
4475	* Status : UNTESTED STUB
4476	*
4477	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4478	*****************************************************************************/
4479
4480	BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
4481	DESKTOPENUMPROCA lpEnumFunc,
4482	LPARAM lParam)
4483	{
4484	dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
4485	hWinSta,
4486	lpEnumFunc,
4487	lParam));
4488
4489	return (FALSE);
4490	}
4491
4492
4493	/*****************************************************************************
4494	* Name : BOOL WIN32API EnumDesktopsW
4495	* Purpose : The EnumDesktops function enumerates all desktops in the window
4496	* station assigned to the calling process. The function does so by
4497	* passing the name of each desktop, in turn, to an application-
4498	* defined callback function.
4499	* Parameters: HWINSTA hwinsta handle of window station to enumerate
4500	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
4501	* LPARAM lParam 32-bit value to pass to the callback function
4502	* Variables :
4503	* Result : If the function succeeds, the return value is TRUE.
4504	* If the function fails, the return value is FALSE. To get extended
4505	* error information, call GetLastError.
4506	* Remark :
4507	* Status : UNTESTED STUB
4508	*
4509	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4510	*****************************************************************************/
4511
4512	BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
4513	DESKTOPENUMPROCW lpEnumFunc,
4514	LPARAM lParam)
4515	{
4516	dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
4517	hWinSta,
4518	lpEnumFunc,
4519	lParam));
4520
4521	return (FALSE);
4522	}
4523
4524
4525
4526	/*****************************************************************************
4527	* Name : BOOL WIN32API EnumDisplaySettingsW
4528	* Purpose : The EnumDisplaySettings function obtains information about one
4529	* of a display device's graphics modes. You can obtain information
4530	* for all of a display device's graphics modes by making a series
4531	* of calls to this function.
4532	* Parameters: LPCTSTR lpszDeviceName specifies the display device
4533	* DWORD iModeNum specifies the graphics mode
4534	* LPDEVMODE lpDevMode points to structure to receive settings
4535	* Variables :
4536	* Result : If the function succeeds, the return value is TRUE.
4537	* If the function fails, the return value is FALSE.
4538	* Remark :
4539	* Status : UNTESTED STUB
4540	*
4541	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4542	*****************************************************************************/
4543
4544	BOOL WIN32API EnumDisplaySettingsW(LPCSTR lpszDeviceName,
4545	DWORD iModeNum,
4546	LPDEVMODEW lpDevMode)
4547	{
4548	dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
4549	lpszDeviceName,
4550	iModeNum,
4551	lpDevMode));
4552
4553	return (EnumDisplaySettingsA(lpszDeviceName,
4554	iModeNum,
4555	(LPDEVMODEA)lpDevMode));
4556	}
4557
4558
4559	/*****************************************************************************
4560	* Name : BOOL WIN32API EnumWindowStationsA
4561	* Purpose : The EnumWindowStations function enumerates all windowstations
4562	* in the system by passing the name of each window station, in
4563	* turn, to an application-defined callback function.
4564	* Parameters:
4565	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4566	* LPARAM lParam 32-bit value to pass to the callback function
4567	* Result : If the function succeeds, the return value is TRUE.
4568	* If the function fails the return value is FALSE. To get extended
4569	* error information, call GetLastError.
4570	* Remark :
4571	* Status : UNTESTED STUB
4572	*
4573	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4574	*****************************************************************************/
4575
4576	BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
4577	LPARAM lParam)
4578	{
4579	dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
4580	lpEnumFunc,
4581	lParam));
4582
4583	return (FALSE);
4584	}
4585
4586
4587	/*****************************************************************************
4588	* Name : BOOL WIN32API EnumWindowStationsW
4589	* Purpose : The EnumWindowStations function enumerates all windowstations
4590	* in the system by passing the name of each window station, in
4591	* turn, to an application-defined callback function.
4592	* Parameters:
4593	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4594	* LPARAM lParam 32-bit value to pass to the callback function
4595	* Result : If the function succeeds, the return value is TRUE.
4596	* If the function fails the return value is FALSE. To get extended
4597	* error information, call GetLastError.
4598	* Remark :
4599	* Status : UNTESTED STUB
4600	*
4601	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4602	*****************************************************************************/
4603
4604	BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
4605	LPARAM lParam)
4606	{
4607	dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
4608	lpEnumFunc,
4609	lParam));
4610
4611	return (FALSE);
4612	}
4613
4614
4615	/*****************************************************************************
4616	* Name : HWND WIN32API FindWindowExW
4617	* Purpose : The FindWindowEx function retrieves the handle of a window whose
4618	* class name and window name match the specified strings. The
4619	* function searches child windows, beginning with the one following
4620	* the given child window.
4621	* Parameters: HWND hwndParent handle of parent window
4622	* HWND hwndChildAfter handle of a child window
4623	* LPCTSTR lpszClass address of class name
4624	* LPCTSTR lpszWindow address of window name
4625	* Variables :
4626	* Result : If the function succeeds, the return value is the handle of the
4627	* window that has the specified class and window names.
4628	* If the function fails, the return value is NULL. To get extended
4629	* error information, call GetLastError.
4630	* Remark :
4631	* Status : UNTESTED STUB
4632	*
4633	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4634	*****************************************************************************/
4635
4636	HWND WIN32API FindWindowExW(HWND hwndParent,
4637	HWND hwndChildAfter,
4638	LPCWSTR lpszClass,
4639	LPCWSTR lpszWindow)
4640	{
4641	dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
4642	hwndParent,
4643	hwndChildAfter,
4644	lpszClass,
4645	lpszWindow));
4646
4647	return (NULL);
4648	}
4649
4650	/*****************************************************************************
4651	* Name : BOOL WIN32API GetInputState
4652	* Purpose : The GetInputState function determines whether there are
4653	* mouse-button or keyboard messages in the calling thread's message queue.
4654	* Parameters:
4655	* Variables :
4656	* Result : If the queue contains one or more new mouse-button or keyboard
4657	* messages, the return value is TRUE.
4658	* If the function fails, the return value is FALSE.
4659	* Remark :
4660	* Status : UNTESTED STUB
4661	*
4662	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4663	*****************************************************************************/
4664
4665	BOOL WIN32API GetInputState(VOID)
4666	{
4667	dprintf(("USER32:GetInputState () not implemented.\n"));
4668
4669	return (FALSE);
4670	}
4671
4672
4673	/*****************************************************************************
4674	* Name : UINT WIN32API GetKBCodePage
4675	* Purpose : The GetKBCodePage function is provided for compatibility with
4676	* earlier versions of Windows. In the Win32 application programming
4677	* interface (API) it just calls the GetOEMCP function.
4678	* Parameters:
4679	* Variables :
4680	* Result : If the function succeeds, the return value is an OEM code-page
4681	* identifier, or it is the default identifier if the registry
4682	* value is not readable. For a list of OEM code-page identifiers,
4683	* see GetOEMCP.
4684	* Remark :
4685	* Status : UNTESTED
4686	*
4687	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4688	*****************************************************************************/
4689
4690	UINT WIN32API GetKBCodePage(VOID)
4691	{
4692	return (GetOEMCP());
4693	}
4694
4695
4696	/*****************************************************************************
4697	* Name : BOOL WIN32API GetKeyboardLayoutNameA
4698	* Purpose : The GetKeyboardLayoutName function retrieves the name of the
4699	* active keyboard layout.
4700	* Parameters: LPTSTR pwszKLID address of buffer for layout name
4701	* Variables :
4702	* Result : If the function succeeds, the return value is TRUE.
4703	* If the function fails, the return value is FALSE. To get extended
4704	* error information, call GetLastError.
4705	* Remark :
4706	* Status : UNTESTED STUB
4707	*
4708	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4709	*****************************************************************************/
4710
4711	BOOL WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
4712	{
4713	dprintf(("USER32:GetKeyboardLayoutNameA (%08x) not implemented.",
4714	pwszKLID));
4715
4716	return(FALSE);
4717	}
4718
4719
4720	/*****************************************************************************
4721	* Name : BOOL WIN32API GetKeyboardLayoutNameW
4722	* Purpose : The GetKeyboardLayoutName function retrieves the name of the
4723	* active keyboard layout.
4724	* Parameters: LPTSTR pwszKLID address of buffer for layout name
4725	* Variables :
4726	* Result : If the function succeeds, the return value is TRUE.
4727	* If the function fails, the return value is FALSE. To get extended
4728	* error information, call GetLastError.
4729	* Remark :
4730	* Status : UNTESTED STUB
4731	*
4732	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4733	*****************************************************************************/
4734
4735	BOOL WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
4736	{
4737	dprintf(("USER32:GetKeyboardLayoutNameW (%08x) not implemented.",
4738	pwszKLID));
4739
4740	return(FALSE);
4741	}
4742
4743
4744
4745
4746	/*****************************************************************************
4747	* Name : HWINSTA WIN32API GetProcessWindowStation
4748	* Purpose : The GetProcessWindowStation function returns a handle of the
4749	* window station associated with the calling process.
4750	* Parameters:
4751	* Variables :
4752	* Result : If the function succeeds, the return value is a handle of the
4753	* window station associated with the calling process.
4754	* If the function fails, the return value is NULL. This can occur
4755	* if the calling process is not an application written for Windows
4756	* NT. To get extended error information, call GetLastError.
4757	* Remark :
4758	* Status : UNTESTED STUB
4759	*
4760	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4761	*****************************************************************************/
4762
4763	HWINSTA WIN32API GetProcessWindowStation(VOID)
4764	{
4765	dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
4766
4767	return (NULL);
4768	}
4769
4770
4771
4772	/*****************************************************************************
4773	* Name : HDESK WIN32API GetThreadDesktop
4774	* Purpose : The GetThreadDesktop function returns a handle to the desktop
4775	* associated with a specified thread.
4776	* Parameters: DWORD dwThreadId thread identifier
4777	* Variables :
4778	* Result : If the function succeeds, the return value is the handle of the
4779	* desktop associated with the specified thread.
4780	* Remark :
4781	* Status : UNTESTED STUB
4782	*
4783	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4784	*****************************************************************************/
4785
4786	HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
4787	{
4788	dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
4789	dwThreadId));
4790
4791	return (NULL);
4792	}
4793
4794
4795	/*****************************************************************************
4796	* Name : BOOL WIN32API GetUserObjectInformationA
4797	* Purpose : The GetUserObjectInformation function returns information about
4798	* a window station or desktop object.
4799	* Parameters: HANDLE hObj handle of object to get information for
4800	* int nIndex type of information to get
4801	* PVOID pvInfo points to buffer that receives the information
4802	* DWORD nLength size, in bytes, of pvInfo buffer
4803	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4804	* Variables :
4805	* Result : If the function succeeds, the return value is TRUE.
4806	* If the function fails, the return value is FALSE. To get extended
4807	* error information, call GetLastError.
4808	* Remark :
4809	* Status : UNTESTED STUB
4810	*
4811	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4812	*****************************************************************************/
4813
4814	BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
4815	int nIndex,
4816	PVOID pvInfo,
4817	DWORD nLength,
4818	LPDWORD lpnLengthNeeded)
4819	{
4820	dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4821	hObj,
4822	nIndex,
4823	pvInfo,
4824	nLength,
4825	lpnLengthNeeded));
4826
4827	return (FALSE);
4828	}
4829
4830
4831	/*****************************************************************************
4832	* Name : BOOL WIN32API GetUserObjectInformationW
4833	* Purpose : The GetUserObjectInformation function returns information about
4834	* a window station or desktop object.
4835	* Parameters: HANDLE hObj handle of object to get information for
4836	* int nIndex type of information to get
4837	* PVOID pvInfo points to buffer that receives the information
4838	* DWORD nLength size, in bytes, of pvInfo buffer
4839	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4840	* Variables :
4841	* Result : If the function succeeds, the return value is TRUE.
4842	* If the function fails, the return value is FALSE. To get extended
4843	* error information, call GetLastError.
4844	* Remark :
4845	* Status : UNTESTED STUB
4846	*
4847	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4848	*****************************************************************************/
4849
4850	BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
4851	int nIndex,
4852	PVOID pvInfo,
4853	DWORD nLength,
4854	LPDWORD lpnLengthNeeded)
4855	{
4856	dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4857	hObj,
4858	nIndex,
4859	pvInfo,
4860	nLength,
4861	lpnLengthNeeded));
4862
4863	return (FALSE);
4864	}
4865
4866
4867	/*****************************************************************************
4868	* Name : BOOL WIN32API GetUserObjectSecurity
4869	* Purpose : The GetUserObjectSecurity function retrieves security information
4870	* for the specified user object.
4871	* Parameters: HANDLE hObj handle of user object
4872	* SECURITY_INFORMATION * pSIRequested address of requested security information
4873	* LPSECURITY_DESCRIPTOR pSID address of security descriptor
4874	* DWORD nLength size of buffer for security descriptor
4875	* LPDWORD lpnLengthNeeded address of required size of buffer
4876	* Variables :
4877	* Result : If the function succeeds, the return value is TRUE.
4878	* If the function fails, the return value is FALSE. To get extended
4879	* error information, call GetLastError.
4880	* Remark :
4881	* Status : UNTESTED STUB
4882	*
4883	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4884	*****************************************************************************/
4885
4886	BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
4887	SECURITY_INFORMATION * pSIRequested,
4888	LPSECURITY_DESCRIPTOR pSID,
4889	DWORD nLength,
4890	LPDWORD lpnLengthNeeded)
4891	{
4892	dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4893	hObj,
4894	pSIRequested,
4895	pSID,
4896	nLength,
4897	lpnLengthNeeded));
4898
4899	return (FALSE);
4900	}
4901
4902
4903
4904	/*****************************************************************************
4905	* Name : int WIN32API GetWindowRgn
4906	* Purpose : The GetWindowRgn function obtains a copy of the window region of a window.
4907	* Parameters: HWND hWnd handle to window whose window region is to be obtained
4908	* HRGN hRgn handle to region that receives a copy of the window region
4909	* Variables :
4910	* Result : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
4911	* Remark :
4912	* Status : UNTESTED STUB
4913	*
4914	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4915	*****************************************************************************/
4916
4917	int WIN32API GetWindowRgn (HWND hWnd,
4918	HRGN hRgn)
4919	{
4920	dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
4921	hWnd,
4922	hRgn));
4923
4924	return (NULLREGION);
4925	}
4926
4927
4928
4929	/*****************************************************************************
4930	* Name : HCURSOR WIN32API LoadCursorFromFileA
4931	* Purpose : The LoadCursorFromFile function creates a cursor based on data
4932	* contained in a file. The file is specified by its name or by a
4933	* system cursor identifier. The function returns a handle to the
4934	* newly created cursor. Files containing cursor data may be in
4935	* either cursor (.CUR) or animated cursor (.ANI) format.
4936	* Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4937	* Variables :
4938	* Result : If the function is successful, the return value is a handle to
4939	* the new cursor.
4940	* If the function fails, the return value is NULL. To get extended
4941	* error information, call GetLastError. GetLastError may return
4942	* the following
4943	* Remark :
4944	* Status : UNTESTED STUB
4945	*
4946	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4947	*****************************************************************************/
4948
4949	HCURSOR WIN32API LoadCursorFromFileA(LPCTSTR lpFileName)
4950	{
4951	dprintf(("USER32:LoadCursorFromFileA (%s) not implemented.\n",
4952	lpFileName));
4953
4954	return (NULL);
4955	}
4956
4957
4958	/*****************************************************************************
4959	* Name : HCURSOR WIN32API LoadCursorFromFileW
4960	* Purpose : The LoadCursorFromFile function creates a cursor based on data
4961	* contained in a file. The file is specified by its name or by a
4962	* system cursor identifier. The function returns a handle to the
4963	* newly created cursor. Files containing cursor data may be in
4964	* either cursor (.CUR) or animated cursor (.ANI) format.
4965	* Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4966	* Variables :
4967	* Result : If the function is successful, the return value is a handle to
4968	* the new cursor.
4969	* If the function fails, the return value is NULL. To get extended
4970	* error information, call GetLastError. GetLastError may return
4971	* the following
4972	* Remark :
4973	* Status : UNTESTED STUB
4974	*
4975	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4976	*****************************************************************************/
4977
4978	HCURSOR WIN32API LoadCursorFromFileW(LPCWSTR lpFileName)
4979	{
4980	dprintf(("USER32:LoadCursorFromFileW (%s) not implemented.\n",
4981	lpFileName));
4982
4983	return (NULL);
4984	}
4985
4986
4987	/*****************************************************************************
4988	* Name : HLK WIN32API LoadKeyboardLayoutA
4989	* Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
4990	* the system. Several keyboard layouts can be loaded at a time, but
4991	* only one per process is active at a time. Loading multiple keyboard
4992	* layouts makes it possible to rapidly switch between layouts.
4993	* Parameters:
4994	* Variables :
4995	* Result : If the function succeeds, the return value is the handle of the
4996	* keyboard layout.
4997	* If the function fails, the return value is NULL. To get extended
4998	* error information, call GetLastError.
4999	* Remark :
5000	* Status : UNTESTED STUB
5001	*
5002	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5003	*****************************************************************************/
5004
5005	HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
5006	UINT Flags)
5007	{
5008	dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
5009	pwszKLID,
5010	Flags));
5011
5012	return (NULL);
5013	}
5014
5015
5016	/*****************************************************************************
5017	* Name : HLK WIN32API LoadKeyboardLayoutW
5018	* Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
5019	* the system. Several keyboard layouts can be loaded at a time, but
5020	* only one per process is active at a time. Loading multiple keyboard
5021	* layouts makes it possible to rapidly switch between layouts.
5022	* Parameters:
5023	* Variables :
5024	* Result : If the function succeeds, the return value is the handle of the
5025	* keyboard layout.
5026	* If the function fails, the return value is NULL. To get extended
5027	* error information, call GetLastError.
5028	* Remark :
5029	* Status : UNTESTED STUB
5030	*
5031	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5032	*****************************************************************************/
5033
5034	HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
5035	UINT Flags)
5036	{
5037	dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
5038	pwszKLID,
5039	Flags));
5040
5041	return (NULL);
5042	}
5043
5044
5045	/*****************************************************************************
5046	* Name : UINT WIN32API MapVirtualKeyExA
5047	* Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
5048	* code into a scan code or character value, or translates a scan
5049	* code into a virtual-key code. The function translates the codes
5050	* using the input language and physical keyboard layout identified
5051	* by the given keyboard layout handle.
5052	* Parameters:
5053	* Variables :
5054	* Result : The return value is either a scan code, a virtual-key code, or
5055	* a character value, depending on the value of uCode and uMapType.
5056	* If there is no translation, the return value is zero.
5057	* Remark :
5058	* Status : UNTESTED STUB
5059	*
5060	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5061	*****************************************************************************/
5062
5063	UINT WIN32API MapVirtualKeyExA(UINT uCode,
5064	UINT uMapType,
5065	HKL dwhkl)
5066	{
5067	dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
5068	uCode,
5069	uMapType,
5070	dwhkl));
5071
5072	return (0);
5073	}
5074
5075
5076	/*****************************************************************************
5077	* Name : UINT WIN32API MapVirtualKeyExW
5078	* Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
5079	* code into a scan code or character value, or translates a scan
5080	* code into a virtual-key code. The function translates the codes
5081	* using the input language and physical keyboard layout identified
5082	* by the given keyboard layout handle.
5083	* Parameters:
5084	* Variables :
5085	* Result : The return value is either a scan code, a virtual-key code, or
5086	* a character value, depending on the value of uCode and uMapType.
5087	* If there is no translation, the return value is zero.
5088	* Remark :
5089	* Status : UNTESTED STUB
5090	*
5091	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5092	*****************************************************************************/
5093
5094	UINT WIN32API MapVirtualKeyExW(UINT uCode,
5095	UINT uMapType,
5096	HKL dwhkl)
5097	{
5098	dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
5099	uCode,
5100	uMapType,
5101	dwhkl));
5102
5103	return (0);
5104	}
5105
5106
5107	/*****************************************************************************
5108	* Name : int WIN32API MessageBoxExA
5109	* Purpose : The MessageBoxEx function creates, displays, and operates a message box.
5110	* Parameters: HWND hWnd handle of owner window
5111	* LPCTSTR lpText address of text in message box
5112	* LPCTSTR lpCaption address of title of message box
5113	* UINT uType style of message box
5114	* WORD wLanguageId language identifier
5115	* Variables :
5116	* Result : If the function succeeds, the return value is a nonzero menu-item
5117	* value returned by the dialog box.
5118	* Remark :
5119	* Status : UNTESTED STUB
5120	*
5121	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5122	*****************************************************************************/
5123
5124	int WIN32API MessageBoxExA(HWND hWnd,
5125	LPCTSTR lpText,
5126	LPCTSTR lpCaption,
5127	UINT uType,
5128	WORD wLanguageId)
5129	{
5130	dprintf(("USER32:MessageBoxExA (%08xh,%s,%s,%u,%08w) not implemented.\n",
5131	hWnd,
5132	lpText,
5133	lpCaption,
5134	uType,
5135	wLanguageId));
5136
5137	return (MessageBoxA(hWnd,
5138	lpText,
5139	lpCaption,
5140	uType));
5141	}
5142
5143
5144	/*****************************************************************************
5145	* Name : int WIN32API MessageBoxExW
5146	* Purpose : The MessageBoxEx function creates, displays, and operates a message box.
5147	* Parameters: HWND hWnd handle of owner window
5148	* LPCTSTR lpText address of text in message box
5149	* LPCTSTR lpCaption address of title of message box
5150	* UINT uType style of message box
5151	* WORD wLanguageId language identifier
5152	* Variables :
5153	* Result : If the function succeeds, the return value is a nonzero menu-item
5154	* value returned by the dialog box.
5155	* Remark :
5156	* Status : UNTESTED STUB
5157	*
5158	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5159	*****************************************************************************/
5160
5161	int WIN32API MessageBoxExW(HWND hWnd,
5162	LPCWSTR lpText,
5163	LPCWSTR lpCaption,
5164	UINT uType,
5165	WORD wLanguageId)
5166	{
5167
5168	dprintf(("USER32:MessageBoxExW (%08xh,%x,%x,%u,%08w) not implemented.\n",
5169	hWnd,
5170	lpText,
5171	lpCaption,
5172	uType,
5173	wLanguageId));
5174
5175	return MessageBoxW(hWnd, lpText, lpCaption, uType);
5176	}
5177
5178
5179	/*****************************************************************************
5180	* Name : BOOL WIN32API MessageBoxIndirectW
5181	* Purpose : The MessageBoxIndirect function creates, displays, and operates
5182	* a message box. The message box contains application-defined
5183	* message text and title, any icon, and any combination of
5184	* predefined push buttons.
5185	* Parameters:
5186	* Variables :
5187	* Result :
5188	* Remark :
5189	* Status : UNTESTED STUB
5190	*
5191	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5192	*****************************************************************************/
5193
5194	BOOL WIN32API MessageBoxIndirectW(LPMSGBOXPARAMSW lpMsgBoxParams)
5195	{
5196	dprintf(("USER32:MessageBoxIndirectW (%08x) not implemented.\n",
5197	lpMsgBoxParams));
5198
5199	return (FALSE);
5200	}
5201
5202
5203	/*****************************************************************************
5204	* Name : BOOL WIN32API MessageBoxIndirectA
5205	* Purpose : The MessageBoxIndirect function creates, displays, and operates
5206	* a message box. The message box contains application-defined
5207	* message text and title, any icon, and any combination of
5208	* predefined push buttons.
5209	* Parameters:
5210	* Variables :
5211	* Result :
5212	* Remark :
5213	* Status : UNTESTED STUB
5214	*
5215	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5216	*****************************************************************************/
5217
5218	BOOL WIN32API MessageBoxIndirectA(LPMSGBOXPARAMSA lpMsgBoxParams)
5219	{
5220	dprintf(("USER32:MessageBoxIndirectA (%08x) not implemented.\n",
5221	lpMsgBoxParams));
5222
5223	return (FALSE);
5224	}
5225
5226
5227	/*****************************************************************************
5228	* Name : DWORD WIN32API OemKeyScan
5229	* Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
5230	* into the OEM scan codes and shift states. The function provides
5231	* information that allows a program to send OEM text to another
5232	* program by simulating keyboard input.
5233	* Parameters:
5234	* Variables :
5235	* Result :
5236	* Remark :
5237	* Status : UNTESTED STUB
5238	*
5239	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5240	*****************************************************************************/
5241
5242	DWORD WIN32API OemKeyScan(WORD wOemChar)
5243	{
5244	dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
5245	wOemChar));
5246
5247	return (wOemChar);
5248	}
5249
5250
5251	/*****************************************************************************
5252	* Name : HDESK WIN32API OpenDesktopA
5253	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
5254	* A desktop is a secure object contained within a window station
5255	* object. A desktop has a logical display surface and contains
5256	* windows, menus and hooks.
5257	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5258	* DWORD dwFlags flags to control interaction with other applications
5259	* BOOL fInherit specifies whether returned handle is inheritable
5260	* DWORD dwDesiredAccess specifies access of returned handle
5261	* Variables :
5262	* Result : If the function succeeds, the return value is the handle to the
5263	* opened desktop.
5264	* If the function fails, the return value is NULL. To get extended
5265	* error information, call GetLastError.
5266	* Remark :
5267	* Status : UNTESTED STUB
5268	*
5269	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5270	*****************************************************************************/
5271
5272	HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
5273	DWORD dwFlags,
5274	BOOL fInherit,
5275	DWORD dwDesiredAccess)
5276	{
5277	dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
5278	lpszDesktopName,
5279	dwFlags,
5280	fInherit,
5281	dwDesiredAccess));
5282
5283	return (NULL);
5284	}
5285
5286
5287	/*****************************************************************************
5288	* Name : HDESK WIN32API OpenDesktopW
5289	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
5290	* A desktop is a secure object contained within a window station
5291	* object. A desktop has a logical display surface and contains
5292	* windows, menus and hooks.
5293	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5294	* DWORD dwFlags flags to control interaction with other applications
5295	* BOOL fInherit specifies whether returned handle is inheritable
5296	* DWORD dwDesiredAccess specifies access of returned handle
5297	* Variables :
5298	* Result : If the function succeeds, the return value is the handle to the
5299	* opened desktop.
5300	* If the function fails, the return value is NULL. To get extended
5301	* error information, call GetLastError.
5302	* Remark :
5303	* Status : UNTESTED STUB
5304	*
5305	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5306	*****************************************************************************/
5307
5308	HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
5309	DWORD dwFlags,
5310	BOOL fInherit,
5311	DWORD dwDesiredAccess)
5312	{
5313	dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
5314	lpszDesktopName,
5315	dwFlags,
5316	fInherit,
5317	dwDesiredAccess));
5318
5319	return (NULL);
5320	}
5321
5322
5323	/*****************************************************************************
5324	* Name : HDESK WIN32API OpenInputDesktop
5325	* Purpose : The OpenInputDesktop function returns a handle to the desktop
5326	* that receives user input. The input desktop is a desktop on the
5327	* window station associated with the logged-on user.
5328	* Parameters: DWORD dwFlags flags to control interaction with other applications
5329	* BOOL fInherit specifies whether returned handle is inheritable
5330	* DWORD dwDesiredAccess specifies access of returned handle
5331	* Variables :
5332	* Result : If the function succeeds, the return value is a handle of the
5333	* desktop that receives user input.
5334	* If the function fails, the return value is NULL. To get extended
5335	* error information, call GetLastError.
5336	* Remark :
5337	* Status : UNTESTED STUB
5338	*
5339	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5340	*****************************************************************************/
5341
5342	HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
5343	BOOL fInherit,
5344	DWORD dwDesiredAccess)
5345	{
5346	dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
5347	dwFlags,
5348	fInherit,
5349	dwDesiredAccess));
5350
5351	return (NULL);
5352	}
5353
5354
5355	/*****************************************************************************
5356	* Name : HWINSTA WIN32API OpenWindowStationA
5357	* Purpose : The OpenWindowStation function returns a handle to an existing
5358	* window station.
5359	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
5360	* BOOL fInherit specifies whether returned handle is inheritable
5361	* DWORD dwDesiredAccess specifies access of returned handle
5362	* Variables :
5363	* Result : If the function succeeds, the return value is the handle to the
5364	* specified window station.
5365	* If the function fails, the return value is NULL. To get extended
5366	* error information, call GetLastError.
5367	* Remark :
5368	* Status : UNTESTED STUB
5369	*
5370	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5371	*****************************************************************************/
5372
5373	HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
5374	BOOL fInherit,
5375	DWORD dwDesiredAccess)
5376	{
5377	dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
5378	lpszWinStaName,
5379	fInherit,
5380	dwDesiredAccess));
5381
5382	return (NULL);
5383	}
5384
5385
5386	/*****************************************************************************
5387	* Name : HWINSTA WIN32API OpenWindowStationW
5388	* Purpose : The OpenWindowStation function returns a handle to an existing
5389	* window station.
5390	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
5391	* BOOL fInherit specifies whether returned handle is inheritable
5392	* DWORD dwDesiredAccess specifies access of returned handle
5393	* Variables :
5394	* Result : If the function succeeds, the return value is the handle to the
5395	* specified window station.
5396	* If the function fails, the return value is NULL. To get extended
5397	* error information, call GetLastError.
5398
5399	* Remark :
5400	* Status : UNTESTED STUB
5401	*
5402	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5403	*****************************************************************************/
5404
5405	HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
5406	BOOL fInherit,
5407	DWORD dwDesiredAccess)
5408	{
5409	dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
5410	lpszWinStaName,
5411	fInherit,
5412	dwDesiredAccess));
5413
5414	return (NULL);
5415	}
5416
5417
5418	/*****************************************************************************
5419	* Name : BOOL WIN32API PaintDesktop
5420	* Purpose : The PaintDesktop function fills the clipping region in the
5421	* specified device context with the desktop pattern or wallpaper.
5422	* The function is provided primarily for shell desktops.
5423	* Parameters:
5424	* Variables :
5425	* Result : If the function succeeds, the return value is TRUE.
5426	* If the function fails, the return value is FALSE.
5427	* Remark :
5428	* Status : UNTESTED STUB
5429	*
5430	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5431	*****************************************************************************/
5432
5433	BOOL WIN32API PaintDesktop(HDC hdc)
5434	{
5435	dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
5436	hdc));
5437
5438	return (FALSE);
5439	}
5440
5441
5442	/*****************************************************************************
5443	* Name : BOOL WIN32API SendMessageCallbackA
5444	* Purpose : The SendMessageCallback function sends the specified message to
5445	* a window or windows. The function calls the window procedure for
5446	* the specified window and returns immediately. After the window
5447	* procedure processes the message, the system calls the specified
5448	* callback function, passing the result of the message processing
5449	* and an application-defined value to the callback function.
5450	* Parameters: HWND hwnd handle of destination window
5451	* UINT uMsg message to send
5452	* WPARAM wParam first message parameter
5453	* LPARAM lParam second message parameter
5454	* SENDASYNCPROC lpResultCallBack function to receive message value
5455	* DWORD dwData value to pass to callback function
5456	* Variables :
5457	* Result : If the function succeeds, the return value is TRUE.
5458	* If the function fails, the return value is FALSE. To get extended
5459	* error information, call GetLastError.
5460	* Remark :
5461	* Status : UNTESTED STUB
5462	*
5463	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5464	*****************************************************************************/
5465
5466	BOOL WIN32API SendMessageCallbackA(HWND hWnd,
5467	UINT uMsg,
5468	WPARAM wParam,
5469	LPARAM lParam,
5470	SENDASYNCPROC lpResultCallBack,
5471	DWORD dwData)
5472	{
5473	dprintf(("USER32:SendMessageCallBackA (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5474	hWnd,
5475	uMsg,
5476	wParam,
5477	lParam,
5478	lpResultCallBack,
5479	dwData));
5480
5481	return (FALSE);
5482	}
5483
5484
5485	/*****************************************************************************
5486	* Name : BOOL WIN32API SendMessageCallbackW
5487	* Purpose : The SendMessageCallback function sends the specified message to
5488	* a window or windows. The function calls the window procedure for
5489	* the specified window and returns immediately. After the window
5490	* procedure processes the message, the system calls the specified
5491	* callback function, passing the result of the message processing
5492	* and an application-defined value to the callback function.
5493	* Parameters: HWND hwnd handle of destination window
5494	* UINT uMsg message to send
5495	* WPARAM wParam first message parameter
5496	* LPARAM lParam second message parameter
5497	* SENDASYNCPROC lpResultCallBack function to receive message value
5498	* DWORD dwData value to pass to callback function
5499	* Variables :
5500	* Result : If the function succeeds, the return value is TRUE.
5501	* If the function fails, the return value is FALSE. To get extended
5502	* error information, call GetLastError.
5503	* Remark :
5504	* Status : UNTESTED STUB
5505	*
5506	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5507	*****************************************************************************/
5508
5509	BOOL WIN32API SendMessageCallbackW(HWND hWnd,
5510	UINT uMsg,
5511	WPARAM wParam,
5512	LPARAM lParam,
5513	SENDASYNCPROC lpResultCallBack,
5514	DWORD dwData)
5515	{
5516	dprintf(("USER32:SendMessageCallBackW (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5517	hWnd,
5518	uMsg,
5519	wParam,
5520	lParam,
5521	lpResultCallBack,
5522	dwData));
5523
5524	return (FALSE);
5525	}
5526
5527
5528	/*****************************************************************************
5529	* Name : VOID WIN32API SetDebugErrorLevel
5530	* Purpose : The SetDebugErrorLevel function sets the minimum error level at
5531	* which Windows will generate debugging events and pass them to a debugger.
5532	* Parameters: DWORD dwLevel debugging error level
5533	* Variables :
5534	* Result :
5535	* Remark :
5536	* Status : UNTESTED STUB
5537	*
5538	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5539	*****************************************************************************/
5540
5541	VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
5542	{
5543	dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
5544	dwLevel));
5545	}
5546
5547
5548	/*****************************************************************************
5549	* Name : BOOL WIN32API SetProcessWindowStation
5550	* Purpose : The SetProcessWindowStation function assigns a window station
5551	* to the calling process. This enables the process to access
5552	* objects in the window station such as desktops, the clipboard,
5553	* and global atoms. All subsequent operations on the window station
5554	* use the access rights granted to hWinSta.
5555	* Parameters:
5556	* Variables :
5557	* Result : If the function succeeds, the return value is TRUE.
5558	* If the function fails, the return value is FALSE. To get extended
5559	* error information, call GetLastError.
5560	* Remark :
5561	* Status : UNTESTED STUB
5562	*
5563	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5564	*****************************************************************************/
5565
5566	BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
5567	{
5568	dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
5569	hWinSta));
5570
5571	return (FALSE);
5572	}
5573
5574
5575	/*****************************************************************************
5576	* Name : BOOL WIN32API SetSystemCursor
5577	* Purpose : The SetSystemCursor function replaces the contents of the system
5578	* cursor specified by dwCursorId with the contents of the cursor
5579	* specified by hCursor, and then destroys hCursor. This function
5580	* lets an application customize the system cursors.
5581	* Parameters: HCURSOR hCursor set specified system cursor to this cursor's
5582	* contents, then destroy this
5583	* DWORD dwCursorID system cursor specified by its identifier
5584	* Variables :
5585	* Result : If the function succeeds, the return value is TRUE.
5586	* If the function fails, the return value is FALSE. To get extended
5587	* error information, call GetLastError.
5588	* Remark :
5589	* Status : UNTESTED STUB
5590	*
5591	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5592	*****************************************************************************/
5593
5594	BOOL WIN32API SetSystemCursor(HCURSOR hCursor,
5595	DWORD dwCursorId)
5596	{
5597	dprintf(("USER32:SetSystemCursor (%08xh,%08x) not implemented.\n",
5598	hCursor,
5599	dwCursorId));
5600
5601	return (FALSE);
5602	}
5603
5604
5605	/*****************************************************************************
5606	* Name : BOOL WIN32API SetThreadDesktop
5607	* Purpose : The SetThreadDesktop function assigns a desktop to the calling
5608	* thread. All subsequent operations on the desktop use the access
5609	* rights granted to hDesk.
5610	* Parameters: HDESK hDesk handle of the desktop to assign to this thread
5611	* Variables :
5612	* Result : If the function succeeds, the return value is TRUE.
5613	* If the function fails, the return value is FALSE. To get extended
5614	* error information, call GetLastError.
5615	* Remark :
5616	* Status : UNTESTED STUB
5617	*
5618	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5619	*****************************************************************************/
5620
5621	BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
5622	{
5623	dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
5624	hDesktop));
5625
5626	return (FALSE);
5627	}
5628
5629
5630	/*****************************************************************************
5631	* Name : BOOL WIN32API SetUserObjectInformationA
5632	* Purpose : The SetUserObjectInformation function sets information about a
5633	* window station or desktop object.
5634	* Parameters: HANDLE hObject handle of the object for which to set information
5635	* int nIndex type of information to set
5636	* PVOID lpvInfo points to a buffer that contains the information
5637	* DWORD cbInfo size, in bytes, of lpvInfo buffer
5638	* Variables :
5639	* Result : If the function succeeds, the return value is TRUE.
5640	* If the function fails the return value is FALSE. To get extended
5641	* error information, call GetLastError.
5642	* Remark :
5643	* Status : UNTESTED STUB
5644	*
5645	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5646	*****************************************************************************/
5647
5648	BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
5649	int nIndex,
5650	PVOID lpvInfo,
5651	DWORD cbInfo)
5652	{
5653	dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
5654	hObject,
5655	nIndex,
5656	lpvInfo,
5657	cbInfo));
5658
5659	return (FALSE);
5660	}
5661
5662
5663	/*****************************************************************************
5664	* Name : BOOL WIN32API SetUserObjectInformationW
5665	* Purpose : The SetUserObjectInformation function sets information about a
5666	* window station or desktop object.
5667	* Parameters: HANDLE hObject handle of the object for which to set information
5668	* int nIndex type of information to set
5669	* PVOID lpvInfo points to a buffer that contains the information
5670	* DWORD cbInfo size, in bytes, of lpvInfo buffer
5671	* Variables :
5672	* Result : If the function succeeds, the return value is TRUE.
5673	* If the function fails the return value is FALSE. To get extended
5674	* error information, call GetLastError.
5675	* Remark :
5676	* Status : UNTESTED STUB
5677	*
5678	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5679	*****************************************************************************/
5680
5681	BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
5682	int nIndex,
5683	PVOID lpvInfo,
5684	DWORD cbInfo)
5685	{
5686	dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
5687	hObject,
5688	nIndex,
5689	lpvInfo,
5690	cbInfo));
5691
5692	return (FALSE);
5693	}
5694
5695
5696	/*****************************************************************************
5697	* Name : BOOL WIN32API SetUserObjectSecurity
5698	* Purpose : The SetUserObjectSecurity function sets the security of a user
5699	* object. This can be, for example, a window or a DDE conversation
5700	* Parameters: HANDLE hObject handle of user object
5701	* SECURITY_INFORMATION * psi address of security information
5702	* LPSECURITY_DESCRIPTOR psd address of security descriptor
5703	* Variables :
5704	* Result : If the function succeeds, the return value is TRUE.
5705	* If the function fails, the return value is FALSE. To get extended
5706	* error information, call GetLastError.
5707	* Remark :
5708	* Status : UNTESTED STUB
5709	*
5710	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5711	*****************************************************************************/
5712
5713	BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
5714	SECURITY_INFORMATION * psi,
5715	LPSECURITY_DESCRIPTOR psd)
5716	{
5717	dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
5718	hObject,
5719	psi,
5720	psd));
5721
5722	return (FALSE);
5723	}
5724
5725
5726	/*****************************************************************************
5727	* Name : int WIN32API SetWindowRgn
5728	* Purpose : The SetWindowRgn function sets the window region of a window. The
5729	* window region determines the area within the window where the
5730	* operating system permits drawing. The operating system does not
5731	* display any portion of a window that lies outside of the window region
5732	* Parameters: HWND hWnd handle to window whose window region is to be set
5733	* HRGN hRgn handle to region
5734	* BOOL bRedraw window redraw flag
5735	* Variables :
5736	* Result : If the function succeeds, the return value is non-zero.
5737	* If the function fails, the return value is zero.
5738	* Remark :
5739	* Status : UNTESTED STUB
5740	*
5741	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5742	*****************************************************************************/
5743
5744	int WIN32API SetWindowRgn(HWND hWnd,
5745	HRGN hRgn,
5746	BOOL bRedraw)
5747	{
5748	dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
5749	hWnd,
5750	hRgn,
5751	bRedraw));
5752
5753	return (0);
5754	}
5755
5756
5757	/*****************************************************************************
5758	* Name : BOOL WIN32API SetWindowsHookW
5759	* Purpose : The SetWindowsHook function is not implemented in the Win32 API.
5760	* Win32-based applications should use the SetWindowsHookEx function.
5761	* Parameters:
5762	* Variables :
5763	* Result :
5764	* Remark : ARGH ! MICROSOFT !
5765	* Status : UNTESTED STUB
5766	*
5767	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5768	*****************************************************************************/
5769
5770	HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
5771
5772	{
5773	return (FALSE);
5774	}
5775
5776
5777	/*****************************************************************************
5778	* Name : BOOL WIN32API ShowWindowAsync
5779	* Purpose : The ShowWindowAsync function sets the show state of a window
5780	* created by a different thread.
5781	* Parameters: HWND hwnd handle of window
5782	* int nCmdShow show state of window
5783	* Variables :
5784	* Result : If the window was previously visible, the return value is TRUE.
5785	* If the window was previously hidden, the return value is FALSE.
5786	* Remark :
5787	* Status : UNTESTED STUB
5788	*
5789	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5790	*****************************************************************************/
5791
5792	BOOL WIN32API ShowWindowAsync (HWND hWnd,
5793	int nCmdShow)
5794	{
5795	dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
5796	hWnd,
5797	nCmdShow));
5798
5799	return (FALSE);
5800	}
5801
5802
5803	/*****************************************************************************
5804	* Name : BOOL WIN32API SwitchDesktop
5805	* Purpose : The SwitchDesktop function makes a desktop visible and activates
5806	* it. This enables the desktop to receive input from the user. The
5807	* calling process must have DESKTOP_SWITCHDESKTOP access to the
5808	* desktop for the SwitchDesktop function to succeed.
5809	* Parameters:
5810	* Variables :
5811	* Result : If the function succeeds, the return value is TRUE.
5812	* If the function fails, the return value is FALSE. To get extended
5813	* error information, call GetLastError.
5814	* Remark :
5815	* Status : UNTESTED STUB
5816	*
5817	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5818	*****************************************************************************/
5819
5820	BOOL WIN32API SwitchDesktop(HDESK hDesktop)
5821	{
5822	dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
5823	hDesktop));
5824
5825	return (FALSE);
5826	}
5827
5828
5829	/*****************************************************************************
5830	* Name : WORD WIN32API TileWindows
5831	* Purpose : The TileWindows function tiles the specified windows, or the child
5832	* windows of the specified parent window.
5833	* Parameters: HWND hwndParent handle of parent window
5834	* WORD wFlags types of windows not to arrange
5835	* LPCRECT lpRect rectangle to arrange windows in
5836	* WORD cChildrenb number of windows to arrange
5837	* const HWND *ahwndChildren array of window handles
5838	* Variables :
5839	* Result : If the function succeeds, the return value is the number of
5840	* windows arranged.
5841	* If the function fails, the return value is zero.
5842	* Remark :
5843	* Status : UNTESTED STUB
5844	*
5845	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5846	*****************************************************************************/
5847
5848	WORD WIN32API TileWindows(HWND hwndParent,
5849	UINT wFlags,
5850	const LPRECT lpRect,
5851	UINT cChildrenb,
5852	const HWND *ahwndChildren)
5853	{
5854	dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5855	hwndParent,
5856	wFlags,
5857	lpRect,
5858	cChildrenb,
5859	ahwndChildren));
5860
5861	return (0);
5862	}
5863
5864
5865	/*****************************************************************************
5866	* Name : int WIN32API ToAscii
5867	* Purpose : The ToAscii function translates the specified virtual-key code
5868	* and keyboard state to the corresponding Windows character or characters.
5869	* Parameters: UINT uVirtKey virtual-key code
5870	* UINT uScanCode scan code
5871	* PBYTE lpbKeyState address of key-state array
5872	* LPWORD lpwTransKey buffer for translated key
5873	* UINT fuState active-menu flag
5874	* Variables :
5875	* Result : 0 The specified virtual key has no translation for the current
5876	* state of the keyboard.
5877	* 1 One Windows character was copied to the buffer.
5878	* 2 Two characters were copied to the buffer. This usually happens
5879	* when a dead-key character (accent or diacritic) stored in the
5880	* keyboard layout cannot be composed with the specified virtual
5881	* key to form a single character.
5882	* Remark :
5883	* Status : UNTESTED STUB
5884	*
5885	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5886	*****************************************************************************/
5887
5888	int WIN32API ToAscii(UINT uVirtKey,
5889	UINT uScanCode,
5890	PBYTE lpbKeyState,
5891	LPWORD lpwTransKey,
5892	UINT fuState)
5893	{
5894	dprintf(("USER32:ToAscii (%u,%u,%08xh,%08xh,%u) not implemented.\n",
5895	uVirtKey,
5896	uScanCode,
5897	lpbKeyState,
5898	lpwTransKey,
5899	fuState));
5900
5901	return (0);
5902	}
5903
5904
5905	/*****************************************************************************
5906	* Name : int WIN32API ToAsciiEx
5907	* Purpose : The ToAscii function translates the specified virtual-key code
5908	* and keyboard state to the corresponding Windows character or characters.
5909	* Parameters: UINT uVirtKey virtual-key code
5910	* UINT uScanCode scan code
5911	* PBYTE lpbKeyState address of key-state array
5912	* LPWORD lpwTransKey buffer for translated key
5913	* UINT fuState active-menu flag
5914	* HLK hlk keyboard layout handle
5915	* Variables :
5916	* Result : 0 The specified virtual key has no translation for the current
5917	* state of the keyboard.
5918	* 1 One Windows character was copied to the buffer.
5919	* 2 Two characters were copied to the buffer. This usually happens
5920	* when a dead-key character (accent or diacritic) stored in the
5921	* keyboard layout cannot be composed with the specified virtual
5922	* key to form a single character.
5923	* Remark :
5924	* Status : UNTESTED STUB
5925	*
5926	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5927	*****************************************************************************/
5928
5929	int WIN32API ToAsciiEx(UINT uVirtKey,
5930	UINT uScanCode,
5931	PBYTE lpbKeyState,
5932	LPWORD lpwTransKey,
5933	UINT fuState,
5934	HKL hkl)
5935	{
5936	dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5937	uVirtKey,
5938	uScanCode,
5939	lpbKeyState,
5940	lpwTransKey,
5941	fuState,
5942	hkl));
5943
5944	return (0);
5945	}
5946
5947
5948	/*****************************************************************************
5949	* Name : int WIN32API ToUnicode
5950	* Purpose : The ToUnicode function translates the specified virtual-key code
5951	* and keyboard state to the corresponding Unicode character or characters.
5952	* Parameters: UINT wVirtKey virtual-key code
5953	* UINT wScanCode scan code
5954	* PBYTE lpKeyState address of key-state array
5955	* LPWSTR pwszBuff buffer for translated key
5956	* int cchBuff size of translated key buffer
5957	* UINT wFlags set of function-conditioning flags
5958	* Variables :
5959	* Result : - 1 The specified virtual key is a dead-key character (accent or
5960	* diacritic). This value is returned regardless of the keyboard
5961	* layout, even if several characters have been typed and are
5962	* stored in the keyboard state. If possible, even with Unicode
5963	* keyboard layouts, the function has written a spacing version of
5964	* the dead-key character to the buffer specified by pwszBuffer.
5965	* For example, the function writes the character SPACING ACUTE
5966	* (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
5967	* 0 The specified virtual key has no translation for the current
5968	* state of the keyboard. Nothing was written to the buffer
5969	* specified by pwszBuffer.
5970	* 1 One character was written to the buffer specified by pwszBuffer.
5971	* 2 or more Two or more characters were written to the buffer specified by
5972	* pwszBuff. The most common cause for this is that a dead-key
5973	* character (accent or diacritic) stored in the keyboard layout
5974	* could not be combined with the specified virtual key to form a
5975	* single character.
5976	* Remark :
5977	* Status : UNTESTED STUB
5978	*
5979	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5980	*****************************************************************************/
5981
5982	int WIN32API ToUnicode(UINT uVirtKey,
5983	UINT uScanCode,
5984	PBYTE lpKeyState,
5985	LPWSTR pwszBuff,
5986	int cchBuff,
5987	UINT wFlags)
5988	{
5989	dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5990	uVirtKey,
5991	uScanCode,
5992	lpKeyState,
5993	pwszBuff,
5994	cchBuff,
5995	wFlags));
5996
5997	return (0);
5998	}
5999
6000
6001	/*****************************************************************************
6002	* Name : BOOL WIN32API UnloadKeyboardLayout
6003	* Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
6004	* Parameters: HKL hkl handle of keyboard layout
6005	* Variables :
6006	* Result : If the function succeeds, the return value is the handle of the
6007	* keyboard layout; otherwise, it is NULL. To get extended error
6008	* information, use the GetLastError function.
6009	* Remark :
6010	* Status : UNTESTED STUB
6011	*
6012	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6013	*****************************************************************************/
6014
6015	BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
6016	{
6017	dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
6018	hkl));
6019
6020	return (0);
6021	}
6022
6023
6024	/*****************************************************************************
6025	* Name : SHORT WIN32API VkKeyScanExW
6026	* Purpose : The VkKeyScanEx function translates a character to the
6027	* corresponding virtual-key code and shift state. The function
6028	* translates the character using the input language and physical
6029	* keyboard layout identified by the given keyboard layout handle.
6030	* Parameters: UINT uChar character to translate
6031	* HKL hkl keyboard layout handle
6032	* Variables :
6033	* Result : see docs
6034	* Remark :
6035	* Status : UNTESTED STUB
6036	*
6037	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6038	*****************************************************************************/
6039
6040	WORD WIN32API VkKeyScanExW(WCHAR uChar,
6041	HKL hkl)
6042	{
6043	dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
6044	uChar,
6045	hkl));
6046
6047	return (uChar);
6048	}
6049
6050
6051	/*****************************************************************************
6052	* Name : SHORT WIN32API VkKeyScanExA
6053	* Purpose : The VkKeyScanEx function translates a character to the
6054	* corresponding virtual-key code and shift state. The function
6055	* translates the character using the input language and physical
6056	* keyboard layout identified by the given keyboard layout handle.
6057	* Parameters: UINT uChar character to translate
6058	* HKL hkl keyboard layout handle
6059	* Variables :
6060	* Result : see docs
6061	* Remark :
6062	* Status : UNTESTED STUB
6063	*
6064	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6065	*****************************************************************************/
6066
6067	WORD WIN32API VkKeyScanExA(CHAR uChar,
6068	HKL hkl)
6069	{
6070	dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
6071	uChar,
6072	hkl));
6073
6074	return (uChar);
6075	}
6076
6077
6078	/*****************************************************************************
6079	* Name : VOID WIN32API keybd_event
6080	* Purpose : The keybd_event function synthesizes a keystroke. The system
6081	* can use such a synthesized keystroke to generate a WM_KEYUP or
6082	* WM_KEYDOWN message. The keyboard driver's interrupt handler calls
6083	* the keybd_event function.
6084	* Parameters: BYTE bVk virtual-key code
6085
6086	* BYTE bScan hardware scan code
6087	* DWORD dwFlags flags specifying various function options
6088	* DWORD dwExtraInfo additional data associated with keystroke
6089	* Variables :
6090	* Result :
6091	* Remark :
6092	* Status : UNTESTED STUB
6093	*
6094	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6095	*****************************************************************************/
6096
6097	VOID WIN32API keybd_event (BYTE bVk,
6098	BYTE bScan,
6099	DWORD dwFlags,
6100	DWORD dwExtraInfo)
6101	{
6102	dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
6103	bVk,
6104	bScan,
6105	dwFlags,
6106	dwExtraInfo));
6107	}
6108
6109
6110	/*****************************************************************************
6111	* Name : VOID WIN32API mouse_event
6112	* Purpose : The mouse_event function synthesizes mouse motion and button clicks.
6113	* Parameters: DWORD dwFlags flags specifying various motion/click variants
6114	* DWORD dx horizontal mouse position or position change
6115	* DWORD dy vertical mouse position or position change
6116	* DWORD cButtons unused, reserved for future use, set to zero
6117	* DWORD dwExtraInfo 32 bits of application-defined information
6118	* Variables :
6119	* Result :
6120	* Remark :
6121	* Status : UNTESTED STUB
6122	*
6123	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6124	*****************************************************************************/
6125
6126	VOID WIN32API mouse_event(DWORD dwFlags,
6127	DWORD dx,
6128	DWORD dy,
6129	DWORD cButtons,
6130	DWORD dwExtraInfo)
6131	{
6132	dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
6133	dwFlags,
6134	dx,
6135	dy,
6136	cButtons,
6137	dwExtraInfo));
6138	}
6139
6140
6141	/*****************************************************************************
6142	* Name : BOOL WIN32API SetShellWindow
6143	* Purpose : Unknown
6144	* Parameters: Unknown
6145	* Variables :
6146	* Result :
6147	* Remark :
6148	* Status : UNTESTED UNKNOWN STUB
6149	*
6150	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6151	*****************************************************************************/
6152
6153	BOOL WIN32API SetShellWindow(DWORD x1)
6154	{
6155	dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
6156	x1));
6157
6158	return (FALSE); /* default */
6159	}
6160
6161
6162	/*****************************************************************************
6163	* Name : BOOL WIN32API PlaySoundEvent
6164	* Purpose : Unknown
6165	* Parameters: Unknown
6166	* Variables :
6167	* Result :
6168	* Remark :
6169	* Status : UNTESTED UNKNOWN STUB
6170	*
6171	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6172	*****************************************************************************/
6173
6174	BOOL WIN32API PlaySoundEvent(DWORD x1)
6175	{
6176	dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
6177	x1));
6178
6179	return (FALSE); /* default */
6180	}
6181
6182
6183	/*****************************************************************************
6184	* Name : BOOL WIN32API TileChildWindows
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 TileChildWindows(DWORD x1,
6196	DWORD x2)
6197	{
6198	dprintf(("USER32: TileChildWindows(%08xh,%08xh) not implemented.\n",
6199	x1,
6200	x2));
6201
6202	return (FALSE); /* default */
6203	}
6204
6205
6206	/*****************************************************************************
6207	* Name : BOOL WIN32API SetSysColorsTemp
6208	* Purpose : Unknown
6209	* Parameters: Unknown
6210	* Variables :
6211	* Result :
6212	* Remark :
6213	* Status : UNTESTED UNKNOWN STUB
6214	*
6215	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6216	*****************************************************************************/
6217
6218	BOOL WIN32API SetSysColorsTemp(void)
6219	{
6220	dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
6221
6222	return (FALSE); /* default */
6223	}
6224
6225
6226	/*****************************************************************************
6227	* Name : BOOL WIN32API RegisterNetworkCapabilities
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 RegisterNetworkCapabilities(DWORD x1,
6239	DWORD x2)
6240	{
6241	dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
6242	x1,
6243	x2));
6244
6245	return (FALSE); /* default */
6246	}
6247
6248
6249	/*****************************************************************************
6250	* Name : BOOL WIN32API EndTask
6251	* Purpose : Unknown
6252	* Parameters: Unknown
6253	* Variables :
6254	* Result :
6255	* Remark :
6256	* Status : UNTESTED UNKNOWN STUB
6257	*
6258	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6259	*****************************************************************************/
6260
6261	BOOL WIN32API EndTask(DWORD x1,
6262	DWORD x2,
6263	DWORD x3)
6264	{
6265	dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
6266	x1,
6267	x2,
6268	x3));
6269
6270	return (FALSE); /* default */
6271	}
6272
6273
6274	/*****************************************************************************
6275	* Name : BOOL WIN32API SwitchToThisWindow
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 SwitchToThisWindow(HWND hwnd,
6287	BOOL x2)
6288	{
6289	dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
6290	hwnd,
6291	x2));
6292
6293	return (FALSE); /* default */
6294	}
6295
6296
6297	/*****************************************************************************
6298	* Name : BOOL WIN32API GetNextQueueWindow
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 GetNextQueueWindow(DWORD x1,
6310	DWORD x2)
6311	{
6312	dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
6313	x1,
6314	x2));
6315
6316	return (FALSE); /* default */
6317	}
6318
6319
6320	/*****************************************************************************
6321	* Name : BOOL WIN32API YieldTask
6322	* Purpose : Unknown
6323	* Parameters: Unknown
6324	* Variables :
6325	* Result :
6326	* Remark :
6327	* Status : UNTESTED UNKNOWN STUB
6328	*
6329	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6330	*****************************************************************************/
6331
6332	BOOL WIN32API YieldTask(void)
6333	{
6334	dprintf(("USER32: YieldTask() not implemented.\n"));
6335
6336	return (FALSE); /* default */
6337	}
6338
6339
6340	/*****************************************************************************
6341	* Name : BOOL WIN32API WinOldAppHackoMatic
6342	* Purpose : Unknown
6343	* Parameters: Unknown
6344	* Variables :
6345	* Result :
6346	* Remark :
6347	* Status : UNTESTED UNKNOWN STUB
6348	*
6349	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6350	*****************************************************************************/
6351
6352	BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
6353	{
6354	dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
6355	x1));
6356
6357	return (FALSE); /* default */
6358	}
6359
6360
6361	/*****************************************************************************
6362	* Name : BOOL WIN32API DragObject
6363	* Purpose : Unknown
6364	* Parameters: Unknown
6365	* Variables :
6366	* Result :
6367	* Remark :
6368	* Status : UNTESTED UNKNOWN STUB
6369	*
6370	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6371	*****************************************************************************/
6372
6373	DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
6374	{
6375	dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6376	x1,
6377	x2,
6378	x3,
6379	x4,
6380	x5));
6381
6382	return (FALSE); /* default */
6383	}
6384
6385
6386	/*****************************************************************************
6387	* Name : BOOL WIN32API CascadeChildWindows
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 CascadeChildWindows(DWORD x1,
6399	DWORD x2)
6400	{
6401	dprintf(("USER32: CascadeChildWindows(%08xh,%08xh) not implemented.\n",
6402	x1,
6403	x2));
6404
6405	return (FALSE); /* default */
6406	}
6407
6408
6409	/*****************************************************************************
6410	* Name : BOOL WIN32API RegisterSystemThread
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 RegisterSystemThread(DWORD x1,
6422	DWORD x2)
6423	{
6424	dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
6425	x1,
6426	x2));
6427
6428	return (FALSE); /* default */
6429	}
6430
6431
6432	/*****************************************************************************
6433	* Name : BOOL WIN32API IsHungThread
6434	* Purpose : Unknown
6435	* Parameters: Unknown
6436	* Variables :
6437	* Result :
6438	* Remark :
6439	* Status : UNTESTED UNKNOWN STUB
6440	*
6441	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6442	*****************************************************************************/
6443
6444	BOOL WIN32API IsHungThread(DWORD x1)
6445	{
6446	dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
6447	x1));
6448
6449	return (FALSE); /* default */
6450	}
6451
6452
6453	/*****************************************************************************
6454	* Name : BOOL WIN32API SysErrorBox
6455	* Purpose : Unknown
6456	* Parameters: Unknown
6457	* Variables :
6458	* Result :
6459	* Remark : HARDERR like ?
6460	* Status : UNTESTED UNKNOWN STUB
6461	*
6462	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6463	*****************************************************************************/
6464
6465	BOOL WIN32API SysErrorBox(DWORD x1,
6466	DWORD x2,
6467	DWORD x3)
6468	{
6469	dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh) not implemented.\n",
6470	x1,
6471	x2,
6472	x3));
6473
6474	return (FALSE); /* default */
6475	}
6476
6477
6478	/*****************************************************************************
6479	* Name : BOOL WIN32API UserSignalProc
6480	* Purpose : Unknown
6481	* Parameters: Unknown
6482	* Variables :
6483	* Result :
6484	* Remark :
6485	* Status : UNTESTED UNKNOWN STUB
6486	*
6487	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6488	*****************************************************************************/
6489
6490	BOOL WIN32API UserSignalProc(DWORD x1,
6491	DWORD x2,
6492	DWORD x3,
6493	DWORD x4)
6494	{
6495	dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6496	x1,
6497	x2,
6498	x3,
6499	x4));
6500
6501	return (FALSE); /* default */
6502	}
6503
6504
6505	/*****************************************************************************
6506	* Name : BOOL WIN32API GetShellWindow
6507	* Purpose : Unknown
6508	* Parameters: Unknown
6509	* Variables :
6510	* Result :
6511	* Remark :
6512	* Status : UNTESTED UNKNOWN STUB
6513	*
6514	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6515	*****************************************************************************/
6516
6517	HWND WIN32API GetShellWindow(void)
6518	{
6519	dprintf(("USER32: GetShellWindow() not implemented.\n"));
6520
6521	return (0); /* default */
6522	}

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

Download in other formats: