Context Navigation

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

Visit:

Last change on this file since 17 was 17, checked in by phaller, 26 years ago
Code cleanup #1 for build, mainly addresses linkage problems
File size: 234.8 KB

Line
1	/* $Id: user32.cpp,v 1.2 1999-05-31 22:08:15 phaller Exp $ */
2
3	/*
4	* Win32 misc user32 API functions for OS/2
5	*
6	* Copyright 1998 Sander van Leeuwen
7	* Copyright 1998 Patrick Haller
8	* Copyright 1998 Peter Fitzsimmons
9	*
10	*
11	* Project Odin Software License can be found in LICENSE.TXT
12	*
13	*/
14	/*****************************************************************************
15	* Name : USER32.CPP
16	* Purpose : This module maps all Win32 functions contained in USER32.DLL
17	* to their OS/2-specific counterparts as far as possible.
18	*****************************************************************************/
19
20	#include <os2win.h>
21	#include "misc.h"
22
23	#include "user32.h"
24	#include "wndproc.h"
25	#include "wndsubproc.h"
26	#include "wndclass.h"
27	#include "icon.h"
28	#include "usrcall.h"
29	#include "syscolor.h"
30
31	#include <wchar.h>
32	#include <stdlib.h>
33	#include <string.h>
34
35	//undocumented stuff
36	// WIN32API CalcChildScroll
37	// WIN32API CascadeChildWindows
38	// WIN32API ClientThreadConnect
39	// WIN32API DragObject
40	// WIN32API DrawCaptionTempA
41	// WIN32API DrawCaptionTempW
42	// WIN32API DrawFrame
43	// WIN32API EditWndProc
44	// WIN32API EndTask
45	// WIN32API GetInputDesktop
46	// WIN32API GetInternalWindowPos
47	// WIN32API GetNextQueueWindow
48	// WIN32API GetShellWindow
49	// WIN32API InitSharedTable
50	// WIN32API InitTask
51	// WIN32API InternalGetWindowText
52	// WIN32API IsHungThread
53	// WIN32API LockWindowStation
54	// WIN32API ModifyAccess
55	// WIN32API PlaySoundEvent
56	// WIN32API RegisterLogonProcess
57	// WIN32API RegisterNetworkCapabilities
58	// WIN32API RegisterSystemThread
59	// WIN32API RegisterTasklist
60	// WIN32API SetDeskWallpaper
61	// WIN32API SetDesktopBitmap
62	// WIN32API SetInternalWindowPos
63	// WIN32API SetLogonNotifyWindow
64	// WIN32API SetShellWindow
65	// WIN32API SetSysColorsTemp
66	// WIN32API SetWindowFullScreenState
67	// WIN32API SwitchToThisWindow
68	// WIN32API SysErrorBox
69	// WIN32API TileChildWindows
70	// WIN32API UnlockWindowStation
71	// WIN32API UserClientDllInitialize
72	// WIN32API UserSignalProc
73	// WIN32API WinOldAppHackoMatic
74	// WIN32API WNDPROC_CALLBACK
75	// WIN32API YieldTask
76
77
78
79
80	//******************************************************************************
81	//******************************************************************************
82	HWND WIN32API GetActiveWindow()
83	{
84	return(O32_GetActiveWindow());
85	}
86	//******************************************************************************
87	//******************************************************************************
88	int __cdecl wsprintfA(char *lpOut, LPCSTR lpFmt, ...)
89	{
90	int rc;
91	va_list argptr;
92
93	#ifdef DEBUG
94	WriteLog("USER32: wsprintfA\n");
95	WriteLog("USER32: %s\n", lpFmt);
96	#endif
97	va_start(argptr, lpFmt);
98	rc = O32_wvsprintf(lpOut, (char *)lpFmt, argptr);
99	va_end(argptr);
100	#ifdef DEBUG
101	WriteLog("USER32: %s\n", lpOut);
102	#endif
103	return(rc);
104	}
105	//******************************************************************************
106	//******************************************************************************
107	int __cdecl wsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, ...)
108	{
109	int rc;
110	char *lpFmtA;
111	char szOut[512];
112	va_list argptr;
113
114	dprintf(("USER32: wsprintfW(%08xh,%08xh).\n",
115	lpOut,
116	lpFmt));
117
118	lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
119
120	/* @@@PH 98/07/13 transform "%s" to "%ls" does the unicode magic */
121	{
122	PSZ pszTemp;
123	PSZ pszTemp1;
124	ULONG ulStrings;
125	ULONG ulIndex; /* temporary string counter */
126
127	for (ulStrings = 0, /* determine number of placeholders */
128	pszTemp = lpFmtA;
129
130	(pszTemp != NULL) &&
131	(*pszTemp != 0);
132
133	ulStrings++)
134	{
135	pszTemp = strstr(pszTemp,
136	"%s");
137	if (pszTemp != NULL) /* skip 2 characters */
138	{
139	pszTemp++;
140	pszTemp++;
141	}
142	else
143	break; /* leave loop immediately */
144	}
145
146	if (ulStrings != 0) /* transformation required ? */
147	{
148	/* now reallocate lpFmt */
149	ulStrings += strlen(lpFmtA); /* calculate total string length */
150	pszTemp = lpFmtA; /* save string pointer */
151	pszTemp1 = lpFmtA; /* save string pointer */
152
153	/* @@@PH allocation has to be compatible to FreeAsciiString !!! */
154	lpFmtA = (char *)malloc(ulStrings + 1);
155	if (lpFmtA == NULL) /* check proper allocation */
156	return (0); /* raise error condition */
157
158	for (ulIndex = 0;
159	ulIndex <= ulStrings;
160	ulIndex++,
161	pszTemp++)
162	{
163	if ((pszTemp[0] == '%') &&
164	(pszTemp[1] == 's') )
165	{
166	/* replace %s by %ls */
167	lpFmtA[ulIndex++] = '%';
168	lpFmtA[ulIndex ] = 'l';
169	lpFmtA[ulIndex+1] = 's';
170	}
171	else
172	lpFmtA[ulIndex] = pszTemp; / just copy over the character */
173	}
174
175	lpFmtA[ulStrings] = 0; /* string termination */
176
177	FreeAsciiString(pszTemp1); /* the original string is obsolete */
178	}
179	}
180
181	dprintf(("USER32: wsprintfW (%s).\n",
182	lpFmt));
183
184	va_start(argptr,
185	lpFmt);
186
187	rc = O32_wvsprintf(szOut,
188	lpFmtA,
189	argptr);
190
191	AsciiToUnicode(szOut,
192	lpOut);
193
194	FreeAsciiString(lpFmtA);
195	return(rc);
196	}
197	//******************************************************************************
198	//******************************************************************************
199	int WIN32API MessageBoxA(HWND hwndOwner, LPCTSTR lpszText, LPCTSTR lpszTitle, UINT fuStyle)
200	{
201	dprintf(("USER32: MessageBoxA %s %s\n", lpszText, lpszTitle));
202	return(O32_MessageBox(hwndOwner, lpszText, lpszTitle, fuStyle));
203	}
204	//******************************************************************************
205	//******************************************************************************
206	BOOL WIN32API MessageBeep( UINT arg1)
207	{
208	#ifdef DEBUG
209	WriteLog("USER32: MessageBeep\n");
210	#endif
211	return O32_MessageBeep(arg1);
212	}
213	//******************************************************************************
214	//******************************************************************************
215	LONG WIN32API SendDlgItemMessageA( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
216	{
217	#ifdef DEBUG
218	WriteLog("USER32: SendDlgItemMessageA\n");
219	#endif
220	return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
221	}
222	//******************************************************************************
223	//******************************************************************************
224	VOID WIN32API PostQuitMessage( int arg1)
225	{
226	dprintf(("USER32: PostQuitMessage\n"));
227	O32_PostQuitMessage(arg1);
228	}
229	//******************************************************************************
230	//******************************************************************************
231	BOOL WIN32API IsDlgButtonChecked( HWND arg1, UINT arg2)
232	{
233	dprintf(("USER32: IsDlgButtonChecked\n"));
234	return O32_IsDlgButtonChecked(arg1, arg2);
235	}
236	//******************************************************************************
237	//******************************************************************************
238	int WIN32API GetWindowTextLengthA( HWND arg1)
239	{
240	dprintf(("USER32: GetWindowTextLength\n"));
241	return O32_GetWindowTextLength(arg1);
242	}
243	//******************************************************************************
244	//******************************************************************************
245	int WIN32API GetWindowTextA( HWND arg1, LPSTR arg2, int arg3)
246	{
247	dprintf(("USER32: GetWindowText\n"));
248	return O32_GetWindowText(arg1, arg2, arg3);
249	}
250	//******************************************************************************
251	//******************************************************************************
252	BOOL WIN32API GetWindowRect( HWND arg1, PRECT arg2)
253	{
254	BOOL rc;
255
256	rc = O32_GetWindowRect(arg1, arg2);
257	dprintf(("USER32: GetWindowRect %X returned %d\n", arg1, rc));
258	return(rc);
259	}
260	//******************************************************************************
261	//******************************************************************************
262	HWND WIN32API GetNextDlgTabItem( HWND arg1, HWND arg2, BOOL arg3)
263	{
264	dprintf(("USER32: GetNextDlgTabItem\n"));
265	return O32_GetNextDlgTabItem(arg1, arg2, arg3);
266	}
267	//******************************************************************************
268	//******************************************************************************
269	BOOL WIN32API GetMessageA( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
270	{
271	//// dprintf(("USER32: GetMessage\n"));
272	return O32_GetMessage(arg1, arg2, arg3, arg4);
273	}
274	//******************************************************************************
275	//******************************************************************************
276	HWND WIN32API GetFocus(void)
277	{
278	dprintf(("USER32: GetFocus\n"));
279	return O32_GetFocus();
280	}
281	//******************************************************************************
282	//******************************************************************************
283	HWND WIN32API GetDlgItem(HWND arg1, int arg2)
284	{
285	HWND rc;
286
287	rc = O32_GetDlgItem(arg1, arg2);
288	dprintf(("USER32: GetDlgItem %d returned %d\n", arg2, rc));
289	return(rc);
290	}
291	//******************************************************************************
292	//******************************************************************************
293	int WIN32API GetDlgCtrlID( HWND arg1)
294	{
295	dprintf(("USER32: GetDlgCtrlID\n"));
296	return O32_GetDlgCtrlID(arg1);
297	}
298	//******************************************************************************
299	//******************************************************************************
300	HWND WIN32API GetDesktopWindow(void)
301	{
302	dprintf(("USER32: GetDesktopWindow\n"));
303	return O32_GetDesktopWindow();
304	}
305	//******************************************************************************
306	//******************************************************************************
307	BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
308	{
309	BOOL rc;
310	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
311
312	dprintf(("USER32: EnumThreadWindows\n"));
313	rc = O32_EnumThreadWindows(dwThreadId, callback->GetOS2Callback(), (LPARAM)callback);
314	if(callback)
315	delete callback;
316	return(rc);
317	}
318	//******************************************************************************
319	//******************************************************************************
320	BOOL WIN32API EndDialog( HWND arg1, int arg2)
321	{
322	BOOL rc;
323
324	dprintf(("USER32: EndDialog\n"));
325	rc = O32_EndDialog(arg1, arg2);
326	return(rc);
327	}
328	//******************************************************************************
329	//******************************************************************************
330	LONG WIN32API DispatchMessageA( const MSG * arg1)
331	{
332	//// dprintf(("USER32: DispatchMessage\n"));
333	return O32_DispatchMessage(arg1);
334	}
335	//******************************************************************************
336	//******************************************************************************
337	BOOL WIN32API OffsetRect( PRECT arg1, int arg2, int arg3)
338	{
339	#ifdef DEBUG
340	//// WriteLog("USER32: OffsetRect\n");
341	#endif
342	return O32_OffsetRect(arg1, arg2, arg3);
343	}
344	//******************************************************************************
345	//******************************************************************************
346	BOOL WIN32API CopyRect( PRECT arg1, const RECT * arg2)
347	{
348	// ddprintf(("USER32: CopyRect\n"));
349	return O32_CopyRect(arg1, arg2);
350	}
351	//******************************************************************************
352	//******************************************************************************
353	BOOL WIN32API CheckDlgButton( HWND arg1, int arg2, UINT arg3)
354	{
355	dprintf(("USER32: CheckDlgButton\n"));
356	return O32_CheckDlgButton(arg1, arg2, arg3);
357	}
358	//******************************************************************************
359	//******************************************************************************
360	HWND WIN32API SetFocus( HWND arg1)
361	{
362	dprintf(("USER32: SetFocus\n"));
363	return O32_SetFocus(arg1);
364	}
365	//******************************************************************************
366	//******************************************************************************
367	BOOL WIN32API TranslateMessage( const MSG * arg1)
368	{
369	#ifdef DEBUG
370	//// WriteLog("USER32: TranslateMessage\n");
371	#endif
372	return O32_TranslateMessage(arg1);
373	}
374	//******************************************************************************
375	//******************************************************************************
376	BOOL WIN32API SetWindowPos( HWND arg1, HWND arg2, int arg3, int arg4, int arg5, int arg6, UINT arg7)
377	{
378	#ifdef DEBUG
379	WriteLog("USER32: SetWindowPos\n");
380	#endif
381	return O32_SetWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
382	}
383	//******************************************************************************
384	//******************************************************************************
385	BOOL WIN32API ShowWindow(HWND arg1, int arg2)
386	{
387	#ifdef DEBUG
388	WriteLog("USER32: ShowWindow %X %d\n", arg1, arg2);
389	#endif
390	return O32_ShowWindow(arg1, arg2);
391	}
392	//******************************************************************************
393	//******************************************************************************
394	BOOL WIN32API SetWindowTextA(HWND arg1, LPCSTR arg2)
395	{
396	#ifdef DEBUG
397	WriteLog("USER32: SetWindowText %s\n", arg2);
398	#endif
399	return O32_SetWindowText(arg1, arg2);
400	}
401	//******************************************************************************
402	//******************************************************************************
403	BOOL WIN32API SetForegroundWindow(HWND arg1)
404	{
405	#ifdef DEBUG
406	WriteLog("USER32: SetForegroundWindow\n");
407	#endif
408	return O32_SetForegroundWindow(arg1);
409	}
410	//******************************************************************************
411	//******************************************************************************
412	int WIN32API ReleaseDC( HWND arg1, HDC arg2)
413	{
414	#ifdef DEBUG
415	WriteLog("USER32: ReleaseDC\n");
416	#endif
417	return O32_ReleaseDC(arg1, arg2);
418	}
419	//******************************************************************************
420	//******************************************************************************
421	BOOL WIN32API InvalidateRect(HWND arg1, const RECT *arg2, BOOL arg3)
422	{
423	#ifdef DEBUG
424	if(arg2)
425	WriteLog("USER32: InvalidateRect for window %X (%d,%d)(%d,%d) %d\n", arg1, arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
426	else WriteLog("USER32: InvalidateRect for window %X NULL, %d\n", arg1, arg3);
427	#endif
428	return O32_InvalidateRect(arg1, arg2, arg3);
429	}
430	//******************************************************************************
431	//******************************************************************************
432	BOOL WIN32API GetUpdateRect( HWND arg1, PRECT arg2, BOOL arg3)
433	{
434	#ifdef DEBUG
435	WriteLog("USER32: GetUpdateRect\n");
436	#endif
437	return O32_GetUpdateRect(arg1, arg2, arg3);
438	}
439	//******************************************************************************
440	//******************************************************************************
441	HDC WIN32API GetDC( HWND arg1)
442	{
443	HDC hdc;
444
445	hdc = O32_GetDC(arg1);
446	#ifdef DEBUG
447	WriteLog("USER32: GetDC of %X returns %X\n", arg1, hdc);
448	#endif
449	return(hdc);
450	}
451	//******************************************************************************
452	//******************************************************************************
453	HDC WIN32API GetDCEx(HWND arg1, HRGN arg2, DWORD arg3)
454	{
455	#ifdef DEBUG
456	WriteLog("USER32: GetDCEx\n");
457	#endif
458	return O32_GetDCEx(arg1, arg2, arg3);
459	}
460	//******************************************************************************
461	//******************************************************************************
462	BOOL WIN32API GetClientRect( HWND arg1, PRECT arg2)
463	{
464	#ifdef DEBUG
465	WriteLog("USER32: GetClientRect of %X\n", arg1);
466	#endif
467
468	return O32_GetClientRect(arg1, arg2);
469	}
470	//******************************************************************************
471	//******************************************************************************
472	HWND WIN32API FindWindowA(LPCSTR arg1, LPCSTR arg2)
473	{
474	#ifdef DEBUG
475	WriteLog("USER32: FindWindow\n");
476	#endif
477	return O32_FindWindow(arg1, arg2);
478	}
479	//******************************************************************************
480	//******************************************************************************
481	HWND WIN32API FindWindowExA(HWND arg1, HWND arg2, LPCSTR arg3, LPCSTR arg4)
482	{
483	#ifdef DEBUG
484	WriteLog("USER32: FindWindowExA, not completely implemented\n");
485	#endif
486	return O32_FindWindow(arg3, arg4);
487	}
488	//******************************************************************************
489	//******************************************************************************
490	BOOL WIN32API FlashWindow( HWND arg1, BOOL arg2)
491	{
492	#ifdef DEBUG
493	WriteLog("USER32: FlashWindow\n");
494	#endif
495	return O32_FlashWindow(arg1, arg2);
496	}
497	//******************************************************************************
498	//******************************************************************************
499	BOOL WIN32API EndPaint( HWND arg1, const PAINTSTRUCT * arg2)
500	{
501	#ifdef DEBUG
502	WriteLog("USER32: EndPaint\n");
503	#endif
504	return O32_EndPaint(arg1, arg2);
505	}
506	//******************************************************************************
507	//******************************************************************************
508	BOOL WIN32API MoveWindow(HWND arg1, int arg2, int arg3, int arg4, int arg5, BOOL arg6)
509	{
510	BOOL rc;
511
512	rc = O32_MoveWindow(arg1, arg2, arg3, arg4, arg5, arg6);
513	dprintf(("USER32: MoveWindow %X to (%d,%d) size (%d,%d), repaint = %d returned %d\n", arg1, arg2, arg3, arg4, arg5, arg6, rc));
514	return(rc);
515	}
516	//******************************************************************************
517	//******************************************************************************
518	HWND WIN32API CreateWindowExA(DWORD dwExStyle,
519	LPCSTR arg2,
520	LPCSTR arg3,
521	DWORD dwStyle,
522	int x,
523	int y,
524	int nWidth,
525	int nHeight,
526	HWND arg9,
527	HMENU arg10,
528	HINSTANCE arg11,
529	PVOID arg12)
530	{
531	HWND hwnd;
532	Win32WindowProc *window = NULL;
533
534	/* @@@PH 98/06/12 CreateWindow crashes somewhere in Open32 */
535	if(arg3 == NULL)
536	arg3 = (LPCSTR)"CRASH, CRASH";
537
538	//SvL: This break generic.exe & notepad.exe (probably many others too)
539	//These parameters can be CW_USEDEFAULT, which is 0x80000000
540	#if 0
541	if (nWidth < 0) nWidth = 0;
542	if (x < 0) x = 0;
543	if (nHeight< 0) nHeight = 0;
544	if (y < 0) y = 0;
545	#endif
546
547	//SvL: Breaks applications
548	#if 0
549	/* @@@PH 98/06/21 redraw problems disappear when WS_SYNCPAINT is on */
550	#ifndef WS_VISIBLE
551	#define WS_VISIBLE 0x80000000L
552	#endif
553
554	#ifndef WS_SYNCPAINT
555	#define WS_SYNCPAINT 0x02000000L
556	#endif
557
558	dwStyle \|= WS_SYNCPAINT;
559
560	/* @@@PH 98/06/21 experimental fix for WinHlp32 */
561	// SOL.EXE crashes here, but WINHLP32 does not display the
562	// navigation buttons otherwise.
563	dwStyle \|= WS_VISIBLE;
564	#endif
565
566	#ifdef DEBUG
567	WriteLog("USER32: CreateWindow: dwExStyle = %X\n", dwExStyle);
568	if((int)arg2 >> 16 != 0)
569	WriteLog("USER32: CreateWindow: classname = %s\n", arg2);
570	else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
571	WriteLog("USER32: CreateWindow: windowname= %s\n", arg3);
572	WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
573	WriteLog("USER32: CreateWindow: x = %d\n", x);
574	WriteLog("USER32: CreateWindow: y = %d\n", y);
575	WriteLog("USER32: CreateWindow: nWidth = %d\n", nWidth);
576	WriteLog("USER32: CreateWindow: nHeight = %d\n", nHeight);
577	WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
578	WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
579	WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
580	WriteLog("USER32: CreateWindow: param = %X\n", arg12);
581	#endif
582
583	if((int) arg2 >> 16 != 0 && strcmp(arg2, "COMBOBOX") == 0)
584	{
585	dprintf(("COMBOBOX creation"));
586	//TODO: #%@#%$ Open32 doesn't support this
587	dwStyle &= ~(CBS_OWNERDRAWFIXED \| CBS_OWNERDRAWVARIABLE);
588
589	/* @@@PH 98/06/12 drop down combos are problematic too */
590	/* so we translate the styles to OS/2 style */
591	dwStyle \|= CBS_DROPDOWN \| CBS_DROPDOWNLIST;
592	}
593
594	//Classname might be name of system class, in which case we don't
595	//need to use our own callback
596	// if(Win32WindowClass::FindClass((LPSTR)arg2) != NULL) {
597	window = new Win32WindowProc(arg11, arg2);
598	// }
599
600	hwnd = O32_CreateWindowEx(dwExStyle,
601	arg2,
602	arg3,
603	dwStyle,
604	x,
605	y,
606	nWidth,
607	nHeight,
608	arg9,
609	arg10,
610	arg11,
611	arg12);
612
613	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
614	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
615	delete(window);
616	window = 0;
617	}
618	if(window) {
619	window->SetWindowHandle(hwnd);
620	}
621	dprintf(("USER32: ************CreateWindowExA %s (%d,%d,%d,%d), hwnd = %X\n", arg2, x, y, nWidth, nHeight, hwnd));
622	return(hwnd);
623	}
624	//******************************************************************************
625	//******************************************************************************
626	LRESULT WIN32API SendMessageA(HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
627	{
628	LRESULT rc;
629
630	#ifdef DEBUG
631	WriteLog("USER32: SendMessage....\n");
632	#endif
633	rc = O32_SendMessage(arg1, arg2, arg3, arg4);
634	#ifdef DEBUG
635	WriteLog("USER32: *****SendMessage %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
636	#endif
637	return(rc);
638	}
639	//******************************************************************************
640	//******************************************************************************
641	HWND WIN32API SetActiveWindow( HWND arg1)
642	{
643	#ifdef DEBUG
644	WriteLog("USER32: SetActiveWindow\n");
645	#endif
646	return O32_SetActiveWindow(arg1);
647	}
648	//******************************************************************************
649	//******************************************************************************
650	HDC WIN32API BeginPaint(HWND arg1, PPAINTSTRUCT arg2)
651	{
652	dprintf(("USER32: BeginPaint %X\n", arg2));
653	return O32_BeginPaint(arg1, arg2);
654	}
655	//******************************************************************************
656	//******************************************************************************
657	BOOL WIN32API IsDialogMessageA( HWND arg1, LPMSG arg2)
658	{
659	#ifdef DEBUG
660	//// WriteLog("USER32: IsDialogMessage\n");
661	#endif
662	return O32_IsDialogMessage(arg1, arg2);
663	}
664	//******************************************************************************
665	//******************************************************************************
666	int WIN32API DrawTextA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5)
667	{
668	#ifdef DEBUG
669	WriteLog("USER32: DrawTextA %s", arg2);
670	#endif
671	return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
672	}
673	//******************************************************************************
674	//******************************************************************************
675	int WIN32API DrawTextExA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
676	{
677	#ifdef DEBUG
678	WriteLog("USER32: DrawTextExA (not completely implemented) %s", arg2);
679	#endif
680	return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
681	}
682	//******************************************************************************
683	//******************************************************************************
684	int WIN32API GetSystemMetrics(int arg1)
685	{
686	int rc;
687
688	switch(arg1) {
689	case SM_CXICONSPACING: //TODO: size of grid cell for large icons
690	rc = O32_GetSystemMetrics(SM_CXICON);
691	break;
692	case SM_CYICONSPACING:
693	rc = O32_GetSystemMetrics(SM_CYICON);
694	break;
695	case SM_PENWINDOWS:
696	rc = FALSE;
697	break;
698	case SM_DBCSENABLED:
699	rc = FALSE;
700	break;
701	case SM_CXEDGE: //size of 3D window edge (not supported)
702	rc = 1;
703	break;
704	case SM_CYEDGE:
705	rc = 1;
706	break;
707	case SM_CXMINSPACING: //can be SM_CXMINIMIZED or larger
708	rc = O32_GetSystemMetrics(SM_CXMINIMIZED);
709	break;
710	case SM_CYMINSPACING:
711	rc = GetSystemMetrics(SM_CYMINIMIZED);
712	break;
713	case SM_CXSMICON: //recommended size of small icons (TODO: adjust to screen res.)
714	rc = 16;
715	break;
716	case SM_CYSMICON:
717	rc = 16;
718	break;
719	case SM_CYSMCAPTION: //size in pixels of a small caption (TODO: ????)
720	rc = 8;
721	break;
722	case SM_CXSMSIZE: //size of small caption buttons (pixels) (TODO: implement properly)
723	rc = 16;
724	break;
725	case SM_CYSMSIZE:
726	rc = 16;
727	break;
728	case SM_CXMENUSIZE: //TODO: size of menu bar buttons (such as MDI window close)
729	rc = 16;
730	break;
731	case SM_CYMENUSIZE:
732	rc = 16;
733	break;
734	case SM_ARRANGE:
735	rc = ARW_BOTTOMLEFT \| ARW_LEFT;
736	break;
737	case SM_CXMINIMIZED:
738	break;
739	case SM_CYMINIMIZED:
740	break;
741	case SM_CXMAXTRACK: //max window size
742	case SM_CXMAXIMIZED: //max toplevel window size
743	rc = O32_GetSystemMetrics(SM_CXSCREEN);
744	break;
745	case SM_CYMAXTRACK:
746	case SM_CYMAXIMIZED:
747	rc = O32_GetSystemMetrics(SM_CYSCREEN);
748	break;
749	case SM_NETWORK:
750	rc = 0x01; //TODO: default = yes
751	break;
752	case SM_CLEANBOOT:
753	rc = 0; //normal boot
754	break;
755	case SM_CXDRAG: //nr of pixels before drag becomes a real one
756	rc = 2;
757	break;
758	case SM_CYDRAG:
759	rc = 2;
760	break;
761	case SM_SHOWSOUNDS: //show instead of play sound
762	rc = FALSE;
763	break;
764	case SM_CXMENUCHECK:
765	rc = 4; //TODO
766	break;
767	case SM_CYMENUCHECK:
768	rc = O32_GetSystemMetrics(SM_CYMENU);
769	break;
770	case SM_SLOWMACHINE:
771	rc = FALSE; //even a slow machine is fast with OS/2 :)
772	break;
773	case SM_MIDEASTENABLED:
774	rc = FALSE;
775	break;
776	case SM_CMETRICS:
777	rc = O32_GetSystemMetrics(44); //Open32 changed this one
778	break;
779	default:
780	rc = O32_GetSystemMetrics(arg1);
781	break;
782	}
783	#ifdef DEBUG
784	WriteLog("USER32: GetSystemMetrics %d returned %d\n", arg1, rc);
785	#endif
786	return(rc);
787	}
788	//******************************************************************************
789	//******************************************************************************
790	UINT WIN32API SetTimer( HWND arg1, UINT arg2, UINT arg3, TIMERPROC arg4)
791	{
792	#ifdef DEBUG
793	WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
794	#endif
795	//SvL: Write callback handler class for this one
796	return O32_SetTimer(arg1, arg2, arg3, (TIMERPROC_O32)arg4);
797	}
798	//******************************************************************************
799	//******************************************************************************
800	BOOL WIN32API KillTimer(HWND arg1, UINT arg2)
801	{
802	#ifdef DEBUG
803	WriteLog("USER32: KillTimer\n");
804	#endif
805	return O32_KillTimer(arg1, arg2);
806	}
807	//******************************************************************************
808	//******************************************************************************
809	BOOL WIN32API DestroyWindow(HWND arg1)
810	{
811	#ifdef DEBUG
812	WriteLog("USER32: DestroyWindow\n");
813	#endif
814	return O32_DestroyWindow(arg1);
815	}
816	//******************************************************************************
817	//******************************************************************************
818	BOOL WIN32API PostMessageA( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
819	{
820	#ifdef DEBUG
821	WriteLog("USER32: PostMessageA %X %X %X %X\n", arg1, arg2, arg3, arg4);
822	#endif
823	return O32_PostMessage(arg1, arg2, arg3, arg4);
824	}
825	//******************************************************************************
826	//******************************************************************************
827	BOOL WIN32API InflateRect( PRECT arg1, int arg2, int arg3)
828	{
829	#ifdef DEBUG
830	WriteLog("USER32: InflateRect\n");
831	#endif
832	return O32_InflateRect(arg1, arg2, arg3);
833	}
834	//******************************************************************************
835	//TODO:How can we emulate this one in OS/2???
836	//******************************************************************************
837	DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
838	{
839	#ifdef DEBUG
840	WriteLog("USER32: WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
841	#endif
842
843	if(dwTimeOut == INFINITE) return(0);
844
845	// DosSleep(dwTimeOut/16);
846	return(0);
847	}
848	//******************************************************************************
849	//******************************************************************************
850	UINT WIN32API GetDlgItemTextA(HWND arg1, int arg2, LPSTR arg3, UINT arg4)
851	{
852	UINT rc;
853
854	rc = O32_GetDlgItemText(arg1, arg2, arg3, arg4);
855	#ifdef DEBUG
856	if(rc)
857	WriteLog("USER32: GetDlgItemTextA returned %s\n", arg3);
858	else WriteLog("USER32: GetDlgItemTextA returned 0 (%d)\n", GetLastError());
859	#endif
860	return(rc);
861	}
862	//******************************************************************************
863	//******************************************************************************
864	BOOL WIN32API PeekMessageA(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
865	{
866	#ifdef DEBUG
867	// WriteLog("USER32: PeekMessage\n");
868	#endif
869	return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
870	}
871	//******************************************************************************
872	//******************************************************************************
873	int WIN32API ShowCursor( BOOL arg1)
874	{
875	#ifdef DEBUG
876	WriteLog("USER32: ShowCursor\n");
877	#endif
878	return O32_ShowCursor(arg1);
879	}
880	//******************************************************************************
881	//BUGBUG: UpdateWindow sends a WM_ERASEBKGRND when it shouldn't!
882	// So we just do it manually
883	//******************************************************************************
884	BOOL WIN32API UpdateWindow(HWND hwnd)
885	{
886	RECT rect;
887
888	#ifdef DEBUG
889	WriteLog("USER32: UpdateWindow\n");
890	#endif
891	if(O32_GetUpdateRect(hwnd, &rect, FALSE) != FALSE) {//update region empty?
892	WndCallback(hwnd, WM_PAINT, 0, 0);
893	// O32_PostMessage(hwnd, WM_PAINT, 0, 0);
894	}
895	#ifdef DEBUG
896	else WriteLog("USER32: Update region empty!\n");
897	#endif
898	return(TRUE);
899	}
900	//******************************************************************************
901	//******************************************************************************
902	BOOL WIN32API AdjustWindowRect( PRECT arg1, DWORD arg2, BOOL arg3)
903	{
904	#ifdef DEBUG
905	WriteLog("USER32: AdjustWindowRect\n");
906	#endif
907	return O32_AdjustWindowRect(arg1, arg2, arg3);
908	}
909	//******************************************************************************
910	//******************************************************************************
911	BOOL WIN32API AdjustWindowRectEx( PRECT arg1, DWORD arg2, BOOL arg3, DWORD arg4)
912	{
913	#ifdef DEBUG
914	WriteLog("USER32: AdjustWindowRectEx\n");
915	#endif
916	return O32_AdjustWindowRectEx(arg1, arg2, arg3, arg4);
917	}
918	//******************************************************************************
919	//******************************************************************************
920	BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
921	{
922	#ifdef DEBUG
923	//// WriteLog("USER32: ClientToScreen\n");
924	#endif
925	return O32_ClientToScreen(arg1, arg2);
926	}
927	//******************************************************************************
928	//******************************************************************************
929	BOOL WIN32API SetRect( PRECT arg1, int arg2, int arg3, int arg4, int arg5)
930	{
931	#ifdef DEBUG
932	WriteLog("USER32: SetRect\n");
933	#endif
934	return O32_SetRect(arg1, arg2, arg3, arg4, arg5);
935	}
936	//******************************************************************************
937	//******************************************************************************
938	LONG WIN32API GetWindowLongA(HWND hwnd, int nIndex)
939	{
940	LONG rc;
941
942	#ifdef DEBUG
943	WriteLog("USER32: GetWindowLong %X %d\n", hwnd, nIndex);
944	#endif
945	if(nIndex == GWL_WNDPROC \|\| nIndex == DWL_DLGPROC) {
946	Win32WindowProc *window = Win32WindowProc::FindProc(hwnd);
947	if(window && !(nIndex == DWL_DLGPROC && window->IsWindow() == TRUE)) {
948	return (LONG)window->GetWin32Callback();
949	}
950	}
951	rc = O32_GetWindowLong(hwnd, nIndex);
952	#ifdef DEBUG
953	WriteLog("USER32: GetWindowLong returned %X\n", rc);
954	#endif
955	return(rc);
956	}
957	//******************************************************************************
958	//******************************************************************************
959	BOOL WIN32API SetDlgItemInt( HWND arg1, int arg2, UINT arg3, BOOL arg4)
960	{
961	#ifdef DEBUG
962	WriteLog("USER32: SetDlgItemInt\n");
963	#endif
964	return O32_SetDlgItemInt(arg1, arg2, arg3, arg4);
965	}
966	//******************************************************************************
967	//******************************************************************************
968	BOOL WIN32API SetDlgItemTextA( HWND arg1, int arg2, LPCSTR arg3)
969	{
970	#ifdef DEBUG
971	WriteLog("USER32: SetDlgItemText to %s\n", arg3);
972	#endif
973	return O32_SetDlgItemText(arg1, arg2, arg3);
974	}
975	//******************************************************************************
976	//******************************************************************************
977	BOOL WIN32API WinHelpA( HWND arg1, LPCSTR arg2, UINT arg3, DWORD arg4)
978	{
979	#ifdef DEBUG
980	WriteLog("USER32: WinHelp not implemented %s\n", arg2);
981	#endif
982	// return O32_WinHelp(arg1, arg2, arg3, arg4);
983	return(TRUE);
984	}
985	//******************************************************************************
986	//******************************************************************************
987	BOOL WIN32API IsIconic( HWND arg1)
988	{
989	#ifdef DEBUG
990	WriteLog("USER32: IsIconic\n");
991	#endif
992	return O32_IsIconic(arg1);
993	}
994	//******************************************************************************
995	//******************************************************************************
996	int WIN32API TranslateAcceleratorA(HWND arg1, HACCEL arg2, LPMSG arg3)
997	{
998	#ifdef DEBUG
999	//// WriteLog("USER32: TranslateAccelerator\n");
1000	#endif
1001	return O32_TranslateAccelerator(arg1, arg2, arg3);
1002	}
1003	//******************************************************************************
1004	//******************************************************************************
1005	HWND WIN32API GetWindow(HWND arg1, UINT arg2)
1006	{
1007	HWND rc;
1008
1009	rc = O32_GetWindow(arg1, arg2);
1010	#ifdef DEBUG
1011	WriteLog("USER32: GetWindow %X %d returned %d\n", arg1, arg2, rc);
1012	#endif
1013	return(rc);
1014	}
1015	//******************************************************************************
1016	//******************************************************************************
1017	HDC WIN32API GetWindowDC(HWND arg1)
1018	{
1019	#ifdef DEBUG
1020	WriteLog("USER32: GetWindowDC\n");
1021	#endif
1022	return O32_GetWindowDC(arg1);
1023	}
1024	//******************************************************************************
1025	//******************************************************************************
1026	BOOL WIN32API SubtractRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
1027	{
1028	#ifdef DEBUG
1029	WriteLog("USER32: SubtractRect");
1030	#endif
1031	return O32_SubtractRect(arg1, arg2, arg3);
1032	}
1033	//******************************************************************************
1034	//SvL: 24-6-'97 - Added
1035	//******************************************************************************
1036	BOOL WIN32API ClipCursor(const RECT * arg1)
1037	{
1038	#ifdef DEBUG
1039	WriteLog("USER32: ClipCursor\n");
1040	#endif
1041	return O32_ClipCursor(arg1);
1042	}
1043	//******************************************************************************
1044	//SvL: 24-6-'97 - Added
1045	//TODO: Not implemented
1046	//******************************************************************************
1047	WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1048	{
1049	#ifdef DEBUG
1050	//// WriteLog("USER32: GetAsyncKeyState Not implemented\n");
1051	#endif
1052	return 0;
1053	}
1054	//******************************************************************************
1055	//SvL: 24-6-'97 - Added
1056	//******************************************************************************
1057	HCURSOR WIN32API GetCursor(void)
1058	{
1059	#ifdef DEBUG
1060	//// WriteLog("USER32: GetCursor\n");
1061	#endif
1062	return O32_GetCursor();
1063	}
1064	//******************************************************************************
1065	//SvL: 24-6-'97 - Added
1066	//******************************************************************************
1067	BOOL WIN32API GetCursorPos( PPOINT arg1)
1068	{
1069	#ifdef DEBUG
1070	//// WriteLog("USER32: GetCursorPos\n");
1071	#endif
1072	return O32_GetCursorPos(arg1);
1073	}
1074	//******************************************************************************
1075	//SvL: 24-6-'97 - Added
1076	//******************************************************************************
1077	UINT WIN32API RegisterWindowMessageA(LPCSTR arg1)
1078	{
1079	UINT rc;
1080
1081	rc = O32_RegisterWindowMessage(arg1);
1082	#ifdef DEBUG
1083	WriteLog("USER32: RegisterWindowMessageA %s returned %X\n", arg1, rc);
1084	#endif
1085	return(rc);
1086	}
1087	//******************************************************************************
1088	//SvL: 24-6-'97 - Added
1089	//******************************************************************************
1090	WORD WIN32API VkKeyScanA( char arg1)
1091	{
1092	#ifdef DEBUG
1093	WriteLog("USER32: VkKeyScanA\n");
1094	#endif
1095	return O32_VkKeyScan(arg1);
1096	}
1097	//******************************************************************************
1098	//SvL: 24-6-'97 - Added
1099	//******************************************************************************
1100	SHORT WIN32API GetKeyState( int arg1)
1101	{
1102	#ifdef DEBUG
1103	WriteLog("USER32: GetKeyState %d\n", arg1);
1104	#endif
1105	return O32_GetKeyState(arg1);
1106	}
1107	//******************************************************************************
1108	//******************************************************************************
1109	HCURSOR WIN32API SetCursor( HCURSOR arg1)
1110	{
1111	#ifdef DEBUG
1112	WriteLog("USER32: SetCursor\n");
1113	#endif
1114	return O32_SetCursor(arg1);
1115	}
1116	//******************************************************************************
1117	//******************************************************************************
1118	BOOL WIN32API SetCursorPos( int arg1, int arg2)
1119	{
1120	#ifdef DEBUG
1121	WriteLog("USER32: SetCursorPos\n");
1122	#endif
1123	return O32_SetCursorPos(arg1, arg2);
1124	}
1125	//******************************************************************************
1126	//******************************************************************************
1127	BOOL WIN32API EnableScrollBar( HWND arg1, INT arg2, UINT arg3)
1128	{
1129	#ifdef DEBUG
1130	WriteLog("USER32: EnableScrollBar\n");
1131	#endif
1132	return O32_EnableScrollBar(arg1, arg2, arg3);
1133	}
1134	//******************************************************************************
1135	//******************************************************************************
1136	BOOL WIN32API EnableWindow( HWND arg1, BOOL arg2)
1137	{
1138	#ifdef DEBUG
1139	WriteLog("USER32: EnableWindow\n");
1140	#endif
1141	return O32_EnableWindow(arg1, arg2);
1142	}
1143	//******************************************************************************
1144	//******************************************************************************
1145	HWND WIN32API SetCapture( HWND arg1)
1146	{
1147	#ifdef DEBUG
1148	WriteLog("USER32: SetCapture\n");
1149	#endif
1150	return O32_SetCapture(arg1);
1151	}
1152	//******************************************************************************
1153	//******************************************************************************
1154	BOOL WIN32API ReleaseCapture(void)
1155	{
1156	#ifdef DEBUG
1157	WriteLog("USER32: ReleaseCapture\n");
1158	#endif
1159	return O32_ReleaseCapture();
1160	}
1161	//******************************************************************************
1162	//******************************************************************************
1163	DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD arg5)
1164	{
1165	#ifdef DEBUG
1166	WriteLog("USER32: MsgWaitForMultipleObjects\n");
1167	#endif
1168	return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
1169	}
1170	//******************************************************************************
1171	//******************************************************************************
1172	HDWP WIN32API BeginDeferWindowPos( int arg1)
1173	{
1174	#ifdef DEBUG
1175	WriteLog("USER32: BeginDeferWindowPos\n");
1176	#endif
1177	return O32_BeginDeferWindowPos(arg1);
1178	}
1179	//******************************************************************************
1180	//******************************************************************************
1181	BOOL WIN32API BringWindowToTop( HWND arg1)
1182	{
1183	#ifdef DEBUG
1184	WriteLog("USER32: BringWindowToTop\n");
1185	#endif
1186	return O32_BringWindowToTop(arg1);
1187	}
1188	//******************************************************************************
1189	//******************************************************************************
1190	BOOL WIN32API CallMsgFilterA( LPMSG arg1, int arg2)
1191	{
1192	#ifdef DEBUG
1193	WriteLog("USER32: CallMsgFilterA\n");
1194	#endif
1195	return O32_CallMsgFilter(arg1, arg2);
1196	}
1197	//******************************************************************************
1198	//******************************************************************************
1199	BOOL WIN32API CallMsgFilterW( LPMSG arg1, int arg2)
1200	{
1201	#ifdef DEBUG
1202	WriteLog("USER32: CallMsgFilterW\n");
1203	#endif
1204	// NOTE: This will not work as is (needs UNICODE support)
1205	return O32_CallMsgFilter(arg1, arg2);
1206	}
1207	//******************************************************************************
1208	//******************************************************************************
1209	LRESULT WIN32API CallWindowProcA(WNDPROC wndprcPrev,
1210	HWND arg2,
1211	UINT arg3,
1212	WPARAM arg4,
1213	LPARAM arg5)
1214	{
1215	#ifdef DEBUG
1216	//// WriteLog("USER32: CallWindowProcA %X hwnd=%X, msg = %X\n", wndprcPrev, arg2, arg3);
1217	#endif
1218
1219	if(Win32WindowSubProc::FindSubProc((WNDPROC_O32)wndprcPrev) != NULL) {
1220	WNDPROC_O32 orgprc = (WNDPROC_O32)wndprcPrev; //is original Open32 system class callback (_System)
1221	return orgprc(arg2, arg3, arg4, arg5);
1222	}
1223	else return wndprcPrev(arg2, arg3, arg4, arg5); //win32 callback (__stdcall)
1224	}
1225	//******************************************************************************
1226	//******************************************************************************
1227	LRESULT WIN32API CallWindowProcW(WNDPROC arg1,
1228	HWND arg2,
1229	UINT arg3,
1230	WPARAM arg4,
1231	LPARAM arg5)
1232	{
1233	dprintf(("USER32: CallWindowProcW(%08xh,%08xh,%08xh,%08xh,%08xh) not properly implemented.\n",
1234	arg1,
1235	arg2,
1236	arg3,
1237	arg4,
1238	arg5));
1239
1240	return CallWindowProcA(arg1,
1241	arg2,
1242	arg3,
1243	arg4,
1244	arg5);
1245	}
1246	//******************************************************************************
1247	//******************************************************************************
1248	BOOL WIN32API ChangeClipboardChain( HWND arg1, HWND arg2)
1249	{
1250	#ifdef DEBUG
1251	WriteLog("USER32: ChangeClipboardChain\n");
1252	#endif
1253	return O32_ChangeClipboardChain(arg1, arg2);
1254	}
1255	//******************************************************************************
1256	//******************************************************************************
1257	UINT WIN32API ArrangeIconicWindows( HWND arg1)
1258	{
1259	#ifdef DEBUG
1260	WriteLog("USER32: ArrangeIconicWindows\n");
1261	#endif
1262	return O32_ArrangeIconicWindows(arg1);
1263	}
1264	//******************************************************************************
1265	//******************************************************************************
1266	BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT arg4)
1267	{
1268	#ifdef DEBUG
1269	WriteLog("USER32: CheckRadioButton\n");
1270	#endif
1271	return O32_CheckRadioButton(arg1, arg2, arg3, arg4);
1272	}
1273	//******************************************************************************
1274	//******************************************************************************
1275	HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
1276	{
1277	#ifdef DEBUG
1278	WriteLog("USER32: ChildWindowFromPoint\n");
1279	#endif
1280	return O32_ChildWindowFromPoint(arg1, arg2);
1281	}
1282	//******************************************************************************
1283	//******************************************************************************
1284	HWND WIN32API ChildWindowFromPointEx(HWND arg1, POINT arg2, UINT uFlags)
1285	{
1286	#ifdef DEBUG
1287	WriteLog("USER32: ChildWindowFromPointEx, not completely supported!\n");
1288	#endif
1289	return O32_ChildWindowFromPoint(arg1, arg2);
1290	}
1291	//******************************************************************************
1292	//******************************************************************************
1293	BOOL WIN32API CloseClipboard(void)
1294	{
1295	#ifdef DEBUG
1296	WriteLog("USER32: CloseClipboard\n");
1297	#endif
1298	return O32_CloseClipboard();
1299	}
1300	//******************************************************************************
1301	//******************************************************************************
1302	BOOL WIN32API CloseWindow( HWND arg1)
1303	{
1304	#ifdef DEBUG
1305	WriteLog("USER32: CloseWindow\n");
1306	#endif
1307	return O32_CloseWindow(arg1);
1308	}
1309	//******************************************************************************
1310	//******************************************************************************
1311	HICON WIN32API CopyIcon( HICON arg1)
1312	{
1313	#ifdef DEBUG
1314	WriteLog("USER32: CopyIcon\n");
1315	#endif
1316	return O32_CopyIcon(arg1);
1317	}
1318	//******************************************************************************
1319	//******************************************************************************
1320	int WIN32API CountClipboardFormats(void)
1321	{
1322	#ifdef DEBUG
1323	WriteLog("USER32: CountClipboardFormats\n");
1324	#endif
1325	return O32_CountClipboardFormats();
1326	}
1327	//******************************************************************************
1328	//******************************************************************************
1329	HACCEL WIN32API CreateAcceleratorTableA( LPACCEL arg1, int arg2)
1330	{
1331	#ifdef DEBUG
1332	WriteLog("USER32: CreateAcceleratorTableA\n");
1333	#endif
1334	return O32_CreateAcceleratorTable(arg1, arg2);
1335	}
1336	//******************************************************************************
1337	//******************************************************************************
1338	HACCEL WIN32API CreateAcceleratorTableW( LPACCEL arg1, int arg2)
1339	{
1340	#ifdef DEBUG
1341	WriteLog("USER32: CreateAcceleratorTableW\n");
1342	#endif
1343	// NOTE: This will not work as is (needs UNICODE support)
1344	return O32_CreateAcceleratorTable(arg1, arg2);
1345	}
1346	//******************************************************************************
1347	//******************************************************************************
1348	BOOL WIN32API CreateCaret( HWND arg1, HBITMAP arg2, int arg3, int arg4)
1349	{
1350	#ifdef DEBUG
1351	WriteLog("USER32: CreateCaret\n");
1352	#endif
1353	return O32_CreateCaret(arg1, arg2, arg3, arg4);
1354	}
1355	//******************************************************************************
1356	//******************************************************************************
1357	HCURSOR WIN32API CreateCursor( HINSTANCE arg1, int arg2, int arg3, int arg4, int arg5, const VOID * arg6, const VOID * arg7)
1358	{
1359	#ifdef DEBUG
1360	WriteLog("USER32: CreateCursor\n");
1361	#endif
1362	return O32_CreateCursor(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1363	}
1364	//******************************************************************************
1365	//******************************************************************************
1366	HICON WIN32API CreateIcon( HINSTANCE arg1, INT arg2, INT arg3, BYTE arg4, BYTE arg5, LPCVOID arg6, LPCVOID arg7)
1367	{
1368	#ifdef DEBUG
1369	WriteLog("USER32: CreateIcon\n");
1370	#endif
1371	return O32_CreateIcon(arg1, arg2, arg3, arg4, arg5, (const BYTE )arg6, (const BYTE )arg7);
1372	}
1373	//******************************************************************************
1374	//ASSERT dwVer == win31 (ok according to SDK docs)
1375	//******************************************************************************
1376	HICON WIN32API CreateIconFromResource(PBYTE presbits, UINT dwResSize,
1377	BOOL fIcon, DWORD dwVer)
1378	{
1379	HICON hicon;
1380	DWORD OS2ResSize = 0;
1381	PBYTE OS2Icon = ConvertWin32Icon(presbits, dwResSize, &OS2ResSize);
1382
1383	hicon = O32_CreateIconFromResource(OS2Icon, OS2ResSize, fIcon, dwVer);
1384	#ifdef DEBUG
1385	WriteLog("USER32: CreateIconFromResource returned %X (%X)\n", hicon, GetLastError());
1386	#endif
1387	if(OS2Icon)
1388	FreeIcon(OS2Icon);
1389
1390	return(hicon);
1391	}
1392	//******************************************************************************
1393	//******************************************************************************
1394	HICON WIN32API CreateIconFromResourceEx(PBYTE presbits, UINT dwResSize,
1395	BOOL fIcon, DWORD dwVer,
1396	int cxDesired, int cyDesired,
1397	UINT Flags)
1398	{
1399	#ifdef DEBUG
1400	WriteLog("USER32: CreateIconFromResourceEx %X %d %d %X %d %d %X, not completely supported!\n", presbits, dwResSize, fIcon, dwVer, cxDesired, cyDesired, Flags);
1401	#endif
1402	return CreateIconFromResource(presbits, dwResSize, fIcon, dwVer);
1403	}
1404	//******************************************************************************
1405	//******************************************************************************
1406	HICON WIN32API CreateIconIndirect(LPICONINFO arg1)
1407	{
1408	#ifdef DEBUG
1409	WriteLog("USER32: CreateIconIndirect\n");
1410	#endif
1411	return O32_CreateIconIndirect(arg1);
1412	}
1413	//******************************************************************************
1414	//******************************************************************************
1415	HWND WIN32API CreateMDIWindowA(LPCSTR arg1, LPCSTR arg2, DWORD arg3,
1416	int arg4, int arg5, int arg6, int arg7,
1417	HWND arg8, HINSTANCE arg9, LPARAM arg10)
1418	{
1419	HWND hwnd;
1420
1421	#ifdef DEBUG
1422	WriteLog("USER32: CreateMDIWindowA\n");
1423	#endif
1424	Win32WindowProc *window = new Win32WindowProc(arg9, arg1);
1425	hwnd = O32_CreateMDIWindow((LPSTR)arg1, (LPSTR)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1426	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1427	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1428	delete(window);
1429	window = 0;
1430	}
1431
1432	#ifdef DEBUG
1433	WriteLog("USER32: CreateMDIWindowA returned %X\n", hwnd);
1434	#endif
1435	return hwnd;
1436	}
1437	//******************************************************************************
1438	//******************************************************************************
1439	HWND WIN32API CreateMDIWindowW(LPCWSTR arg1, LPCWSTR arg2, DWORD arg3, int arg4,
1440	int arg5, int arg6, int arg7, HWND arg8, HINSTANCE arg9,
1441	LPARAM arg10)
1442	{
1443	HWND hwnd;
1444	char astring1 = NULL, astring2 = NULL;
1445	Win32WindowProc *window = NULL;
1446
1447	if((int)arg1 >> 16 != 0) {
1448	astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1449	}
1450	else astring1 = (char *)arg2;
1451
1452	astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1453
1454	//Classname might be name of system class, in which case we don't
1455	//need to use our own callback
1456	// if(Win32WindowClass::FindClass((LPSTR)astring1) != NULL) {
1457	window = new Win32WindowProc(arg9, astring1);
1458	// }
1459	hwnd = O32_CreateMDIWindow(astring1, astring2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1460	//SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1461	if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1462	delete(window);
1463	window = 0;
1464	}
1465	if(window) {
1466	window->SetWindowHandle(hwnd);
1467	}
1468
1469	if(astring1) FreeAsciiString(astring1);
1470	FreeAsciiString(astring2);
1471	#ifdef DEBUG
1472	WriteLog("USER32: CreateMDIWindowW hwnd = %X\n", hwnd);
1473	#endif
1474	return(hwnd);
1475	}
1476	//******************************************************************************
1477	//******************************************************************************
1478	HWND WIN32API CreateWindowExW(DWORD arg1,
1479	LPCWSTR arg2,
1480	LPCWSTR arg3,
1481	DWORD dwStyle,
1482	int arg5,
1483	int arg6,
1484	int arg7,
1485	int arg8,
1486	HWND arg9,
1487	HMENU arg10,
1488	HINSTANCE arg11,
1489	PVOID arg12)
1490	{
1491	HWND hwnd;
1492	char *astring1 = NULL,
1493	*astring2 = NULL;
1494	Win32WindowProc *window = NULL;
1495
1496	/* @@@PH 98/06/21 changed to call OS2CreateWindowExA */
1497	if((int)arg2 >> 16 != 0)
1498	astring1 = UnicodeToAsciiString((LPWSTR)arg2);
1499	else
1500	astring1 = (char *)arg2;
1501
1502	astring2 = UnicodeToAsciiString((LPWSTR)arg3);
1503
1504	#ifdef DEBUG
1505	WriteLog("USER32: CreateWindowExW: dwExStyle = %X\n", arg1);
1506	if((int)arg2 >> 16 != 0)
1507	WriteLog("USER32: CreateWindow: classname = %s\n", astring1);
1508	else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
1509	WriteLog("USER32: CreateWindow: windowname= %s\n", astring2);
1510	WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
1511	WriteLog("USER32: CreateWindow: x = %d\n", arg5);
1512	WriteLog("USER32: CreateWindow: y = %d\n", arg6);
1513	WriteLog("USER32: CreateWindow: nWidth = %d\n", arg7);
1514	WriteLog("USER32: CreateWindow: nHeight = %d\n", arg8);
1515	WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
1516	WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
1517	WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
1518	WriteLog("USER32: CreateWindow: param = %X\n", arg12);
1519	#endif
1520
1521	hwnd = CreateWindowExA(arg1,
1522	astring1,
1523	astring2,
1524	dwStyle,
1525	arg5,
1526	arg6,
1527	arg7,
1528	arg8,
1529	arg9,
1530	arg10,
1531	arg11,
1532	arg12);
1533
1534	if(astring1)
1535	FreeAsciiString(astring1);
1536
1537	FreeAsciiString(astring2);
1538
1539	#ifdef DEBUG
1540	WriteLog("USER32: ************CreateWindowExW hwnd = %X (%X)\n", hwnd, GetLastError());
1541	#endif
1542	return(hwnd);
1543	}
1544	//******************************************************************************
1545	//******************************************************************************
1546	HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
1547	{
1548	#ifdef DEBUG
1549	WriteLog("USER32: DeferWindowPos\n");
1550	#endif
1551	return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1552	}
1553	//******************************************************************************
1554	//******************************************************************************
1555	BOOL WIN32API DestroyAcceleratorTable( HACCEL arg1)
1556	{
1557	#ifdef DEBUG
1558	WriteLog("USER32: DestroyAcceleratorTable\n");
1559	#endif
1560	return O32_DestroyAcceleratorTable(arg1);
1561	}
1562	//******************************************************************************
1563	//******************************************************************************
1564	BOOL WIN32API DestroyCaret(void)
1565	{
1566	#ifdef DEBUG
1567	WriteLog("USER32: DestroyCaret\n");
1568	#endif
1569	return O32_DestroyCaret();
1570	}
1571	//******************************************************************************
1572	//******************************************************************************
1573	BOOL WIN32API DestroyCursor( HCURSOR arg1)
1574	{
1575	#ifdef DEBUG
1576	WriteLog("USER32: DestroyCursor\n");
1577	#endif
1578	return O32_DestroyCursor(arg1);
1579	}
1580	//******************************************************************************
1581	//******************************************************************************
1582	BOOL WIN32API DestroyIcon( HICON arg1)
1583	{
1584	#ifdef DEBUG
1585	WriteLog("USER32: DestroyIcon\n");
1586	#endif
1587	return O32_DestroyIcon(arg1);
1588	}
1589	//******************************************************************************
1590	//******************************************************************************
1591	LONG WIN32API DispatchMessageW( const MSG * arg1)
1592	{
1593	#ifdef DEBUG
1594	WriteLog("USER32: DispatchMessageW\n");
1595	#endif
1596	// NOTE: This will not work as is (needs UNICODE support)
1597	return O32_DispatchMessage(arg1);
1598	}
1599	//******************************************************************************
1600	//******************************************************************************
1601	int WIN32API DlgDirListA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1602	{
1603	#ifdef DEBUG
1604	WriteLog("USER32: DlgDirListA\n");
1605	#endif
1606	return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1607	}
1608	//******************************************************************************
1609	//******************************************************************************
1610	int WIN32API DlgDirListComboBoxA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1611	{
1612	#ifdef DEBUG
1613	WriteLog("USER32: DlgDirListComboBoxA\n");
1614	#endif
1615	return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1616	}
1617	//******************************************************************************
1618	//******************************************************************************
1619	int WIN32API DlgDirListComboBoxW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1620	{
1621	#ifdef DEBUG
1622	WriteLog("USER32: DlgDirListComboBoxW NOT WORKING\n");
1623	#endif
1624	// NOTE: This will not work as is (needs UNICODE support)
1625	return 0;
1626	// return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1627	}
1628	//******************************************************************************
1629	//******************************************************************************
1630	int WIN32API DlgDirListW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1631	{
1632	#ifdef DEBUG
1633	WriteLog("USER32: DlgDirListW NOT WORKING\n");
1634	#endif
1635	// NOTE: This will not work as is (needs UNICODE support)
1636	return 0;
1637	// return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1638	}
1639	//******************************************************************************
1640	//******************************************************************************
1641	BOOL WIN32API DlgDirSelectComboBoxExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1642	{
1643	#ifdef DEBUG
1644	WriteLog("USER32: DlgDirSelectComboBoxExA\n");
1645	#endif
1646	return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1647	}
1648	//******************************************************************************
1649	//******************************************************************************
1650	BOOL WIN32API DlgDirSelectComboBoxExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1651	{
1652	#ifdef DEBUG
1653	WriteLog("USER32: DlgDirSelectComboBoxExW NOT WORKING\n");
1654	#endif
1655	// NOTE: This will not work as is (needs UNICODE support)
1656	return 0;
1657	// return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1658	}
1659	//******************************************************************************
1660	//******************************************************************************
1661	BOOL WIN32API DlgDirSelectExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1662	{
1663	#ifdef DEBUG
1664	WriteLog("USER32: DlgDirSelectExA\n");
1665	#endif
1666	return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1667	}
1668	//******************************************************************************
1669	//******************************************************************************
1670	BOOL WIN32API DlgDirSelectExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1671	{
1672	#ifdef DEBUG
1673	WriteLog("USER32: DlgDirSelectExW NOT WORKING\n");
1674	#endif
1675	// NOTE: This will not work as is (needs UNICODE support)
1676	return 0;
1677	// return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1678	}
1679	//******************************************************************************
1680	//******************************************************************************
1681	BOOL WIN32API DrawFocusRect( HDC arg1, const RECT * arg2)
1682	{
1683	#ifdef DEBUG
1684	WriteLog("USER32: DrawFocusRect\n");
1685	#endif
1686	return O32_DrawFocusRect(arg1, arg2);
1687	}
1688	//******************************************************************************
1689	//******************************************************************************
1690	BOOL WIN32API DrawIcon( HDC arg1, int arg2, int arg3, HICON arg4)
1691	{
1692	#ifdef DEBUG
1693	WriteLog("USER32: DrawIcon\n");
1694	#endif
1695	return O32_DrawIcon(arg1, arg2, arg3, arg4);
1696	}
1697	//******************************************************************************
1698	//******************************************************************************
1699	BOOL WIN32API DrawIconEx(HDC hdc, int xLeft, int xRight, HICON hIcon,
1700	int cxWidth, int cyWidth, UINT istepIfAniCur,
1701	HBRUSH hbrFlickerFreeDraw, UINT diFlags)
1702	{
1703	#ifdef DEBUG
1704	WriteLog("USER32: DrawIcon, partially implemented\n");
1705	#endif
1706	return O32_DrawIcon(hdc, xLeft, xRight, hIcon);
1707	}
1708	//******************************************************************************
1709	//******************************************************************************
1710	BOOL WIN32API DrawMenuBar( HWND arg1)
1711	{
1712	#ifdef DEBUG
1713	WriteLog("USER32: DrawMenuBar\n");
1714	#endif
1715	return O32_DrawMenuBar(arg1);
1716	}
1717	//******************************************************************************
1718	//******************************************************************************
1719	int WIN32API DrawTextW( HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5)
1720	{
1721	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1722	int rc;
1723
1724	#ifdef DEBUG
1725	WriteLog("USER32: DrawTextW %s\n", astring);
1726	#endif
1727	rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1728	FreeAsciiString(astring);
1729	return(rc);
1730	}
1731	//******************************************************************************
1732	//******************************************************************************
1733	int WIN32API DrawTextExW(HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
1734	{
1735	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1736	int rc;
1737
1738	#ifdef DEBUG
1739	WriteLog("USER32: DrawTextExW (not completely supported) %s\n", astring);
1740	#endif
1741	rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1742	FreeAsciiString(astring);
1743	return(rc);
1744	}
1745	//******************************************************************************
1746	//******************************************************************************
1747	BOOL WIN32API EmptyClipboard(void)
1748	{
1749	#ifdef DEBUG
1750	WriteLog("USER32: EmptyClipboard\n");
1751	#endif
1752	return O32_EmptyClipboard();
1753	}
1754	//******************************************************************************
1755	//******************************************************************************
1756	BOOL WIN32API EndDeferWindowPos( HDWP arg1)
1757	{
1758	#ifdef DEBUG
1759	WriteLog("USER32: EndDeferWindowPos\n");
1760	#endif
1761	return O32_EndDeferWindowPos(arg1);
1762	}
1763	//******************************************************************************
1764	//******************************************************************************
1765	BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1766	{
1767	BOOL rc;
1768	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1769
1770	#ifdef DEBUG
1771	WriteLog("USER32: EnumChildWindows\n");
1772	#endif
1773	rc = O32_EnumChildWindows(hwnd, callback->GetOS2Callback(), (LPARAM)callback);
1774	if(callback)
1775	delete callback;
1776	return(rc);
1777	}
1778	//******************************************************************************
1779	//******************************************************************************
1780	UINT WIN32API EnumClipboardFormats(UINT arg1)
1781	{
1782	#ifdef DEBUG
1783	WriteLog("USER32: EnumClipboardFormats\n");
1784	#endif
1785	return O32_EnumClipboardFormats(arg1);
1786	}
1787	//******************************************************************************
1788	//******************************************************************************
1789	int WIN32API EnumPropsA(HWND arg1, PROPENUMPROCA arg2)
1790	{
1791	#ifdef DEBUG
1792	WriteLog("USER32: EnumPropsA DOES NOT WORK\n");
1793	#endif
1794	//calling convention problems
1795	return 0;
1796	// return O32_EnumProps(arg1, (PROPENUMPROC_O32)arg2);
1797	}
1798	//******************************************************************************
1799	//******************************************************************************
1800	int WIN32API EnumPropsExA( HWND arg1, PROPENUMPROCEXA arg2, LPARAM arg3)
1801	{
1802	#ifdef DEBUG
1803	WriteLog("USER32: EnumPropsExA DOES NOT WORK\n");
1804	#endif
1805	//calling convention problems
1806	return 0;
1807	// return O32_EnumPropsEx(arg1, arg2, (PROPENUMPROCEX_O32)arg3);
1808	}
1809	//******************************************************************************
1810	//******************************************************************************
1811	int WIN32API EnumPropsExW( HWND arg1, PROPENUMPROCEXW arg2, LPARAM arg3)
1812	{
1813	#ifdef DEBUG
1814	WriteLog("USER32: EnumPropsExW\n");
1815	#endif
1816	// NOTE: This will not work as is (needs UNICODE support)
1817	//calling convention problems
1818	return 0;
1819	// return O32_EnumPropsEx(arg1, arg2, arg3);
1820	}
1821	//******************************************************************************
1822	//******************************************************************************
1823	int WIN32API EnumPropsW( HWND arg1, PROPENUMPROCW arg2)
1824	{
1825	#ifdef DEBUG
1826	WriteLog("USER32: EnumPropsW\n");
1827	#endif
1828	// NOTE: This will not work as is (needs UNICODE support)
1829	//calling convention problems
1830	return 0;
1831	// return O32_EnumProps(arg1, arg2);
1832	}
1833	//******************************************************************************
1834	//******************************************************************************
1835	BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1836	{
1837	BOOL rc;
1838	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1839
1840	#ifdef DEBUG
1841	WriteLog("USER32: EnumWindows\n");
1842	#endif
1843	rc = O32_EnumWindows(callback->GetOS2Callback(), (LPARAM)callback);
1844	if(callback)
1845	delete callback;
1846	return(rc);
1847	}
1848	//******************************************************************************
1849	//******************************************************************************
1850	BOOL WIN32API EqualRect( const RECT * arg1, const RECT * arg2)
1851	{
1852	#ifdef DEBUG
1853	WriteLog("USER32: EqualRect\n");
1854	#endif
1855	return O32_EqualRect(arg1, arg2);
1856	}
1857	//******************************************************************************
1858	//******************************************************************************
1859	BOOL WIN32API ExcludeUpdateRgn( HDC arg1, HWND arg2)
1860	{
1861	#ifdef DEBUG
1862	WriteLog("USER32: ExcludeUpdateRgn\n");
1863	#endif
1864	return O32_ExcludeUpdateRgn(arg1, arg2);
1865	}
1866	//******************************************************************************
1867	//******************************************************************************
1868	BOOL WIN32API ExitWindowsEx( UINT arg1, DWORD arg2)
1869	{
1870	#ifdef DEBUG
1871	WriteLog("USER32: ExitWindowsEx\n");
1872	#endif
1873	return O32_ExitWindowsEx(arg1, arg2);
1874	}
1875	//******************************************************************************
1876	//******************************************************************************
1877	int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
1878	{
1879	#ifdef DEBUG
1880	WriteLog("USER32: FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
1881	#endif
1882	return O32_FillRect(arg1, arg2, arg3);
1883	}
1884	//******************************************************************************
1885	//******************************************************************************
1886	HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
1887	{
1888	char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1889	char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1890	HWND rc;
1891
1892	#ifdef DEBUG
1893	WriteLog("USER32: FindWindowW\n");
1894	#endif
1895	rc = O32_FindWindow(astring1, astring2);
1896	FreeAsciiString(astring1);
1897	FreeAsciiString(astring2);
1898	return rc;
1899	}
1900	//******************************************************************************
1901	//******************************************************************************
1902	int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH arg3)
1903	{
1904	#ifdef DEBUG
1905	WriteLog("USER32: FrameRect\n");
1906	#endif
1907	return O32_FrameRect(arg1, arg2, arg3);
1908	}
1909	//******************************************************************************
1910	//******************************************************************************
1911	HWND WIN32API GetCapture(void)
1912	{
1913	#ifdef DEBUG
1914	WriteLog("USER32: GetCapture\n");
1915	#endif
1916	return O32_GetCapture();
1917	}
1918	//******************************************************************************
1919	//******************************************************************************
1920	UINT WIN32API GetCaretBlinkTime(void)
1921	{
1922	#ifdef DEBUG
1923	WriteLog("USER32: GetCaretBlinkTime\n");
1924	#endif
1925	return O32_GetCaretBlinkTime();
1926	}
1927	//******************************************************************************
1928	//******************************************************************************
1929	BOOL WIN32API GetCaretPos( PPOINT arg1)
1930	{
1931	#ifdef DEBUG
1932	WriteLog("USER32: GetCaretPos\n");
1933	#endif
1934	return O32_GetCaretPos(arg1);
1935	}
1936	//******************************************************************************
1937	//******************************************************************************
1938	BOOL WIN32API GetClipCursor( PRECT arg1)
1939	{
1940	#ifdef DEBUG
1941	WriteLog("USER32: GetClipCursor\n");
1942	#endif
1943	return O32_GetClipCursor(arg1);
1944	}
1945	//******************************************************************************
1946	//******************************************************************************
1947	HANDLE WIN32API GetClipboardData( UINT arg1)
1948	{
1949	#ifdef DEBUG
1950	WriteLog("USER32: GetClipboardData\n");
1951	#endif
1952	return O32_GetClipboardData(arg1);
1953	}
1954	//******************************************************************************
1955	//******************************************************************************
1956	int WIN32API GetClipboardFormatNameA( UINT arg1, LPSTR arg2, int arg3)
1957	{
1958	#ifdef DEBUG
1959	WriteLog("USER32: GetClipboardFormatNameA %s\n", arg2);
1960	#endif
1961	return O32_GetClipboardFormatName(arg1, arg2, arg3);
1962	}
1963	//******************************************************************************
1964	//******************************************************************************
1965	int WIN32API GetClipboardFormatNameW(UINT arg1, LPWSTR arg2, int arg3)
1966	{
1967	int rc;
1968	char *astring = UnicodeToAsciiString(arg2);
1969
1970	#ifdef DEBUG
1971	WriteLog("USER32: GetClipboardFormatNameW %s\n", astring);
1972	#endif
1973	rc = O32_GetClipboardFormatName(arg1, astring, arg3);
1974	FreeAsciiString(astring);
1975	return(rc);
1976	}
1977	//******************************************************************************
1978	//******************************************************************************
1979	HWND WIN32API GetClipboardOwner(void)
1980	{
1981	#ifdef DEBUG
1982	WriteLog("USER32: GetClipboardOwner\n");
1983	#endif
1984	return O32_GetClipboardOwner();
1985	}
1986	//******************************************************************************
1987	//******************************************************************************
1988	HWND WIN32API GetClipboardViewer(void)
1989	{
1990	#ifdef DEBUG
1991	WriteLog("USER32: GetClipboardViewer\n");
1992	#endif
1993	return O32_GetClipboardViewer();
1994	}
1995	//******************************************************************************
1996	//******************************************************************************
1997	DWORD WIN32API GetDialogBaseUnits(void)
1998	{
1999	#ifdef DEBUG
2000	WriteLog("USER32: GetDialogBaseUnits\n");
2001	#endif
2002	return O32_GetDialogBaseUnits();
2003	}
2004	//******************************************************************************
2005	//******************************************************************************
2006	UINT WIN32API GetDlgItemInt( HWND arg1, int arg2, PBOOL arg3, BOOL arg4)
2007	{
2008	#ifdef DEBUG
2009	WriteLog("USER32: GetDlgItemInt\n");
2010	#endif
2011	return O32_GetDlgItemInt(arg1, arg2, arg3, arg4);
2012	}
2013	//******************************************************************************
2014	//******************************************************************************
2015	UINT WIN32API GetDlgItemTextW( HWND arg1, int arg2, LPWSTR arg3, UINT arg4)
2016	{
2017	#ifdef DEBUG
2018	WriteLog("USER32: GetDlgItemTextW NOT WORKING\n");
2019	#endif
2020	// NOTE: This will not work as is (needs UNICODE support)
2021	return 0;
2022	// return O32_GetDlgItemText(arg1, arg2, arg3, arg4);
2023	}
2024	//******************************************************************************
2025	//******************************************************************************
2026	UINT WIN32API GetDoubleClickTime(void)
2027	{
2028	#ifdef DEBUG
2029	WriteLog("USER32: GetDoubleClickTime\n");
2030	#endif
2031	return O32_GetDoubleClickTime();
2032	}
2033	//******************************************************************************
2034	//******************************************************************************
2035	HWND WIN32API GetForegroundWindow(void)
2036	{
2037	#ifdef DEBUG
2038	WriteLog("USER32: GetForegroundWindow\n");
2039	#endif
2040	return O32_GetForegroundWindow();
2041	}
2042	//******************************************************************************
2043	//******************************************************************************
2044	BOOL WIN32API GetIconInfo( HICON arg1, LPICONINFO arg2)
2045	{
2046	#ifdef DEBUG
2047	WriteLog("USER32: GetIconInfo\n");
2048	#endif
2049	return O32_GetIconInfo(arg1, arg2);
2050	}
2051	//******************************************************************************
2052	//******************************************************************************
2053	int WIN32API GetKeyNameTextA( LPARAM arg1, LPSTR arg2, int arg3)
2054	{
2055	#ifdef DEBUG
2056	WriteLog("USER32: GetKeyNameTextA\n");
2057	#endif
2058	return O32_GetKeyNameText(arg1, arg2, arg3);
2059	}
2060	//******************************************************************************
2061	//******************************************************************************
2062	int WIN32API GetKeyNameTextW( LPARAM arg1, LPWSTR arg2, int arg3)
2063	{
2064	#ifdef DEBUG
2065	WriteLog("USER32: GetKeyNameTextW DOES NOT WORK\n");
2066	#endif
2067	// NOTE: This will not work as is (needs UNICODE support)
2068	return 0;
2069	// return O32_GetKeyNameText(arg1, arg2, arg3);
2070	}
2071	//******************************************************************************
2072	//******************************************************************************
2073	int WIN32API GetKeyboardType( int arg1)
2074	{
2075	#ifdef DEBUG
2076	WriteLog("USER32: GetKeyboardType\n");
2077	#endif
2078	return O32_GetKeyboardType(arg1);
2079	}
2080	//******************************************************************************
2081	//******************************************************************************
2082	HWND WIN32API GetLastActivePopup( HWND arg1)
2083	{
2084	#ifdef DEBUG
2085	WriteLog("USER32: GetLastActivePopup\n");
2086	#endif
2087	return O32_GetLastActivePopup(arg1);
2088	}
2089	//******************************************************************************
2090	//******************************************************************************
2091	LONG WIN32API GetMessageExtraInfo(void)
2092	{
2093	dprintf(("USER32: GetMessageExtraInfo\n"));
2094	return O32_GetMessageExtraInfo();
2095	}
2096	//******************************************************************************
2097	//******************************************************************************
2098	DWORD WIN32API GetMessagePos(void)
2099	{
2100	dprintf(("USER32: GetMessagePos\n"));
2101	return O32_GetMessagePos();
2102	}
2103	//******************************************************************************
2104	//******************************************************************************
2105	LONG WIN32API GetMessageTime(void)
2106	{
2107	dprintf(("USER32: GetMessageTime\n"));
2108	return O32_GetMessageTime();
2109	}
2110	//******************************************************************************
2111	//******************************************************************************
2112	BOOL WIN32API GetMessageW(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
2113	{
2114	BOOL rc;
2115
2116	// NOTE: This will not work as is (needs UNICODE support)
2117	rc = O32_GetMessage(arg1, arg2, arg3, arg4);
2118	dprintf(("USER32: GetMessageW %X returned %d\n", arg2, rc));
2119	return(rc);
2120	}
2121	//******************************************************************************
2122	//******************************************************************************
2123	HWND WIN32API GetNextDlgGroupItem( HWND arg1, HWND arg2, BOOL arg3)
2124	{
2125	#ifdef DEBUG
2126	WriteLog("USER32: GetNextDlgGroupItem\n");
2127	#endif
2128	return O32_GetNextDlgGroupItem(arg1, arg2, arg3);
2129	}
2130	//******************************************************************************
2131	//******************************************************************************
2132	HWND WIN32API GetOpenClipboardWindow(void)
2133	{
2134	#ifdef DEBUG
2135	WriteLog("USER32: GetOpenClipboardWindow\n");
2136	#endif
2137	return O32_GetOpenClipboardWindow();
2138	}
2139	//******************************************************************************
2140	//******************************************************************************
2141	HWND WIN32API GetParent( HWND arg1)
2142	{
2143	#ifdef DEBUG
2144	//// WriteLog("USER32: GetParent\n");
2145	#endif
2146	return O32_GetParent(arg1);
2147	}
2148	//******************************************************************************
2149	//******************************************************************************
2150	int WIN32API GetPriorityClipboardFormat( PUINT arg1, int arg2)
2151	{
2152	#ifdef DEBUG
2153	WriteLog("USER32: GetPriorityClipboardFormat\n");
2154	#endif
2155	return O32_GetPriorityClipboardFormat(arg1, arg2);
2156	}
2157	//******************************************************************************
2158	//******************************************************************************
2159	HANDLE WIN32API GetPropA( HWND arg1, LPCSTR arg2)
2160	{
2161	#ifdef DEBUG
2162	if((int)arg2 >> 16 != 0)
2163	WriteLog("USER32: GetPropA %s\n", arg2);
2164	else WriteLog("USER32: GetPropA %X\n", arg2);
2165	#endif
2166	return O32_GetProp(arg1, arg2);
2167	}
2168	//******************************************************************************
2169	//******************************************************************************
2170	HANDLE WIN32API GetPropW(HWND arg1, LPCWSTR arg2)
2171	{
2172	BOOL handle;
2173	char *astring;
2174
2175	if((int)arg2 >> 16 != 0)
2176	astring = UnicodeToAsciiString((LPWSTR)arg2);
2177	else astring = (char *)arg2;
2178	#ifdef DEBUG
2179	if((int)arg2 >> 16 != 0)
2180	WriteLog("USER32: GetPropW %s\n", astring);
2181	else WriteLog("USER32: GetPropW %X\n", astring);
2182	#endif
2183	handle = GetPropA(arg1, (LPCSTR)astring);
2184	if((int)arg2 >> 16 != 0)
2185	FreeAsciiString(astring);
2186
2187	return(handle);
2188	}
2189	//******************************************************************************
2190	//******************************************************************************
2191	DWORD WIN32API GetQueueStatus( UINT arg1)
2192	{
2193	#ifdef DEBUG
2194	WriteLog("USER32: GetQueueStatus\n");
2195	#endif
2196	return O32_GetQueueStatus(arg1);
2197	}
2198	//******************************************************************************
2199	//******************************************************************************
2200	int WIN32API GetScrollPos(HWND hwnd, int fnBar)
2201	{
2202	int pos;
2203
2204	pos = GetScrollPos(hwnd, fnBar);
2205	#ifdef DEBUG
2206	WriteLog("USER32: GetScrollPos of %X type %d returned %d\n", hwnd, fnBar, pos);
2207	#endif
2208	return(pos);
2209	}
2210	//******************************************************************************
2211	//******************************************************************************
2212	BOOL WIN32API GetScrollRange( HWND arg1, int arg2, int * arg3, int * arg4)
2213	{
2214	#ifdef DEBUG
2215	WriteLog("USER32: GetScrollRange\n");
2216	#endif
2217	return O32_GetScrollRange(arg1, arg2, arg3, arg4);
2218	}
2219	//******************************************************************************
2220	//******************************************************************************
2221	DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
2222	{
2223	#ifdef DEBUG
2224	WriteLog("USER32: GetTabbedTextExtentA\n");
2225	#endif
2226	return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
2227	}
2228	//******************************************************************************
2229	//******************************************************************************
2230	DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
2231	{
2232	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2233	DWORD rc;
2234
2235	#ifdef DEBUG
2236	WriteLog("USER32: GetTabbedTextExtentW\n");
2237	#endif
2238	rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
2239	FreeAsciiString(astring);
2240	return rc;
2241	}
2242	//******************************************************************************
2243	//******************************************************************************
2244	HWND WIN32API GetTopWindow( HWND arg1)
2245	{
2246	#ifdef DEBUG
2247	//// WriteLog("USER32: GetTopWindow\n");
2248	#endif
2249	return O32_GetTopWindow(arg1);
2250	}
2251	//******************************************************************************
2252	//******************************************************************************
2253	int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2254	{
2255	#ifdef DEBUG
2256	WriteLog("USER32: GetUpdateRgn\n");
2257	#endif
2258	return O32_GetUpdateRgn(arg1, arg2, arg3);
2259	}
2260	//******************************************************************************
2261	//******************************************************************************
2262	LONG WIN32API GetWindowLongW( HWND arg1, int arg2)
2263	{
2264	#ifdef DEBUG
2265	WriteLog("USER32: GetWindowLongW\n");
2266	#endif
2267	return GetWindowLongA(arg1, arg2); //class procedures..
2268	}
2269	//******************************************************************************
2270	//******************************************************************************
2271	BOOL WIN32API GetWindowPlacement( HWND arg1, LPWINDOWPLACEMENT arg2)
2272	{
2273	#ifdef DEBUG
2274	WriteLog("USER32: GetWindowPlacement\n");
2275	#endif
2276	return O32_GetWindowPlacement(arg1, arg2);
2277	}
2278	//******************************************************************************
2279	//******************************************************************************
2280	int WIN32API GetWindowTextLengthW( HWND arg1)
2281	{
2282	#ifdef DEBUG
2283	WriteLog("USER32: GetWindowTextLengthW\n");
2284	#endif
2285	return O32_GetWindowTextLength(arg1);
2286	}
2287	//******************************************************************************
2288	//******************************************************************************
2289	int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
2290	{
2291	char title[128];
2292	int rc;
2293
2294	rc = O32_GetWindowText(hwnd, title, sizeof(title));
2295	#ifdef DEBUG
2296	WriteLog("USER32: GetWindowTextW returned %s\n", title);
2297	#endif
2298	if(rc > cch) {
2299	title[cch-1] = 0;
2300	rc = cch;
2301	}
2302	AsciiToUnicode(title, lpsz);
2303	return(rc);
2304	}
2305	//******************************************************************************
2306	//******************************************************************************
2307	DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD arg2)
2308	{
2309	#ifdef DEBUG
2310	WriteLog("USER32: GetWindowThreadProcessId\n");
2311	#endif
2312	return O32_GetWindowThreadProcessId(arg1, arg2);
2313	}
2314	//******************************************************************************
2315	//******************************************************************************
2316	WORD WIN32API GetWindowWord( HWND arg1, int arg2)
2317	{
2318	#ifdef DEBUG
2319	WriteLog("USER32: GetWindowWord\n");
2320	#endif
2321	return O32_GetWindowWord(arg1, arg2);
2322	}
2323	//******************************************************************************
2324	//******************************************************************************
2325	BOOL WIN32API HideCaret( HWND arg1)
2326	{
2327	#ifdef DEBUG
2328	WriteLog("USER32: HideCaret\n");
2329	#endif
2330	return O32_HideCaret(arg1);
2331	}
2332	//******************************************************************************
2333	//******************************************************************************
2334	BOOL WIN32API InSendMessage(void)
2335	{
2336	#ifdef DEBUG
2337	WriteLog("USER32: InSendMessage\n");
2338	#endif
2339	return O32_InSendMessage();
2340	}
2341	//******************************************************************************
2342	//******************************************************************************
2343	BOOL WIN32API IntersectRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
2344	{
2345	#ifdef DEBUG
2346	//// WriteLog("USER32: IntersectRect\n");
2347	#endif
2348	return O32_IntersectRect(arg1, arg2, arg3);
2349	}
2350	//******************************************************************************
2351	//******************************************************************************
2352	BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2353	{
2354	#ifdef DEBUG
2355	WriteLog("USER32: InvalidateRgn\n");
2356	#endif
2357	return O32_InvalidateRgn(arg1, arg2, arg3);
2358	}
2359	//******************************************************************************
2360	//******************************************************************************
2361	BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
2362	{
2363	#ifdef DEBUG
2364	WriteLog("USER32: InvertRect\n");
2365	#endif
2366	return O32_InvertRect(arg1, arg2);
2367	}
2368	//******************************************************************************
2369	//******************************************************************************
2370	BOOL WIN32API IsChild( HWND arg1, HWND arg2)
2371	{
2372	#ifdef DEBUG
2373	WriteLog("USER32: IsChild\n");
2374	#endif
2375	return O32_IsChild(arg1, arg2);
2376	}
2377	//******************************************************************************
2378	//******************************************************************************
2379	BOOL WIN32API IsClipboardFormatAvailable( UINT arg1)
2380	{
2381	#ifdef DEBUG
2382	WriteLog("USER32: IsClipboardFormatAvailable\n");
2383	#endif
2384	return O32_IsClipboardFormatAvailable(arg1);
2385	}
2386	//******************************************************************************
2387	//******************************************************************************
2388	BOOL WIN32API IsDialogMessageW( HWND arg1, LPMSG arg2)
2389	{
2390	#ifdef DEBUG
2391	WriteLog("USER32: IsDialogMessageW\n");
2392	#endif
2393	// NOTE: This will not work as is (needs UNICODE support)
2394	return O32_IsDialogMessage(arg1, arg2);
2395	}
2396	//******************************************************************************
2397	//******************************************************************************
2398	BOOL WIN32API IsRectEmpty( const RECT * arg1)
2399	{
2400	#ifdef DEBUG
2401	WriteLog("USER32: IsRectEmpty\n");
2402	#endif
2403	return O32_IsRectEmpty(arg1);
2404	}
2405	//******************************************************************************
2406	//******************************************************************************
2407	BOOL WIN32API IsWindow( HWND arg1)
2408	{
2409	#ifdef DEBUG
2410	WriteLog("USER32: IsWindow\n");
2411	#endif
2412	return O32_IsWindow(arg1);
2413	}
2414	//******************************************************************************
2415	//******************************************************************************
2416	BOOL WIN32API IsWindowEnabled( HWND arg1)
2417	{
2418	#ifdef DEBUG
2419	WriteLog("USER32: IsWindowEnabled\n");
2420	#endif
2421	return O32_IsWindowEnabled(arg1);
2422	}
2423	//******************************************************************************
2424	//******************************************************************************
2425	BOOL WIN32API IsWindowVisible( HWND arg1)
2426	{
2427	#ifdef DEBUG
2428	WriteLog("USER32: IsWindowVisible\n");
2429	#endif
2430	return O32_IsWindowVisible(arg1);
2431	}
2432	//******************************************************************************
2433	//******************************************************************************
2434	BOOL WIN32API IsZoomed( HWND arg1)
2435	{
2436	#ifdef DEBUG
2437	WriteLog("USER32: IsZoomed\n");
2438	#endif
2439	return O32_IsZoomed(arg1);
2440	}
2441	//******************************************************************************
2442	//******************************************************************************
2443	BOOL WIN32API LockWindowUpdate( HWND arg1)
2444	{
2445	#ifdef DEBUG
2446	WriteLog("USER32: LockWindowUpdate\n");
2447	#endif
2448	return O32_LockWindowUpdate(arg1);
2449	}
2450	//******************************************************************************
2451	//******************************************************************************
2452	BOOL WIN32API MapDialogRect( HWND arg1, PRECT arg2)
2453	{
2454	#ifdef DEBUG
2455	WriteLog("USER32: MapDialogRect\n");
2456	#endif
2457	return O32_MapDialogRect(arg1, arg2);
2458	}
2459	//******************************************************************************
2460	//******************************************************************************
2461	UINT WIN32API MapVirtualKeyA( UINT arg1, UINT arg2)
2462	{
2463	#ifdef DEBUG
2464	WriteLog("USER32: MapVirtualKeyA\n");
2465	#endif
2466	return O32_MapVirtualKey(arg1, arg2);
2467	}
2468	//******************************************************************************
2469	//******************************************************************************
2470	UINT WIN32API MapVirtualKeyW( UINT arg1, UINT arg2)
2471	{
2472	#ifdef DEBUG
2473	WriteLog("USER32: MapVirtualKeyW\n");
2474	#endif
2475	// NOTE: This will not work as is (needs UNICODE support)
2476	return O32_MapVirtualKey(arg1, arg2);
2477	}
2478	//******************************************************************************
2479	//******************************************************************************
2480	int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
2481	{
2482	#ifdef DEBUG
2483	WriteLog("USER32: MapWindowPoints\n");
2484	#endif
2485	return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
2486	}
2487	//******************************************************************************
2488	//******************************************************************************
2489	int WIN32API MessageBoxW(HWND arg1, LPCWSTR arg2, LPCWSTR arg3, UINT arg4)
2490	{
2491	char astring1, astring2;
2492	int rc;
2493
2494	astring1 = UnicodeToAsciiString((LPWSTR)arg2);
2495	astring2 = UnicodeToAsciiString((LPWSTR)arg3);
2496	#ifdef DEBUG
2497	WriteLog("USER32: MessageBoxW %s %s\n", astring1, astring2);
2498	#endif
2499	rc = O32_MessageBox(arg1, astring1, astring2, arg4);
2500	FreeAsciiString(astring1);
2501	FreeAsciiString(astring2);
2502	return(rc);
2503	}
2504	//******************************************************************************
2505	//******************************************************************************
2506	BOOL WIN32API OpenClipboard( HWND arg1)
2507	{
2508	#ifdef DEBUG
2509	WriteLog("USER32: OpenClipboard\n");
2510	#endif
2511	return O32_OpenClipboard(arg1);
2512	}
2513	//******************************************************************************
2514	//******************************************************************************
2515	BOOL WIN32API PeekMessageW( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
2516	{
2517	#ifdef DEBUG
2518	WriteLog("USER32: PeekMessageW\n");
2519	#endif
2520	// NOTE: This will not work as is (needs UNICODE support)
2521	return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
2522	}
2523	//******************************************************************************
2524	//******************************************************************************
2525	// NOTE: Open32 function doesn't have the 'W'.
2526	BOOL WIN32API PostMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2527	{
2528	#ifdef DEBUG
2529	WriteLog("USER32: PostMessageW\n");
2530	#endif
2531	// NOTE: This will not work as is (needs UNICODE support)
2532	return O32_PostMessage(arg1, arg2, arg3, arg4);
2533	}
2534	//******************************************************************************
2535	//******************************************************************************
2536	BOOL WIN32API PostThreadMessageA( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2537	{
2538	#ifdef DEBUG
2539	WriteLog("USER32: PostThreadMessageA\n");
2540	#endif
2541	return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2542	}
2543	//******************************************************************************
2544	//******************************************************************************
2545	BOOL WIN32API PostThreadMessageW( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2546	{
2547	#ifdef DEBUG
2548	WriteLog("USER32: PostThreadMessageW\n");
2549	#endif
2550	// NOTE: This will not work as is (needs UNICODE support)
2551	return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2552	}
2553	//******************************************************************************
2554	//******************************************************************************
2555	BOOL WIN32API PtInRect( const RECT * arg1, POINT arg2)
2556	{
2557	#ifdef DEBUG
2558	WriteLog("USER32: PtInRect\n");
2559	#endif
2560	return O32_PtInRect(arg1, arg2);
2561	}
2562	//******************************************************************************
2563	//******************************************************************************
2564	BOOL WIN32API RedrawWindow( HWND arg1, const RECT * arg2, HRGN arg3, UINT arg4)
2565	{
2566	BOOL rc;
2567
2568	rc = O32_RedrawWindow(arg1, arg2, arg3, arg4);
2569	#ifdef DEBUG
2570	WriteLog("USER32: RedrawWindow %X , %X, %X, %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2571	#endif
2572	InvalidateRect(arg1, arg2, TRUE);
2573	UpdateWindow(arg1);
2574	SendMessageA(arg1, WM_PAINT, 0, 0);
2575	return(rc);
2576	}
2577	//******************************************************************************
2578	//******************************************************************************
2579	UINT WIN32API RegisterClipboardFormatA( LPCSTR arg1)
2580	{
2581	#ifdef DEBUG
2582	WriteLog("USER32: RegisterClipboardFormatA\n");
2583	#endif
2584	return O32_RegisterClipboardFormat(arg1);
2585	}
2586	//******************************************************************************
2587	//******************************************************************************
2588	UINT WIN32API RegisterClipboardFormatW(LPCWSTR arg1)
2589	{
2590	UINT rc;
2591	char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2592
2593	#ifdef DEBUG
2594	WriteLog("USER32: RegisterClipboardFormatW %s\n", astring);
2595	#endif
2596	rc = O32_RegisterClipboardFormat(astring);
2597	FreeAsciiString(astring);
2598	#ifdef DEBUG
2599	WriteLog("USER32: RegisterClipboardFormatW returned %d\n", rc);
2600	#endif
2601	return(rc);
2602	}
2603	//******************************************************************************
2604	//******************************************************************************
2605	UINT WIN32API RegisterWindowMessageW( LPCWSTR arg1)
2606	{
2607	char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2608	UINT rc;
2609
2610	#ifdef DEBUG
2611	WriteLog("USER32: RegisterWindowMessageW\n");
2612	#endif
2613	rc = O32_RegisterWindowMessage(astring);
2614	FreeAsciiString(astring);
2615	return rc;
2616	}
2617	//******************************************************************************
2618	//******************************************************************************
2619	HANDLE WIN32API RemovePropA( HWND arg1, LPCSTR arg2)
2620	{
2621	#ifdef DEBUG
2622	WriteLog("USER32: RemovePropA\n");
2623	#endif
2624	return O32_RemoveProp(arg1, arg2);
2625	}
2626	//******************************************************************************
2627	//******************************************************************************
2628	HANDLE WIN32API RemovePropW( HWND arg1, LPCWSTR arg2)
2629	{
2630	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2631	HANDLE rc;
2632
2633	#ifdef DEBUG
2634	WriteLog("USER32: RemovePropW\n");
2635	#endif
2636	rc = O32_RemoveProp(arg1, astring);
2637	FreeAsciiString(astring);
2638	return rc;
2639	}
2640	//******************************************************************************
2641	//******************************************************************************
2642	BOOL WIN32API ReplyMessage( LRESULT arg1)
2643	{
2644	#ifdef DEBUG
2645	WriteLog("USER32: ReplyMessage\n");
2646	#endif
2647	return O32_ReplyMessage(arg1);
2648	}
2649	//******************************************************************************
2650	//******************************************************************************
2651	BOOL WIN32API ScreenToClient( HWND arg1, LPPOINT arg2)
2652	{
2653	#ifdef DEBUG
2654	WriteLog("USER32: ScreenToClient\n");
2655	#endif
2656	return O32_ScreenToClient(arg1, arg2);
2657	}
2658	//******************************************************************************
2659	//******************************************************************************
2660	BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7)
2661	{
2662	#ifdef DEBUG
2663	WriteLog("USER32: ScrollDC\n");
2664	#endif
2665	return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2666	}
2667	//******************************************************************************
2668	//******************************************************************************
2669	BOOL WIN32API ScrollWindow( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5)
2670	{
2671	#ifdef DEBUG
2672	WriteLog("USER32: ScrollWindow\n");
2673	#endif
2674	return O32_ScrollWindow(arg1, arg2, arg3, arg4, arg5);
2675	}
2676	//******************************************************************************
2677	//******************************************************************************
2678	BOOL WIN32API ScrollWindowEx( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7, UINT arg8)
2679	{
2680	#ifdef DEBUG
2681	WriteLog("USER32: ScrollWindowEx\n");
2682	#endif
2683	return O32_ScrollWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2684	}
2685	//******************************************************************************
2686	//******************************************************************************
2687	LONG WIN32API SendDlgItemMessageW( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
2688	{
2689	#ifdef DEBUG
2690	WriteLog("USER32: SendDlgItemMessageW\n");
2691	#endif
2692	return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
2693	}
2694	//******************************************************************************
2695	//******************************************************************************
2696	LRESULT WIN32API SendMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2697	{
2698	LRESULT rc;
2699
2700	#ifdef DEBUG
2701	WriteLog("USER32: SendMessageW....\n");
2702	#endif
2703	rc = O32_SendMessage(arg1, arg2, arg3, arg4);
2704	#ifdef DEBUG
2705	WriteLog("USER32: SendMessageW %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2706	#endif
2707	return(rc);
2708	}
2709	//******************************************************************************
2710	//******************************************************************************
2711	BOOL WIN32API SetCaretBlinkTime( UINT arg1)
2712	{
2713	#ifdef DEBUG
2714	WriteLog("USER32: SetCaretBlinkTime\n");
2715	#endif
2716	return O32_SetCaretBlinkTime(arg1);
2717	}
2718	//******************************************************************************
2719	//******************************************************************************
2720	BOOL WIN32API SetCaretPos( int arg1, int arg2)
2721	{
2722	dprintf(("USER32: SetCaretPos\n"));
2723	return O32_SetCaretPos(arg1, arg2);
2724	}
2725	//******************************************************************************
2726	//******************************************************************************
2727	HANDLE WIN32API SetClipboardData( UINT arg1, HANDLE arg2)
2728	{
2729	dprintf(("USER32: SetClipboardData\n"));
2730	return O32_SetClipboardData(arg1, arg2);
2731	}
2732	//******************************************************************************
2733	//******************************************************************************
2734	HWND WIN32API SetClipboardViewer( HWND arg1)
2735	{
2736	dprintf(("USER32: SetClipboardViewer\n"));
2737	return O32_SetClipboardViewer(arg1);
2738	}
2739	//******************************************************************************
2740	//******************************************************************************
2741	BOOL WIN32API SetDlgItemTextW( HWND arg1, int arg2, LPCWSTR arg3)
2742	{
2743	char *astring = UnicodeToAsciiString((LPWSTR)arg3);
2744	BOOL rc;
2745
2746	#ifdef DEBUG
2747	WriteLog("USER32: SetDlgItemTextW\n");
2748	#endif
2749	// NOTE: This will not work as is (needs UNICODE support)
2750	rc = O32_SetDlgItemText(arg1, arg2, astring);
2751	FreeAsciiString(astring);
2752	return rc;
2753	}
2754	//******************************************************************************
2755	//******************************************************************************
2756	BOOL WIN32API SetDoubleClickTime( UINT arg1)
2757	{
2758	#ifdef DEBUG
2759	WriteLog("USER32: SetDoubleClickTime\n");
2760	#endif
2761	return O32_SetDoubleClickTime(arg1);
2762	}
2763	//******************************************************************************
2764	//******************************************************************************
2765	HWND WIN32API SetParent( HWND arg1, HWND arg2)
2766	{
2767	#ifdef DEBUG
2768	WriteLog("USER32: SetParent\n");
2769	#endif
2770	return O32_SetParent(arg1, arg2);
2771	}
2772	//******************************************************************************
2773	//******************************************************************************
2774	BOOL WIN32API SetPropA( HWND arg1, LPCSTR arg2, HANDLE arg3)
2775	{
2776	#ifdef DEBUG
2777	if((int)arg2 >> 16 != 0)
2778	WriteLog("USER32: SetPropA %S\n", arg2);
2779	else WriteLog("USER32: SetPropA %X\n", arg2);
2780	#endif
2781	return O32_SetProp(arg1, arg2, arg3);
2782	}
2783	//******************************************************************************
2784	//******************************************************************************
2785	BOOL WIN32API SetPropW(HWND arg1, LPCWSTR arg2, HANDLE arg3)
2786	{
2787	BOOL rc;
2788	char *astring;
2789
2790	if((int)arg2 >> 16 != 0)
2791	astring = UnicodeToAsciiString((LPWSTR)arg2);
2792	else astring = (char *)arg2;
2793
2794	#ifdef DEBUG
2795	if((int)arg2 >> 16 != 0)
2796	WriteLog("USER32: SetPropW %S\n", astring);
2797	else WriteLog("USER32: SetPropW %X\n", astring);
2798	#endif
2799	rc = O32_SetProp(arg1, astring, arg3);
2800	if((int)astring >> 16 != 0)
2801	FreeAsciiString(astring);
2802	return(rc);
2803	}
2804	//******************************************************************************
2805	//******************************************************************************
2806	BOOL WIN32API SetRectEmpty( PRECT arg1)
2807	{
2808	#ifdef DEBUG
2809	WriteLog("USER32: SetRectEmpty\n");
2810	#endif
2811	return O32_SetRectEmpty(arg1);
2812	}
2813	//******************************************************************************
2814	//******************************************************************************
2815	int WIN32API SetScrollPos( HWND arg1, int arg2, int arg3, BOOL arg4)
2816	{
2817	#ifdef DEBUG
2818	WriteLog("USER32: SetScrollPos\n");
2819	#endif
2820	return O32_SetScrollPos(arg1, arg2, arg3, arg4);
2821	}
2822	//******************************************************************************
2823	//******************************************************************************
2824	BOOL WIN32API SetScrollRange( HWND arg1, int arg2, int arg3, int arg4, BOOL arg5)
2825	{
2826	#ifdef DEBUG
2827	WriteLog("USER32: SetScrollRange\n");
2828	#endif
2829	return O32_SetScrollRange(arg1, arg2, arg3, arg4, arg5);
2830	}
2831	//******************************************************************************
2832	//******************************************************************************
2833	LONG WIN32API SetWindowLongA(HWND hwnd, int nIndex, LONG arg3)
2834	{
2835	LONG rc;
2836
2837	dprintf(("USER32: SetWindowLongA %X %d %X\n", hwnd, nIndex, arg3));
2838	if(nIndex == GWL_WNDPROC \|\| nIndex == DWL_DLGPROC) {
2839	Win32WindowProc *wndproc = Win32WindowProc::FindProc(hwnd);
2840	if(wndproc == NULL) {//created with system class and app wants to change the handler
2841	dprintf(("USER32: SetWindowLong new WindowProc for system class\n"));
2842	wndproc = new Win32WindowProc((WNDPROC)arg3);
2843	wndproc->SetWindowHandle(hwnd);
2844	rc = O32_GetWindowLong(hwnd, nIndex);
2845	Win32WindowSubProc *subwndproc = new Win32WindowSubProc(hwnd, (WNDPROC_O32)rc);
2846	O32_SetWindowLong(hwnd, nIndex, (LONG)wndproc->GetOS2Callback());
2847	return((LONG)subwndproc->GetWin32Callback());
2848	}
2849	else {
2850	if(!(nIndex == DWL_DLGPROC && wndproc->IsWindow() == TRUE)) {
2851	rc = (LONG)wndproc->GetWin32Callback();
2852	dprintf(("USER32: SetWindowLong change WindowProc %X to %X\n", rc, arg3));
2853	wndproc->SetWin32Callback((WNDPROC)arg3);
2854	return(rc);
2855	}
2856	//else window that accesses it's normal window data
2857	}
2858	}
2859	return O32_SetWindowLong(hwnd, nIndex, arg3);
2860	}
2861	//******************************************************************************
2862	//TODO: Is this always correct? (GWL_ID: window identifier??)
2863	//******************************************************************************
2864	LONG WIN32API SetWindowLongW(HWND arg1, int arg2, LONG arg3)
2865	{
2866	dprintf(("USER32: SetWindowLongW %X %d %X\n", arg1, arg2, arg3));
2867	return SetWindowLongA(arg1, arg2, arg3);
2868	}
2869	//******************************************************************************
2870	//******************************************************************************
2871	BOOL WIN32API SetWindowPlacement( HWND arg1, const WINDOWPLACEMENT * arg2)
2872	{
2873	dprintf(("USER32: SetWindowPlacement\n"));
2874	return O32_SetWindowPlacement(arg1, arg2);
2875	}
2876	//******************************************************************************
2877	//******************************************************************************
2878	BOOL WIN32API SetWindowTextW( HWND arg1, LPCWSTR arg2)
2879	{
2880	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2881	BOOL rc;
2882
2883	rc = SetWindowTextA(arg1, (LPCSTR)astring);
2884	dprintf(("USER32: SetWindowTextW %X %s returned %d\n", arg1, astring, rc));
2885	FreeAsciiString(astring);
2886	return(rc);
2887	}
2888	//******************************************************************************
2889	//******************************************************************************
2890	WORD WIN32API SetWindowWord( HWND arg1, int arg2, WORD arg3)
2891	{
2892	dprintf(("USER32: SetWindowWord\n"));
2893	return O32_SetWindowWord(arg1, arg2, arg3);
2894	}
2895	//******************************************************************************
2896	//******************************************************************************
2897	BOOL WIN32API ShowCaret( HWND arg1)
2898	{
2899	dprintf(("USER32: ShowCaret\n"));
2900	return O32_ShowCaret(arg1);
2901	}
2902	//******************************************************************************
2903	//******************************************************************************
2904	BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
2905	{
2906	dprintf(("USER32: ShowOwnedPopups\n"));
2907	return O32_ShowOwnedPopups(arg1, arg2);
2908	}
2909	//******************************************************************************
2910	//******************************************************************************
2911	BOOL WIN32API ShowScrollBar( HWND arg1, int arg2, BOOL arg3)
2912	{
2913	#ifdef DEBUG
2914	WriteLog("USER32: ShowScrollBar\n");
2915	#endif
2916	return O32_ShowScrollBar(arg1, arg2, arg3);
2917	}
2918	//******************************************************************************
2919	//******************************************************************************
2920	BOOL WIN32API SwapMouseButton( BOOL arg1)
2921	{
2922	#ifdef DEBUG
2923	WriteLog("USER32: SwapMouseButton\n");
2924	#endif
2925	return O32_SwapMouseButton(arg1);
2926	}
2927	//******************************************************************************
2928	//******************************************************************************
2929	BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
2930	{
2931	BOOL rc;
2932	NONCLIENTMETRICSA cmetric = (NONCLIENTMETRICSA )pvParam;
2933
2934	switch(uiAction) {
2935	case SPI_SCREENSAVERRUNNING:
2936	(BOOL )pvParam = FALSE;
2937	rc = TRUE;
2938	break;
2939	case SPI_GETDRAGFULLWINDOWS:
2940	(BOOL )pvParam = FALSE;
2941	rc = TRUE;
2942	break;
2943	case SPI_GETNONCLIENTMETRICS:
2944	memset(cmetric, 0, sizeof(NONCLIENTMETRICSA));
2945	cmetric->cbSize = sizeof(NONCLIENTMETRICSA);
2946	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfCaptionFont),0);
2947	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMenuFont),0);
2948	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfStatusFont),0);
2949	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMessageFont),0);
2950	cmetric->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
2951	cmetric->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
2952	cmetric->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
2953	cmetric->iCaptionWidth = 32; //TODO
2954	cmetric->iCaptionHeight = 16; //TODO
2955	cmetric->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
2956	cmetric->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
2957	cmetric->iMenuWidth = 32; //TODO
2958	cmetric->iMenuHeight = GetSystemMetrics(SM_CYMENU);
2959	rc = TRUE;
2960	break;
2961	case 104: //TODO: Undocumented
2962	rc = 16;
2963	break;
2964	default:
2965	rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
2966	break;
2967	}
2968	#ifdef DEBUG
2969	WriteLog("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc);
2970	#endif
2971	return(rc);
2972	}
2973	//******************************************************************************
2974	//TODO: Check for more options that have different structs for Unicode!!!!
2975	//******************************************************************************
2976	BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
2977	{
2978	BOOL rc;
2979	NONCLIENTMETRICSW clientMetricsW = (NONCLIENTMETRICSW )pvParam;
2980	NONCLIENTMETRICSA clientMetricsA = {0};
2981	PVOID pvParamA;
2982	UINT uiParamA;
2983
2984	switch(uiAction) {
2985	case SPI_SETNONCLIENTMETRICS:
2986	clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
2987	clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
2988	clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
2989	clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
2990	clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
2991	clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
2992	ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
2993	clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
2994	clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
2995	ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
2996	clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
2997	clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
2998	ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
2999	ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
3000	ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
3001	//no break
3002	case SPI_GETNONCLIENTMETRICS:
3003	uiParamA = sizeof(NONCLIENTMETRICSA);
3004	pvParamA = &clientMetricsA;
3005	break;
3006	default:
3007	pvParamA = pvParam;
3008	uiParamA = uiParam;
3009	break;
3010	}
3011	rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
3012
3013	switch(uiAction) {
3014	case SPI_GETNONCLIENTMETRICS:
3015	clientMetricsW->cbSize = sizeof(*clientMetricsW);
3016	clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
3017	clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
3018	clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
3019	clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
3020	clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
3021	ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
3022
3023	clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
3024	clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
3025	ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
3026
3027	clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
3028	clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
3029	ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
3030	ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
3031	ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
3032	break;
3033	}
3034	#ifdef DEBUG
3035	WriteLog("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc);
3036	#endif
3037	return(rc);
3038	}
3039	//******************************************************************************
3040	//******************************************************************************
3041	LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3042	{
3043	#ifdef DEBUG
3044	WriteLog("USER32: TabbedTextOutA\n");
3045	#endif
3046	return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
3047	}
3048	//******************************************************************************
3049	//******************************************************************************
3050	LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3051	{
3052	char *astring = UnicodeToAsciiString((LPWSTR)arg4);
3053	LONG rc;
3054
3055	#ifdef DEBUG
3056	WriteLog("USER32: TabbedTextOutW\n");
3057	#endif
3058	rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
3059	FreeAsciiString(astring);
3060	return rc;
3061	}
3062	//******************************************************************************
3063	//******************************************************************************
3064	int WIN32API TranslateAccelerator( HWND arg1, HACCEL arg2, LPMSG arg3)
3065	{
3066	#ifdef DEBUG
3067	WriteLog("USER32: TranslateAccelerator\n");
3068	#endif
3069	return O32_TranslateAccelerator(arg1, arg2, arg3);
3070	}
3071	//******************************************************************************
3072	//******************************************************************************
3073	int WIN32API TranslateAcceleratorW( HWND arg1, HACCEL arg2, LPMSG arg3)
3074	{
3075	#ifdef DEBUG
3076	WriteLog("USER32: TranslateAcceleratorW\n");
3077	#endif
3078	// NOTE: This will not work as is (needs UNICODE support)
3079	return O32_TranslateAccelerator(arg1, arg2, arg3);
3080	}
3081	//******************************************************************************
3082	//******************************************************************************
3083	BOOL WIN32API TranslateMDISysAccel( HWND arg1, LPMSG arg2)
3084	{
3085	#ifdef DEBUG
3086	//// WriteLog("USER32: TranslateMDISysAccel\n");
3087	#endif
3088	return O32_TranslateMDISysAccel(arg1, arg2);
3089	}
3090	//******************************************************************************
3091	//******************************************************************************
3092	BOOL WIN32API UnionRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
3093	{
3094	#ifdef DEBUG
3095	WriteLog("USER32: UnionRect\n");
3096	#endif
3097	return O32_UnionRect(arg1, arg2, arg3);
3098	}
3099	//******************************************************************************
3100	//******************************************************************************
3101	BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
3102	{
3103	#ifdef DEBUG
3104	WriteLog("USER32: ValidateRect\n");
3105	#endif
3106	return O32_ValidateRect(arg1, arg2);
3107	}
3108	//******************************************************************************
3109	//******************************************************************************
3110	BOOL WIN32API ValidateRgn( HWND arg1, HRGN arg2)
3111	{
3112	#ifdef DEBUG
3113	WriteLog("USER32: ValidateRgn\n");
3114	#endif
3115	return O32_ValidateRgn(arg1, arg2);
3116	}
3117	//******************************************************************************
3118	//******************************************************************************
3119	WORD WIN32API VkKeyScanW( WCHAR arg1)
3120	{
3121	#ifdef DEBUG
3122	WriteLog("USER32: VkKeyScanW\n");
3123	#endif
3124	// NOTE: This will not work as is (needs UNICODE support)
3125	return O32_VkKeyScan((char)arg1);
3126	}
3127	//******************************************************************************
3128	//******************************************************************************
3129	BOOL WIN32API WaitMessage(void)
3130	{
3131	#ifdef DEBUG
3132	WriteLog("USER32: WaitMessage\n");
3133	#endif
3134	return O32_WaitMessage();
3135	}
3136	//******************************************************************************
3137	//******************************************************************************
3138	BOOL WIN32API WinHelpW( HWND arg1, LPCWSTR arg2, UINT arg3, DWORD arg4)
3139	{
3140	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
3141	BOOL rc;
3142
3143	#ifdef DEBUG
3144	WriteLog("USER32: WinHelpW\n");
3145	#endif
3146	rc = WinHelpA(arg1, astring, arg3, arg4);
3147	FreeAsciiString(astring);
3148	return rc;
3149	}
3150	//******************************************************************************
3151	//******************************************************************************
3152	HWND WIN32API WindowFromDC( HDC arg1)
3153	{
3154	#ifdef DEBUG
3155	WriteLog("USER32: WindowFromDC\n");
3156	#endif
3157	return O32_WindowFromDC(arg1);
3158	}
3159	//******************************************************************************
3160	//******************************************************************************
3161	HWND WIN32API WindowFromPoint( POINT arg1)
3162	{
3163	#ifdef DEBUG
3164	WriteLog("USER32: WindowFromPoint\n");
3165	#endif
3166	return O32_WindowFromPoint(arg1);
3167	}
3168	//******************************************************************************
3169	//******************************************************************************
3170	int WIN32API wvsprintfA( LPSTR arg1, LPCSTR arg2, va_list arg3)
3171	{
3172	#ifdef DEBUG
3173	WriteLog("USER32: wvsprintfA\n");
3174	#endif
3175	return O32_wvsprintf(arg1, arg2, (LPCVOID *)arg3);
3176	}
3177	//******************************************************************************
3178	//******************************************************************************
3179	int WIN32API wvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, va_list argptr)
3180	{
3181	int rc;
3182	char szOut[256];
3183	char *lpFmtA;
3184
3185	lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
3186	#ifdef DEBUG
3187	WriteLog("USER32: wvsprintfW, DOES NOT HANDLE UNICODE STRINGS!\n");
3188	WriteLog("USER32: %s\n", lpFmt);
3189	#endif
3190	rc = O32_wvsprintf(szOut, lpFmtA, (LPCVOID)argptr);
3191
3192	AsciiToUnicode(szOut, lpOut);
3193	#ifdef DEBUG
3194	WriteLog("USER32: %s\n", lpOut);
3195	#endif
3196	FreeAsciiString(lpFmtA);
3197	return(rc);
3198	}
3199	//******************************************************************************
3200	//No need to support this
3201	//******************************************************************************
3202	BOOL WIN32API SetMessageQueue(int cMessagesMax)
3203	{
3204	#ifdef DEBUG
3205	WriteLog("USER32: SetMessageQueue\n");
3206	#endif
3207	return(TRUE);
3208	}
3209	//******************************************************************************
3210	//TODO: Not complete
3211	//******************************************************************************
3212	BOOL WIN32API GetScrollInfo(HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
3213	{
3214	#ifdef DEBUG
3215	WriteLog("USER32: GetScrollInfo\n");
3216	#endif
3217	if(lpsi == NULL)
3218	return(FALSE);
3219
3220	if(lpsi->fMask & SIF_POS)
3221	lpsi->nPos = GetScrollPos(hwnd, fnBar);
3222	if(lpsi->fMask & SIF_RANGE)
3223	GetScrollRange(hwnd, fnBar, &lpsi->nMin, &lpsi->nMax);
3224	if(lpsi->fMask & SIF_PAGE) {
3225	#ifdef DEBUG
3226	WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3227	#endif
3228	lpsi->nPage = 25;
3229	}
3230	return(TRUE);
3231	}
3232	//******************************************************************************
3233	//TODO: Not complete
3234	//******************************************************************************
3235	INT WIN32API SetScrollInfo(HWND hwnd, INT fnBar, const SCROLLINFO *lpsi, BOOL fRedraw)
3236	{
3237	int smin, smax;
3238
3239	#ifdef DEBUG
3240	WriteLog("USER32: SetScrollInfo\n");
3241	#endif
3242	if(lpsi == NULL)
3243	return(FALSE);
3244
3245	if(lpsi->fMask & SIF_POS)
3246	SetScrollPos(hwnd, fnBar, lpsi->nPos, fRedraw);
3247	if(lpsi->fMask & SIF_RANGE)
3248	SetScrollRange(hwnd, fnBar, lpsi->nMin, lpsi->nMax, fRedraw);
3249	if(lpsi->fMask & SIF_PAGE) {
3250	#ifdef DEBUG
3251	WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3252	#endif
3253	}
3254	if(lpsi->fMask & SIF_DISABLENOSCROLL) {
3255	#ifdef DEBUG
3256	WriteLog("USER32: GetScrollInfo, disable scrollbar not yet implemented\n");
3257	#endif
3258	}
3259	return(TRUE);
3260	}
3261	//******************************************************************************
3262	//******************************************************************************
3263	BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3264	LPARAM lpData, int nCount, int X, int Y, int nWidth,
3265	int nHeight)
3266	{
3267	BOOL rc;
3268	COLORREF curclr;
3269
3270	#ifdef DEBUG
3271	WriteLog("USER32: GrayStringA, not completely implemented\n");
3272	#endif
3273	if(lpOutputFunc == NULL && lpData == NULL) {
3274	#ifdef DEBUG
3275	WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3276	#endif
3277	return(FALSE);
3278	}
3279	if(lpOutputFunc) {
3280	return(lpOutputFunc(hdc, lpData, nCount));
3281	}
3282	curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3283	rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
3284	SetTextColor(hdc, curclr);
3285
3286	return(rc);
3287	}
3288	//******************************************************************************
3289	//******************************************************************************
3290	BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3291	LPARAM lpData, int nCount, int X, int Y, int nWidth,
3292	int nHeight)
3293	{
3294	BOOL rc;
3295	char *astring;
3296	COLORREF curclr;
3297
3298	#ifdef DEBUG
3299	WriteLog("USER32: GrayStringW, not completely implemented\n");
3300	#endif
3301
3302	if(lpOutputFunc == NULL && lpData == NULL) {
3303	#ifdef DEBUG
3304	WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3305	#endif
3306	return(FALSE);
3307	}
3308	if(nCount == 0)
3309	nCount = UniStrlen((UniChar*)lpData);
3310
3311	if(lpOutputFunc) {
3312	return(lpOutputFunc(hdc, lpData, nCount));
3313	}
3314	astring = UnicodeToAsciiString((LPWSTR)lpData);
3315
3316	curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3317	rc = TextOutA(hdc, X, Y, astring, nCount);
3318	SetTextColor(hdc, curclr);
3319
3320	FreeAsciiString(astring);
3321	return(rc);
3322	}
3323	//******************************************************************************
3324	//TODO:
3325	//******************************************************************************
3326	int WIN32API CopyAcceleratorTableA(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3327	int cAccelEntries)
3328	{
3329	#ifdef DEBUG
3330	WriteLog("USER32: CopyAcceleratorTableA, not implemented\n");
3331	#endif
3332	return(0);
3333	}
3334	//******************************************************************************
3335	//TODO:
3336	//******************************************************************************
3337	int WIN32API CopyAcceleratorTableW(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3338	int cAccelEntries)
3339	{
3340	#ifdef DEBUG
3341	WriteLog("USER32: CopyAcceleratorTableW, not implemented\n");
3342	#endif
3343	return(0);
3344	}
3345	//******************************************************************************
3346	//Stolen from Wine (controls\uitools.c)
3347	//******************************************************************************
3348	BOOL DrawEdgeDiag(HDC hdc, RECT *rect, UINT edge, UINT flags)
3349	{
3350	HPEN facePen, shadowPen, lightPen, blackPen, grayPen, nullPen;
3351	HPEN iPen, oPen, oldPen;
3352	HBRUSH oldBrush, faceBrush;
3353	int cl, cr, ct, cb;
3354	BOOL mainDiag;
3355	POINT tp;
3356	RECT r;
3357
3358	/* If both rasied and sunken is specified, they anihilate one another */
3359	if( !((flags & BF_MONO) \|\| (flags & BF_FLAT)) ){
3360	if( (edge & BDR_RAISEDOUTER) && (edge & BDR_SUNKENOUTER) )
3361	return FALSE;
3362	if( (edge & BDR_RAISEDINNER) && (edge & BDR_SUNKENINNER) )
3363	return FALSE;
3364	}
3365
3366	/* Create/get the tools of the trade... */
3367	facePen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNFACE));
3368	shadowPen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNSHADOW));
3369	lightPen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNHILIGHT));
3370	grayPen = CreatePen(PS_SOLID, 0, RGB(168, 152, 144));
3371	blackPen = GetStockObject(BLACK_PEN);
3372	nullPen = GetStockObject(NULL_PEN);
3373	faceBrush = GetSysColorBrush(COLOR_BTNFACE);
3374	oldPen = SelectObject(hdc, nullPen);
3375	oldBrush = SelectObject(hdc, faceBrush);
3376
3377	/* this is my working rectangle */
3378	r = *rect;
3379
3380	if(flags & BF_MONO){
3381	oPen = blackPen;
3382	iPen = nullPen;
3383	}else if(flags & BF_FLAT){
3384	oPen = shadowPen;
3385	iPen = facePen;
3386	}else {
3387	if(flags & BF_SOFT){
3388	if(flags & BF_BOTTOM){
3389	oPen = (edge & BDR_RAISEDOUTER) ? blackPen : lightPen;
3390	iPen = (edge & BDR_RAISEDINNER) ? shadowPen : grayPen;
3391	}
3392	else{
3393	oPen = (edge & BDR_RAISEDOUTER) ? lightPen : blackPen;
3394	iPen = (edge & BDR_RAISEDINNER) ? grayPen : shadowPen;
3395	}
3396	}
3397	else{
3398	if(flags & BF_BOTTOM){
3399	oPen = (edge & BDR_RAISEDOUTER) ? blackPen : lightPen;
3400	iPen = (edge & BDR_RAISEDINNER) ? shadowPen : grayPen;
3401	}
3402	else{
3403	oPen = (edge & BDR_RAISEDOUTER) ? grayPen : shadowPen;
3404	iPen = (edge & BDR_RAISEDINNER) ? lightPen : blackPen;
3405	}
3406	}
3407	}
3408
3409	if(flags & BF_BOTTOM){
3410	if(flags & BF_LEFT){
3411	cr = -1; cl = 0;
3412	ct = 0; cb = -1;
3413	mainDiag = TRUE;
3414	tp.x = r.left; tp.y = r.top;
3415	}
3416	else{ /* RIGHT */
3417	cr = -1; cl = 0;
3418	ct = 1; cb = 0;
3419	tp.x = r.left; tp.y = r.bottom-1;
3420	mainDiag = FALSE;
3421	}
3422	}
3423	else{ /* TOP */
3424	if(flags & BF_LEFT){
3425	cr = 0; cl = 1;
3426	ct = 0; cb = -1;
3427	mainDiag = FALSE;
3428	tp.x = r.right; tp.y = r.top;
3429	}
3430	else{ /* RIGHT */
3431	cr = 0; cl = 1;
3432	ct = 1; cb = 0;
3433	tp.x = r.right; tp.y = r.bottom-1;
3434	mainDiag = TRUE;
3435	}
3436	}
3437
3438	/* if it has external edge, draw it */
3439	if(edge & BDR_OUTER){
3440	SelectObject(hdc, oPen);
3441	MoveToEx(hdc, r.left, mainDiag ? r.bottom-1 : r.top, 0);
3442	LineTo(hdc, r.right, mainDiag ? r.top-1 : r.bottom);
3443	r.left += cl; r.right += cr; r.top += ct; r.bottom += cb;
3444	}
3445
3446	/* if it has internal edge, draw it */
3447	if(edge & BDR_INNER){
3448	SelectObject(hdc, iPen);
3449	MoveToEx(hdc, r.left, mainDiag ? r.bottom-1 : r.top, 0);
3450	LineTo(hdc, r.right, mainDiag ? r.top-1 : r.bottom);
3451	r.left += cl; r.right += cr; r.top += ct; r.bottom += cb;
3452	}
3453
3454	if((flags & BF_MIDDLE) && !(flags & BF_MONO)){
3455	POINT p[3];
3456	p[0].x = mainDiag ? r.right: r.left;
3457	p[0].y = r.top;
3458	p[1].x = mainDiag ? r.left : r.right;
3459	p[1].y = r.bottom;
3460	p[2].x = tp.x;
3461	p[2].y = tp.y;
3462	SelectObject(hdc, nullPen);
3463	SelectObject(hdc, faceBrush);
3464	Polygon(hdc, p, 3);
3465	}
3466
3467	if(flags & BF_ADJUST)
3468	*rect = r;
3469
3470	/* Restore the DC */
3471	SelectObject(hdc, oldPen);
3472	SelectObject(hdc, oldBrush);
3473
3474	/* Clean-up */
3475	DeleteObject(facePen);
3476	DeleteObject(shadowPen);
3477	DeleteObject(lightPen);
3478	DeleteObject(grayPen);
3479
3480	return TRUE;
3481	}
3482	//******************************************************************************
3483	//Stolen from Wine (controls\uitools.c)
3484	//******************************************************************************
3485	BOOL WIN32API DrawEdge(HDC hdc, LPRECT rect, UINT edge, UINT flags)
3486	{
3487	HBRUSH faceBrush, shadowBrush, lightBrush, blackBrush, grayBrush, nullBrush;
3488	HBRUSH iNBrush, iSBrush, iEBrush, iWBrush;
3489	HBRUSH oNBrush, oSBrush, oEBrush, oWBrush;
3490	HBRUSH oldBrush;
3491	POINT point[2];
3492	RECT r;
3493
3494	#ifdef DEBUG
3495	WriteLog("USER32: DrawEdge %X %X, partially implemented\n", edge, flags);
3496	WriteLog("USER32: DrawEdge (%d,%d) (%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom);
3497	#endif
3498
3499	if(flags & BF_DIAGONAL) {
3500	return DrawEdgeDiag(hdc, rect, edge, flags);
3501	}
3502	/* If both rasied and sunken is specified, they anihilate one another */
3503	if( !((flags & BF_MONO) \|\| (flags & BF_FLAT)) ){
3504	if( (edge & BDR_RAISEDOUTER) && (edge & BDR_SUNKENOUTER) )
3505	return FALSE;
3506	if( (edge & BDR_RAISEDINNER) && (edge & BDR_SUNKENINNER) )
3507	return FALSE;
3508	}
3509
3510	faceBrush = GetSysColorBrush(COLOR_BTNFACE);
3511	shadowBrush = GetSysColorBrush(COLOR_BTNSHADOW);
3512	lightBrush = GetSysColorBrush(COLOR_BTNHILIGHT);
3513	blackBrush = GetStockObject(BLACK_BRUSH);
3514	grayBrush = GetStockObject(LTGRAY_BRUSH);
3515	nullBrush = GetStockObject(NULL_BRUSH);
3516	oldBrush = SelectObject(hdc, nullBrush);
3517
3518	/* this is my working rectangle */
3519	r = *rect;
3520
3521	if(flags & BF_MONO){
3522	oNBrush = oSBrush = oEBrush = oWBrush = blackBrush;
3523	iNBrush = iSBrush = iEBrush = iWBrush = nullBrush;
3524	}else if(flags & BF_FLAT){
3525	oNBrush = oSBrush = oEBrush = oWBrush = shadowBrush;
3526	iNBrush = iSBrush = iEBrush = iWBrush = faceBrush;
3527	}else {
3528	if(flags & BF_SOFT){
3529	oNBrush = oWBrush = (edge & BDR_RAISEDOUTER) ? lightBrush : blackBrush;
3530	oSBrush = oEBrush = (edge & BDR_RAISEDOUTER) ? blackBrush : lightBrush;
3531	iNBrush = iWBrush = (edge & BDR_RAISEDINNER) ? grayBrush : shadowBrush;
3532	iSBrush = iEBrush = (edge & BDR_RAISEDINNER) ? shadowBrush : grayBrush;
3533	}
3534	else{
3535	oNBrush = oWBrush = (edge & BDR_RAISEDOUTER) ? grayBrush : shadowBrush;
3536	oSBrush = oEBrush = (edge & BDR_RAISEDOUTER) ? blackBrush : lightBrush;
3537	iNBrush = iWBrush = (edge & BDR_RAISEDINNER) ? lightBrush : blackBrush;
3538	iSBrush = iEBrush = (edge & BDR_RAISEDINNER) ? shadowBrush : grayBrush;
3539	}
3540	}
3541
3542	/* if it has external edge, draw it */
3543	if(edge & BDR_OUTER){
3544	if(flags & BF_RIGHT){
3545	SelectObject(hdc, oEBrush);
3546	PatBlt(hdc, r.right-1, r.top, 1, r.bottom - r.top, PATCOPY);
3547	r.right--;
3548	}
3549	if(flags & BF_BOTTOM){
3550	SelectObject(hdc, oSBrush);
3551	PatBlt(hdc, r.left, r.bottom-1, r.right-r.left, 1, PATCOPY);
3552	r.bottom--;
3553	}
3554	if(flags & BF_LEFT){
3555	SelectObject(hdc, oWBrush);
3556	PatBlt(hdc, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
3557	r.left++;
3558	}
3559	if(flags & BF_TOP){
3560	SelectObject(hdc, oNBrush);
3561	PatBlt(hdc, r.left, r.top, r.right-r.left, 1, PATCOPY);
3562	r.top++;
3563	}
3564	}
3565
3566	/* if it has internal edge, draw it */
3567	if(edge & BDR_INNER){
3568	if(flags & BF_RIGHT){
3569	SelectObject(hdc, iEBrush);
3570	PatBlt(hdc, r.right-1, r.top, 1, r.bottom - r.top, PATCOPY);
3571	r.right--;
3572	}
3573	if(flags & BF_BOTTOM){
3574	SelectObject(hdc, iSBrush);
3575	PatBlt(hdc, r.left, r.bottom-1, r.right-r.left, 1, PATCOPY);
3576	r.bottom--;
3577	}
3578	if(flags & BF_LEFT){
3579	SelectObject(hdc, iWBrush);
3580	PatBlt(hdc, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
3581	r.left++;
3582	}
3583	if(flags & BF_TOP){
3584	SelectObject(hdc, iNBrush);
3585	PatBlt(hdc, r.left, r.top, r.right-r.left, 1, PATCOPY);
3586	r.top++;
3587	}
3588	}
3589
3590	/* if we got to fill the middle, to it now */
3591	if((flags & BF_MIDDLE) && !(flags & BF_MONO))
3592	FillRect(hdc, &r, faceBrush);
3593
3594	/* adjust the rectangle if required */
3595	if(flags & BF_ADJUST)
3596	*rect = r;
3597
3598	/* Restore the DC */
3599	SelectObject(hdc, oldBrush);
3600
3601	return TRUE;
3602	}
3603	//******************************************************************************
3604	//******************************************************************************
3605	LRESULT WIN32API SendMessageTimeoutA(HWND hwnd, UINT Msg, WPARAM wParam,
3606	LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3607	LPDWORD lpdwResult)
3608	{
3609	#ifdef DEBUG
3610	WriteLog("USER32: SendMessageTimeoutA, partially implemented\n");
3611	#endif
3612	//ignore fuFlags & wTimeOut
3613	*lpdwResult = SendMessageA(hwnd, Msg, wParam, lParam);
3614	return(TRUE);
3615	}
3616	//******************************************************************************
3617	//******************************************************************************
3618	LRESULT WIN32API SendMessageTimeoutW(HWND hwnd, UINT Msg, WPARAM wParam,
3619	LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3620	LPDWORD lpdwResult)
3621	{
3622	#ifdef DEBUG
3623	WriteLog("USER32: SendMessageTimeoutW, partially implemented\n");
3624	#endif
3625	return(SendMessageTimeoutA(hwnd, Msg, wParam, lParam, fuFlags, uTimeOut, lpdwResult));
3626	}
3627	//******************************************************************************
3628	//******************************************************************************
3629	HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
3630	{
3631	#ifdef DEBUG
3632	WriteLog("USER32: CopyImage, not implemented\n");
3633	#endif
3634	switch(uType) {
3635	case IMAGE_BITMAP:
3636	case IMAGE_CURSOR:
3637	case IMAGE_ICON:
3638	default:
3639	#ifdef DEBUG
3640	WriteLog("USER32: CopyImage, unknown type\n");
3641	#endif
3642	return(NULL);
3643	}
3644	return(NULL);
3645	}
3646	//******************************************************************************
3647	//******************************************************************************
3648	BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
3649	{
3650	#ifdef DEBUG
3651	WriteLog("USER32: GetKeyboardState, not properly implemented\n");
3652	#endif
3653	memset(lpKeyState, 0, 256);
3654	return(TRUE);
3655	}
3656	//******************************************************************************
3657	//******************************************************************************
3658	BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
3659	{
3660	#ifdef DEBUG
3661	WriteLog("USER32: SetKeyboardState, not implemented\n");
3662	#endif
3663	return(TRUE);
3664	}
3665	//******************************************************************************
3666	//******************************************************************************
3667	BOOL WIN32API DrawFrameControl(HDC hdc, LPRECT lprc, UINT uType, UINT uState)
3668	{
3669	#ifdef DEBUG
3670	WriteLog("USER32: DrawFrameControl, not implemented\n");
3671	#endif
3672	return(TRUE);
3673	}
3674	//******************************************************************************
3675	//******************************************************************************
3676	BOOL WIN32API SendNotifyMessageA(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3677	{
3678	#ifdef DEBUG
3679	WriteLog("USER32: SendNotifyMessageA, not completely implemented\n");
3680	#endif
3681	return(SendMessageA(hwnd, Msg, wParam, lParam));
3682	}
3683	//******************************************************************************
3684	//******************************************************************************
3685	BOOL WIN32API SendNotifyMessageW(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3686	{
3687	#ifdef DEBUG
3688	WriteLog("USER32: SendNotifyMessageW, not completely implemented\n");
3689	#endif
3690	return(SendMessageA(hwnd, Msg, wParam, lParam));
3691	}
3692	//******************************************************************************
3693	//2nd parameter not used according to SDK (yet?)
3694	//******************************************************************************
3695	VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
3696	{
3697	#ifdef DEBUG
3698	WriteLog("USER32: SetLastErrorEx\n");
3699	#endif
3700	SetLastError(dwErrCode);
3701	}
3702	//******************************************************************************
3703	//******************************************************************************
3704	LPARAM WIN32API SetMessageExtraInfo(LPARAM lParam)
3705	{
3706	#ifdef DEBUG
3707	WriteLog("USER32: SetMessageExtraInfo, not implemented\n");
3708	#endif
3709	return(0);
3710	}
3711	//******************************************************************************
3712	//******************************************************************************
3713	BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
3714	{
3715	#ifdef DEBUG
3716	WriteLog("USER32: ActivateKeyboardLayout, not implemented\n");
3717	#endif
3718	return(TRUE);
3719	}
3720	//******************************************************************************
3721	//******************************************************************************
3722	int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
3723	{
3724	#ifdef DEBUG
3725	WriteLog("USER32: GetKeyboardLayoutList, not implemented\n");
3726	#endif
3727	return(0);
3728	}
3729	//******************************************************************************
3730	//******************************************************************************
3731	HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
3732	{
3733	#ifdef DEBUG
3734	WriteLog("USER32: GetKeyboardLayout, not implemented\n");
3735	#endif
3736	return(0);
3737	}
3738	//******************************************************************************
3739	//******************************************************************************
3740	int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
3741	{
3742	#ifdef DEBUG
3743	WriteLog("USER32: LookupIconIdFromDirectory, not implemented\n");
3744	#endif
3745	return(0);
3746	}
3747	//******************************************************************************
3748	//******************************************************************************
3749	int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL fIcon,
3750	int cxDesired, int cyDesired,
3751	UINT Flags)
3752	{
3753	#ifdef DEBUG
3754	WriteLog("USER32: LookupIconIdFromDirectoryEx, not implemented\n");
3755	#endif
3756	return(0);
3757	}
3758	//******************************************************************************
3759	//DWORD idAttach; /* thread to attach */
3760	//DWORD idAttachTo; /* thread to attach to */
3761	//BOOL fAttach; /* attach or detach */
3762	//******************************************************************************
3763	BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
3764	{
3765	#ifdef DEBUG
3766	WriteLog("USER32: AttachThreadInput, not implemented\n");
3767	#endif
3768	return(TRUE);
3769	}
3770	//******************************************************************************
3771	//******************************************************************************
3772	BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
3773	{
3774	#ifdef DEBUG
3775	WriteLog("USER32: RegisterHotKey, not implemented\n");
3776	#endif
3777	return(TRUE);
3778	}
3779	//******************************************************************************
3780	//******************************************************************************
3781	BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
3782	{
3783	#ifdef DEBUG
3784	WriteLog("USER32: UnregisterHotKey, not implemented\n");
3785	#endif
3786	return(TRUE);
3787	}
3788	//******************************************************************************
3789	//******************************************************************************
3790	BOOL WIN32API DrawStateA(HDC hdc, HBRUSH hbc, DRAWSTATEPROC lpOutputFunc,
3791	LPARAM lData, WPARAM wData, int x, int y, int cx,
3792	int cy, UINT fuFlags)
3793	{
3794	#ifdef DEBUG
3795	WriteLog("USER32: DrawStateA, not implemented\n");
3796	#endif
3797	return(TRUE);
3798	}
3799	//******************************************************************************
3800	//******************************************************************************
3801	//******************************************************************************
3802	//******************************************************************************
3803	BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
3804	{
3805	#ifdef DEBUG
3806	WriteLog("USER32: SetWindowContextHelpId, not implemented\n");
3807	#endif
3808	return(TRUE);
3809	}
3810	//******************************************************************************
3811	//******************************************************************************
3812	DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
3813	{
3814	#ifdef DEBUG
3815	WriteLog("USER32: GetWindowContextHelpId, not implemented\n");
3816	#endif
3817	return(0);
3818	}
3819	//******************************************************************************
3820	//restores iconized window to previous size/position
3821	//******************************************************************************
3822	BOOL WIN32API OpenIcon(HWND hwnd)
3823	{
3824	#ifdef DEBUG
3825	WriteLog("USER32: OpenIcon\n");
3826	#endif
3827	if(!IsIconic(hwnd))
3828	return FALSE;
3829	ShowWindow(hwnd, SW_SHOWNORMAL);
3830	return TRUE;
3831	}
3832	//******************************************************************************
3833	//******************************************************************************
3834	BOOL WIN32API IsWindowUnicode(HWND hwnd)
3835	{
3836	#ifdef DEBUG
3837	WriteLog("USER32: IsWindowUnicode, not implemented\n");
3838	#endif
3839	return(FALSE);
3840	}
3841	//******************************************************************************
3842	//******************************************************************************
3843	BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
3844	{
3845	#ifdef DEBUG
3846	WriteLog("USER32: GetMonitorInfoA not supported!!\n");
3847	#endif
3848	return(FALSE);
3849	}
3850	//******************************************************************************
3851	//******************************************************************************
3852	BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
3853	{
3854	#ifdef DEBUG
3855	WriteLog("USER32: GetMonitorInfoW not supported!!\n");
3856	#endif
3857	return(FALSE);
3858	}
3859	//******************************************************************************
3860	//******************************************************************************
3861	HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
3862	{
3863	#ifdef DEBUG
3864	WriteLog("USER32: MonitorFromWindow not correctly supported??\n");
3865	#endif
3866	return(0);
3867	}
3868	//******************************************************************************
3869	//******************************************************************************
3870	HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
3871	{
3872	#ifdef DEBUG
3873	WriteLog("USER32: MonitorFromRect not correctly supported??\n");
3874	#endif
3875	return(0);
3876	}
3877	//******************************************************************************
3878	//******************************************************************************
3879	HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
3880	{
3881	#ifdef DEBUG
3882	WriteLog("USER32: MonitorFromPoint not correctly supported??\n");
3883	#endif
3884	return(0);
3885	}
3886	//******************************************************************************
3887	//******************************************************************************
3888	BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
3889	{
3890	#ifdef DEBUG
3891	WriteLog("USER32: EnumDisplayMonitors not supported??\n");
3892	#endif
3893	return(FALSE);
3894	}
3895	//******************************************************************************
3896	//******************************************************************************
3897	BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
3898	LPDEVMODEA lpDevMode)
3899	{
3900	#ifdef DEBUG
3901	WriteLog("USER32: EnumDisplaySettingsA FAKED\n");
3902	#endif
3903	switch(iModeNum) {
3904	case 0:
3905	lpDevMode->dmBitsPerPel = 16;
3906	lpDevMode->dmPelsWidth = 768;
3907	lpDevMode->dmPelsHeight = 1024;
3908	lpDevMode->dmDisplayFlags = 0;
3909	lpDevMode->dmDisplayFrequency = 70;
3910	break;
3911	case 1:
3912	lpDevMode->dmBitsPerPel = 16;
3913	lpDevMode->dmPelsWidth = 640;
3914	lpDevMode->dmPelsHeight = 480;
3915	lpDevMode->dmDisplayFlags = 0;
3916	lpDevMode->dmDisplayFrequency = 70;
3917	break;
3918	default:
3919	return(FALSE);
3920	}
3921	return(TRUE);
3922	}
3923	//******************************************************************************
3924	//******************************************************************************
3925	LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA lpDevMode, DWORD dwFlags)
3926	{
3927	#ifdef DEBUG
3928	if(lpDevMode) {
3929	WriteLog("USER32: ChangeDisplaySettingsA FAKED %X\n", dwFlags);
3930	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
3931	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsWidth %d\n", lpDevMode->dmPelsWidth);
3932	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
3933	}
3934	#endif
3935	return(DISP_CHANGE_SUCCESSFUL);
3936	}
3937	//******************************************************************************
3938	//******************************************************************************
3939
3940
3941	/*****************************************************************************
3942	* Name : BOOL WIN32API AnyPopup
3943	* Purpose : The AnyPopup function indicates whether an owned, visible,
3944	* top-level pop-up, or overlapped window exists on the screen. The
3945	* function searches the entire Windows screen, not just the calling
3946	* application's client area.
3947	* Parameters: VOID
3948	* Variables :
3949	* Result : If a pop-up window exists, the return value is TRUE even if the
3950	* pop-up window is completely covered by other windows. Otherwise,
3951	* it is FALSE.
3952	* Remark : AnyPopup is a Windows version 1.x function and is retained for
3953	* compatibility purposes. It is generally not useful.
3954	* Status : UNTESTED STUB
3955	*
3956	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3957	*****************************************************************************/
3958
3959	BOOL WIN32API AnyPopup(VOID)
3960	{
3961	dprintf(("USER32:AnyPopup() not implemented.\n"));
3962
3963	return (FALSE);
3964	}
3965
3966
3967	/*****************************************************************************
3968	* Name : long WIN32API BroadcastSystemMessage
3969	* Purpose : The BroadcastSystemMessage function sends a message to the given
3970	* recipients. The recipients can be applications, installable
3971	* drivers, Windows-based network drivers, system-level device
3972	* drivers, or any combination of these system components.
3973	* Parameters: DWORD dwFlags,
3974	LPDWORD lpdwRecipients,
3975	UINT uiMessage,
3976	WPARAM wParam,
3977	LPARAM lParam
3978	* Variables :
3979	* Result : If the function succeeds, the return value is a positive value.
3980	* If the function is unable to broadcast the message, the return value is -1.
3981	* If the dwFlags parameter is BSF_QUERY and at least one recipient returned FALSE to the corresponding message, the return value is zero.
3982	* Remark :
3983	* Status : UNTESTED STUB
3984	*
3985	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3986	*****************************************************************************/
3987
3988	long WIN32API BroadcastSystemMessage(DWORD dwFlags,
3989	LPDWORD lpdwRecipients,
3990	UINT uiMessage,
3991	WPARAM wParam,
3992	LPARAM lParam)
3993	{
3994	dprintf(("USER32:BroadcastSystemMessage(%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
3995	dwFlags,
3996	lpdwRecipients,
3997	uiMessage,
3998	wParam,
3999	lParam));
4000
4001	return (-1);
4002	}
4003
4004
4005	/*****************************************************************************
4006	* Name : WORD WIN32API CascadeWindows
4007	* Purpose : The CascadeWindows function cascades the specified windows or
4008	* the child windows of the specified parent window.
4009	* Parameters: HWND hwndParent handle of parent window
4010	* UINT wHow types of windows not to arrange
4011	* CONST RECT * lpRect rectangle to arrange windows in
4012	* UINT cKids number of windows to arrange
4013	* const HWND FAR * lpKids array of window handles
4014	* Variables :
4015	* Result : If the function succeeds, the return value is the number of windows arranged.
4016	* If the function fails, the return value is zero.
4017	* Remark :
4018	* Status : UNTESTED STUB
4019	*
4020	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4021	*****************************************************************************/
4022
4023	WORD WIN32API CascadeWindows(HWND hwndParent,
4024	UINT wHow,
4025	CONST LPRECT lpRect,
4026	UINT cKids,
4027	const HWND *lpKids)
4028	{
4029	dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
4030	hwndParent,
4031	wHow,
4032	lpRect,
4033	cKids,
4034	lpKids));
4035
4036	return (0);
4037	}
4038
4039
4040	/*****************************************************************************
4041	* Name : LONG WIN32API ChangeDisplaySettingsW
4042	* Purpose : The ChangeDisplaySettings function changes the display settings
4043	* to the specified graphics mode.
4044	* Parameters: LPDEVMODEW lpDevModeW
4045	* DWORD dwFlags
4046	* Variables :
4047	* Result : DISP_CHANGE_SUCCESSFUL The settings change was successful.
4048	* DISP_CHANGE_RESTART The computer must be restarted in order for the graphics mode to work.
4049	* DISP_CHANGE_BADFLAGS An invalid set of flags was passed in.
4050	* DISP_CHANGE_FAILED The display driver failed the specified graphics mode.
4051	* DISP_CHANGE_BADMODE The graphics mode is not supported.
4052	* DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
4053	* Remark :
4054	* Status : UNTESTED STUB
4055	*
4056	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4057	*****************************************************************************/
4058
4059	LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
4060	DWORD dwFlags)
4061	{
4062	dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
4063	lpDevMode,
4064	dwFlags));
4065
4066	return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
4067	dwFlags));
4068	}
4069
4070	/*****************************************************************************
4071	* Name : BOOL WIN32API CloseDesktop
4072	* Purpose : The CloseDesktop function closes an open handle of a desktop
4073	* object. A desktop is a secure object contained within a window
4074	* station object. A desktop has a logical display surface and
4075	* contains windows, menus and hooks.
4076	* Parameters: HDESK hDesktop
4077	* Variables :
4078	* Result : If the function succeeds, the return value is TRUE.
4079	* If the functions fails, the return value is FALSE. To get
4080	* extended error information, call GetLastError.
4081	* Remark :
4082	* Status : UNTESTED STUB
4083	*
4084	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4085	*****************************************************************************/
4086
4087	BOOL WIN32API CloseDesktop(HDESK hDesktop)
4088	{
4089	dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
4090	hDesktop));
4091
4092	return (FALSE);
4093	}
4094
4095
4096	/*****************************************************************************
4097	* Name : BOOL WIN32API CloseWindowStation
4098	* Purpose : The CloseWindowStation function closes an open window station handle.
4099	* Parameters: HWINSTA hWinSta
4100	* Variables :
4101	* Result :
4102	* Remark : If the function succeeds, the return value is TRUE.
4103	* If the functions fails, the return value is FALSE. To get
4104	* extended error information, call GetLastError.
4105	* Status : UNTESTED STUB
4106	*
4107	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4108	*****************************************************************************/
4109
4110	BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
4111	{
4112	dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
4113	hWinSta));
4114
4115	return (FALSE);
4116	}
4117
4118
4119	/*****************************************************************************
4120	* Name : HDESK WIN32API CreateDesktopA
4121	* Purpose : The CreateDesktop function creates a new desktop on the window
4122	* station associated with the calling process.
4123	* Parameters: LPCTSTR lpszDesktop name of the new desktop
4124	* LPCTSTR lpszDevice name of display device to assign to the desktop
4125	* LPDEVMODE pDevMode reserved; must be NULL
4126	* DWORD dwFlags flags to control interaction with other applications
4127	* DWORD dwDesiredAccess specifies access of returned handle
4128	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
4129	* Variables :
4130	* Result : If the function succeeds, the return value is a handle of the
4131	* newly created desktop.
4132	* If the function fails, the return value is NULL. To get extended
4133	* error information, call GetLastError.
4134	* Remark :
4135	* Status : UNTESTED STUB
4136	*
4137	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4138	*****************************************************************************/
4139
4140	HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
4141	LPCTSTR lpszDevice,
4142	LPDEVMODEA pDevMode,
4143	DWORD dwFlags,
4144	DWORD dwDesiredAccess,
4145	LPSECURITY_ATTRIBUTES lpsa)
4146	{
4147	dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4148	lpszDesktop,
4149	lpszDevice,
4150	pDevMode,
4151	dwFlags,
4152	dwDesiredAccess,
4153	lpsa));
4154
4155	return (NULL);
4156	}
4157
4158
4159	/*****************************************************************************
4160	* Name : HDESK WIN32API CreateDesktopW
4161	* Purpose : The CreateDesktop function creates a new desktop on the window
4162	* station associated with the calling process.
4163	* Parameters: LPCTSTR lpszDesktop name of the new desktop
4164	* LPCTSTR lpszDevice name of display device to assign to the desktop
4165	* LPDEVMODE pDevMode reserved; must be NULL
4166	* DWORD dwFlags flags to control interaction with other applications
4167	* DWORD dwDesiredAccess specifies access of returned handle
4168	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
4169	* Variables :
4170	* Result : If the function succeeds, the return value is a handle of the
4171	* newly created desktop.
4172	* If the function fails, the return value is NULL. To get extended
4173	* error information, call GetLastError.
4174	* Remark :
4175	* Status : UNTESTED STUB
4176	*
4177	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4178	*****************************************************************************/
4179
4180	HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
4181	LPCTSTR lpszDevice,
4182	LPDEVMODEW pDevMode,
4183	DWORD dwFlags,
4184	DWORD dwDesiredAccess,
4185	LPSECURITY_ATTRIBUTES lpsa)
4186	{
4187	dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4188	lpszDesktop,
4189	lpszDevice,
4190	pDevMode,
4191	dwFlags,
4192	dwDesiredAccess,
4193	lpsa));
4194
4195	return (NULL);
4196	}
4197
4198
4199	/*****************************************************************************
4200	* Name : HWINSTA WIN32API CreateWindowStationA
4201	* Purpose : The CreateWindowStation function creates a window station object.
4202	* It returns a handle that can be used to access the window station.
4203	* A window station is a secure object that contains a set of global
4204	* atoms, a clipboard, and a set of desktop objects.
4205	* Parameters: LPTSTR lpwinsta name of the new window station
4206	* DWORD dwReserved reserved; must be NULL
4207	* DWORD dwDesiredAccess specifies access of returned handle
4208	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4209	* Variables :
4210	* Result : If the function succeeds, the return value is the handle to the
4211	* newly created window station.
4212	* If the function fails, the return value is NULL. To get extended
4213	* error information, call GetLastError.
4214	* Remark :
4215	* Status : UNTESTED STUB
4216	*
4217	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4218	*****************************************************************************/
4219
4220	HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
4221	DWORD dwReserved,
4222	DWORD dwDesiredAccess,
4223	LPSECURITY_ATTRIBUTES lpsa)
4224	{
4225	dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
4226	lpWinSta,
4227	dwReserved,
4228	dwDesiredAccess,
4229	lpsa));
4230
4231	return (NULL);
4232	}
4233
4234
4235	/*****************************************************************************
4236	* Name : HWINSTA WIN32API CreateWindowStationW
4237	* Purpose : The CreateWindowStation function creates a window station object.
4238	* It returns a handle that can be used to access the window station.
4239	* A window station is a secure object that contains a set of global
4240	* atoms, a clipboard, and a set of desktop objects.
4241	* Parameters: LPTSTR lpwinsta name of the new window station
4242	* DWORD dwReserved reserved; must be NULL
4243	* DWORD dwDesiredAccess specifies access of returned handle
4244	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4245	* Variables :
4246	* Result : If the function succeeds, the return value is the handle to the
4247	* newly created window station.
4248	* If the function fails, the return value is NULL. To get extended
4249	* error information, call GetLastError.
4250	* Remark :
4251	* Status : UNTESTED STUB
4252	*
4253	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4254	*****************************************************************************/
4255
4256	HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
4257	DWORD dwReserved,
4258	DWORD dwDesiredAccess,
4259	LPSECURITY_ATTRIBUTES lpsa)
4260	{
4261	dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
4262	lpWinSta,
4263	dwReserved,
4264	dwDesiredAccess,
4265	lpsa));
4266
4267	return (NULL);
4268	}
4269
4270	/*****************************************************************************
4271	* Name : BOOL WIN32API DragDetect
4272	* Purpose : The DragDetect function captures the mouse and tracks its movement
4273	* Parameters: HWND hwnd
4274	* POINT pt
4275	* Variables :
4276	* Result : If the user moved the mouse outside of the drag rectangle while
4277	* holding the left button down, the return value is TRUE.
4278	* If the user did not move the mouse outside of the drag rectangle
4279	* while holding the left button down, the return value is FALSE.
4280	* Remark :
4281	* Status : UNTESTED STUB
4282	*
4283	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4284	*****************************************************************************/
4285
4286	BOOL WIN32API DragDetect(HWND hwnd,
4287	POINT pt)
4288	{
4289	dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
4290	hwnd));
4291
4292	return (FALSE);
4293	}
4294
4295
4296	/*****************************************************************************
4297	* Name : BOOL WIN32API DrawAnimatedRects
4298	* Purpose : The DrawAnimatedRects function draws a wire-frame rectangle
4299	* and animates it to indicate the opening of an icon or the
4300	* minimizing or maximizing of a window.
4301	* Parameters: HWND hwnd handle of clipping window
4302	* int idAni type of animation
4303	* CONST RECT * lprcFrom address of rectangle coordinates (minimized)
4304	* CONST RECT * lprcTo address of rectangle coordinates (restored)
4305	* Variables :
4306	* Result : If the function succeeds, the return value is TRUE.
4307	* If the function fails, the return value is FALSE.
4308	* Remark :
4309	* Status : UNTESTED STUB
4310	*
4311	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4312	*****************************************************************************/
4313
4314	BOOL WIN32API DrawAnimatedRects(HWND hwnd,
4315	int idAni,
4316	CONST RECT *lprcFrom,
4317	CONST RECT *lprcTo)
4318	{
4319	dprintf(("USER32:DrawAnimatedRects (%08xh,%u,%08xh,%08x) not implemented.\n",
4320	hwnd,
4321	idAni,
4322	lprcFrom,
4323	lprcTo));
4324
4325	return (TRUE);
4326	}
4327
4328
4329	/*****************************************************************************
4330	* Name : VOID WIN32API DrawCaption
4331	* Purpose : The DrawCaption function draws a window caption.
4332	* Parameters: HDC hdc handle of device context
4333	* LPRECT lprc address of bounding rectangle coordinates
4334	* HFONT hfont handle of font for caption
4335	* HICON hicon handle of icon in caption
4336	* LPSTR lpszText address of caption string
4337	* WORD wFlags drawing options
4338	* Variables :
4339	* Result :
4340	* Remark :
4341	* Status : UNTESTED STUB
4342	*
4343	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4344	*****************************************************************************/
4345
4346	BOOL WIN32API DrawCaption (HWND hwnd,
4347	HDC hdc,
4348	const RECT *lprc,
4349	UINT wFlags)
4350	{
4351	dprintf(("USER32:DrawCaption (%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4352	hwnd,
4353	hdc,
4354	lprc,
4355	wFlags));
4356
4357	return FALSE;
4358	}
4359
4360
4361	/*****************************************************************************
4362	* Name :
4363	* Purpose :
4364	* Parameters:
4365	* Variables :
4366	* Result :
4367	* Remark :
4368	* Status : UNTESTED STUB
4369	*
4370	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4371	*****************************************************************************/
4372
4373	BOOL WIN32API DrawStateW(HDC hdc,
4374	HBRUSH hBrush,
4375	DRAWSTATEPROC lpOutputFunc,
4376	LPARAM lParam,
4377	WPARAM wParam,
4378	int x,
4379	int y,
4380	int cx,
4381	int cy,
4382	UINT fuFlags)
4383	{
4384	dprintf(("USER32:DrawStateW (%08xh,%08xh,%08xh,%08xh,%08xh,%d,%d,%d,%d,%08x) not implemented.\n",
4385	hdc,
4386	hBrush,
4387	lpOutputFunc,
4388	lParam,
4389	wParam,
4390	x,
4391	y,
4392	cx,
4393	cy,
4394	fuFlags));
4395
4396	return(DrawStateA(hdc,
4397	hBrush,
4398	lpOutputFunc,
4399	lParam,
4400	wParam,
4401	x,
4402	y,
4403	cx,
4404	cy,
4405	fuFlags));
4406	}
4407
4408
4409	/*****************************************************************************
4410	* Name : BOOL WIN32API EnumDesktopWindows
4411	* Purpose : The EnumDesktopWindows function enumerates all windows in a
4412	* desktop by passing the handle of each window, in turn, to an
4413	* application-defined callback function.
4414	* Parameters: HDESK hDesktop handle of desktop to enumerate
4415	* WNDENUMPROC lpfn points to application's callback function
4416	* LPARAM lParam 32-bit value to pass to the callback function
4417	* Variables :
4418	* Result : If the function succeeds, the return value is TRUE.
4419	* If the function fails, the return value is FALSE. To get
4420	* extended error information, call GetLastError.
4421	* Remark :
4422	* Status : UNTESTED STUB
4423	*
4424	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4425	*****************************************************************************/
4426
4427	BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
4428	WNDENUMPROC lpfn,
4429	LPARAM lParam)
4430	{
4431	dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
4432	hDesktop,
4433	lpfn,
4434	lParam));
4435
4436	return (FALSE);
4437	}
4438
4439
4440	/*****************************************************************************
4441	* Name : BOOL WIN32API EnumDesktopsA
4442	* Purpose : The EnumDesktops function enumerates all desktops in the window
4443	* station assigned to the calling process. The function does so by
4444	* passing the name of each desktop, in turn, to an application-
4445	* defined callback function.
4446	* Parameters: HWINSTA hwinsta handle of window station to enumerate
4447	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
4448	* LPARAM lParam 32-bit value to pass to the callback function
4449	* Variables :
4450	* Result : If the function succeeds, the return value is TRUE.
4451	* If the function fails, the return value is FALSE. To get extended
4452	* error information, call GetLastError.
4453	* Remark :
4454	* Status : UNTESTED STUB
4455	*
4456	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4457	*****************************************************************************/
4458
4459	BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
4460	DESKTOPENUMPROCA lpEnumFunc,
4461	LPARAM lParam)
4462	{
4463	dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
4464	hWinSta,
4465	lpEnumFunc,
4466	lParam));
4467
4468	return (FALSE);
4469	}
4470
4471
4472	/*****************************************************************************
4473	* Name : BOOL WIN32API EnumDesktopsW
4474	* Purpose : The EnumDesktops function enumerates all desktops in the window
4475	* station assigned to the calling process. The function does so by
4476	* passing the name of each desktop, in turn, to an application-
4477	* defined callback function.
4478	* Parameters: HWINSTA hwinsta handle of window station to enumerate
4479	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
4480	* LPARAM lParam 32-bit value to pass to the callback function
4481	* Variables :
4482	* Result : If the function succeeds, the return value is TRUE.
4483	* If the function fails, the return value is FALSE. To get extended
4484	* error information, call GetLastError.
4485	* Remark :
4486	* Status : UNTESTED STUB
4487	*
4488	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4489	*****************************************************************************/
4490
4491	BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
4492	DESKTOPENUMPROCW lpEnumFunc,
4493	LPARAM lParam)
4494	{
4495	dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
4496	hWinSta,
4497	lpEnumFunc,
4498	lParam));
4499
4500	return (FALSE);
4501	}
4502
4503
4504
4505	/*****************************************************************************
4506	* Name : BOOL WIN32API EnumDisplaySettingsW
4507	* Purpose : The EnumDisplaySettings function obtains information about one
4508	* of a display device's graphics modes. You can obtain information
4509	* for all of a display device's graphics modes by making a series
4510	* of calls to this function.
4511	* Parameters: LPCTSTR lpszDeviceName specifies the display device
4512	* DWORD iModeNum specifies the graphics mode
4513	* LPDEVMODE lpDevMode points to structure to receive settings
4514	* Variables :
4515	* Result : If the function succeeds, the return value is TRUE.
4516	* If the function fails, the return value is FALSE.
4517	* Remark :
4518	* Status : UNTESTED STUB
4519	*
4520	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4521	*****************************************************************************/
4522
4523	BOOL WIN32API EnumDisplaySettingsW(LPCSTR lpszDeviceName,
4524	DWORD iModeNum,
4525	LPDEVMODEW lpDevMode)
4526	{
4527	dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
4528	lpszDeviceName,
4529	iModeNum,
4530	lpDevMode));
4531
4532	return (EnumDisplaySettingsA(lpszDeviceName,
4533	iModeNum,
4534	(LPDEVMODEA)lpDevMode));
4535	}
4536
4537
4538	/*****************************************************************************
4539	* Name : BOOL WIN32API EnumWindowStationsA
4540	* Purpose : The EnumWindowStations function enumerates all windowstations
4541	* in the system by passing the name of each window station, in
4542	* turn, to an application-defined callback function.
4543	* Parameters:
4544	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4545	* LPARAM lParam 32-bit value to pass to the callback function
4546	* Result : If the function succeeds, the return value is TRUE.
4547	* If the function fails the return value is FALSE. To get extended
4548	* error information, call GetLastError.
4549	* Remark :
4550	* Status : UNTESTED STUB
4551	*
4552	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4553	*****************************************************************************/
4554
4555	BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
4556	LPARAM lParam)
4557	{
4558	dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
4559	lpEnumFunc,
4560	lParam));
4561
4562	return (FALSE);
4563	}
4564
4565
4566	/*****************************************************************************
4567	* Name : BOOL WIN32API EnumWindowStationsW
4568	* Purpose : The EnumWindowStations function enumerates all windowstations
4569	* in the system by passing the name of each window station, in
4570	* turn, to an application-defined callback function.
4571	* Parameters:
4572	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4573	* LPARAM lParam 32-bit value to pass to the callback function
4574	* Result : If the function succeeds, the return value is TRUE.
4575	* If the function fails the return value is FALSE. To get extended
4576	* error information, call GetLastError.
4577	* Remark :
4578	* Status : UNTESTED STUB
4579	*
4580	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4581	*****************************************************************************/
4582
4583	BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
4584	LPARAM lParam)
4585	{
4586	dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
4587	lpEnumFunc,
4588	lParam));
4589
4590	return (FALSE);
4591	}
4592
4593
4594	/*****************************************************************************
4595	* Name : HWND WIN32API FindWindowExW
4596	* Purpose : The FindWindowEx function retrieves the handle of a window whose
4597	* class name and window name match the specified strings. The
4598	* function searches child windows, beginning with the one following
4599	* the given child window.
4600	* Parameters: HWND hwndParent handle of parent window
4601	* HWND hwndChildAfter handle of a child window
4602	* LPCTSTR lpszClass address of class name
4603	* LPCTSTR lpszWindow address of window name
4604	* Variables :
4605	* Result : If the function succeeds, the return value is the handle of the
4606	* window that has the specified class and window names.
4607	* If the function fails, the return value is NULL. To get extended
4608	* error information, call GetLastError.
4609	* Remark :
4610	* Status : UNTESTED STUB
4611	*
4612	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4613	*****************************************************************************/
4614
4615	HWND WIN32API FindWindowExW(HWND hwndParent,
4616	HWND hwndChildAfter,
4617	LPCWSTR lpszClass,
4618	LPCWSTR lpszWindow)
4619	{
4620	dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
4621	hwndParent,
4622	hwndChildAfter,
4623	lpszClass,
4624	lpszWindow));
4625
4626	return (NULL);
4627	}
4628
4629	/*****************************************************************************
4630	* Name : BOOL WIN32API GetInputState
4631	* Purpose : The GetInputState function determines whether there are
4632	* mouse-button or keyboard messages in the calling thread's message queue.
4633	* Parameters:
4634	* Variables :
4635	* Result : If the queue contains one or more new mouse-button or keyboard
4636	* messages, the return value is TRUE.
4637	* If the function fails, the return value is FALSE.
4638	* Remark :
4639	* Status : UNTESTED STUB
4640	*
4641	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4642	*****************************************************************************/
4643
4644	BOOL WIN32API GetInputState(VOID)
4645	{
4646	dprintf(("USER32:GetInputState () not implemented.\n"));
4647
4648	return (FALSE);
4649	}
4650
4651
4652	/*****************************************************************************
4653	* Name : UINT WIN32API GetKBCodePage
4654	* Purpose : The GetKBCodePage function is provided for compatibility with
4655	* earlier versions of Windows. In the Win32 application programming
4656	* interface (API) it just calls the GetOEMCP function.
4657	* Parameters:
4658	* Variables :
4659	* Result : If the function succeeds, the return value is an OEM code-page
4660	* identifier, or it is the default identifier if the registry
4661	* value is not readable. For a list of OEM code-page identifiers,
4662	* see GetOEMCP.
4663	* Remark :
4664	* Status : UNTESTED
4665	*
4666	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4667	*****************************************************************************/
4668
4669	UINT WIN32API GetKBCodePage(VOID)
4670	{
4671	return (GetOEMCP());
4672	}
4673
4674
4675	/*****************************************************************************
4676	* Name : BOOL WIN32API GetKeyboardLayoutNameA
4677	* Purpose : The GetKeyboardLayoutName function retrieves the name of the
4678	* active keyboard layout.
4679	* Parameters: LPTSTR pwszKLID address of buffer for layout name
4680	* Variables :
4681	* Result : If the function succeeds, the return value is TRUE.
4682	* If the function fails, the return value is FALSE. To get extended
4683	* error information, call GetLastError.
4684	* Remark :
4685	* Status : UNTESTED STUB
4686	*
4687	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4688	*****************************************************************************/
4689
4690	BOOL WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
4691	{
4692	dprintf(("USER32:GetKeyboardLayoutNameA (%08x) not implemented.",
4693	pwszKLID));
4694
4695	return(FALSE);
4696	}
4697
4698
4699	/*****************************************************************************
4700	* Name : BOOL WIN32API GetKeyboardLayoutNameW
4701	* Purpose : The GetKeyboardLayoutName function retrieves the name of the
4702	* active keyboard layout.
4703	* Parameters: LPTSTR pwszKLID address of buffer for layout name
4704	* Variables :
4705	* Result : If the function succeeds, the return value is TRUE.
4706	* If the function fails, the return value is FALSE. To get extended
4707	* error information, call GetLastError.
4708	* Remark :
4709	* Status : UNTESTED STUB
4710	*
4711	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4712	*****************************************************************************/
4713
4714	BOOL WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
4715	{
4716	dprintf(("USER32:GetKeyboardLayoutNameW (%08x) not implemented.",
4717	pwszKLID));
4718
4719	return(FALSE);
4720	}
4721
4722
4723
4724
4725	/*****************************************************************************
4726	* Name : HWINSTA WIN32API GetProcessWindowStation
4727	* Purpose : The GetProcessWindowStation function returns a handle of the
4728	* window station associated with the calling process.
4729	* Parameters:
4730	* Variables :
4731	* Result : If the function succeeds, the return value is a handle of the
4732	* window station associated with the calling process.
4733	* If the function fails, the return value is NULL. This can occur
4734	* if the calling process is not an application written for Windows
4735	* NT. To get extended error information, call GetLastError.
4736	* Remark :
4737	* Status : UNTESTED STUB
4738	*
4739	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4740	*****************************************************************************/
4741
4742	HWINSTA WIN32API GetProcessWindowStation(VOID)
4743	{
4744	dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
4745
4746	return (NULL);
4747	}
4748
4749
4750
4751	/*****************************************************************************
4752	* Name : HDESK WIN32API GetThreadDesktop
4753	* Purpose : The GetThreadDesktop function returns a handle to the desktop
4754	* associated with a specified thread.
4755	* Parameters: DWORD dwThreadId thread identifier
4756	* Variables :
4757	* Result : If the function succeeds, the return value is the handle of the
4758	* desktop associated with the specified thread.
4759	* Remark :
4760	* Status : UNTESTED STUB
4761	*
4762	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4763	*****************************************************************************/
4764
4765	HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
4766	{
4767	dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
4768	dwThreadId));
4769
4770	return (NULL);
4771	}
4772
4773
4774	/*****************************************************************************
4775	* Name : BOOL WIN32API GetUserObjectInformationA
4776	* Purpose : The GetUserObjectInformation function returns information about
4777	* a window station or desktop object.
4778	* Parameters: HANDLE hObj handle of object to get information for
4779	* int nIndex type of information to get
4780	* PVOID pvInfo points to buffer that receives the information
4781	* DWORD nLength size, in bytes, of pvInfo buffer
4782	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4783	* Variables :
4784	* Result : If the function succeeds, the return value is TRUE.
4785	* If the function fails, the return value is FALSE. To get extended
4786	* error information, call GetLastError.
4787	* Remark :
4788	* Status : UNTESTED STUB
4789	*
4790	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4791	*****************************************************************************/
4792
4793	BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
4794	int nIndex,
4795	PVOID pvInfo,
4796	DWORD nLength,
4797	LPDWORD lpnLengthNeeded)
4798	{
4799	dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4800	hObj,
4801	nIndex,
4802	pvInfo,
4803	nLength,
4804	lpnLengthNeeded));
4805
4806	return (FALSE);
4807	}
4808
4809
4810	/*****************************************************************************
4811	* Name : BOOL WIN32API GetUserObjectInformationW
4812	* Purpose : The GetUserObjectInformation function returns information about
4813	* a window station or desktop object.
4814	* Parameters: HANDLE hObj handle of object to get information for
4815	* int nIndex type of information to get
4816	* PVOID pvInfo points to buffer that receives the information
4817	* DWORD nLength size, in bytes, of pvInfo buffer
4818	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4819	* Variables :
4820	* Result : If the function succeeds, the return value is TRUE.
4821	* If the function fails, the return value is FALSE. To get extended
4822	* error information, call GetLastError.
4823	* Remark :
4824	* Status : UNTESTED STUB
4825	*
4826	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4827	*****************************************************************************/
4828
4829	BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
4830	int nIndex,
4831	PVOID pvInfo,
4832	DWORD nLength,
4833	LPDWORD lpnLengthNeeded)
4834	{
4835	dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4836	hObj,
4837	nIndex,
4838	pvInfo,
4839	nLength,
4840	lpnLengthNeeded));
4841
4842	return (FALSE);
4843	}
4844
4845
4846	/*****************************************************************************
4847	* Name : BOOL WIN32API GetUserObjectSecurity
4848	* Purpose : The GetUserObjectSecurity function retrieves security information
4849	* for the specified user object.
4850	* Parameters: HANDLE hObj handle of user object
4851	* SECURITY_INFORMATION * pSIRequested address of requested security information
4852	* LPSECURITY_DESCRIPTOR pSID address of security descriptor
4853	* DWORD nLength size of buffer for security descriptor
4854	* LPDWORD lpnLengthNeeded address of required size of buffer
4855	* Variables :
4856	* Result : If the function succeeds, the return value is TRUE.
4857	* If the function fails, the return value is FALSE. To get extended
4858	* error information, call GetLastError.
4859	* Remark :
4860	* Status : UNTESTED STUB
4861	*
4862	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4863	*****************************************************************************/
4864
4865	BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
4866	SECURITY_INFORMATION * pSIRequested,
4867	LPSECURITY_DESCRIPTOR pSID,
4868	DWORD nLength,
4869	LPDWORD lpnLengthNeeded)
4870	{
4871	dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4872	hObj,
4873	pSIRequested,
4874	pSID,
4875	nLength,
4876	lpnLengthNeeded));
4877
4878	return (FALSE);
4879	}
4880
4881
4882
4883	/*****************************************************************************
4884	* Name : int WIN32API GetWindowRgn
4885	* Purpose : The GetWindowRgn function obtains a copy of the window region of a window.
4886	* Parameters: HWND hWnd handle to window whose window region is to be obtained
4887	* HRGN hRgn handle to region that receives a copy of the window region
4888	* Variables :
4889	* Result : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
4890	* Remark :
4891	* Status : UNTESTED STUB
4892	*
4893	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4894	*****************************************************************************/
4895
4896	int WIN32API GetWindowRgn (HWND hWnd,
4897	HRGN hRgn)
4898	{
4899	dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
4900	hWnd,
4901	hRgn));
4902
4903	return (NULLREGION);
4904	}
4905
4906
4907
4908	/*****************************************************************************
4909	* Name : HCURSOR WIN32API LoadCursorFromFileA
4910	* Purpose : The LoadCursorFromFile function creates a cursor based on data
4911	* contained in a file. The file is specified by its name or by a
4912	* system cursor identifier. The function returns a handle to the
4913	* newly created cursor. Files containing cursor data may be in
4914	* either cursor (.CUR) or animated cursor (.ANI) format.
4915	* Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4916	* Variables :
4917	* Result : If the function is successful, the return value is a handle to
4918	* the new cursor.
4919	* If the function fails, the return value is NULL. To get extended
4920	* error information, call GetLastError. GetLastError may return
4921	* the following
4922	* Remark :
4923	* Status : UNTESTED STUB
4924	*
4925	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4926	*****************************************************************************/
4927
4928	HCURSOR WIN32API LoadCursorFromFileA(LPCTSTR lpFileName)
4929	{
4930	dprintf(("USER32:LoadCursorFromFileA (%s) not implemented.\n",
4931	lpFileName));
4932
4933	return (NULL);
4934	}
4935
4936
4937	/*****************************************************************************
4938	* Name : HCURSOR WIN32API LoadCursorFromFileW
4939	* Purpose : The LoadCursorFromFile function creates a cursor based on data
4940	* contained in a file. The file is specified by its name or by a
4941	* system cursor identifier. The function returns a handle to the
4942	* newly created cursor. Files containing cursor data may be in
4943	* either cursor (.CUR) or animated cursor (.ANI) format.
4944	* Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4945	* Variables :
4946	* Result : If the function is successful, the return value is a handle to
4947	* the new cursor.
4948	* If the function fails, the return value is NULL. To get extended
4949	* error information, call GetLastError. GetLastError may return
4950	* the following
4951	* Remark :
4952	* Status : UNTESTED STUB
4953	*
4954	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4955	*****************************************************************************/
4956
4957	HCURSOR WIN32API LoadCursorFromFileW(LPCWSTR lpFileName)
4958	{
4959	dprintf(("USER32:LoadCursorFromFileW (%s) not implemented.\n",
4960	lpFileName));
4961
4962	return (NULL);
4963	}
4964
4965
4966	/*****************************************************************************
4967	* Name : HLK WIN32API LoadKeyboardLayoutA
4968	* Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
4969	* the system. Several keyboard layouts can be loaded at a time, but
4970	* only one per process is active at a time. Loading multiple keyboard
4971	* layouts makes it possible to rapidly switch between layouts.
4972	* Parameters:
4973	* Variables :
4974	* Result : If the function succeeds, the return value is the handle of the
4975	* keyboard layout.
4976	* If the function fails, the return value is NULL. To get extended
4977	* error information, call GetLastError.
4978	* Remark :
4979	* Status : UNTESTED STUB
4980	*
4981	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4982	*****************************************************************************/
4983
4984	HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
4985	UINT Flags)
4986	{
4987	dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
4988	pwszKLID,
4989	Flags));
4990
4991	return (NULL);
4992	}
4993
4994
4995	/*****************************************************************************
4996	* Name : HLK WIN32API LoadKeyboardLayoutW
4997	* Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
4998	* the system. Several keyboard layouts can be loaded at a time, but
4999	* only one per process is active at a time. Loading multiple keyboard
5000	* layouts makes it possible to rapidly switch between layouts.
5001	* Parameters:
5002	* Variables :
5003	* Result : If the function succeeds, the return value is the handle of the
5004	* keyboard layout.
5005	* If the function fails, the return value is NULL. To get extended
5006	* error information, call GetLastError.
5007	* Remark :
5008	* Status : UNTESTED STUB
5009	*
5010	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5011	*****************************************************************************/
5012
5013	HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
5014	UINT Flags)
5015	{
5016	dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
5017	pwszKLID,
5018	Flags));
5019
5020	return (NULL);
5021	}
5022
5023
5024	/*****************************************************************************
5025	* Name : UINT WIN32API MapVirtualKeyExA
5026	* Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
5027	* code into a scan code or character value, or translates a scan
5028	* code into a virtual-key code. The function translates the codes
5029	* using the input language and physical keyboard layout identified
5030	* by the given keyboard layout handle.
5031	* Parameters:
5032	* Variables :
5033	* Result : The return value is either a scan code, a virtual-key code, or
5034	* a character value, depending on the value of uCode and uMapType.
5035	* If there is no translation, the return value is zero.
5036	* Remark :
5037	* Status : UNTESTED STUB
5038	*
5039	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5040	*****************************************************************************/
5041
5042	UINT WIN32API MapVirtualKeyExA(UINT uCode,
5043	UINT uMapType,
5044	HKL dwhkl)
5045	{
5046	dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
5047	uCode,
5048	uMapType,
5049	dwhkl));
5050
5051	return (0);
5052	}
5053
5054
5055	/*****************************************************************************
5056	* Name : UINT WIN32API MapVirtualKeyExW
5057	* Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
5058	* code into a scan code or character value, or translates a scan
5059	* code into a virtual-key code. The function translates the codes
5060	* using the input language and physical keyboard layout identified
5061	* by the given keyboard layout handle.
5062	* Parameters:
5063	* Variables :
5064	* Result : The return value is either a scan code, a virtual-key code, or
5065	* a character value, depending on the value of uCode and uMapType.
5066	* If there is no translation, the return value is zero.
5067	* Remark :
5068	* Status : UNTESTED STUB
5069	*
5070	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5071	*****************************************************************************/
5072
5073	UINT WIN32API MapVirtualKeyExW(UINT uCode,
5074	UINT uMapType,
5075	HKL dwhkl)
5076	{
5077	dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
5078	uCode,
5079	uMapType,
5080	dwhkl));
5081
5082	return (0);
5083	}
5084
5085
5086	/*****************************************************************************
5087	* Name : int WIN32API MessageBoxExA
5088	* Purpose : The MessageBoxEx function creates, displays, and operates a message box.
5089	* Parameters: HWND hWnd handle of owner window
5090	* LPCTSTR lpText address of text in message box
5091	* LPCTSTR lpCaption address of title of message box
5092	* UINT uType style of message box
5093	* WORD wLanguageId language identifier
5094	* Variables :
5095	* Result : If the function succeeds, the return value is a nonzero menu-item
5096	* value returned by the dialog box.
5097	* Remark :
5098	* Status : UNTESTED STUB
5099	*
5100	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5101	*****************************************************************************/
5102
5103	int WIN32API MessageBoxExA(HWND hWnd,
5104	LPCTSTR lpText,
5105	LPCTSTR lpCaption,
5106	UINT uType,
5107	WORD wLanguageId)
5108	{
5109	dprintf(("USER32:MessageBoxExA (%08xh,%s,%s,%u,%08w) not implemented.\n",
5110	hWnd,
5111	lpText,
5112	lpCaption,
5113	uType,
5114	wLanguageId));
5115
5116	return (MessageBoxA(hWnd,
5117	lpText,
5118	lpCaption,
5119	uType));
5120	}
5121
5122
5123	/*****************************************************************************
5124	* Name : int WIN32API MessageBoxExW
5125	* Purpose : The MessageBoxEx function creates, displays, and operates a message box.
5126	* Parameters: HWND hWnd handle of owner window
5127	* LPCTSTR lpText address of text in message box
5128	* LPCTSTR lpCaption address of title of message box
5129	* UINT uType style of message box
5130	* WORD wLanguageId language identifier
5131	* Variables :
5132	* Result : If the function succeeds, the return value is a nonzero menu-item
5133	* value returned by the dialog box.
5134	* Remark :
5135	* Status : UNTESTED STUB
5136	*
5137	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5138	*****************************************************************************/
5139
5140	int WIN32API MessageBoxExW(HWND hWnd,
5141	LPCWSTR lpText,
5142	LPCWSTR lpCaption,
5143	UINT uType,
5144	WORD wLanguageId)
5145	{
5146
5147	dprintf(("USER32:MessageBoxExW (%08xh,%x,%x,%u,%08w) not implemented.\n",
5148	hWnd,
5149	lpText,
5150	lpCaption,
5151	uType,
5152	wLanguageId));
5153
5154	return MessageBoxW(hWnd, lpText, lpCaption, uType);
5155	}
5156
5157
5158	/*****************************************************************************
5159	* Name : BOOL WIN32API MessageBoxIndirectW
5160	* Purpose : The MessageBoxIndirect function creates, displays, and operates
5161	* a message box. The message box contains application-defined
5162	* message text and title, any icon, and any combination of
5163	* predefined push buttons.
5164	* Parameters:
5165	* Variables :
5166	* Result :
5167	* Remark :
5168	* Status : UNTESTED STUB
5169	*
5170	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5171	*****************************************************************************/
5172
5173	BOOL WIN32API MessageBoxIndirectW(LPMSGBOXPARAMSW lpMsgBoxParams)
5174	{
5175	dprintf(("USER32:MessageBoxIndirectW (%08x) not implemented.\n",
5176	lpMsgBoxParams));
5177
5178	return (FALSE);
5179	}
5180
5181
5182	/*****************************************************************************
5183	* Name : BOOL WIN32API MessageBoxIndirectA
5184	* Purpose : The MessageBoxIndirect function creates, displays, and operates
5185	* a message box. The message box contains application-defined
5186	* message text and title, any icon, and any combination of
5187	* predefined push buttons.
5188	* Parameters:
5189	* Variables :
5190	* Result :
5191	* Remark :
5192	* Status : UNTESTED STUB
5193	*
5194	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5195	*****************************************************************************/
5196
5197	BOOL WIN32API MessageBoxIndirectA(LPMSGBOXPARAMSA lpMsgBoxParams)
5198	{
5199	dprintf(("USER32:MessageBoxIndirectA (%08x) not implemented.\n",
5200	lpMsgBoxParams));
5201
5202	return (FALSE);
5203	}
5204
5205
5206	/*****************************************************************************
5207	* Name : DWORD WIN32API OemKeyScan
5208	* Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
5209	* into the OEM scan codes and shift states. The function provides
5210	* information that allows a program to send OEM text to another
5211	* program by simulating keyboard input.
5212	* Parameters:
5213	* Variables :
5214	* Result :
5215	* Remark :
5216	* Status : UNTESTED STUB
5217	*
5218	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5219	*****************************************************************************/
5220
5221	DWORD WIN32API OemKeyScan(WORD wOemChar)
5222	{
5223	dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
5224	wOemChar));
5225
5226	return (wOemChar);
5227	}
5228
5229
5230	/*****************************************************************************
5231	* Name : HDESK WIN32API OpenDesktopA
5232	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
5233	* A desktop is a secure object contained within a window station
5234	* object. A desktop has a logical display surface and contains
5235	* windows, menus and hooks.
5236	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5237	* DWORD dwFlags flags to control interaction with other applications
5238	* BOOL fInherit specifies whether returned handle is inheritable
5239	* DWORD dwDesiredAccess specifies access of returned handle
5240	* Variables :
5241	* Result : If the function succeeds, the return value is the handle to the
5242	* opened desktop.
5243	* If the function fails, the return value is NULL. To get extended
5244	* error information, call GetLastError.
5245	* Remark :
5246	* Status : UNTESTED STUB
5247	*
5248	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5249	*****************************************************************************/
5250
5251	HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
5252	DWORD dwFlags,
5253	BOOL fInherit,
5254	DWORD dwDesiredAccess)
5255	{
5256	dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
5257	lpszDesktopName,
5258	dwFlags,
5259	fInherit,
5260	dwDesiredAccess));
5261
5262	return (NULL);
5263	}
5264
5265
5266	/*****************************************************************************
5267	* Name : HDESK WIN32API OpenDesktopW
5268	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
5269	* A desktop is a secure object contained within a window station
5270	* object. A desktop has a logical display surface and contains
5271	* windows, menus and hooks.
5272	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5273	* DWORD dwFlags flags to control interaction with other applications
5274	* BOOL fInherit specifies whether returned handle is inheritable
5275	* DWORD dwDesiredAccess specifies access of returned handle
5276	* Variables :
5277	* Result : If the function succeeds, the return value is the handle to the
5278	* opened desktop.
5279	* If the function fails, the return value is NULL. To get extended
5280	* error information, call GetLastError.
5281	* Remark :
5282	* Status : UNTESTED STUB
5283	*
5284	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5285	*****************************************************************************/
5286
5287	HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
5288	DWORD dwFlags,
5289	BOOL fInherit,
5290	DWORD dwDesiredAccess)
5291	{
5292	dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
5293	lpszDesktopName,
5294	dwFlags,
5295	fInherit,
5296	dwDesiredAccess));
5297
5298	return (NULL);
5299	}
5300
5301
5302	/*****************************************************************************
5303	* Name : HDESK WIN32API OpenInputDesktop
5304	* Purpose : The OpenInputDesktop function returns a handle to the desktop
5305	* that receives user input. The input desktop is a desktop on the
5306	* window station associated with the logged-on user.
5307	* Parameters: DWORD dwFlags flags to control interaction with other applications
5308	* BOOL fInherit specifies whether returned handle is inheritable
5309	* DWORD dwDesiredAccess specifies access of returned handle
5310	* Variables :
5311	* Result : If the function succeeds, the return value is a handle of the
5312	* desktop that receives user input.
5313	* If the function fails, the return value is NULL. To get extended
5314	* error information, call GetLastError.
5315	* Remark :
5316	* Status : UNTESTED STUB
5317	*
5318	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5319	*****************************************************************************/
5320
5321	HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
5322	BOOL fInherit,
5323	DWORD dwDesiredAccess)
5324	{
5325	dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
5326	dwFlags,
5327	fInherit,
5328	dwDesiredAccess));
5329
5330	return (NULL);
5331	}
5332
5333
5334	/*****************************************************************************
5335	* Name : HWINSTA WIN32API OpenWindowStationA
5336	* Purpose : The OpenWindowStation function returns a handle to an existing
5337	* window station.
5338	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
5339	* BOOL fInherit specifies whether returned handle is inheritable
5340	* DWORD dwDesiredAccess specifies access of returned handle
5341	* Variables :
5342	* Result : If the function succeeds, the return value is the handle to the
5343	* specified window station.
5344	* If the function fails, the return value is NULL. To get extended
5345	* error information, call GetLastError.
5346	* Remark :
5347	* Status : UNTESTED STUB
5348	*
5349	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5350	*****************************************************************************/
5351
5352	HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
5353	BOOL fInherit,
5354	DWORD dwDesiredAccess)
5355	{
5356	dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
5357	lpszWinStaName,
5358	fInherit,
5359	dwDesiredAccess));
5360
5361	return (NULL);
5362	}
5363
5364
5365	/*****************************************************************************
5366	* Name : HWINSTA WIN32API OpenWindowStationW
5367	* Purpose : The OpenWindowStation function returns a handle to an existing
5368	* window station.
5369	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
5370	* BOOL fInherit specifies whether returned handle is inheritable
5371	* DWORD dwDesiredAccess specifies access of returned handle
5372	* Variables :
5373	* Result : If the function succeeds, the return value is the handle to the
5374	* specified window station.
5375	* If the function fails, the return value is NULL. To get extended
5376	* error information, call GetLastError.
5377
5378	* Remark :
5379	* Status : UNTESTED STUB
5380	*
5381	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5382	*****************************************************************************/
5383
5384	HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
5385	BOOL fInherit,
5386	DWORD dwDesiredAccess)
5387	{
5388	dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
5389	lpszWinStaName,
5390	fInherit,
5391	dwDesiredAccess));
5392
5393	return (NULL);
5394	}
5395
5396
5397	/*****************************************************************************
5398	* Name : BOOL WIN32API PaintDesktop
5399	* Purpose : The PaintDesktop function fills the clipping region in the
5400	* specified device context with the desktop pattern or wallpaper.
5401	* The function is provided primarily for shell desktops.
5402	* Parameters:
5403	* Variables :
5404	* Result : If the function succeeds, the return value is TRUE.
5405	* If the function fails, the return value is FALSE.
5406	* Remark :
5407	* Status : UNTESTED STUB
5408	*
5409	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5410	*****************************************************************************/
5411
5412	BOOL WIN32API PaintDesktop(HDC hdc)
5413	{
5414	dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
5415	hdc));
5416
5417	return (FALSE);
5418	}
5419
5420
5421	/*****************************************************************************
5422	* Name : BOOL WIN32API SendMessageCallbackA
5423	* Purpose : The SendMessageCallback function sends the specified message to
5424	* a window or windows. The function calls the window procedure for
5425	* the specified window and returns immediately. After the window
5426	* procedure processes the message, the system calls the specified
5427	* callback function, passing the result of the message processing
5428	* and an application-defined value to the callback function.
5429	* Parameters: HWND hwnd handle of destination window
5430	* UINT uMsg message to send
5431	* WPARAM wParam first message parameter
5432	* LPARAM lParam second message parameter
5433	* SENDASYNCPROC lpResultCallBack function to receive message value
5434	* DWORD dwData value to pass to callback function
5435	* Variables :
5436	* Result : If the function succeeds, the return value is TRUE.
5437	* If the function fails, the return value is FALSE. To get extended
5438	* error information, call GetLastError.
5439	* Remark :
5440	* Status : UNTESTED STUB
5441	*
5442	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5443	*****************************************************************************/
5444
5445	BOOL WIN32API SendMessageCallbackA(HWND hWnd,
5446	UINT uMsg,
5447	WPARAM wParam,
5448	LPARAM lParam,
5449	SENDASYNCPROC lpResultCallBack,
5450	DWORD dwData)
5451	{
5452	dprintf(("USER32:SendMessageCallBackA (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5453	hWnd,
5454	uMsg,
5455	wParam,
5456	lParam,
5457	lpResultCallBack,
5458	dwData));
5459
5460	return (FALSE);
5461	}
5462
5463
5464	/*****************************************************************************
5465	* Name : BOOL WIN32API SendMessageCallbackW
5466	* Purpose : The SendMessageCallback function sends the specified message to
5467	* a window or windows. The function calls the window procedure for
5468	* the specified window and returns immediately. After the window
5469	* procedure processes the message, the system calls the specified
5470	* callback function, passing the result of the message processing
5471	* and an application-defined value to the callback function.
5472	* Parameters: HWND hwnd handle of destination window
5473	* UINT uMsg message to send
5474	* WPARAM wParam first message parameter
5475	* LPARAM lParam second message parameter
5476	* SENDASYNCPROC lpResultCallBack function to receive message value
5477	* DWORD dwData value to pass to callback function
5478	* Variables :
5479	* Result : If the function succeeds, the return value is TRUE.
5480	* If the function fails, the return value is FALSE. To get extended
5481	* error information, call GetLastError.
5482	* Remark :
5483	* Status : UNTESTED STUB
5484	*
5485	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5486	*****************************************************************************/
5487
5488	BOOL WIN32API SendMessageCallbackW(HWND hWnd,
5489	UINT uMsg,
5490	WPARAM wParam,
5491	LPARAM lParam,
5492	SENDASYNCPROC lpResultCallBack,
5493	DWORD dwData)
5494	{
5495	dprintf(("USER32:SendMessageCallBackW (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5496	hWnd,
5497	uMsg,
5498	wParam,
5499	lParam,
5500	lpResultCallBack,
5501	dwData));
5502
5503	return (FALSE);
5504	}
5505
5506
5507	/*****************************************************************************
5508	* Name : VOID WIN32API SetDebugErrorLevel
5509	* Purpose : The SetDebugErrorLevel function sets the minimum error level at
5510	* which Windows will generate debugging events and pass them to a debugger.
5511	* Parameters: DWORD dwLevel debugging error level
5512	* Variables :
5513	* Result :
5514	* Remark :
5515	* Status : UNTESTED STUB
5516	*
5517	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5518	*****************************************************************************/
5519
5520	VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
5521	{
5522	dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
5523	dwLevel));
5524	}
5525
5526
5527	/*****************************************************************************
5528	* Name : BOOL WIN32API SetProcessWindowStation
5529	* Purpose : The SetProcessWindowStation function assigns a window station
5530	* to the calling process. This enables the process to access
5531	* objects in the window station such as desktops, the clipboard,
5532	* and global atoms. All subsequent operations on the window station
5533	* use the access rights granted to hWinSta.
5534	* Parameters:
5535	* Variables :
5536	* Result : If the function succeeds, the return value is TRUE.
5537	* If the function fails, the return value is FALSE. To get extended
5538	* error information, call GetLastError.
5539	* Remark :
5540	* Status : UNTESTED STUB
5541	*
5542	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5543	*****************************************************************************/
5544
5545	BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
5546	{
5547	dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
5548	hWinSta));
5549
5550	return (FALSE);
5551	}
5552
5553
5554	/*****************************************************************************
5555	* Name : BOOL WIN32API SetSystemCursor
5556	* Purpose : The SetSystemCursor function replaces the contents of the system
5557	* cursor specified by dwCursorId with the contents of the cursor
5558	* specified by hCursor, and then destroys hCursor. This function
5559	* lets an application customize the system cursors.
5560	* Parameters: HCURSOR hCursor set specified system cursor to this cursor's
5561	* contents, then destroy this
5562	* DWORD dwCursorID system cursor specified by its identifier
5563	* Variables :
5564	* Result : If the function succeeds, the return value is TRUE.
5565	* If the function fails, the return value is FALSE. To get extended
5566	* error information, call GetLastError.
5567	* Remark :
5568	* Status : UNTESTED STUB
5569	*
5570	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5571	*****************************************************************************/
5572
5573	BOOL WIN32API SetSystemCursor(HCURSOR hCursor,
5574	DWORD dwCursorId)
5575	{
5576	dprintf(("USER32:SetSystemCursor (%08xh,%08x) not implemented.\n",
5577	hCursor,
5578	dwCursorId));
5579
5580	return (FALSE);
5581	}
5582
5583
5584	/*****************************************************************************
5585	* Name : BOOL WIN32API SetThreadDesktop
5586	* Purpose : The SetThreadDesktop function assigns a desktop to the calling
5587	* thread. All subsequent operations on the desktop use the access
5588	* rights granted to hDesk.
5589	* Parameters: HDESK hDesk handle of the desktop to assign to this thread
5590	* Variables :
5591	* Result : If the function succeeds, the return value is TRUE.
5592	* If the function fails, the return value is FALSE. To get extended
5593	* error information, call GetLastError.
5594	* Remark :
5595	* Status : UNTESTED STUB
5596	*
5597	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5598	*****************************************************************************/
5599
5600	BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
5601	{
5602	dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
5603	hDesktop));
5604
5605	return (FALSE);
5606	}
5607
5608
5609	/*****************************************************************************
5610	* Name : BOOL WIN32API SetUserObjectInformationA
5611	* Purpose : The SetUserObjectInformation function sets information about a
5612	* window station or desktop object.
5613	* Parameters: HANDLE hObject handle of the object for which to set information
5614	* int nIndex type of information to set
5615	* PVOID lpvInfo points to a buffer that contains the information
5616	* DWORD cbInfo size, in bytes, of lpvInfo buffer
5617	* Variables :
5618	* Result : If the function succeeds, the return value is TRUE.
5619	* If the function fails the return value is FALSE. To get extended
5620	* error information, call GetLastError.
5621	* Remark :
5622	* Status : UNTESTED STUB
5623	*
5624	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5625	*****************************************************************************/
5626
5627	BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
5628	int nIndex,
5629	PVOID lpvInfo,
5630	DWORD cbInfo)
5631	{
5632	dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
5633	hObject,
5634	nIndex,
5635	lpvInfo,
5636	cbInfo));
5637
5638	return (FALSE);
5639	}
5640
5641
5642	/*****************************************************************************
5643	* Name : BOOL WIN32API SetUserObjectInformationW
5644	* Purpose : The SetUserObjectInformation function sets information about a
5645	* window station or desktop object.
5646	* Parameters: HANDLE hObject handle of the object for which to set information
5647	* int nIndex type of information to set
5648	* PVOID lpvInfo points to a buffer that contains the information
5649	* DWORD cbInfo size, in bytes, of lpvInfo buffer
5650	* Variables :
5651	* Result : If the function succeeds, the return value is TRUE.
5652	* If the function fails the return value is FALSE. To get extended
5653	* error information, call GetLastError.
5654	* Remark :
5655	* Status : UNTESTED STUB
5656	*
5657	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5658	*****************************************************************************/
5659
5660	BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
5661	int nIndex,
5662	PVOID lpvInfo,
5663	DWORD cbInfo)
5664	{
5665	dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
5666	hObject,
5667	nIndex,
5668	lpvInfo,
5669	cbInfo));
5670
5671	return (FALSE);
5672	}
5673
5674
5675	/*****************************************************************************
5676	* Name : BOOL WIN32API SetUserObjectSecurity
5677	* Purpose : The SetUserObjectSecurity function sets the security of a user
5678	* object. This can be, for example, a window or a DDE conversation
5679	* Parameters: HANDLE hObject handle of user object
5680	* SECURITY_INFORMATION * psi address of security information
5681	* LPSECURITY_DESCRIPTOR psd address of security descriptor
5682	* Variables :
5683	* Result : If the function succeeds, the return value is TRUE.
5684	* If the function fails, the return value is FALSE. To get extended
5685	* error information, call GetLastError.
5686	* Remark :
5687	* Status : UNTESTED STUB
5688	*
5689	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5690	*****************************************************************************/
5691
5692	BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
5693	SECURITY_INFORMATION * psi,
5694	LPSECURITY_DESCRIPTOR psd)
5695	{
5696	dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
5697	hObject,
5698	psi,
5699	psd));
5700
5701	return (FALSE);
5702	}
5703
5704
5705	/*****************************************************************************
5706	* Name : int WIN32API SetWindowRgn
5707	* Purpose : The SetWindowRgn function sets the window region of a window. The
5708	* window region determines the area within the window where the
5709	* operating system permits drawing. The operating system does not
5710	* display any portion of a window that lies outside of the window region
5711	* Parameters: HWND hWnd handle to window whose window region is to be set
5712	* HRGN hRgn handle to region
5713	* BOOL bRedraw window redraw flag
5714	* Variables :
5715	* Result : If the function succeeds, the return value is non-zero.
5716	* If the function fails, the return value is zero.
5717	* Remark :
5718	* Status : UNTESTED STUB
5719	*
5720	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5721	*****************************************************************************/
5722
5723	int WIN32API SetWindowRgn(HWND hWnd,
5724	HRGN hRgn,
5725	BOOL bRedraw)
5726	{
5727	dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
5728	hWnd,
5729	hRgn,
5730	bRedraw));
5731
5732	return (0);
5733	}
5734
5735
5736	/*****************************************************************************
5737	* Name : BOOL WIN32API SetWindowsHookW
5738	* Purpose : The SetWindowsHook function is not implemented in the Win32 API.
5739	* Win32-based applications should use the SetWindowsHookEx function.
5740	* Parameters:
5741	* Variables :
5742	* Result :
5743	* Remark : ARGH ! MICROSOFT !
5744	* Status : UNTESTED STUB
5745	*
5746	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5747	*****************************************************************************/
5748
5749	HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
5750
5751	{
5752	return (FALSE);
5753	}
5754
5755
5756	/*****************************************************************************
5757	* Name : BOOL WIN32API ShowWindowAsync
5758	* Purpose : The ShowWindowAsync function sets the show state of a window
5759	* created by a different thread.
5760	* Parameters: HWND hwnd handle of window
5761	* int nCmdShow show state of window
5762	* Variables :
5763	* Result : If the window was previously visible, the return value is TRUE.
5764	* If the window was previously hidden, the return value is FALSE.
5765	* Remark :
5766	* Status : UNTESTED STUB
5767	*
5768	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5769	*****************************************************************************/
5770
5771	BOOL WIN32API ShowWindowAsync (HWND hWnd,
5772	int nCmdShow)
5773	{
5774	dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
5775	hWnd,
5776	nCmdShow));
5777
5778	return (FALSE);
5779	}
5780
5781
5782	/*****************************************************************************
5783	* Name : BOOL WIN32API SwitchDesktop
5784	* Purpose : The SwitchDesktop function makes a desktop visible and activates
5785	* it. This enables the desktop to receive input from the user. The
5786	* calling process must have DESKTOP_SWITCHDESKTOP access to the
5787	* desktop for the SwitchDesktop function to succeed.
5788	* Parameters:
5789	* Variables :
5790	* Result : If the function succeeds, the return value is TRUE.
5791	* If the function fails, the return value is FALSE. To get extended
5792	* error information, call GetLastError.
5793	* Remark :
5794	* Status : UNTESTED STUB
5795	*
5796	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5797	*****************************************************************************/
5798
5799	BOOL WIN32API SwitchDesktop(HDESK hDesktop)
5800	{
5801	dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
5802	hDesktop));
5803
5804	return (FALSE);
5805	}
5806
5807
5808	/*****************************************************************************
5809	* Name : WORD WIN32API TileWindows
5810	* Purpose : The TileWindows function tiles the specified windows, or the child
5811	* windows of the specified parent window.
5812	* Parameters: HWND hwndParent handle of parent window
5813	* WORD wFlags types of windows not to arrange
5814	* LPCRECT lpRect rectangle to arrange windows in
5815	* WORD cChildrenb number of windows to arrange
5816	* const HWND *ahwndChildren array of window handles
5817	* Variables :
5818	* Result : If the function succeeds, the return value is the number of
5819	* windows arranged.
5820	* If the function fails, the return value is zero.
5821	* Remark :
5822	* Status : UNTESTED STUB
5823	*
5824	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5825	*****************************************************************************/
5826
5827	WORD WIN32API TileWindows(HWND hwndParent,
5828	UINT wFlags,
5829	const LPRECT lpRect,
5830	UINT cChildrenb,
5831	const HWND *ahwndChildren)
5832	{
5833	dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5834	hwndParent,
5835	wFlags,
5836	lpRect,
5837	cChildrenb,
5838	ahwndChildren));
5839
5840	return (0);
5841	}
5842
5843
5844	/*****************************************************************************
5845	* Name : int WIN32API ToAscii
5846	* Purpose : The ToAscii function translates the specified virtual-key code
5847	* and keyboard state to the corresponding Windows character or characters.
5848	* Parameters: UINT uVirtKey virtual-key code
5849	* UINT uScanCode scan code
5850	* PBYTE lpbKeyState address of key-state array
5851	* LPWORD lpwTransKey buffer for translated key
5852	* UINT fuState active-menu flag
5853	* Variables :
5854	* Result : 0 The specified virtual key has no translation for the current
5855	* state of the keyboard.
5856	* 1 One Windows character was copied to the buffer.
5857	* 2 Two characters were copied to the buffer. This usually happens
5858	* when a dead-key character (accent or diacritic) stored in the
5859	* keyboard layout cannot be composed with the specified virtual
5860	* key to form a single character.
5861	* Remark :
5862	* Status : UNTESTED STUB
5863	*
5864	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5865	*****************************************************************************/
5866
5867	int WIN32API ToAscii(UINT uVirtKey,
5868	UINT uScanCode,
5869	PBYTE lpbKeyState,
5870	LPWORD lpwTransKey,
5871	UINT fuState)
5872	{
5873	dprintf(("USER32:ToAscii (%u,%u,%08xh,%08xh,%u) not implemented.\n",
5874	uVirtKey,
5875	uScanCode,
5876	lpbKeyState,
5877	lpwTransKey,
5878	fuState));
5879
5880	return (0);
5881	}
5882
5883
5884	/*****************************************************************************
5885	* Name : int WIN32API ToAsciiEx
5886	* Purpose : The ToAscii function translates the specified virtual-key code
5887	* and keyboard state to the corresponding Windows character or characters.
5888	* Parameters: UINT uVirtKey virtual-key code
5889	* UINT uScanCode scan code
5890	* PBYTE lpbKeyState address of key-state array
5891	* LPWORD lpwTransKey buffer for translated key
5892	* UINT fuState active-menu flag
5893	* HLK hlk keyboard layout handle
5894	* Variables :
5895	* Result : 0 The specified virtual key has no translation for the current
5896	* state of the keyboard.
5897	* 1 One Windows character was copied to the buffer.
5898	* 2 Two characters were copied to the buffer. This usually happens
5899	* when a dead-key character (accent or diacritic) stored in the
5900	* keyboard layout cannot be composed with the specified virtual
5901	* key to form a single character.
5902	* Remark :
5903	* Status : UNTESTED STUB
5904	*
5905	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5906	*****************************************************************************/
5907
5908	int WIN32API ToAsciiEx(UINT uVirtKey,
5909	UINT uScanCode,
5910	PBYTE lpbKeyState,
5911	LPWORD lpwTransKey,
5912	UINT fuState,
5913	HKL hkl)
5914	{
5915	dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5916	uVirtKey,
5917	uScanCode,
5918	lpbKeyState,
5919	lpwTransKey,
5920	fuState,
5921	hkl));
5922
5923	return (0);
5924	}
5925
5926
5927	/*****************************************************************************
5928	* Name : int WIN32API ToUnicode
5929	* Purpose : The ToUnicode function translates the specified virtual-key code
5930	* and keyboard state to the corresponding Unicode character or characters.
5931	* Parameters: UINT wVirtKey virtual-key code
5932	* UINT wScanCode scan code
5933	* PBYTE lpKeyState address of key-state array
5934	* LPWSTR pwszBuff buffer for translated key
5935	* int cchBuff size of translated key buffer
5936	* UINT wFlags set of function-conditioning flags
5937	* Variables :
5938	* Result : - 1 The specified virtual key is a dead-key character (accent or
5939	* diacritic). This value is returned regardless of the keyboard
5940	* layout, even if several characters have been typed and are
5941	* stored in the keyboard state. If possible, even with Unicode
5942	* keyboard layouts, the function has written a spacing version of
5943	* the dead-key character to the buffer specified by pwszBuffer.
5944	* For example, the function writes the character SPACING ACUTE
5945	* (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
5946	* 0 The specified virtual key has no translation for the current
5947	* state of the keyboard. Nothing was written to the buffer
5948	* specified by pwszBuffer.
5949	* 1 One character was written to the buffer specified by pwszBuffer.
5950	* 2 or more Two or more characters were written to the buffer specified by
5951	* pwszBuff. The most common cause for this is that a dead-key
5952	* character (accent or diacritic) stored in the keyboard layout
5953	* could not be combined with the specified virtual key to form a
5954	* single character.
5955	* Remark :
5956	* Status : UNTESTED STUB
5957	*
5958	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5959	*****************************************************************************/
5960
5961	int WIN32API ToUnicode(UINT uVirtKey,
5962	UINT uScanCode,
5963	PBYTE lpKeyState,
5964	LPWSTR pwszBuff,
5965	int cchBuff,
5966	UINT wFlags)
5967	{
5968	dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5969	uVirtKey,
5970	uScanCode,
5971	lpKeyState,
5972	pwszBuff,
5973	cchBuff,
5974	wFlags));
5975
5976	return (0);
5977	}
5978
5979
5980	/*****************************************************************************
5981	* Name : BOOL WIN32API UnloadKeyboardLayout
5982	* Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
5983	* Parameters: HKL hkl handle of keyboard layout
5984	* Variables :
5985	* Result : If the function succeeds, the return value is the handle of the
5986	* keyboard layout; otherwise, it is NULL. To get extended error
5987	* information, use the GetLastError function.
5988	* Remark :
5989	* Status : UNTESTED STUB
5990	*
5991	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
5992	*****************************************************************************/
5993
5994	BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
5995	{
5996	dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
5997	hkl));
5998
5999	return (0);
6000	}
6001
6002
6003	/*****************************************************************************
6004	* Name : SHORT WIN32API VkKeyScanExW
6005	* Purpose : The VkKeyScanEx function translates a character to the
6006	* corresponding virtual-key code and shift state. The function
6007	* translates the character using the input language and physical
6008	* keyboard layout identified by the given keyboard layout handle.
6009	* Parameters: UINT uChar character to translate
6010	* HKL hkl keyboard layout handle
6011	* Variables :
6012	* Result : see docs
6013	* Remark :
6014	* Status : UNTESTED STUB
6015	*
6016	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6017	*****************************************************************************/
6018
6019	WORD WIN32API VkKeyScanExW(WCHAR uChar,
6020	HKL hkl)
6021	{
6022	dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
6023	uChar,
6024	hkl));
6025
6026	return (uChar);
6027	}
6028
6029
6030	/*****************************************************************************
6031	* Name : SHORT WIN32API VkKeyScanExA
6032	* Purpose : The VkKeyScanEx function translates a character to the
6033	* corresponding virtual-key code and shift state. The function
6034	* translates the character using the input language and physical
6035	* keyboard layout identified by the given keyboard layout handle.
6036	* Parameters: UINT uChar character to translate
6037	* HKL hkl keyboard layout handle
6038	* Variables :
6039	* Result : see docs
6040	* Remark :
6041	* Status : UNTESTED STUB
6042	*
6043	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6044	*****************************************************************************/
6045
6046	WORD WIN32API VkKeyScanExA(CHAR uChar,
6047	HKL hkl)
6048	{
6049	dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
6050	uChar,
6051	hkl));
6052
6053	return (uChar);
6054	}
6055
6056
6057	/*****************************************************************************
6058	* Name : VOID WIN32API keybd_event
6059	* Purpose : The keybd_event function synthesizes a keystroke. The system
6060	* can use such a synthesized keystroke to generate a WM_KEYUP or
6061	* WM_KEYDOWN message. The keyboard driver's interrupt handler calls
6062	* the keybd_event function.
6063	* Parameters: BYTE bVk virtual-key code
6064
6065	* BYTE bScan hardware scan code
6066	* DWORD dwFlags flags specifying various function options
6067	* DWORD dwExtraInfo additional data associated with keystroke
6068	* Variables :
6069	* Result :
6070	* Remark :
6071	* Status : UNTESTED STUB
6072	*
6073	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6074	*****************************************************************************/
6075
6076	VOID WIN32API keybd_event (BYTE bVk,
6077	BYTE bScan,
6078	DWORD dwFlags,
6079	DWORD dwExtraInfo)
6080	{
6081	dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
6082	bVk,
6083	bScan,
6084	dwFlags,
6085	dwExtraInfo));
6086	}
6087
6088
6089	/*****************************************************************************
6090	* Name : VOID WIN32API mouse_event
6091	* Purpose : The mouse_event function synthesizes mouse motion and button clicks.
6092	* Parameters: DWORD dwFlags flags specifying various motion/click variants
6093	* DWORD dx horizontal mouse position or position change
6094	* DWORD dy vertical mouse position or position change
6095	* DWORD cButtons unused, reserved for future use, set to zero
6096	* DWORD dwExtraInfo 32 bits of application-defined information
6097	* Variables :
6098	* Result :
6099	* Remark :
6100	* Status : UNTESTED STUB
6101	*
6102	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
6103	*****************************************************************************/
6104
6105	VOID WIN32API mouse_event(DWORD dwFlags,
6106	DWORD dx,
6107	DWORD dy,
6108	DWORD cButtons,
6109	DWORD dwExtraInfo)
6110	{
6111	dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
6112	dwFlags,
6113	dx,
6114	dy,
6115	cButtons,
6116	dwExtraInfo));
6117	}
6118
6119
6120	/*****************************************************************************
6121	* Name : BOOL WIN32API SetShellWindow
6122	* Purpose : Unknown
6123	* Parameters: Unknown
6124	* Variables :
6125	* Result :
6126	* Remark :
6127	* Status : UNTESTED UNKNOWN STUB
6128	*
6129	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6130	*****************************************************************************/
6131
6132	BOOL WIN32API SetShellWindow(DWORD x1)
6133	{
6134	dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
6135	x1));
6136
6137	return (FALSE); /* default */
6138	}
6139
6140
6141	/*****************************************************************************
6142	* Name : BOOL WIN32API PlaySoundEvent
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 PlaySoundEvent(DWORD x1)
6154	{
6155	dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
6156	x1));
6157
6158	return (FALSE); /* default */
6159	}
6160
6161
6162	/*****************************************************************************
6163	* Name : BOOL WIN32API TileChildWindows
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 TileChildWindows(DWORD x1,
6175	DWORD x2)
6176	{
6177	dprintf(("USER32: TileChildWindows(%08xh,%08xh) not implemented.\n",
6178	x1,
6179	x2));
6180
6181	return (FALSE); /* default */
6182	}
6183
6184
6185	/*****************************************************************************
6186	* Name : BOOL WIN32API SetSysColorsTemp
6187	* Purpose : Unknown
6188	* Parameters: Unknown
6189	* Variables :
6190	* Result :
6191	* Remark :
6192	* Status : UNTESTED UNKNOWN STUB
6193	*
6194	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6195	*****************************************************************************/
6196
6197	BOOL WIN32API SetSysColorsTemp(void)
6198	{
6199	dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
6200
6201	return (FALSE); /* default */
6202	}
6203
6204
6205	/*****************************************************************************
6206	* Name : BOOL WIN32API RegisterNetworkCapabilities
6207	* Purpose : Unknown
6208	* Parameters: Unknown
6209	* Variables :
6210	* Result :
6211	* Remark :
6212	* Status : UNTESTED UNKNOWN STUB
6213	*
6214	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6215	*****************************************************************************/
6216
6217	BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
6218	DWORD x2)
6219	{
6220	dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
6221	x1,
6222	x2));
6223
6224	return (FALSE); /* default */
6225	}
6226
6227
6228	/*****************************************************************************
6229	* Name : BOOL WIN32API EndTask
6230	* Purpose : Unknown
6231	* Parameters: Unknown
6232	* Variables :
6233	* Result :
6234	* Remark :
6235	* Status : UNTESTED UNKNOWN STUB
6236	*
6237	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6238	*****************************************************************************/
6239
6240	BOOL WIN32API EndTask(DWORD x1,
6241	DWORD x2,
6242	DWORD x3)
6243	{
6244	dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
6245	x1,
6246	x2,
6247	x3));
6248
6249	return (FALSE); /* default */
6250	}
6251
6252
6253	/*****************************************************************************
6254	* Name : BOOL WIN32API SwitchToThisWindow
6255	* Purpose : Unknown
6256	* Parameters: Unknown
6257	* Variables :
6258	* Result :
6259	* Remark :
6260	* Status : UNTESTED UNKNOWN STUB
6261	*
6262	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6263	*****************************************************************************/
6264
6265	BOOL WIN32API SwitchToThisWindow(HWND hwnd,
6266	BOOL x2)
6267	{
6268	dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
6269	hwnd,
6270	x2));
6271
6272	return (FALSE); /* default */
6273	}
6274
6275
6276	/*****************************************************************************
6277	* Name : BOOL WIN32API GetNextQueueWindow
6278	* Purpose : Unknown
6279	* Parameters: Unknown
6280	* Variables :
6281	* Result :
6282	* Remark :
6283	* Status : UNTESTED UNKNOWN STUB
6284	*
6285	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6286	*****************************************************************************/
6287
6288	BOOL WIN32API GetNextQueueWindow(DWORD x1,
6289	DWORD x2)
6290	{
6291	dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
6292	x1,
6293	x2));
6294
6295	return (FALSE); /* default */
6296	}
6297
6298
6299	/*****************************************************************************
6300	* Name : BOOL WIN32API YieldTask
6301	* Purpose : Unknown
6302	* Parameters: Unknown
6303	* Variables :
6304	* Result :
6305	* Remark :
6306	* Status : UNTESTED UNKNOWN STUB
6307	*
6308	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6309	*****************************************************************************/
6310
6311	BOOL WIN32API YieldTask(void)
6312	{
6313	dprintf(("USER32: YieldTask() not implemented.\n"));
6314
6315	return (FALSE); /* default */
6316	}
6317
6318
6319	/*****************************************************************************
6320	* Name : BOOL WIN32API WinOldAppHackoMatic
6321	* Purpose : Unknown
6322	* Parameters: Unknown
6323	* Variables :
6324	* Result :
6325	* Remark :
6326	* Status : UNTESTED UNKNOWN STUB
6327	*
6328	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6329	*****************************************************************************/
6330
6331	BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
6332	{
6333	dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
6334	x1));
6335
6336	return (FALSE); /* default */
6337	}
6338
6339
6340	/*****************************************************************************
6341	* Name : BOOL WIN32API DragObject
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	DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
6353	{
6354	dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6355	x1,
6356	x2,
6357	x3,
6358	x4,
6359	x5));
6360
6361	return (FALSE); /* default */
6362	}
6363
6364
6365	/*****************************************************************************
6366	* Name : BOOL WIN32API CascadeChildWindows
6367	* Purpose : Unknown
6368	* Parameters: Unknown
6369	* Variables :
6370	* Result :
6371	* Remark :
6372	* Status : UNTESTED UNKNOWN STUB
6373	*
6374	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6375	*****************************************************************************/
6376
6377	BOOL WIN32API CascadeChildWindows(DWORD x1,
6378	DWORD x2)
6379	{
6380	dprintf(("USER32: CascadeChildWindows(%08xh,%08xh) not implemented.\n",
6381	x1,
6382	x2));
6383
6384	return (FALSE); /* default */
6385	}
6386
6387
6388	/*****************************************************************************
6389	* Name : BOOL WIN32API RegisterSystemThread
6390	* Purpose : Unknown
6391	* Parameters: Unknown
6392	* Variables :
6393	* Result :
6394	* Remark :
6395	* Status : UNTESTED UNKNOWN STUB
6396	*
6397	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6398	*****************************************************************************/
6399
6400	BOOL WIN32API RegisterSystemThread(DWORD x1,
6401	DWORD x2)
6402	{
6403	dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
6404	x1,
6405	x2));
6406
6407	return (FALSE); /* default */
6408	}
6409
6410
6411	/*****************************************************************************
6412	* Name : BOOL WIN32API IsHungThread
6413	* Purpose : Unknown
6414	* Parameters: Unknown
6415	* Variables :
6416	* Result :
6417	* Remark :
6418	* Status : UNTESTED UNKNOWN STUB
6419	*
6420	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6421	*****************************************************************************/
6422
6423	BOOL WIN32API IsHungThread(DWORD x1)
6424	{
6425	dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
6426	x1));
6427
6428	return (FALSE); /* default */
6429	}
6430
6431
6432	/*****************************************************************************
6433	* Name : BOOL WIN32API SysErrorBox
6434	* Purpose : Unknown
6435	* Parameters: Unknown
6436	* Variables :
6437	* Result :
6438	* Remark : HARDERR like ?
6439	* Status : UNTESTED UNKNOWN STUB
6440	*
6441	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6442	*****************************************************************************/
6443
6444	BOOL WIN32API SysErrorBox(DWORD x1,
6445	DWORD x2,
6446	DWORD x3)
6447	{
6448	dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh) not implemented.\n",
6449	x1,
6450	x2,
6451	x3));
6452
6453	return (FALSE); /* default */
6454	}
6455
6456
6457	/*****************************************************************************
6458	* Name : BOOL WIN32API UserSignalProc
6459	* Purpose : Unknown
6460	* Parameters: Unknown
6461	* Variables :
6462	* Result :
6463	* Remark :
6464	* Status : UNTESTED UNKNOWN STUB
6465	*
6466	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6467	*****************************************************************************/
6468
6469	BOOL WIN32API UserSignalProc(DWORD x1,
6470	DWORD x2,
6471	DWORD x3,
6472	DWORD x4)
6473	{
6474	dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6475	x1,
6476	x2,
6477	x3,
6478	x4));
6479
6480	return (FALSE); /* default */
6481	}
6482
6483
6484	/*****************************************************************************
6485	* Name : BOOL WIN32API GetShellWindow
6486	* Purpose : Unknown
6487	* Parameters: Unknown
6488	* Variables :
6489	* Result :
6490	* Remark :
6491	* Status : UNTESTED UNKNOWN STUB
6492	*
6493	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
6494	*****************************************************************************/
6495
6496	HWND WIN32API GetShellWindow(void)
6497	{
6498	dprintf(("USER32: GetShellWindow() not implemented.\n"));
6499
6500	return (0); /* default */
6501	}

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

Download in other formats: