Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: trunk/src/user32/new/user32.cpp@ 315

Visit:

Last change on this file since 315 was 300, checked in by sandervl, 26 years ago
Very preliminary code for Open32 replacement
File size: 170.9 KB

Line
1	/* $Id: user32.cpp,v 1.1 1999-07-14 08:35:36 sandervl Exp $ */
2
3	/*
4	* Win32 misc user32 API functions for OS/2
5	*
6	* Copyright 1998 Sander van Leeuwen
7	* Copyright 1998 Patrick Haller
8	* Copyright 1998 Peter Fitzsimmons
9	* Copyright 1999 Christoph Bratschi
10	*
11	*
12	* Project Odin Software License can be found in LICENSE.TXT
13	*
14	*/
15	/*****************************************************************************
16	* Name : USER32.CPP
17	* Purpose : This module maps all Win32 functions contained in USER32.DLL
18	* to their OS/2-specific counterparts as far as possible.
19	*****************************************************************************/
20
21	#include <os2win.h>
22	#include "misc.h"
23
24	#include "user32.h"
25	#include "icon.h"
26	#include "usrcall.h"
27	#include "syscolor.h"
28
29	#include <wchar.h>
30	#include <stdlib.h>
31	#include <string.h>
32
33	//undocumented stuff
34	// WIN32API CalcChildScroll
35	// WIN32API CascadeChildWindows
36	// WIN32API ClientThreadConnect
37	// WIN32API DragObject
38	// WIN32API DrawFrame
39	// WIN32API EditWndProc
40	// WIN32API EndTask
41	// WIN32API GetInputDesktop
42	// WIN32API GetNextQueueWindow
43	// WIN32API GetShellWindow
44	// WIN32API InitSharedTable
45	// WIN32API InitTask
46	// WIN32API IsHungThread
47	// WIN32API LockWindowStation
48	// WIN32API ModifyAccess
49	// WIN32API PlaySoundEvent
50	// WIN32API RegisterLogonProcess
51	// WIN32API RegisterNetworkCapabilities
52	// WIN32API RegisterSystemThread
53	// WIN32API SetDeskWallpaper
54	// WIN32API SetDesktopBitmap
55	// WIN32API SetInternalWindowPos
56	// WIN32API SetLogonNotifyWindow
57	// WIN32API SetShellWindow
58	// WIN32API SetSysColorsTemp
59	// WIN32API SetWindowFullScreenState
60	// WIN32API SwitchToThisWindow
61	// WIN32API SysErrorBox
62	// WIN32API TileChildWindows
63	// WIN32API UnlockWindowStation
64	// WIN32API UserClientDllInitialize
65	// WIN32API UserSignalProc
66	// WIN32API WinOldAppHackoMatic
67	// WIN32API WNDPROC_CALLBACK
68	// WIN32API YieldTask
69
70
71
72
73	//******************************************************************************
74	//******************************************************************************
75	int __cdecl wsprintfA(char *lpOut, LPCSTR lpFmt, ...)
76	{
77	int rc;
78	va_list argptr;
79
80	#ifdef DEBUG
81	WriteLog("USER32: wsprintfA\n");
82	WriteLog("USER32: %s\n", lpFmt);
83	#endif
84	va_start(argptr, lpFmt);
85	rc = O32_wvsprintf(lpOut, (char *)lpFmt, argptr);
86	va_end(argptr);
87	#ifdef DEBUG
88	WriteLog("USER32: %s\n", lpOut);
89	#endif
90	return(rc);
91	}
92	//******************************************************************************
93	//******************************************************************************
94	int __cdecl wsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, ...)
95	{
96	int rc;
97	char *lpFmtA;
98	char szOut[512];
99	va_list argptr;
100
101	dprintf(("USER32: wsprintfW(%08xh,%08xh).\n",
102	lpOut,
103	lpFmt));
104
105	lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
106
107	/* @@@PH 98/07/13 transform "%s" to "%ls" does the unicode magic */
108	{
109	PCHAR pszTemp;
110	PCHAR pszTemp1;
111	ULONG ulStrings;
112	ULONG ulIndex; /* temporary string counter */
113
114	for (ulStrings = 0, /* determine number of placeholders */
115	pszTemp = lpFmtA;
116
117	(pszTemp != NULL) &&
118	(*pszTemp != 0);
119
120	ulStrings++)
121	{
122	pszTemp = strstr(pszTemp,
123	"%s");
124	if (pszTemp != NULL) /* skip 2 characters */
125	{
126	pszTemp++;
127	pszTemp++;
128	}
129	else
130	break; /* leave loop immediately */
131	}
132
133	if (ulStrings != 0) /* transformation required ? */
134	{
135	/* now reallocate lpFmt */
136	ulStrings += strlen(lpFmtA); /* calculate total string length */
137	pszTemp = lpFmtA; /* save string pointer */
138	pszTemp1 = lpFmtA; /* save string pointer */
139
140	/* @@@PH allocation has to be compatible to FreeAsciiString !!! */
141	lpFmtA = (char *)malloc(ulStrings + 1);
142	if (lpFmtA == NULL) /* check proper allocation */
143	return (0); /* raise error condition */
144
145	for (ulIndex = 0;
146	ulIndex <= ulStrings;
147	ulIndex++,
148	pszTemp++)
149	{
150	if ((pszTemp[0] == '%') &&
151	(pszTemp[1] == 's') )
152	{
153	/* replace %s by %ls */
154	lpFmtA[ulIndex++] = '%';
155	lpFmtA[ulIndex ] = 'l';
156	lpFmtA[ulIndex+1] = 's';
157	}
158	else
159	lpFmtA[ulIndex] = pszTemp; / just copy over the character */
160	}
161
162	lpFmtA[ulStrings] = 0; /* string termination */
163
164	FreeAsciiString(pszTemp1); /* the original string is obsolete */
165	}
166	}
167
168	dprintf(("USER32: wsprintfW (%s).\n",
169	lpFmt));
170
171	va_start(argptr,
172	lpFmt);
173
174	rc = O32_wvsprintf(szOut,
175	lpFmtA,
176	argptr);
177
178	AsciiToUnicode(szOut,
179	lpOut);
180
181	FreeAsciiString(lpFmtA);
182	return(rc);
183	}
184	//******************************************************************************
185	//******************************************************************************
186	BOOL WIN32API MessageBeep( UINT arg1)
187	{
188	#ifdef DEBUG
189	WriteLog("USER32: MessageBeep\n");
190	#endif
191	return O32_MessageBeep(arg1);
192	}
193	//******************************************************************************
194	// Not implemented by Open32 (31-5-99 Christoph Bratschi)
195	//******************************************************************************
196	BOOL WIN32API IsDlgButtonChecked( HWND arg1, UINT arg2)
197	{
198	#ifdef DEBUG
199	WriteLog("USER32: IsDlgButtonChecked\n");
200	#endif
201	// return O32_IsDlgButtonChecked(arg1, arg2);
202	return (BOOL)SendDlgItemMessageA(arg1,arg2,BM_GETCHECK,0,0);
203	}
204	//******************************************************************************
205	//******************************************************************************
206	int WIN32API GetWindowTextLengthA( HWND arg1)
207	{
208	dprintf(("USER32: GetWindowTextLength\n"));
209	return O32_GetWindowTextLength(arg1);
210	}
211	//******************************************************************************
212	//******************************************************************************
213	int WIN32API GetWindowTextA( HWND arg1, LPSTR arg2, int arg3)
214	{
215	dprintf(("USER32: GetWindowTextA\n"));
216	return O32_GetWindowText(arg1, arg2, arg3);
217	}
218	//******************************************************************************
219
220	/*******************************************************************
221	* InternalGetWindowText (USER32.326)
222	*/
223	int WIN32API InternalGetWindowText(HWND hwnd,
224	LPWSTR lpString,
225	INT nMaxCount )
226	{
227	dprintf(("USER32: InternalGetWindowText(%08xh,%08xh,%08xh) not properly implemented.\n",
228	hwnd,
229	lpString,
230	nMaxCount));
231
232	return GetWindowTextW(hwnd,lpString,nMaxCount);
233	}
234
235
236	//******************************************************************************
237	//******************************************************************************
238	//******************************************************************************
239	HWND WIN32API GetNextDlgTabItem( HWND arg1, HWND arg2, BOOL arg3)
240	{
241	dprintf(("USER32: GetNextDlgTabItem\n"));
242	return O32_GetNextDlgTabItem(arg1, arg2, arg3);
243	}
244	//******************************************************************************
245	//******************************************************************************
246	BOOL WIN32API GetMessageA( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
247	{
248	//// dprintf(("USER32: GetMessage\n"));
249	return O32_GetMessage(arg1, arg2, arg3, arg4);
250	}
251	//******************************************************************************
252	//******************************************************************************
253	HWND WIN32API GetFocus(void)
254	{
255	// dprintf(("USER32: GetFocus\n"));
256	return O32_GetFocus();
257	}
258	//******************************************************************************
259	//******************************************************************************
260	HWND WIN32API GetDlgItem(HWND arg1, int arg2)
261	{
262	HWND rc;
263
264	rc = O32_GetDlgItem(arg1, arg2);
265	dprintf(("USER32: GetDlgItem %d returned %d\n", arg2, rc));
266	return(rc);
267	}
268	//******************************************************************************
269	//******************************************************************************
270	int WIN32API GetDlgCtrlID( HWND arg1)
271	{
272	dprintf(("USER32: GetDlgCtrlID\n"));
273	return O32_GetDlgCtrlID(arg1);
274	}
275	//******************************************************************************
276	//******************************************************************************
277	HWND WIN32API GetDesktopWindow(void)
278	{
279	dprintf(("USER32: GetDesktopWindow\n"));
280	return O32_GetDesktopWindow();
281	}
282	//******************************************************************************
283	//******************************************************************************
284	BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
285	{
286	BOOL rc;
287	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
288
289	dprintf(("USER32: EnumThreadWindows\n"));
290	rc = O32_EnumThreadWindows(dwThreadId, callback->GetOS2Callback(), (LPARAM)callback);
291	if(callback)
292	delete callback;
293	return(rc);
294	}
295	//******************************************************************************
296	//******************************************************************************
297	BOOL WIN32API EndDialog( HWND arg1, int arg2)
298	{
299	BOOL rc;
300
301	dprintf(("USER32: EndDialog\n"));
302	rc = O32_EndDialog(arg1, arg2);
303	return(rc);
304	}
305	//******************************************************************************
306	//******************************************************************************
307	BOOL WIN32API OffsetRect( PRECT arg1, int arg2, int arg3)
308	{
309	#ifdef DEBUG
310	//// WriteLog("USER32: OffsetRect\n");
311	#endif
312	return O32_OffsetRect(arg1, arg2, arg3);
313	}
314	//******************************************************************************
315	//******************************************************************************
316	BOOL WIN32API CopyRect( PRECT arg1, const RECT * arg2)
317	{
318	// ddprintf(("USER32: CopyRect\n"));
319	return O32_CopyRect(arg1, arg2);
320	}
321	//******************************************************************************
322	// Not implemented by Open32 (5-31-99 Christoph Bratschi)
323	//******************************************************************************
324	BOOL WIN32API CheckDlgButton( HWND arg1, int arg2, UINT arg3)
325	{
326	#ifdef DEBUG
327	WriteLog("USER32: CheckDlgButton\n");
328	#endif
329	// return O32_CheckDlgButton(arg1, arg2, arg3);
330	return (BOOL)SendDlgItemMessageA(arg1,arg2,BM_SETCHECK,arg3,0);
331	}
332	//******************************************************************************
333	//******************************************************************************
334	HWND WIN32API SetFocus( HWND arg1)
335	{
336	dprintf(("USER32: SetFocus\n"));
337	return O32_SetFocus(arg1);
338	}
339	//******************************************************************************
340	//******************************************************************************
341	int WIN32API ReleaseDC( HWND arg1, HDC arg2)
342	{
343	#ifdef DEBUG
344	WriteLog("USER32: ReleaseDC\n");
345	#endif
346	return O32_ReleaseDC(arg1, arg2);
347	}
348	//******************************************************************************
349	//******************************************************************************
350	BOOL WIN32API InvalidateRect(HWND arg1, const RECT *arg2, BOOL arg3)
351	{
352	#ifdef DEBUG
353	if(arg2)
354	WriteLog("USER32: InvalidateRect for window %X (%d,%d)(%d,%d) %d\n", arg1, arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
355	else WriteLog("USER32: InvalidateRect for window %X NULL, %d\n", arg1, arg3);
356	#endif
357	return O32_InvalidateRect(arg1, arg2, arg3);
358	}
359	//******************************************************************************
360	//******************************************************************************
361	BOOL WIN32API GetUpdateRect( HWND arg1, PRECT arg2, BOOL arg3)
362	{
363	#ifdef DEBUG
364	WriteLog("USER32: GetUpdateRect\n");
365	#endif
366	return O32_GetUpdateRect(arg1, arg2, arg3);
367	}
368	//******************************************************************************
369	//******************************************************************************
370	HDC WIN32API GetDC( HWND arg1)
371	{
372	HDC hdc;
373
374	hdc = O32_GetDC(arg1);
375	#ifdef DEBUG
376	WriteLog("USER32: GetDC of %X returns %X\n", arg1, hdc);
377	#endif
378	return(hdc);
379	}
380	//******************************************************************************
381	//******************************************************************************
382	HDC WIN32API GetDCEx(HWND arg1, HRGN arg2, DWORD arg3)
383	{
384	#ifdef DEBUG
385	WriteLog("USER32: GetDCEx\n");
386	#endif
387	return O32_GetDCEx(arg1, arg2, arg3);
388	}
389	//******************************************************************************
390	//******************************************************************************
391	BOOL WIN32API EndPaint( HWND arg1, const PAINTSTRUCT * arg2)
392	{
393	#ifdef DEBUG
394	WriteLog("USER32: EndPaint\n");
395	#endif
396	return O32_EndPaint(arg1, arg2);
397	}
398	//******************************************************************************
399	//******************************************************************************
400	//******************************************************************************
401	//******************************************************************************
402	HDC WIN32API BeginPaint(HWND arg1, PPAINTSTRUCT arg2)
403	{
404	dprintf(("USER32: BeginPaint %X\n", arg2));
405	return O32_BeginPaint(arg1, arg2);
406	}
407	//******************************************************************************
408	//******************************************************************************
409	int WIN32API GetSystemMetrics(int arg1)
410	{
411	int rc;
412
413	switch(arg1) {
414	case SM_CXICONSPACING: //TODO: size of grid cell for large icons
415	rc = O32_GetSystemMetrics(SM_CXICON);
416	break;
417	case SM_CYICONSPACING:
418	rc = O32_GetSystemMetrics(SM_CYICON);
419	break;
420	case SM_PENWINDOWS:
421	rc = FALSE;
422	break;
423	case SM_DBCSENABLED:
424	rc = FALSE;
425	break;
426	case SM_CXEDGE: //size of 3D window edge (not supported)
427	rc = 1;
428	break;
429	case SM_CYEDGE:
430	rc = 1;
431	break;
432	case SM_CXMINSPACING: //can be SM_CXMINIMIZED or larger
433	rc = O32_GetSystemMetrics(SM_CXMINIMIZED);
434	break;
435	case SM_CYMINSPACING:
436	rc = GetSystemMetrics(SM_CYMINIMIZED);
437	break;
438	case SM_CXSMICON: //recommended size of small icons (TODO: adjust to screen res.)
439	rc = 16;
440	break;
441	case SM_CYSMICON:
442	rc = 16;
443	break;
444	case SM_CYSMCAPTION: //size in pixels of a small caption (TODO: ????)
445	rc = 8;
446	break;
447	case SM_CXSMSIZE: //size of small caption buttons (pixels) (TODO: implement properly)
448	rc = 16;
449	break;
450	case SM_CYSMSIZE:
451	rc = 16;
452	break;
453	case SM_CXMENUSIZE: //TODO: size of menu bar buttons (such as MDI window close)
454	rc = 16;
455	break;
456	case SM_CYMENUSIZE:
457	rc = 16;
458	break;
459	case SM_ARRANGE:
460	rc = ARW_BOTTOMLEFT \| ARW_LEFT;
461	break;
462	case SM_CXMINIMIZED:
463	break;
464	case SM_CYMINIMIZED:
465	break;
466	case SM_CXMAXTRACK: //max window size
467	case SM_CXMAXIMIZED: //max toplevel window size
468	rc = O32_GetSystemMetrics(SM_CXSCREEN);
469	break;
470	case SM_CYMAXTRACK:
471	case SM_CYMAXIMIZED:
472	rc = O32_GetSystemMetrics(SM_CYSCREEN);
473	break;
474	case SM_NETWORK:
475	rc = 0x01; //TODO: default = yes
476	break;
477	case SM_CLEANBOOT:
478	rc = 0; //normal boot
479	break;
480	case SM_CXDRAG: //nr of pixels before drag becomes a real one
481	rc = 2;
482	break;
483	case SM_CYDRAG:
484	rc = 2;
485	break;
486	case SM_SHOWSOUNDS: //show instead of play sound
487	rc = FALSE;
488	break;
489	case SM_CXMENUCHECK:
490	rc = 4; //TODO
491	break;
492	case SM_CYMENUCHECK:
493	rc = O32_GetSystemMetrics(SM_CYMENU);
494	break;
495	case SM_SLOWMACHINE:
496	rc = FALSE; //even a slow machine is fast with OS/2 :)
497	break;
498	case SM_MIDEASTENABLED:
499	rc = FALSE;
500	break;
501	case SM_CMETRICS:
502	rc = O32_GetSystemMetrics(44); //Open32 changed this one
503	break;
504	default:
505	rc = O32_GetSystemMetrics(arg1);
506	break;
507	}
508	#ifdef DEBUG
509	WriteLog("USER32: GetSystemMetrics %d returned %d\n", arg1, rc);
510	#endif
511	return(rc);
512	}
513	//******************************************************************************
514	//******************************************************************************
515	UINT WIN32API SetTimer( HWND arg1, UINT arg2, UINT arg3, TIMERPROC arg4)
516	{
517	#ifdef DEBUG
518	WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
519	#endif
520	//SvL: Write callback handler class for this one
521	return O32_SetTimer(arg1, arg2, arg3, (TIMERPROC_O32)arg4);
522	}
523	//******************************************************************************
524	//******************************************************************************
525	BOOL WIN32API KillTimer(HWND arg1, UINT arg2)
526	{
527	#ifdef DEBUG
528	WriteLog("USER32: KillTimer\n");
529	#endif
530	return O32_KillTimer(arg1, arg2);
531	}
532	//******************************************************************************
533	//******************************************************************************
534	BOOL WIN32API InflateRect( PRECT arg1, int arg2, int arg3)
535	{
536	#ifdef DEBUG
537	WriteLog("USER32: InflateRect\n");
538	#endif
539	return O32_InflateRect(arg1, arg2, arg3);
540	}
541	//******************************************************************************
542	//TODO:How can we emulate this one in OS/2???
543	//******************************************************************************
544	DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
545	{
546	#ifdef DEBUG
547	WriteLog("USER32: WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
548	#endif
549
550	if(dwTimeOut == INFINITE) return(0);
551
552	// DosSleep(dwTimeOut/16);
553	return(0);
554	}
555	//******************************************************************************
556	//******************************************************************************
557	UINT WIN32API GetDlgItemTextA(HWND arg1, int arg2, LPSTR arg3, UINT arg4)
558	{
559	UINT rc;
560
561	rc = O32_GetDlgItemText(arg1, arg2, arg3, arg4);
562	#ifdef DEBUG
563	if(rc)
564	WriteLog("USER32: GetDlgItemTextA returned %s\n", arg3);
565	else WriteLog("USER32: GetDlgItemTextA returned 0 (%d)\n", GetLastError());
566	#endif
567	return(rc);
568	}
569	//******************************************************************************
570	//******************************************************************************
571	int WIN32API ShowCursor( BOOL arg1)
572	{
573	#ifdef DEBUG
574	WriteLog("USER32: ShowCursor\n");
575	#endif
576	return O32_ShowCursor(arg1);
577	}
578	//******************************************************************************
579	//******************************************************************************
580	BOOL WIN32API SetRect( PRECT arg1, int arg2, int arg3, int arg4, int arg5)
581	{
582	#ifdef DEBUG
583	WriteLog("USER32: SetRect\n");
584	#endif
585	return O32_SetRect(arg1, arg2, arg3, arg4, arg5);
586	}
587	//******************************************************************************
588	//******************************************************************************
589	BOOL WIN32API SetDlgItemInt( HWND arg1, int arg2, UINT arg3, BOOL arg4)
590	{
591	#ifdef DEBUG
592	WriteLog("USER32: SetDlgItemInt\n");
593	#endif
594	return O32_SetDlgItemInt(arg1, arg2, arg3, arg4);
595	}
596	//******************************************************************************
597	//******************************************************************************
598	BOOL WIN32API SetDlgItemTextA( HWND arg1, int arg2, LPCSTR arg3)
599	{
600	#ifdef DEBUG
601	WriteLog("USER32: SetDlgItemText to %s\n", arg3);
602	#endif
603	return O32_SetDlgItemText(arg1, arg2, arg3);
604	}
605	//******************************************************************************
606	//******************************************************************************
607	BOOL WIN32API WinHelpA( HWND arg1, LPCSTR arg2, UINT arg3, DWORD arg4)
608	{
609	#ifdef DEBUG
610	WriteLog("USER32: WinHelp not implemented %s\n", arg2);
611	#endif
612	// return O32_WinHelp(arg1, arg2, arg3, arg4);
613	return(TRUE);
614	}
615	//******************************************************************************
616	//******************************************************************************
617	int WIN32API TranslateAcceleratorA(HWND arg1, HACCEL arg2, LPMSG arg3)
618	{
619	#ifdef DEBUG
620	//// WriteLog("USER32: TranslateAccelerator\n");
621	#endif
622	return O32_TranslateAccelerator(arg1, arg2, arg3);
623	}
624	//******************************************************************************
625	//******************************************************************************
626	BOOL WIN32API SubtractRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
627	{
628	#ifdef DEBUG
629	WriteLog("USER32: SubtractRect");
630	#endif
631	return O32_SubtractRect(arg1, arg2, arg3);
632	}
633	//******************************************************************************
634	//SvL: 24-6-'97 - Added
635	//******************************************************************************
636	BOOL WIN32API ClipCursor(const RECT * arg1)
637	{
638	#ifdef DEBUG
639	WriteLog("USER32: ClipCursor\n");
640	#endif
641	return O32_ClipCursor(arg1);
642	}
643	//******************************************************************************
644	//SvL: 24-6-'97 - Added
645	//TODO: Not implemented
646	//******************************************************************************
647	WORD WIN32API GetAsyncKeyState(INT nVirtKey)
648	{
649	#ifdef DEBUG
650	//// WriteLog("USER32: GetAsyncKeyState Not implemented\n");
651	#endif
652	return 0;
653	}
654	//******************************************************************************
655	//SvL: 24-6-'97 - Added
656	//******************************************************************************
657	HCURSOR WIN32API GetCursor(void)
658	{
659	#ifdef DEBUG
660	//// WriteLog("USER32: GetCursor\n");
661	#endif
662	return O32_GetCursor();
663	}
664	//******************************************************************************
665	//SvL: 24-6-'97 - Added
666	//******************************************************************************
667	BOOL WIN32API GetCursorPos( PPOINT arg1)
668	{
669	#ifdef DEBUG
670	//// WriteLog("USER32: GetCursorPos\n");
671	#endif
672	return O32_GetCursorPos(arg1);
673	}
674	//******************************************************************************
675	//SvL: 24-6-'97 - Added
676	//******************************************************************************
677	WORD WIN32API VkKeyScanA( char arg1)
678	{
679	#ifdef DEBUG
680	WriteLog("USER32: VkKeyScanA\n");
681	#endif
682	return O32_VkKeyScan(arg1);
683	}
684	//******************************************************************************
685	//SvL: 24-6-'97 - Added
686	//******************************************************************************
687	SHORT WIN32API GetKeyState( int arg1)
688	{
689	#ifdef DEBUG
690	WriteLog("USER32: GetKeyState %d\n", arg1);
691	#endif
692	return O32_GetKeyState(arg1);
693	}
694	//******************************************************************************
695	//******************************************************************************
696	HCURSOR WIN32API SetCursor( HCURSOR arg1)
697	{
698	#ifdef DEBUG
699	WriteLog("USER32: SetCursor\n");
700	#endif
701	return O32_SetCursor(arg1);
702	}
703	//******************************************************************************
704	//******************************************************************************
705	BOOL WIN32API SetCursorPos( int arg1, int arg2)
706	{
707	#ifdef DEBUG
708	WriteLog("USER32: SetCursorPos\n");
709	#endif
710	return O32_SetCursorPos(arg1, arg2);
711	}
712	//******************************************************************************
713	//******************************************************************************
714	BOOL WIN32API EnableScrollBar( HWND arg1, INT arg2, UINT arg3)
715	{
716	#ifdef DEBUG
717	WriteLog("USER32: EnableScrollBar\n");
718	#endif
719	return O32_EnableScrollBar(arg1, arg2, arg3);
720	}
721	//******************************************************************************
722	//******************************************************************************
723	HWND WIN32API SetCapture( HWND arg1)
724	{
725	#ifdef DEBUG
726	WriteLog("USER32: SetCapture\n");
727	#endif
728	return O32_SetCapture(arg1);
729	}
730	//******************************************************************************
731	//******************************************************************************
732	BOOL WIN32API ReleaseCapture(void)
733	{
734	#ifdef DEBUG
735	WriteLog("USER32: ReleaseCapture\n");
736	#endif
737	return O32_ReleaseCapture();
738	}
739	//******************************************************************************
740	//******************************************************************************
741	DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD arg5)
742	{
743	#ifdef DEBUG
744	WriteLog("USER32: MsgWaitForMultipleObjects\n");
745	#endif
746	return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
747	}
748	//******************************************************************************
749	//******************************************************************************
750	BOOL WIN32API ChangeClipboardChain( HWND arg1, HWND arg2)
751	{
752	#ifdef DEBUG
753	WriteLog("USER32: ChangeClipboardChain\n");
754	#endif
755	return O32_ChangeClipboardChain(arg1, arg2);
756	}
757	//******************************************************************************
758	//******************************************************************************
759	UINT WIN32API ArrangeIconicWindows( HWND arg1)
760	{
761	#ifdef DEBUG
762	WriteLog("USER32: ArrangeIconicWindows\n");
763	#endif
764	return O32_ArrangeIconicWindows(arg1);
765	}
766	//******************************************************************************
767	// Not implemented by Open32 (5-31-99 Christoph Bratschi)
768	//******************************************************************************
769	BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT arg4)
770	{
771	#ifdef DEBUG
772	WriteLog("USER32: CheckRadioButton\n");
773	#endif
774	// return O32_CheckRadioButton(arg1, arg2, arg3, arg4);
775	if (arg2 > arg3) return (FALSE);
776	for (UINT x=arg2;x <= arg3;x++)
777	{
778	SendDlgItemMessageA(arg1,x,BM_SETCHECK,(x == arg4) ? BST_CHECKED : BST_UNCHECKED,0);
779	}
780	return (TRUE);
781	}
782	//******************************************************************************
783	//******************************************************************************
784	BOOL WIN32API CloseClipboard(void)
785	{
786	#ifdef DEBUG
787	WriteLog("USER32: CloseClipboard\n");
788	#endif
789	return O32_CloseClipboard();
790	}
791	//******************************************************************************
792	//******************************************************************************
793	HICON WIN32API CopyIcon( HICON arg1)
794	{
795	#ifdef DEBUG
796	WriteLog("USER32: CopyIcon\n");
797	#endif
798	return O32_CopyIcon(arg1);
799	}
800	//******************************************************************************
801	//******************************************************************************
802	int WIN32API CountClipboardFormats(void)
803	{
804	#ifdef DEBUG
805	WriteLog("USER32: CountClipboardFormats\n");
806	#endif
807	return O32_CountClipboardFormats();
808	}
809	//******************************************************************************
810	//******************************************************************************
811	HACCEL WIN32API CreateAcceleratorTableA( LPACCEL arg1, int arg2)
812	{
813	#ifdef DEBUG
814	WriteLog("USER32: CreateAcceleratorTableA\n");
815	#endif
816	return O32_CreateAcceleratorTable(arg1, arg2);
817	}
818	//******************************************************************************
819	//******************************************************************************
820	HACCEL WIN32API CreateAcceleratorTableW( LPACCEL arg1, int arg2)
821	{
822	#ifdef DEBUG
823	WriteLog("USER32: CreateAcceleratorTableW\n");
824	#endif
825	// NOTE: This will not work as is (needs UNICODE support)
826	return O32_CreateAcceleratorTable(arg1, arg2);
827	}
828	//******************************************************************************
829	//******************************************************************************
830	BOOL WIN32API CreateCaret( HWND arg1, HBITMAP arg2, int arg3, int arg4)
831	{
832	#ifdef DEBUG
833	WriteLog("USER32: CreateCaret\n");
834	#endif
835	return O32_CreateCaret(arg1, arg2, arg3, arg4);
836	}
837	//******************************************************************************
838	//******************************************************************************
839	HCURSOR WIN32API CreateCursor( HINSTANCE arg1, int arg2, int arg3, int arg4, int arg5, const VOID * arg6, const VOID * arg7)
840	{
841	#ifdef DEBUG
842	WriteLog("USER32: CreateCursor\n");
843	#endif
844	return O32_CreateCursor(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
845	}
846	//******************************************************************************
847	//******************************************************************************
848	HICON WIN32API CreateIcon( HINSTANCE arg1, INT arg2, INT arg3, BYTE arg4, BYTE arg5, LPCVOID arg6, LPCVOID arg7)
849	{
850	#ifdef DEBUG
851	WriteLog("USER32: CreateIcon\n");
852	#endif
853	return O32_CreateIcon(arg1, arg2, arg3, arg4, arg5, (const BYTE )arg6, (const BYTE )arg7);
854	}
855	//******************************************************************************
856	//ASSERT dwVer == win31 (ok according to SDK docs)
857	//******************************************************************************
858	HICON WIN32API CreateIconFromResource(PBYTE presbits, UINT dwResSize,
859	BOOL fIcon, DWORD dwVer)
860	{
861	HICON hicon;
862	DWORD OS2ResSize = 0;
863	PBYTE OS2Icon = ConvertWin32Icon(presbits, dwResSize, &OS2ResSize);
864
865	hicon = O32_CreateIconFromResource(OS2Icon, OS2ResSize, fIcon, dwVer);
866	#ifdef DEBUG
867	WriteLog("USER32: CreateIconFromResource returned %X (%X)\n", hicon, GetLastError());
868	#endif
869	if(OS2Icon)
870	FreeIcon(OS2Icon);
871
872	return(hicon);
873	}
874	//******************************************************************************
875	//******************************************************************************
876	HICON WIN32API CreateIconFromResourceEx(PBYTE presbits, UINT dwResSize,
877	BOOL fIcon, DWORD dwVer,
878	int cxDesired, int cyDesired,
879	UINT Flags)
880	{
881	#ifdef DEBUG
882	WriteLog("USER32: CreateIconFromResourceEx %X %d %d %X %d %d %X, not completely supported!\n", presbits, dwResSize, fIcon, dwVer, cxDesired, cyDesired, Flags);
883	#endif
884	return CreateIconFromResource(presbits, dwResSize, fIcon, dwVer);
885	}
886	//******************************************************************************
887	//******************************************************************************
888	HICON WIN32API CreateIconIndirect(LPICONINFO arg1)
889	{
890	#ifdef DEBUG
891	WriteLog("USER32: CreateIconIndirect\n");
892	#endif
893	return O32_CreateIconIndirect(arg1);
894	}
895	//******************************************************************************
896	//******************************************************************************
897	//******************************************************************************
898	//******************************************************************************
899	BOOL WIN32API DestroyAcceleratorTable( HACCEL arg1)
900	{
901	#ifdef DEBUG
902	WriteLog("USER32: DestroyAcceleratorTable\n");
903	#endif
904	return O32_DestroyAcceleratorTable(arg1);
905	}
906	//******************************************************************************
907	//******************************************************************************
908	BOOL WIN32API DestroyCaret(void)
909	{
910	#ifdef DEBUG
911	WriteLog("USER32: DestroyCaret\n");
912	#endif
913	return O32_DestroyCaret();
914	}
915	//******************************************************************************
916	//******************************************************************************
917	BOOL WIN32API DestroyCursor( HCURSOR arg1)
918	{
919	#ifdef DEBUG
920	WriteLog("USER32: DestroyCursor\n");
921	#endif
922	return O32_DestroyCursor(arg1);
923	}
924	//******************************************************************************
925	//******************************************************************************
926	BOOL WIN32API DestroyIcon( HICON arg1)
927	{
928	#ifdef DEBUG
929	WriteLog("USER32: DestroyIcon\n");
930	#endif
931	return O32_DestroyIcon(arg1);
932	}
933	//******************************************************************************
934	//******************************************************************************
935	int WIN32API DlgDirListA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
936	{
937	#ifdef DEBUG
938	WriteLog("USER32: DlgDirListA\n");
939	#endif
940	return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
941	}
942	//******************************************************************************
943	//******************************************************************************
944	int WIN32API DlgDirListComboBoxA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
945	{
946	#ifdef DEBUG
947	WriteLog("USER32: DlgDirListComboBoxA\n");
948	#endif
949	return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
950	}
951	//******************************************************************************
952	//******************************************************************************
953	int WIN32API DlgDirListComboBoxW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
954	{
955	#ifdef DEBUG
956	WriteLog("USER32: DlgDirListComboBoxW NOT WORKING\n");
957	#endif
958	// NOTE: This will not work as is (needs UNICODE support)
959	return 0;
960	// return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
961	}
962	//******************************************************************************
963	//******************************************************************************
964	int WIN32API DlgDirListW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
965	{
966	#ifdef DEBUG
967	WriteLog("USER32: DlgDirListW NOT WORKING\n");
968	#endif
969	// NOTE: This will not work as is (needs UNICODE support)
970	return 0;
971	// return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
972	}
973	//******************************************************************************
974	//******************************************************************************
975	BOOL WIN32API DlgDirSelectComboBoxExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
976	{
977	#ifdef DEBUG
978	WriteLog("USER32: DlgDirSelectComboBoxExA\n");
979	#endif
980	return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
981	}
982	//******************************************************************************
983	//******************************************************************************
984	BOOL WIN32API DlgDirSelectComboBoxExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
985	{
986	#ifdef DEBUG
987	WriteLog("USER32: DlgDirSelectComboBoxExW NOT WORKING\n");
988	#endif
989	// NOTE: This will not work as is (needs UNICODE support)
990	return 0;
991	// return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
992	}
993	//******************************************************************************
994	//******************************************************************************
995	BOOL WIN32API DlgDirSelectExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
996	{
997	#ifdef DEBUG
998	WriteLog("USER32: DlgDirSelectExA\n");
999	#endif
1000	return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1001	}
1002	//******************************************************************************
1003	//******************************************************************************
1004	BOOL WIN32API DlgDirSelectExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1005	{
1006	#ifdef DEBUG
1007	WriteLog("USER32: DlgDirSelectExW NOT WORKING\n");
1008	#endif
1009	// NOTE: This will not work as is (needs UNICODE support)
1010	return 0;
1011	// return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1012	}
1013	//******************************************************************************
1014	//******************************************************************************
1015	BOOL WIN32API EmptyClipboard(void)
1016	{
1017	#ifdef DEBUG
1018	WriteLog("USER32: EmptyClipboard\n");
1019	#endif
1020	return O32_EmptyClipboard();
1021	}
1022	//******************************************************************************
1023	//******************************************************************************
1024	BOOL WIN32API EndDeferWindowPos( HDWP arg1)
1025	{
1026	#ifdef DEBUG
1027	WriteLog("USER32: EndDeferWindowPos\n");
1028	#endif
1029	return O32_EndDeferWindowPos(arg1);
1030	}
1031	//******************************************************************************
1032	//******************************************************************************
1033	BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1034	{
1035	BOOL rc;
1036	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1037
1038	#ifdef DEBUG
1039	WriteLog("USER32: EnumChildWindows\n");
1040	#endif
1041	rc = O32_EnumChildWindows(hwnd, callback->GetOS2Callback(), (LPARAM)callback);
1042	if(callback)
1043	delete callback;
1044	return(rc);
1045	}
1046	//******************************************************************************
1047	//******************************************************************************
1048	UINT WIN32API EnumClipboardFormats(UINT arg1)
1049	{
1050	#ifdef DEBUG
1051	WriteLog("USER32: EnumClipboardFormats\n");
1052	#endif
1053	return O32_EnumClipboardFormats(arg1);
1054	}
1055	//******************************************************************************
1056	//******************************************************************************
1057	int WIN32API EnumPropsA(HWND arg1, PROPENUMPROCA arg2)
1058	{
1059	#ifdef DEBUG
1060	WriteLog("USER32: EnumPropsA DOES NOT WORK\n");
1061	#endif
1062	//calling convention problems
1063	return 0;
1064	// return O32_EnumProps(arg1, (PROPENUMPROC_O32)arg2);
1065	}
1066	//******************************************************************************
1067	//******************************************************************************
1068	int WIN32API EnumPropsExA( HWND arg1, PROPENUMPROCEXA arg2, LPARAM arg3)
1069	{
1070	#ifdef DEBUG
1071	WriteLog("USER32: EnumPropsExA DOES NOT WORK\n");
1072	#endif
1073	//calling convention problems
1074	return 0;
1075	// return O32_EnumPropsEx(arg1, arg2, (PROPENUMPROCEX_O32)arg3);
1076	}
1077	//******************************************************************************
1078	//******************************************************************************
1079	int WIN32API EnumPropsExW( HWND arg1, PROPENUMPROCEXW arg2, LPARAM arg3)
1080	{
1081	#ifdef DEBUG
1082	WriteLog("USER32: EnumPropsExW\n");
1083	#endif
1084	// NOTE: This will not work as is (needs UNICODE support)
1085	//calling convention problems
1086	return 0;
1087	// return O32_EnumPropsEx(arg1, arg2, arg3);
1088	}
1089	//******************************************************************************
1090	//******************************************************************************
1091	int WIN32API EnumPropsW( HWND arg1, PROPENUMPROCW arg2)
1092	{
1093	#ifdef DEBUG
1094	WriteLog("USER32: EnumPropsW\n");
1095	#endif
1096	// NOTE: This will not work as is (needs UNICODE support)
1097	//calling convention problems
1098	return 0;
1099	// return O32_EnumProps(arg1, arg2);
1100	}
1101	//******************************************************************************
1102	//******************************************************************************
1103	BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1104	{
1105	BOOL rc;
1106	EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1107
1108	#ifdef DEBUG
1109	WriteLog("USER32: EnumWindows\n");
1110	#endif
1111	rc = O32_EnumWindows(callback->GetOS2Callback(), (LPARAM)callback);
1112	if(callback)
1113	delete callback;
1114	return(rc);
1115	}
1116	//******************************************************************************
1117	//******************************************************************************
1118	BOOL WIN32API EqualRect( const RECT * arg1, const RECT * arg2)
1119	{
1120	#ifdef DEBUG
1121	WriteLog("USER32: EqualRect\n");
1122	#endif
1123	return O32_EqualRect(arg1, arg2);
1124	}
1125	//******************************************************************************
1126	//******************************************************************************
1127	BOOL WIN32API ExcludeUpdateRgn( HDC arg1, HWND arg2)
1128	{
1129	#ifdef DEBUG
1130	WriteLog("USER32: ExcludeUpdateRgn\n");
1131	#endif
1132	return O32_ExcludeUpdateRgn(arg1, arg2);
1133	}
1134	//******************************************************************************
1135	//******************************************************************************
1136	BOOL WIN32API ExitWindowsEx( UINT arg1, DWORD arg2)
1137	{
1138	#ifdef DEBUG
1139	WriteLog("USER32: ExitWindowsEx\n");
1140	#endif
1141	return O32_ExitWindowsEx(arg1, arg2);
1142	}
1143	//******************************************************************************
1144	//******************************************************************************
1145	int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
1146	{
1147	#ifdef DEBUG
1148	WriteLog("USER32: FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
1149	#endif
1150	return O32_FillRect(arg1, arg2, arg3);
1151	}
1152	//******************************************************************************
1153	//******************************************************************************
1154	HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
1155	{
1156	char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1157	char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1158	HWND rc;
1159
1160	#ifdef DEBUG
1161	WriteLog("USER32: FindWindowW\n");
1162	#endif
1163	rc = O32_FindWindow(astring1, astring2);
1164	FreeAsciiString(astring1);
1165	FreeAsciiString(astring2);
1166	return rc;
1167	}
1168	//******************************************************************************
1169	//******************************************************************************
1170	int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH arg3)
1171	{
1172	#ifdef DEBUG
1173	WriteLog("USER32: FrameRect\n");
1174	#endif
1175	return O32_FrameRect(arg1, arg2, arg3);
1176	}
1177	//******************************************************************************
1178	//******************************************************************************
1179	HWND WIN32API GetCapture(void)
1180	{
1181	#ifdef DEBUG
1182	WriteLog("USER32: GetCapture\n");
1183	#endif
1184	return O32_GetCapture();
1185	}
1186	//******************************************************************************
1187	//******************************************************************************
1188	UINT WIN32API GetCaretBlinkTime(void)
1189	{
1190	#ifdef DEBUG
1191	WriteLog("USER32: GetCaretBlinkTime\n");
1192	#endif
1193	return O32_GetCaretBlinkTime();
1194	}
1195	//******************************************************************************
1196	//******************************************************************************
1197	BOOL WIN32API GetCaretPos( PPOINT arg1)
1198	{
1199	#ifdef DEBUG
1200	WriteLog("USER32: GetCaretPos\n");
1201	#endif
1202	return O32_GetCaretPos(arg1);
1203	}
1204	//******************************************************************************
1205	//******************************************************************************
1206	BOOL WIN32API GetClipCursor( PRECT arg1)
1207	{
1208	#ifdef DEBUG
1209	WriteLog("USER32: GetClipCursor\n");
1210	#endif
1211	return O32_GetClipCursor(arg1);
1212	}
1213	//******************************************************************************
1214	//******************************************************************************
1215	HANDLE WIN32API GetClipboardData( UINT arg1)
1216	{
1217	#ifdef DEBUG
1218	WriteLog("USER32: GetClipboardData\n");
1219	#endif
1220	return O32_GetClipboardData(arg1);
1221	}
1222	//******************************************************************************
1223	//******************************************************************************
1224	int WIN32API GetClipboardFormatNameA( UINT arg1, LPSTR arg2, int arg3)
1225	{
1226	#ifdef DEBUG
1227	WriteLog("USER32: GetClipboardFormatNameA %s\n", arg2);
1228	#endif
1229	return O32_GetClipboardFormatName(arg1, arg2, arg3);
1230	}
1231	//******************************************************************************
1232	//******************************************************************************
1233	int WIN32API GetClipboardFormatNameW(UINT arg1, LPWSTR arg2, int arg3)
1234	{
1235	int rc;
1236	char *astring = UnicodeToAsciiString(arg2);
1237
1238	#ifdef DEBUG
1239	WriteLog("USER32: GetClipboardFormatNameW %s\n", astring);
1240	#endif
1241	rc = O32_GetClipboardFormatName(arg1, astring, arg3);
1242	FreeAsciiString(astring);
1243	return(rc);
1244	}
1245	//******************************************************************************
1246	//******************************************************************************
1247	HWND WIN32API GetClipboardOwner(void)
1248	{
1249	#ifdef DEBUG
1250	WriteLog("USER32: GetClipboardOwner\n");
1251	#endif
1252	return O32_GetClipboardOwner();
1253	}
1254	//******************************************************************************
1255	//******************************************************************************
1256	HWND WIN32API GetClipboardViewer(void)
1257	{
1258	#ifdef DEBUG
1259	WriteLog("USER32: GetClipboardViewer\n");
1260	#endif
1261	return O32_GetClipboardViewer();
1262	}
1263	//******************************************************************************
1264	//******************************************************************************
1265	DWORD WIN32API GetDialogBaseUnits(void)
1266	{
1267	#ifdef DEBUG
1268	WriteLog("USER32: GetDialogBaseUnits\n");
1269	#endif
1270	return O32_GetDialogBaseUnits();
1271	}
1272	//******************************************************************************
1273	//******************************************************************************
1274	UINT WIN32API GetDlgItemInt( HWND arg1, int arg2, PBOOL arg3, BOOL arg4)
1275	{
1276	#ifdef DEBUG
1277	WriteLog("USER32: GetDlgItemInt\n");
1278	#endif
1279	return O32_GetDlgItemInt(arg1, arg2, arg3, arg4);
1280	}
1281
1282
1283	/*****************************************************************************
1284	* Name : UINT WIN32API GetDlgItemTextW
1285	* Purpose : Determine the text of a window control
1286	* Parameters: HWND arg1
1287	* int arg2
1288	* LPWSTR arg3
1289	* UINT arg4
1290	* Variables :
1291	* Result :
1292	* Remark :
1293	* Status : UNTESTED UNKNOWN STUB
1294	*
1295	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
1296	*****************************************************************************/
1297
1298	UINT WIN32API GetDlgItemTextW(HWND arg1,
1299	int arg2,
1300	LPWSTR arg3,
1301	UINT arg4)
1302	{
1303	LPSTR lpBuffer; /* temporary buffer for the ascii result */
1304	UINT uiResult; /* return value of the ascii variant */
1305
1306	dprintf(("USER32: GetDlgItemTextW(%08xh,%08xh,%08xh,%08xh)\n",
1307	arg1,
1308	arg2,
1309	arg3,
1310	arg4));
1311
1312
1313	lpBuffer = (LPSTR)malloc(arg4); /* allocate temporary buffer */
1314	uiResult = GetDlgItemTextA(arg1, /* call ascii variant */
1315	arg2,
1316	lpBuffer,
1317	arg4);
1318
1319	AsciiToUnicodeN(lpBuffer, /* now convert result to unicode */
1320	arg3,
1321	arg4);
1322
1323	free(lpBuffer); /* free the temporary buffer */
1324
1325	return (uiResult); /* OK, that's it */
1326	}
1327
1328
1329	//******************************************************************************
1330	//******************************************************************************
1331	UINT WIN32API GetDoubleClickTime(void)
1332	{
1333	#ifdef DEBUG
1334	WriteLog("USER32: GetDoubleClickTime\n");
1335	#endif
1336	return O32_GetDoubleClickTime();
1337	}
1338	//******************************************************************************
1339	//******************************************************************************
1340	HWND WIN32API GetForegroundWindow(void)
1341	{
1342	#ifdef DEBUG
1343	WriteLog("USER32: GetForegroundWindow\n");
1344	#endif
1345	return O32_GetForegroundWindow();
1346	}
1347	//******************************************************************************
1348	//******************************************************************************
1349	BOOL WIN32API GetIconInfo( HICON arg1, LPICONINFO arg2)
1350	{
1351	#ifdef DEBUG
1352	WriteLog("USER32: GetIconInfo\n");
1353	#endif
1354	return O32_GetIconInfo(arg1, arg2);
1355	}
1356	//******************************************************************************
1357	//******************************************************************************
1358	int WIN32API GetKeyNameTextA( LPARAM arg1, LPSTR arg2, int arg3)
1359	{
1360	#ifdef DEBUG
1361	WriteLog("USER32: GetKeyNameTextA\n");
1362	#endif
1363	return O32_GetKeyNameText(arg1, arg2, arg3);
1364	}
1365	//******************************************************************************
1366	//******************************************************************************
1367	int WIN32API GetKeyNameTextW( LPARAM arg1, LPWSTR arg2, int arg3)
1368	{
1369	#ifdef DEBUG
1370	WriteLog("USER32: GetKeyNameTextW DOES NOT WORK\n");
1371	#endif
1372	// NOTE: This will not work as is (needs UNICODE support)
1373	return 0;
1374	// return O32_GetKeyNameText(arg1, arg2, arg3);
1375	}
1376	//******************************************************************************
1377	//******************************************************************************
1378	int WIN32API GetKeyboardType( int arg1)
1379	{
1380	#ifdef DEBUG
1381	WriteLog("USER32: GetKeyboardType\n");
1382	#endif
1383	return O32_GetKeyboardType(arg1);
1384	}
1385	//******************************************************************************
1386	//******************************************************************************
1387	HWND WIN32API GetLastActivePopup( HWND arg1)
1388	{
1389	#ifdef DEBUG
1390	WriteLog("USER32: GetLastActivePopup\n");
1391	#endif
1392	return O32_GetLastActivePopup(arg1);
1393	}
1394	//******************************************************************************
1395	//******************************************************************************
1396	LONG WIN32API GetMessageExtraInfo(void)
1397	{
1398	dprintf(("USER32: GetMessageExtraInfo\n"));
1399	return O32_GetMessageExtraInfo();
1400	}
1401	//******************************************************************************
1402	//******************************************************************************
1403	DWORD WIN32API GetMessagePos(void)
1404	{
1405	dprintf(("USER32: GetMessagePos\n"));
1406	return O32_GetMessagePos();
1407	}
1408	//******************************************************************************
1409	//******************************************************************************
1410	LONG WIN32API GetMessageTime(void)
1411	{
1412	dprintf(("USER32: GetMessageTime\n"));
1413	return O32_GetMessageTime();
1414	}
1415	//******************************************************************************
1416	//******************************************************************************
1417	BOOL WIN32API GetMessageW(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
1418	{
1419	BOOL rc;
1420
1421	// NOTE: This will not work as is (needs UNICODE support)
1422	rc = O32_GetMessage(arg1, arg2, arg3, arg4);
1423	dprintf(("USER32: GetMessageW %X returned %d\n", arg2, rc));
1424	return(rc);
1425	}
1426	//******************************************************************************
1427	//******************************************************************************
1428	HWND WIN32API GetNextDlgGroupItem( HWND arg1, HWND arg2, BOOL arg3)
1429	{
1430	#ifdef DEBUG
1431	WriteLog("USER32: GetNextDlgGroupItem\n");
1432	#endif
1433	return O32_GetNextDlgGroupItem(arg1, arg2, arg3);
1434	}
1435	//******************************************************************************
1436	//******************************************************************************
1437	HWND WIN32API GetOpenClipboardWindow(void)
1438	{
1439	#ifdef DEBUG
1440	WriteLog("USER32: GetOpenClipboardWindow\n");
1441	#endif
1442	return O32_GetOpenClipboardWindow();
1443	}
1444	//******************************************************************************
1445	//******************************************************************************
1446	int WIN32API GetPriorityClipboardFormat( PUINT arg1, int arg2)
1447	{
1448	#ifdef DEBUG
1449	WriteLog("USER32: GetPriorityClipboardFormat\n");
1450	#endif
1451	return O32_GetPriorityClipboardFormat(arg1, arg2);
1452	}
1453	//******************************************************************************
1454	//******************************************************************************
1455	HANDLE WIN32API GetPropA( HWND arg1, LPCSTR arg2)
1456	{
1457	#ifdef DEBUG
1458	if((int)arg2 >> 16 != 0)
1459	WriteLog("USER32: GetPropA %s\n", arg2);
1460	else WriteLog("USER32: GetPropA %X\n", arg2);
1461	#endif
1462	return O32_GetProp(arg1, arg2);
1463	}
1464	//******************************************************************************
1465	//******************************************************************************
1466	HANDLE WIN32API GetPropW(HWND arg1, LPCWSTR arg2)
1467	{
1468	BOOL handle;
1469	char *astring;
1470
1471	if((int)arg2 >> 16 != 0)
1472	astring = UnicodeToAsciiString((LPWSTR)arg2);
1473	else astring = (char *)arg2;
1474	#ifdef DEBUG
1475	if((int)arg2 >> 16 != 0)
1476	WriteLog("USER32: GetPropW %s\n", astring);
1477	else WriteLog("USER32: GetPropW %X\n", astring);
1478	#endif
1479	handle = GetPropA(arg1, (LPCSTR)astring);
1480	if((int)arg2 >> 16 != 0)
1481	FreeAsciiString(astring);
1482
1483	return(handle);
1484	}
1485	//******************************************************************************
1486	//******************************************************************************
1487	DWORD WIN32API GetQueueStatus( UINT arg1)
1488	{
1489	#ifdef DEBUG
1490	WriteLog("USER32: GetQueueStatus\n");
1491	#endif
1492	return O32_GetQueueStatus(arg1);
1493	}
1494	//******************************************************************************
1495	//******************************************************************************
1496	int WIN32API GetScrollPos(HWND hwnd, int fnBar)
1497	{
1498	int pos;
1499
1500	pos = O32_GetScrollPos(hwnd, fnBar);
1501	#ifdef DEBUG
1502	WriteLog("USER32: GetScrollPos of %X type %d returned %d\n", hwnd, fnBar, pos);
1503	#endif
1504	return(pos);
1505	}
1506	//******************************************************************************
1507	//******************************************************************************
1508	BOOL WIN32API GetScrollRange( HWND arg1, int arg2, int * arg3, int * arg4)
1509	{
1510	#ifdef DEBUG
1511	WriteLog("USER32: GetScrollRange\n");
1512	#endif
1513	return O32_GetScrollRange(arg1, arg2, arg3, arg4);
1514	}
1515	//******************************************************************************
1516	//******************************************************************************
1517	DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
1518	{
1519	#ifdef DEBUG
1520	WriteLog("USER32: GetTabbedTextExtentA\n");
1521	#endif
1522	return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
1523	}
1524	//******************************************************************************
1525	//******************************************************************************
1526	DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
1527	{
1528	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1529	DWORD rc;
1530
1531	#ifdef DEBUG
1532	WriteLog("USER32: GetTabbedTextExtentW\n");
1533	#endif
1534	rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
1535	FreeAsciiString(astring);
1536	return rc;
1537	}
1538	//******************************************************************************
1539	//******************************************************************************
1540	int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL arg3)
1541	{
1542	#ifdef DEBUG
1543	WriteLog("USER32: GetUpdateRgn\n");
1544	#endif
1545	return O32_GetUpdateRgn(arg1, arg2, arg3);
1546	}
1547	//******************************************************************************
1548	//******************************************************************************
1549	BOOL WIN32API GetWindowPlacement( HWND arg1, LPWINDOWPLACEMENT arg2)
1550	{
1551	#ifdef DEBUG
1552	WriteLog("USER32: GetWindowPlacement\n");
1553	#endif
1554	return O32_GetWindowPlacement(arg1, arg2);
1555	}
1556	//******************************************************************************
1557
1558
1559	//******************************************************************************
1560	int WIN32API GetWindowTextLengthW( HWND arg1)
1561	{
1562	#ifdef DEBUG
1563	WriteLog("USER32: GetWindowTextLengthW\n");
1564	#endif
1565	return O32_GetWindowTextLength(arg1);
1566	}
1567	//******************************************************************************
1568	//******************************************************************************
1569	int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
1570	{
1571	char title[128];
1572	int rc;
1573
1574	rc = O32_GetWindowText(hwnd, title, sizeof(title));
1575	#ifdef DEBUG
1576	WriteLog("USER32: GetWindowTextW returned %s\n", title);
1577	#endif
1578	if(rc > cch) {
1579	title[cch-1] = 0;
1580	rc = cch;
1581	}
1582	AsciiToUnicode(title, lpsz);
1583	return(rc);
1584	}
1585	//******************************************************************************
1586	//******************************************************************************
1587	DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD arg2)
1588	{
1589	#ifdef DEBUG
1590	WriteLog("USER32: GetWindowThreadProcessId\n");
1591	#endif
1592	return O32_GetWindowThreadProcessId(arg1, arg2);
1593	}
1594	//******************************************************************************
1595	//******************************************************************************
1596	BOOL WIN32API HideCaret( HWND arg1)
1597	{
1598	#ifdef DEBUG
1599	WriteLog("USER32: HideCaret\n");
1600	#endif
1601	return O32_HideCaret(arg1);
1602	}
1603	//******************************************************************************
1604	//******************************************************************************
1605	BOOL WIN32API IntersectRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
1606	{
1607	#ifdef DEBUG
1608	//// WriteLog("USER32: IntersectRect\n");
1609	#endif
1610	return O32_IntersectRect(arg1, arg2, arg3);
1611	}
1612	//******************************************************************************
1613	//******************************************************************************
1614	BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL arg3)
1615	{
1616	#ifdef DEBUG
1617	WriteLog("USER32: InvalidateRgn\n");
1618	#endif
1619	return O32_InvalidateRgn(arg1, arg2, arg3);
1620	}
1621	//******************************************************************************
1622	//******************************************************************************
1623	BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
1624	{
1625	#ifdef DEBUG
1626	WriteLog("USER32: InvertRect\n");
1627	#endif
1628	return O32_InvertRect(arg1, arg2);
1629	}
1630	//******************************************************************************
1631	//******************************************************************************
1632	BOOL WIN32API IsClipboardFormatAvailable( UINT arg1)
1633	{
1634	#ifdef DEBUG
1635	WriteLog("USER32: IsClipboardFormatAvailable\n");
1636	#endif
1637	return O32_IsClipboardFormatAvailable(arg1);
1638	}
1639	//******************************************************************************
1640	//******************************************************************************
1641	BOOL WIN32API IsRectEmpty( const RECT * arg1)
1642	{
1643	#ifdef DEBUG
1644	WriteLog("USER32: IsRectEmpty\n");
1645	#endif
1646	return O32_IsRectEmpty(arg1);
1647	}
1648	//******************************************************************************
1649	//******************************************************************************
1650	BOOL WIN32API MapDialogRect( HWND arg1, PRECT arg2)
1651	{
1652	#ifdef DEBUG
1653	WriteLog("USER32: MapDialogRect\n");
1654	#endif
1655	return O32_MapDialogRect(arg1, arg2);
1656	}
1657	//******************************************************************************
1658	//******************************************************************************
1659	UINT WIN32API MapVirtualKeyA( UINT arg1, UINT arg2)
1660	{
1661	#ifdef DEBUG
1662	WriteLog("USER32: MapVirtualKeyA\n");
1663	#endif
1664	return O32_MapVirtualKey(arg1, arg2);
1665	}
1666	//******************************************************************************
1667	//******************************************************************************
1668	UINT WIN32API MapVirtualKeyW( UINT arg1, UINT arg2)
1669	{
1670	#ifdef DEBUG
1671	WriteLog("USER32: MapVirtualKeyW\n");
1672	#endif
1673	// NOTE: This will not work as is (needs UNICODE support)
1674	return O32_MapVirtualKey(arg1, arg2);
1675	}
1676	//******************************************************************************
1677	//******************************************************************************
1678	int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
1679	{
1680	#ifdef DEBUG
1681	WriteLog("USER32: MapWindowPoints\n");
1682	#endif
1683	return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
1684	}
1685	//******************************************************************************
1686	//******************************************************************************
1687	BOOL WIN32API OpenClipboard( HWND arg1)
1688	{
1689	#ifdef DEBUG
1690	WriteLog("USER32: OpenClipboard\n");
1691	#endif
1692	return O32_OpenClipboard(arg1);
1693	}
1694	//******************************************************************************
1695	//******************************************************************************
1696	BOOL WIN32API PtInRect( const RECT * arg1, POINT arg2)
1697	{
1698	#ifdef DEBUG1
1699	WriteLog("USER32: PtInRect\n");
1700	#endif
1701	return O32_PtInRect(arg1, arg2);
1702	}
1703	//******************************************************************************
1704	//******************************************************************************
1705	UINT WIN32API RegisterClipboardFormatA( LPCSTR arg1)
1706	{
1707	#ifdef DEBUG
1708	WriteLog("USER32: RegisterClipboardFormatA\n");
1709	#endif
1710	return O32_RegisterClipboardFormat(arg1);
1711	}
1712	//******************************************************************************
1713	//******************************************************************************
1714	UINT WIN32API RegisterClipboardFormatW(LPCWSTR arg1)
1715	{
1716	UINT rc;
1717	char *astring = UnicodeToAsciiString((LPWSTR)arg1);
1718
1719	#ifdef DEBUG
1720	WriteLog("USER32: RegisterClipboardFormatW %s\n", astring);
1721	#endif
1722	rc = O32_RegisterClipboardFormat(astring);
1723	FreeAsciiString(astring);
1724	#ifdef DEBUG
1725	WriteLog("USER32: RegisterClipboardFormatW returned %d\n", rc);
1726	#endif
1727	return(rc);
1728	}
1729	//******************************************************************************
1730	//******************************************************************************
1731	HANDLE WIN32API RemovePropA( HWND arg1, LPCSTR arg2)
1732	{
1733	#ifdef DEBUG
1734	WriteLog("USER32: RemovePropA\n");
1735	#endif
1736	return O32_RemoveProp(arg1, arg2);
1737	}
1738	//******************************************************************************
1739	//******************************************************************************
1740	HANDLE WIN32API RemovePropW( HWND arg1, LPCWSTR arg2)
1741	{
1742	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1743	HANDLE rc;
1744
1745	#ifdef DEBUG
1746	WriteLog("USER32: RemovePropW\n");
1747	#endif
1748	rc = O32_RemoveProp(arg1, astring);
1749	FreeAsciiString(astring);
1750	return rc;
1751	}
1752	//******************************************************************************
1753	//******************************************************************************
1754	BOOL WIN32API ScreenToClient( HWND arg1, LPPOINT arg2)
1755	{
1756	#ifdef DEBUG
1757	WriteLog("USER32: ScreenToClient\n");
1758	#endif
1759	return O32_ScreenToClient(arg1, arg2);
1760	}
1761	//******************************************************************************
1762	//******************************************************************************
1763	BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7)
1764	{
1765	#ifdef DEBUG
1766	WriteLog("USER32: ScrollDC\n");
1767	#endif
1768	return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1769	}
1770	//******************************************************************************
1771	//******************************************************************************
1772	BOOL WIN32API ScrollWindow( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5)
1773	{
1774	#ifdef DEBUG
1775	WriteLog("USER32: ScrollWindow\n");
1776	#endif
1777	return O32_ScrollWindow(arg1, arg2, arg3, arg4, arg5);
1778	}
1779	//******************************************************************************
1780	//******************************************************************************
1781	BOOL WIN32API ScrollWindowEx( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7, UINT arg8)
1782	{
1783	#ifdef DEBUG
1784	WriteLog("USER32: ScrollWindowEx\n");
1785	#endif
1786	return O32_ScrollWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1787	}
1788	//******************************************************************************
1789	//******************************************************************************
1790	BOOL WIN32API SetCaretBlinkTime( UINT arg1)
1791	{
1792	#ifdef DEBUG
1793	WriteLog("USER32: SetCaretBlinkTime\n");
1794	#endif
1795	return O32_SetCaretBlinkTime(arg1);
1796	}
1797	//******************************************************************************
1798	//******************************************************************************
1799	BOOL WIN32API SetCaretPos( int arg1, int arg2)
1800	{
1801	dprintf(("USER32: SetCaretPos\n"));
1802	return O32_SetCaretPos(arg1, arg2);
1803	}
1804	//******************************************************************************
1805	//******************************************************************************
1806	HANDLE WIN32API SetClipboardData( UINT arg1, HANDLE arg2)
1807	{
1808	dprintf(("USER32: SetClipboardData\n"));
1809	return O32_SetClipboardData(arg1, arg2);
1810	}
1811	//******************************************************************************
1812	//******************************************************************************
1813	HWND WIN32API SetClipboardViewer( HWND arg1)
1814	{
1815	dprintf(("USER32: SetClipboardViewer\n"));
1816	return O32_SetClipboardViewer(arg1);
1817	}
1818	//******************************************************************************
1819	//******************************************************************************
1820	BOOL WIN32API SetDlgItemTextW( HWND arg1, int arg2, LPCWSTR arg3)
1821	{
1822	char *astring = UnicodeToAsciiString((LPWSTR)arg3);
1823	BOOL rc;
1824
1825	#ifdef DEBUG
1826	WriteLog("USER32: SetDlgItemTextW\n");
1827	#endif
1828	// NOTE: This will not work as is (needs UNICODE support)
1829	rc = O32_SetDlgItemText(arg1, arg2, astring);
1830	FreeAsciiString(astring);
1831	return rc;
1832	}
1833	//******************************************************************************
1834	//******************************************************************************
1835	BOOL WIN32API SetDoubleClickTime( UINT arg1)
1836	{
1837	#ifdef DEBUG
1838	WriteLog("USER32: SetDoubleClickTime\n");
1839	#endif
1840	return O32_SetDoubleClickTime(arg1);
1841	}
1842	//******************************************************************************
1843	//******************************************************************************
1844	BOOL WIN32API SetPropA( HWND arg1, LPCSTR arg2, HANDLE arg3)
1845	{
1846	#ifdef DEBUG
1847	if((int)arg2 >> 16 != 0)
1848	WriteLog("USER32: SetPropA %S\n", arg2);
1849	else WriteLog("USER32: SetPropA %X\n", arg2);
1850	#endif
1851	return O32_SetProp(arg1, arg2, arg3);
1852	}
1853	//******************************************************************************
1854	//******************************************************************************
1855	BOOL WIN32API SetPropW(HWND arg1, LPCWSTR arg2, HANDLE arg3)
1856	{
1857	BOOL rc;
1858	char *astring;
1859
1860	if((int)arg2 >> 16 != 0)
1861	astring = UnicodeToAsciiString((LPWSTR)arg2);
1862	else astring = (char *)arg2;
1863
1864	#ifdef DEBUG
1865	if((int)arg2 >> 16 != 0)
1866	WriteLog("USER32: SetPropW %S\n", astring);
1867	else WriteLog("USER32: SetPropW %X\n", astring);
1868	#endif
1869	rc = O32_SetProp(arg1, astring, arg3);
1870	if((int)astring >> 16 != 0)
1871	FreeAsciiString(astring);
1872	return(rc);
1873	}
1874	//******************************************************************************
1875	//******************************************************************************
1876	BOOL WIN32API SetRectEmpty( PRECT arg1)
1877	{
1878	#ifdef DEBUG
1879	WriteLog("USER32: SetRectEmpty\n");
1880	#endif
1881	return O32_SetRectEmpty(arg1);
1882	}
1883	//******************************************************************************
1884	//******************************************************************************
1885	int WIN32API SetScrollPos( HWND arg1, int arg2, int arg3, BOOL arg4)
1886	{
1887	#ifdef DEBUG
1888	WriteLog("USER32: SetScrollPos\n");
1889	#endif
1890	return O32_SetScrollPos(arg1, arg2, arg3, arg4);
1891	}
1892	//******************************************************************************
1893	//******************************************************************************
1894	BOOL WIN32API SetScrollRange( HWND arg1, int arg2, int arg3, int arg4, BOOL arg5)
1895	{
1896	#ifdef DEBUG
1897	WriteLog("USER32: SetScrollRange\n");
1898	#endif
1899	return O32_SetScrollRange(arg1, arg2, arg3, arg4, arg5);
1900	}
1901	//******************************************************************************
1902	//******************************************************************************
1903	BOOL WIN32API SetWindowPlacement( HWND arg1, const WINDOWPLACEMENT * arg2)
1904	{
1905	dprintf(("USER32: SetWindowPlacement\n"));
1906	return O32_SetWindowPlacement(arg1, arg2);
1907	}
1908	//******************************************************************************
1909	//******************************************************************************
1910	BOOL WIN32API ShowCaret( HWND arg1)
1911	{
1912	dprintf(("USER32: ShowCaret\n"));
1913	return O32_ShowCaret(arg1);
1914	}
1915	//******************************************************************************
1916	//******************************************************************************
1917	BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
1918	{
1919	dprintf(("USER32: ShowOwnedPopups\n"));
1920	return O32_ShowOwnedPopups(arg1, arg2);
1921	}
1922	//******************************************************************************
1923	//******************************************************************************
1924	BOOL WIN32API ShowScrollBar( HWND arg1, int arg2, BOOL arg3)
1925	{
1926	#ifdef DEBUG
1927	WriteLog("USER32: ShowScrollBar\n");
1928	#endif
1929	return O32_ShowScrollBar(arg1, arg2, arg3);
1930	}
1931	//******************************************************************************
1932	//******************************************************************************
1933	BOOL WIN32API SwapMouseButton( BOOL arg1)
1934	{
1935	#ifdef DEBUG
1936	WriteLog("USER32: SwapMouseButton\n");
1937	#endif
1938	return O32_SwapMouseButton(arg1);
1939	}
1940	//******************************************************************************
1941	//******************************************************************************
1942	BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
1943	{
1944	BOOL rc;
1945	NONCLIENTMETRICSA cmetric = (NONCLIENTMETRICSA )pvParam;
1946
1947	switch(uiAction) {
1948	case SPI_SCREENSAVERRUNNING:
1949	(BOOL )pvParam = FALSE;
1950	rc = TRUE;
1951	break;
1952	case SPI_GETDRAGFULLWINDOWS:
1953	(BOOL )pvParam = FALSE;
1954	rc = TRUE;
1955	break;
1956	case SPI_GETNONCLIENTMETRICS:
1957	memset(cmetric, 0, sizeof(NONCLIENTMETRICSA));
1958	cmetric->cbSize = sizeof(NONCLIENTMETRICSA);
1959	//CB: font info not valid, needs improvements
1960	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfCaptionFont),0);
1961	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMenuFont),0);
1962	//CB: experimental change for statusbar (and tooltips)
1963
1964	//O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfStatusFont),0);
1965	lstrcpyA(cmetric->lfStatusFont.lfFaceName,"WarpSans");
1966	cmetric->lfStatusFont.lfHeight = 9;
1967
1968	O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMessageFont),0);
1969	cmetric->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
1970	cmetric->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
1971	cmetric->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
1972	cmetric->iCaptionWidth = 32; //TODO
1973	cmetric->iCaptionHeight = 16; //TODO
1974	cmetric->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
1975	cmetric->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
1976	cmetric->iMenuWidth = 32; //TODO
1977	cmetric->iMenuHeight = GetSystemMetrics(SM_CYMENU);
1978	rc = TRUE;
1979	break;
1980	case 104: //TODO: Undocumented
1981	rc = 16;
1982	break;
1983	default:
1984	rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
1985	break;
1986	}
1987	#ifdef DEBUG
1988	WriteLog("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc);
1989	#endif
1990	return(rc);
1991	}
1992	//******************************************************************************
1993	//TODO: Check for more options that have different structs for Unicode!!!!
1994	//******************************************************************************
1995	BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
1996	{
1997	BOOL rc;
1998	NONCLIENTMETRICSW clientMetricsW = (NONCLIENTMETRICSW )pvParam;
1999	NONCLIENTMETRICSA clientMetricsA = {0};
2000	PVOID pvParamA;
2001	UINT uiParamA;
2002
2003	switch(uiAction) {
2004	case SPI_SETNONCLIENTMETRICS:
2005	clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
2006	clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
2007	clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
2008	clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
2009	clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
2010	clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
2011	ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
2012	clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
2013	clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
2014	ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
2015	clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
2016	clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
2017	ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
2018	ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
2019	ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
2020	//no break
2021	case SPI_GETNONCLIENTMETRICS:
2022	uiParamA = sizeof(NONCLIENTMETRICSA);
2023	pvParamA = &clientMetricsA;
2024	break;
2025	default:
2026	pvParamA = pvParam;
2027	uiParamA = uiParam;
2028	break;
2029	}
2030	rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
2031
2032	switch(uiAction) {
2033	case SPI_GETNONCLIENTMETRICS:
2034	clientMetricsW->cbSize = sizeof(*clientMetricsW);
2035	clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
2036	clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
2037	clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
2038	clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
2039	clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
2040	ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
2041
2042	clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
2043	clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
2044	ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
2045
2046	clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
2047	clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
2048	ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
2049	ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
2050	ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
2051	break;
2052	}
2053	#ifdef DEBUG
2054	WriteLog("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc);
2055	#endif
2056	return(rc);
2057	}
2058	//******************************************************************************
2059	//******************************************************************************
2060	LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int arg8)
2061	{
2062	#ifdef DEBUG
2063	WriteLog("USER32: TabbedTextOutA\n");
2064	#endif
2065	return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2066	}
2067	//******************************************************************************
2068	//******************************************************************************
2069	LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int arg8)
2070	{
2071	char *astring = UnicodeToAsciiString((LPWSTR)arg4);
2072	LONG rc;
2073
2074	#ifdef DEBUG
2075	WriteLog("USER32: TabbedTextOutW\n");
2076	#endif
2077	rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
2078	FreeAsciiString(astring);
2079	return rc;
2080	}
2081	//******************************************************************************
2082	//******************************************************************************
2083	int WIN32API TranslateAccelerator( HWND arg1, HACCEL arg2, LPMSG arg3)
2084	{
2085	#ifdef DEBUG
2086	WriteLog("USER32: TranslateAccelerator\n");
2087	#endif
2088	return O32_TranslateAccelerator(arg1, arg2, arg3);
2089	}
2090	//******************************************************************************
2091	//******************************************************************************
2092	int WIN32API TranslateAcceleratorW( HWND arg1, HACCEL arg2, LPMSG arg3)
2093	{
2094	#ifdef DEBUG
2095	WriteLog("USER32: TranslateAcceleratorW\n");
2096	#endif
2097	// NOTE: This will not work as is (needs UNICODE support)
2098	return O32_TranslateAccelerator(arg1, arg2, arg3);
2099	}
2100	//******************************************************************************
2101	//******************************************************************************
2102	BOOL WIN32API TranslateMDISysAccel( HWND arg1, LPMSG arg2)
2103	{
2104	#ifdef DEBUG
2105	//// WriteLog("USER32: TranslateMDISysAccel\n");
2106	#endif
2107	return O32_TranslateMDISysAccel(arg1, arg2);
2108	}
2109	//******************************************************************************
2110	//******************************************************************************
2111	BOOL WIN32API UnionRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
2112	{
2113	#ifdef DEBUG
2114	WriteLog("USER32: UnionRect\n");
2115	#endif
2116	return O32_UnionRect(arg1, arg2, arg3);
2117	}
2118	//******************************************************************************
2119	//******************************************************************************
2120	BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
2121	{
2122	#ifdef DEBUG
2123	WriteLog("USER32: ValidateRect\n");
2124	#endif
2125	return O32_ValidateRect(arg1, arg2);
2126	}
2127	//******************************************************************************
2128	//******************************************************************************
2129	BOOL WIN32API ValidateRgn( HWND arg1, HRGN arg2)
2130	{
2131	#ifdef DEBUG
2132	WriteLog("USER32: ValidateRgn\n");
2133	#endif
2134	return O32_ValidateRgn(arg1, arg2);
2135	}
2136	//******************************************************************************
2137	//******************************************************************************
2138	WORD WIN32API VkKeyScanW( WCHAR arg1)
2139	{
2140	#ifdef DEBUG
2141	WriteLog("USER32: VkKeyScanW\n");
2142	#endif
2143	// NOTE: This will not work as is (needs UNICODE support)
2144	return O32_VkKeyScan((char)arg1);
2145	}
2146	//******************************************************************************
2147	//******************************************************************************
2148	BOOL WIN32API WinHelpW( HWND arg1, LPCWSTR arg2, UINT arg3, DWORD arg4)
2149	{
2150	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2151	BOOL rc;
2152
2153	#ifdef DEBUG
2154	WriteLog("USER32: WinHelpW\n");
2155	#endif
2156	rc = WinHelpA(arg1, astring, arg3, arg4);
2157	FreeAsciiString(astring);
2158	return rc;
2159	}
2160	//******************************************************************************
2161	//******************************************************************************
2162	int WIN32API wvsprintfA( LPSTR arg1, LPCSTR arg2, va_list arg3)
2163	{
2164	#ifdef DEBUG
2165	WriteLog("USER32: wvsprintfA\n");
2166	#endif
2167	return O32_wvsprintf(arg1, arg2, (LPCVOID *)arg3);
2168	}
2169	//******************************************************************************
2170	//******************************************************************************
2171	int WIN32API wvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, va_list argptr)
2172	{
2173	int rc;
2174	char szOut[256];
2175	char *lpFmtA;
2176
2177	lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
2178	#ifdef DEBUG
2179	WriteLog("USER32: wvsprintfW, DOES NOT HANDLE UNICODE STRINGS!\n");
2180	WriteLog("USER32: %s\n", lpFmt);
2181	#endif
2182	rc = O32_wvsprintf(szOut, lpFmtA, (LPCVOID)argptr);
2183
2184	AsciiToUnicode(szOut, lpOut);
2185	#ifdef DEBUG
2186	WriteLog("USER32: %s\n", lpOut);
2187	#endif
2188	FreeAsciiString(lpFmtA);
2189	return(rc);
2190	}
2191	//******************************************************************************
2192	//TODO: Not complete
2193	//******************************************************************************
2194	BOOL WIN32API GetScrollInfo(HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
2195	{
2196	#ifdef DEBUG
2197	WriteLog("USER32: GetScrollInfo\n");
2198	#endif
2199	if(lpsi == NULL)
2200	return(FALSE);
2201
2202	if(lpsi->fMask & SIF_POS)
2203	lpsi->nPos = GetScrollPos(hwnd, fnBar);
2204	if(lpsi->fMask & SIF_RANGE)
2205	GetScrollRange(hwnd, fnBar, &lpsi->nMin, &lpsi->nMax);
2206	if(lpsi->fMask & SIF_PAGE) {
2207	#ifdef DEBUG
2208	WriteLog("USER32: GetScrollInfo, page info not implemented\n");
2209	#endif
2210	lpsi->nPage = 25;
2211	}
2212	return(TRUE);
2213	}
2214	//******************************************************************************
2215	//TODO: Not complete
2216	//******************************************************************************
2217	INT WIN32API SetScrollInfo(HWND hwnd, INT fnBar, const SCROLLINFO *lpsi, BOOL fRedraw)
2218	{
2219	int smin, smax;
2220
2221	#ifdef DEBUG
2222	WriteLog("USER32: SetScrollInfo\n");
2223	#endif
2224	if(lpsi == NULL)
2225	return(FALSE);
2226
2227	if(lpsi->fMask & SIF_POS)
2228	SetScrollPos(hwnd, fnBar, lpsi->nPos, fRedraw);
2229	if(lpsi->fMask & SIF_RANGE)
2230	SetScrollRange(hwnd, fnBar, lpsi->nMin, lpsi->nMax, fRedraw);
2231	if(lpsi->fMask & SIF_PAGE) {
2232	#ifdef DEBUG
2233	WriteLog("USER32: GetScrollInfo, page info not implemented\n");
2234	#endif
2235	}
2236	if(lpsi->fMask & SIF_DISABLENOSCROLL) {
2237	#ifdef DEBUG
2238	WriteLog("USER32: GetScrollInfo, disable scrollbar not yet implemented\n");
2239	#endif
2240	}
2241	return(TRUE);
2242	}
2243	//******************************************************************************
2244	//******************************************************************************
2245	BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
2246	LPARAM lpData, int nCount, int X, int Y, int nWidth,
2247	int nHeight)
2248	{
2249	BOOL rc;
2250	COLORREF curclr;
2251
2252	#ifdef DEBUG
2253	WriteLog("USER32: GrayStringA, not completely implemented\n");
2254	#endif
2255	if(lpOutputFunc == NULL && lpData == NULL) {
2256	#ifdef DEBUG
2257	WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
2258	#endif
2259	return(FALSE);
2260	}
2261	if(lpOutputFunc) {
2262	return(lpOutputFunc(hdc, lpData, nCount));
2263	}
2264	curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
2265	rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
2266	SetTextColor(hdc, curclr);
2267
2268	return(rc);
2269	}
2270	//******************************************************************************
2271	//******************************************************************************
2272	BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
2273	LPARAM lpData, int nCount, int X, int Y, int nWidth,
2274	int nHeight)
2275	{
2276	BOOL rc;
2277	char *astring;
2278	COLORREF curclr;
2279
2280	#ifdef DEBUG
2281	WriteLog("USER32: GrayStringW, not completely implemented\n");
2282	#endif
2283
2284	if(lpOutputFunc == NULL && lpData == NULL) {
2285	#ifdef DEBUG
2286	WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
2287	#endif
2288	return(FALSE);
2289	}
2290	if(nCount == 0)
2291	nCount = UniStrlen((UniChar*)lpData);
2292
2293	if(lpOutputFunc) {
2294	return(lpOutputFunc(hdc, lpData, nCount));
2295	}
2296	astring = UnicodeToAsciiString((LPWSTR)lpData);
2297
2298	curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
2299	rc = TextOutA(hdc, X, Y, astring, nCount);
2300	SetTextColor(hdc, curclr);
2301
2302	FreeAsciiString(astring);
2303	return(rc);
2304	}
2305	//******************************************************************************
2306	//TODO:
2307	//******************************************************************************
2308	int WIN32API CopyAcceleratorTableA(HACCEL hAccelSrc, LPACCEL lpAccelDest,
2309	int cAccelEntries)
2310	{
2311	#ifdef DEBUG
2312	WriteLog("USER32: CopyAcceleratorTableA, not implemented\n");
2313	#endif
2314	return(0);
2315	}
2316	//******************************************************************************
2317	//TODO:
2318	//******************************************************************************
2319	int WIN32API CopyAcceleratorTableW(HACCEL hAccelSrc, LPACCEL lpAccelDest,
2320	int cAccelEntries)
2321	{
2322	#ifdef DEBUG
2323	WriteLog("USER32: CopyAcceleratorTableW, not implemented\n");
2324	#endif
2325	return(0);
2326	}
2327	//******************************************************************************
2328	//******************************************************************************
2329	HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
2330	{
2331	#ifdef DEBUG
2332	WriteLog("USER32: CopyImage, not implemented\n");
2333	#endif
2334	switch(uType) {
2335	case IMAGE_BITMAP:
2336	case IMAGE_CURSOR:
2337	case IMAGE_ICON:
2338	default:
2339	#ifdef DEBUG
2340	WriteLog("USER32: CopyImage, unknown type\n");
2341	#endif
2342	return(NULL);
2343	}
2344	return(NULL);
2345	}
2346	//******************************************************************************
2347	//******************************************************************************
2348	BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
2349	{
2350	#ifdef DEBUG
2351	WriteLog("USER32: GetKeyboardState, not properly implemented\n");
2352	#endif
2353	memset(lpKeyState, 0, 256);
2354	return(TRUE);
2355	}
2356	//******************************************************************************
2357	//******************************************************************************
2358	BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
2359	{
2360	#ifdef DEBUG
2361	WriteLog("USER32: SetKeyboardState, not implemented\n");
2362	#endif
2363	return(TRUE);
2364	}
2365	//******************************************************************************
2366	//2nd parameter not used according to SDK (yet?)
2367	//******************************************************************************
2368	VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
2369	{
2370	#ifdef DEBUG
2371	WriteLog("USER32: SetLastErrorEx\n");
2372	#endif
2373	SetLastError(dwErrCode);
2374	}
2375	//******************************************************************************
2376	//******************************************************************************
2377	BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
2378	{
2379	#ifdef DEBUG
2380	WriteLog("USER32: ActivateKeyboardLayout, not implemented\n");
2381	#endif
2382	return(TRUE);
2383	}
2384	//******************************************************************************
2385	//******************************************************************************
2386	int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
2387	{
2388	#ifdef DEBUG
2389	WriteLog("USER32: GetKeyboardLayoutList, not implemented\n");
2390	#endif
2391	return(0);
2392	}
2393	//******************************************************************************
2394	//******************************************************************************
2395	HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
2396	{
2397	#ifdef DEBUG
2398	WriteLog("USER32: GetKeyboardLayout, not implemented\n");
2399	#endif
2400	return(0);
2401	}
2402	//******************************************************************************
2403	//******************************************************************************
2404	int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
2405	{
2406	#ifdef DEBUG
2407	WriteLog("USER32: LookupIconIdFromDirectory, not implemented\n");
2408	#endif
2409	return(0);
2410	}
2411	//******************************************************************************
2412	//******************************************************************************
2413	int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL fIcon,
2414	int cxDesired, int cyDesired,
2415	UINT Flags)
2416	{
2417	#ifdef DEBUG
2418	WriteLog("USER32: LookupIconIdFromDirectoryEx, not implemented\n");
2419	#endif
2420	return(0);
2421	}
2422	//******************************************************************************
2423	//DWORD idAttach; /* thread to attach */
2424	//DWORD idAttachTo; /* thread to attach to */
2425	//BOOL fAttach; /* attach or detach */
2426	//******************************************************************************
2427	BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
2428	{
2429	#ifdef DEBUG
2430	WriteLog("USER32: AttachThreadInput, not implemented\n");
2431	#endif
2432	return(TRUE);
2433	}
2434	//******************************************************************************
2435	//******************************************************************************
2436	BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
2437	{
2438	#ifdef DEBUG
2439	WriteLog("USER32: RegisterHotKey, not implemented\n");
2440	#endif
2441	return(TRUE);
2442	}
2443	//******************************************************************************
2444	//******************************************************************************
2445	BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
2446	{
2447	#ifdef DEBUG
2448	WriteLog("USER32: UnregisterHotKey, not implemented\n");
2449	#endif
2450	return(TRUE);
2451	}
2452	//******************************************************************************
2453	//******************************************************************************
2454	BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
2455	{
2456	#ifdef DEBUG
2457	WriteLog("USER32: SetWindowContextHelpId, not implemented\n");
2458	#endif
2459	return(TRUE);
2460	}
2461	//******************************************************************************
2462	//******************************************************************************
2463	DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
2464	{
2465	#ifdef DEBUG
2466	WriteLog("USER32: GetWindowContextHelpId, not implemented\n");
2467	#endif
2468	return(0);
2469	}
2470	//******************************************************************************
2471	//restores iconized window to previous size/position
2472	//******************************************************************************
2473	BOOL WIN32API OpenIcon(HWND hwnd)
2474	{
2475	#ifdef DEBUG
2476	WriteLog("USER32: OpenIcon\n");
2477	#endif
2478	if(!IsIconic(hwnd))
2479	return FALSE;
2480	ShowWindow(hwnd, SW_SHOWNORMAL);
2481	return TRUE;
2482	}
2483	//******************************************************************************
2484	//******************************************************************************
2485	BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
2486	{
2487	#ifdef DEBUG
2488	WriteLog("USER32: GetMonitorInfoA not supported!!\n");
2489	#endif
2490	return(FALSE);
2491	}
2492	//******************************************************************************
2493	//******************************************************************************
2494	BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
2495	{
2496	#ifdef DEBUG
2497	WriteLog("USER32: GetMonitorInfoW not supported!!\n");
2498	#endif
2499	return(FALSE);
2500	}
2501	//******************************************************************************
2502	//******************************************************************************
2503	HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
2504	{
2505	#ifdef DEBUG
2506	WriteLog("USER32: MonitorFromWindow not correctly supported??\n");
2507	#endif
2508	return(0);
2509	}
2510	//******************************************************************************
2511	//******************************************************************************
2512	HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
2513	{
2514	#ifdef DEBUG
2515	WriteLog("USER32: MonitorFromRect not correctly supported??\n");
2516	#endif
2517	return(0);
2518	}
2519	//******************************************************************************
2520	//******************************************************************************
2521	HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
2522	{
2523	#ifdef DEBUG
2524	WriteLog("USER32: MonitorFromPoint not correctly supported??\n");
2525	#endif
2526	return(0);
2527	}
2528	//******************************************************************************
2529	//******************************************************************************
2530	BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
2531	{
2532	#ifdef DEBUG
2533	WriteLog("USER32: EnumDisplayMonitors not supported??\n");
2534	#endif
2535	return(FALSE);
2536	}
2537	//******************************************************************************
2538	//******************************************************************************
2539	BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
2540	LPDEVMODEA lpDevMode)
2541	{
2542	#ifdef DEBUG
2543	WriteLog("USER32: EnumDisplaySettingsA FAKED\n");
2544	#endif
2545	switch(iModeNum) {
2546	case 0:
2547	lpDevMode->dmBitsPerPel = 16;
2548	lpDevMode->dmPelsWidth = 768;
2549	lpDevMode->dmPelsHeight = 1024;
2550	lpDevMode->dmDisplayFlags = 0;
2551	lpDevMode->dmDisplayFrequency = 70;
2552	break;
2553	case 1:
2554	lpDevMode->dmBitsPerPel = 16;
2555	lpDevMode->dmPelsWidth = 640;
2556	lpDevMode->dmPelsHeight = 480;
2557	lpDevMode->dmDisplayFlags = 0;
2558	lpDevMode->dmDisplayFrequency = 70;
2559	break;
2560	default:
2561	return(FALSE);
2562	}
2563	return(TRUE);
2564	}
2565	//******************************************************************************
2566	//******************************************************************************
2567	LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA lpDevMode, DWORD dwFlags)
2568	{
2569	#ifdef DEBUG
2570	if(lpDevMode) {
2571	WriteLog("USER32: ChangeDisplaySettingsA FAKED %X\n", dwFlags);
2572	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
2573	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsWidth %d\n", lpDevMode->dmPelsWidth);
2574	WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
2575	}
2576	#endif
2577	return(DISP_CHANGE_SUCCESSFUL);
2578	}
2579	//******************************************************************************
2580	//******************************************************************************
2581
2582
2583	/*****************************************************************************
2584	* Name : BOOL WIN32API AnyPopup
2585	* Purpose : The AnyPopup function indicates whether an owned, visible,
2586	* top-level pop-up, or overlapped window exists on the screen. The
2587	* function searches the entire Windows screen, not just the calling
2588	* application's client area.
2589	* Parameters: VOID
2590	* Variables :
2591	* Result : If a pop-up window exists, the return value is TRUE even if the
2592	* pop-up window is completely covered by other windows. Otherwise,
2593	* it is FALSE.
2594	* Remark : AnyPopup is a Windows version 1.x function and is retained for
2595	* compatibility purposes. It is generally not useful.
2596	* Status : UNTESTED STUB
2597	*
2598	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2599	*****************************************************************************/
2600
2601	BOOL WIN32API AnyPopup(VOID)
2602	{
2603	dprintf(("USER32:AnyPopup() not implemented.\n"));
2604
2605	return (FALSE);
2606	}
2607
2608
2609	/*****************************************************************************
2610	* Name : long WIN32API BroadcastSystemMessage
2611	* Purpose : The BroadcastSystemMessage function sends a message to the given
2612	* recipients. The recipients can be applications, installable
2613	* drivers, Windows-based network drivers, system-level device
2614	* drivers, or any combination of these system components.
2615	* Parameters: DWORD dwFlags,
2616	LPDWORD lpdwRecipients,
2617	UINT uiMessage,
2618	WPARAM wParam,
2619	LPARAM lParam
2620	* Variables :
2621	* Result : If the function succeeds, the return value is a positive value.
2622	* If the function is unable to broadcast the message, the return value is -1.
2623	* If the dwFlags parameter is BSF_QUERY and at least one recipient returned FALSE to the corresponding message, the return value is zero.
2624	* Remark :
2625	* Status : UNTESTED STUB
2626	*
2627	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2628	*****************************************************************************/
2629
2630	long WIN32API BroadcastSystemMessage(DWORD dwFlags,
2631	LPDWORD lpdwRecipients,
2632	UINT uiMessage,
2633	WPARAM wParam,
2634	LPARAM lParam)
2635	{
2636	dprintf(("USER32:BroadcastSystemMessage(%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
2637	dwFlags,
2638	lpdwRecipients,
2639	uiMessage,
2640	wParam,
2641	lParam));
2642
2643	return (-1);
2644	}
2645
2646
2647
2648
2649	/*****************************************************************************
2650	* Name : LONG WIN32API ChangeDisplaySettingsW
2651	* Purpose : The ChangeDisplaySettings function changes the display settings
2652	* to the specified graphics mode.
2653	* Parameters: LPDEVMODEW lpDevModeW
2654	* DWORD dwFlags
2655	* Variables :
2656	* Result : DISP_CHANGE_SUCCESSFUL The settings change was successful.
2657	* DISP_CHANGE_RESTART The computer must be restarted in order for the graphics mode to work.
2658	* DISP_CHANGE_BADFLAGS An invalid set of flags was passed in.
2659	* DISP_CHANGE_FAILED The display driver failed the specified graphics mode.
2660	* DISP_CHANGE_BADMODE The graphics mode is not supported.
2661	* DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
2662	* Remark :
2663	* Status : UNTESTED STUB
2664	*
2665	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2666	*****************************************************************************/
2667
2668	LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
2669	DWORD dwFlags)
2670	{
2671	dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
2672	lpDevMode,
2673	dwFlags));
2674
2675	return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
2676	dwFlags));
2677	}
2678
2679	/*****************************************************************************
2680	* Name : BOOL WIN32API CloseDesktop
2681	* Purpose : The CloseDesktop function closes an open handle of a desktop
2682	* object. A desktop is a secure object contained within a window
2683	* station object. A desktop has a logical display surface and
2684	* contains windows, menus and hooks.
2685	* Parameters: HDESK hDesktop
2686	* Variables :
2687	* Result : If the function succeeds, the return value is TRUE.
2688	* If the functions fails, the return value is FALSE. To get
2689	* extended error information, call GetLastError.
2690	* Remark :
2691	* Status : UNTESTED STUB
2692	*
2693	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2694	*****************************************************************************/
2695
2696	BOOL WIN32API CloseDesktop(HDESK hDesktop)
2697	{
2698	dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
2699	hDesktop));
2700
2701	return (FALSE);
2702	}
2703
2704
2705	/*****************************************************************************
2706	* Name : BOOL WIN32API CloseWindowStation
2707	* Purpose : The CloseWindowStation function closes an open window station handle.
2708	* Parameters: HWINSTA hWinSta
2709	* Variables :
2710	* Result :
2711	* Remark : If the function succeeds, the return value is TRUE.
2712	* If the functions fails, the return value is FALSE. To get
2713	* extended error information, call GetLastError.
2714	* Status : UNTESTED STUB
2715	*
2716	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2717	*****************************************************************************/
2718
2719	BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
2720	{
2721	dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
2722	hWinSta));
2723
2724	return (FALSE);
2725	}
2726
2727
2728	/*****************************************************************************
2729	* Name : HDESK WIN32API CreateDesktopA
2730	* Purpose : The CreateDesktop function creates a new desktop on the window
2731	* station associated with the calling process.
2732	* Parameters: LPCTSTR lpszDesktop name of the new desktop
2733	* LPCTSTR lpszDevice name of display device to assign to the desktop
2734	* LPDEVMODE pDevMode reserved; must be NULL
2735	* DWORD dwFlags flags to control interaction with other applications
2736	* DWORD dwDesiredAccess specifies access of returned handle
2737	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
2738	* Variables :
2739	* Result : If the function succeeds, the return value is a handle of the
2740	* newly created desktop.
2741	* If the function fails, the return value is NULL. To get extended
2742	* error information, call GetLastError.
2743	* Remark :
2744	* Status : UNTESTED STUB
2745	*
2746	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2747	*****************************************************************************/
2748
2749	HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
2750	LPCTSTR lpszDevice,
2751	LPDEVMODEA pDevMode,
2752	DWORD dwFlags,
2753	DWORD dwDesiredAccess,
2754	LPSECURITY_ATTRIBUTES lpsa)
2755	{
2756	dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
2757	lpszDesktop,
2758	lpszDevice,
2759	pDevMode,
2760	dwFlags,
2761	dwDesiredAccess,
2762	lpsa));
2763
2764	return (NULL);
2765	}
2766
2767
2768	/*****************************************************************************
2769	* Name : HDESK WIN32API CreateDesktopW
2770	* Purpose : The CreateDesktop function creates a new desktop on the window
2771	* station associated with the calling process.
2772	* Parameters: LPCTSTR lpszDesktop name of the new desktop
2773	* LPCTSTR lpszDevice name of display device to assign to the desktop
2774	* LPDEVMODE pDevMode reserved; must be NULL
2775	* DWORD dwFlags flags to control interaction with other applications
2776	* DWORD dwDesiredAccess specifies access of returned handle
2777	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
2778	* Variables :
2779	* Result : If the function succeeds, the return value is a handle of the
2780	* newly created desktop.
2781	* If the function fails, the return value is NULL. To get extended
2782	* error information, call GetLastError.
2783	* Remark :
2784	* Status : UNTESTED STUB
2785	*
2786	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2787	*****************************************************************************/
2788
2789	HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
2790	LPCTSTR lpszDevice,
2791	LPDEVMODEW pDevMode,
2792	DWORD dwFlags,
2793	DWORD dwDesiredAccess,
2794	LPSECURITY_ATTRIBUTES lpsa)
2795	{
2796	dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
2797	lpszDesktop,
2798	lpszDevice,
2799	pDevMode,
2800	dwFlags,
2801	dwDesiredAccess,
2802	lpsa));
2803
2804	return (NULL);
2805	}
2806
2807
2808	/*****************************************************************************
2809	* Name : HWINSTA WIN32API CreateWindowStationA
2810	* Purpose : The CreateWindowStation function creates a window station object.
2811	* It returns a handle that can be used to access the window station.
2812	* A window station is a secure object that contains a set of global
2813	* atoms, a clipboard, and a set of desktop objects.
2814	* Parameters: LPTSTR lpwinsta name of the new window station
2815	* DWORD dwReserved reserved; must be NULL
2816	* DWORD dwDesiredAccess specifies access of returned handle
2817	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
2818	* Variables :
2819	* Result : If the function succeeds, the return value is the handle to the
2820	* newly created window station.
2821	* If the function fails, the return value is NULL. To get extended
2822	* error information, call GetLastError.
2823	* Remark :
2824	* Status : UNTESTED STUB
2825	*
2826	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2827	*****************************************************************************/
2828
2829	HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
2830	DWORD dwReserved,
2831	DWORD dwDesiredAccess,
2832	LPSECURITY_ATTRIBUTES lpsa)
2833	{
2834	dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
2835	lpWinSta,
2836	dwReserved,
2837	dwDesiredAccess,
2838	lpsa));
2839
2840	return (NULL);
2841	}
2842
2843
2844	/*****************************************************************************
2845	* Name : HWINSTA WIN32API CreateWindowStationW
2846	* Purpose : The CreateWindowStation function creates a window station object.
2847	* It returns a handle that can be used to access the window station.
2848	* A window station is a secure object that contains a set of global
2849	* atoms, a clipboard, and a set of desktop objects.
2850	* Parameters: LPTSTR lpwinsta name of the new window station
2851	* DWORD dwReserved reserved; must be NULL
2852	* DWORD dwDesiredAccess specifies access of returned handle
2853	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
2854	* Variables :
2855	* Result : If the function succeeds, the return value is the handle to the
2856	* newly created window station.
2857	* If the function fails, the return value is NULL. To get extended
2858	* error information, call GetLastError.
2859	* Remark :
2860	* Status : UNTESTED STUB
2861	*
2862	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2863	*****************************************************************************/
2864
2865	HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
2866	DWORD dwReserved,
2867	DWORD dwDesiredAccess,
2868	LPSECURITY_ATTRIBUTES lpsa)
2869	{
2870	dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
2871	lpWinSta,
2872	dwReserved,
2873	dwDesiredAccess,
2874	lpsa));
2875
2876	return (NULL);
2877	}
2878
2879	/*****************************************************************************
2880	* Name : BOOL WIN32API DragDetect
2881	* Purpose : The DragDetect function captures the mouse and tracks its movement
2882	* Parameters: HWND hwnd
2883	* POINT pt
2884	* Variables :
2885	* Result : If the user moved the mouse outside of the drag rectangle while
2886	* holding the left button down, the return value is TRUE.
2887	* If the user did not move the mouse outside of the drag rectangle
2888	* while holding the left button down, the return value is FALSE.
2889	* Remark :
2890	* Status : UNTESTED STUB
2891	*
2892	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2893	*****************************************************************************/
2894
2895	BOOL WIN32API DragDetect(HWND hwnd,
2896	POINT pt)
2897	{
2898	dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
2899	hwnd));
2900
2901	return (FALSE);
2902	}
2903
2904
2905
2906	/*****************************************************************************
2907	* Name : BOOL WIN32API EnumDesktopWindows
2908	* Purpose : The EnumDesktopWindows function enumerates all windows in a
2909	* desktop by passing the handle of each window, in turn, to an
2910	* application-defined callback function.
2911	* Parameters: HDESK hDesktop handle of desktop to enumerate
2912	* WNDENUMPROC lpfn points to application's callback function
2913	* LPARAM lParam 32-bit value to pass to the callback function
2914	* Variables :
2915	* Result : If the function succeeds, the return value is TRUE.
2916	* If the function fails, the return value is FALSE. To get
2917	* extended error information, call GetLastError.
2918	* Remark :
2919	* Status : UNTESTED STUB
2920	*
2921	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2922	*****************************************************************************/
2923
2924	BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
2925	WNDENUMPROC lpfn,
2926	LPARAM lParam)
2927	{
2928	dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
2929	hDesktop,
2930	lpfn,
2931	lParam));
2932
2933	return (FALSE);
2934	}
2935
2936
2937	/*****************************************************************************
2938	* Name : BOOL WIN32API EnumDesktopsA
2939	* Purpose : The EnumDesktops function enumerates all desktops in the window
2940	* station assigned to the calling process. The function does so by
2941	* passing the name of each desktop, in turn, to an application-
2942	* defined callback function.
2943	* Parameters: HWINSTA hwinsta handle of window station to enumerate
2944	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
2945	* LPARAM lParam 32-bit value to pass to the callback function
2946	* Variables :
2947	* Result : If the function succeeds, the return value is TRUE.
2948	* If the function fails, the return value is FALSE. To get extended
2949	* error information, call GetLastError.
2950	* Remark :
2951	* Status : UNTESTED STUB
2952	*
2953	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2954	*****************************************************************************/
2955
2956	BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
2957	DESKTOPENUMPROCA lpEnumFunc,
2958	LPARAM lParam)
2959	{
2960	dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
2961	hWinSta,
2962	lpEnumFunc,
2963	lParam));
2964
2965	return (FALSE);
2966	}
2967
2968
2969	/*****************************************************************************
2970	* Name : BOOL WIN32API EnumDesktopsW
2971	* Purpose : The EnumDesktops function enumerates all desktops in the window
2972	* station assigned to the calling process. The function does so by
2973	* passing the name of each desktop, in turn, to an application-
2974	* defined callback function.
2975	* Parameters: HWINSTA hwinsta handle of window station to enumerate
2976	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
2977	* LPARAM lParam 32-bit value to pass to the callback function
2978	* Variables :
2979	* Result : If the function succeeds, the return value is TRUE.
2980	* If the function fails, the return value is FALSE. To get extended
2981	* error information, call GetLastError.
2982	* Remark :
2983	* Status : UNTESTED STUB
2984	*
2985	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2986	*****************************************************************************/
2987
2988	BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
2989	DESKTOPENUMPROCW lpEnumFunc,
2990	LPARAM lParam)
2991	{
2992	dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
2993	hWinSta,
2994	lpEnumFunc,
2995	lParam));
2996
2997	return (FALSE);
2998	}
2999
3000
3001
3002	/*****************************************************************************
3003	* Name : BOOL WIN32API EnumDisplaySettingsW
3004	* Purpose : The EnumDisplaySettings function obtains information about one
3005	* of a display device's graphics modes. You can obtain information
3006	* for all of a display device's graphics modes by making a series
3007	* of calls to this function.
3008	* Parameters: LPCTSTR lpszDeviceName specifies the display device
3009	* DWORD iModeNum specifies the graphics mode
3010	* LPDEVMODE lpDevMode points to structure to receive settings
3011	* Variables :
3012	* Result : If the function succeeds, the return value is TRUE.
3013	* If the function fails, the return value is FALSE.
3014	* Remark :
3015	* Status : UNTESTED STUB
3016	*
3017	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3018	*****************************************************************************/
3019
3020	BOOL WIN32API EnumDisplaySettingsW(LPCSTR lpszDeviceName,
3021	DWORD iModeNum,
3022	LPDEVMODEW lpDevMode)
3023	{
3024	dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
3025	lpszDeviceName,
3026	iModeNum,
3027	lpDevMode));
3028
3029	return (EnumDisplaySettingsA(lpszDeviceName,
3030	iModeNum,
3031	(LPDEVMODEA)lpDevMode));
3032	}
3033
3034
3035	/*****************************************************************************
3036	* Name : BOOL WIN32API EnumWindowStationsA
3037	* Purpose : The EnumWindowStations function enumerates all windowstations
3038	* in the system by passing the name of each window station, in
3039	* turn, to an application-defined callback function.
3040	* Parameters:
3041	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
3042	* LPARAM lParam 32-bit value to pass to the callback function
3043	* Result : If the function succeeds, the return value is TRUE.
3044	* If the function fails the return value is FALSE. To get extended
3045	* error information, call GetLastError.
3046	* Remark :
3047	* Status : UNTESTED STUB
3048	*
3049	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3050	*****************************************************************************/
3051
3052	BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
3053	LPARAM lParam)
3054	{
3055	dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
3056	lpEnumFunc,
3057	lParam));
3058
3059	return (FALSE);
3060	}
3061
3062
3063	/*****************************************************************************
3064	* Name : BOOL WIN32API EnumWindowStationsW
3065	* Purpose : The EnumWindowStations function enumerates all windowstations
3066	* in the system by passing the name of each window station, in
3067	* turn, to an application-defined callback function.
3068	* Parameters:
3069	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
3070	* LPARAM lParam 32-bit value to pass to the callback function
3071	* Result : If the function succeeds, the return value is TRUE.
3072	* If the function fails the return value is FALSE. To get extended
3073	* error information, call GetLastError.
3074	* Remark :
3075	* Status : UNTESTED STUB
3076	*
3077	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3078	*****************************************************************************/
3079
3080	BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
3081	LPARAM lParam)
3082	{
3083	dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
3084	lpEnumFunc,
3085	lParam));
3086
3087	return (FALSE);
3088	}
3089
3090
3091
3092	/*****************************************************************************
3093	* Name : BOOL WIN32API GetInputState
3094	* Purpose : The GetInputState function determines whether there are
3095	* mouse-button or keyboard messages in the calling thread's message queue.
3096	* Parameters:
3097	* Variables :
3098	* Result : If the queue contains one or more new mouse-button or keyboard
3099	* messages, the return value is TRUE.
3100	* If the function fails, the return value is FALSE.
3101	* Remark :
3102	* Status : UNTESTED STUB
3103	*
3104	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3105	*****************************************************************************/
3106
3107	BOOL WIN32API GetInputState(VOID)
3108	{
3109	dprintf(("USER32:GetInputState () not implemented.\n"));
3110
3111	return (FALSE);
3112	}
3113
3114
3115	/*****************************************************************************
3116	* Name : UINT WIN32API GetKBCodePage
3117	* Purpose : The GetKBCodePage function is provided for compatibility with
3118	* earlier versions of Windows. In the Win32 application programming
3119	* interface (API) it just calls the GetOEMCP function.
3120	* Parameters:
3121	* Variables :
3122	* Result : If the function succeeds, the return value is an OEM code-page
3123	* identifier, or it is the default identifier if the registry
3124	* value is not readable. For a list of OEM code-page identifiers,
3125	* see GetOEMCP.
3126	* Remark :
3127	* Status : UNTESTED
3128	*
3129	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3130	*****************************************************************************/
3131
3132	UINT WIN32API GetKBCodePage(VOID)
3133	{
3134	return (GetOEMCP());
3135	}
3136
3137
3138	/*****************************************************************************
3139	* Name : BOOL WIN32API GetKeyboardLayoutNameA
3140	* Purpose : The GetKeyboardLayoutName function retrieves the name of the
3141	* active keyboard layout.
3142	* Parameters: LPTSTR pwszKLID address of buffer for layout name
3143	* Variables :
3144	* Result : If the function succeeds, the return value is TRUE.
3145	* If the function fails, the return value is FALSE. To get extended
3146	* error information, call GetLastError.
3147	* Remark :
3148	* Status : UNTESTED STUB
3149	*
3150	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3151	*****************************************************************************/
3152
3153	BOOL WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
3154	{
3155	dprintf(("USER32:GetKeyboardLayoutNameA (%08x) not implemented.",
3156	pwszKLID));
3157
3158	return(FALSE);
3159	}
3160
3161
3162	/*****************************************************************************
3163	* Name : BOOL WIN32API GetKeyboardLayoutNameW
3164	* Purpose : The GetKeyboardLayoutName function retrieves the name of the
3165	* active keyboard layout.
3166	* Parameters: LPTSTR pwszKLID address of buffer for layout name
3167	* Variables :
3168	* Result : If the function succeeds, the return value is TRUE.
3169	* If the function fails, the return value is FALSE. To get extended
3170	* error information, call GetLastError.
3171	* Remark :
3172	* Status : UNTESTED STUB
3173	*
3174	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3175	*****************************************************************************/
3176
3177	BOOL WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
3178	{
3179	dprintf(("USER32:GetKeyboardLayoutNameW (%08x) not implemented.",
3180	pwszKLID));
3181
3182	return(FALSE);
3183	}
3184
3185
3186
3187
3188	/*****************************************************************************
3189	* Name : HWINSTA WIN32API GetProcessWindowStation
3190	* Purpose : The GetProcessWindowStation function returns a handle of the
3191	* window station associated with the calling process.
3192	* Parameters:
3193	* Variables :
3194	* Result : If the function succeeds, the return value is a handle of the
3195	* window station associated with the calling process.
3196	* If the function fails, the return value is NULL. This can occur
3197	* if the calling process is not an application written for Windows
3198	* NT. To get extended error information, call GetLastError.
3199	* Remark :
3200	* Status : UNTESTED STUB
3201	*
3202	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3203	*****************************************************************************/
3204
3205	HWINSTA WIN32API GetProcessWindowStation(VOID)
3206	{
3207	dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
3208
3209	return (NULL);
3210	}
3211
3212
3213
3214	/*****************************************************************************
3215	* Name : HDESK WIN32API GetThreadDesktop
3216	* Purpose : The GetThreadDesktop function returns a handle to the desktop
3217	* associated with a specified thread.
3218	* Parameters: DWORD dwThreadId thread identifier
3219	* Variables :
3220	* Result : If the function succeeds, the return value is the handle of the
3221	* desktop associated with the specified thread.
3222	* Remark :
3223	* Status : UNTESTED STUB
3224	*
3225	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3226	*****************************************************************************/
3227
3228	HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
3229	{
3230	dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
3231	dwThreadId));
3232
3233	return (NULL);
3234	}
3235
3236
3237	/*****************************************************************************
3238	* Name : BOOL WIN32API GetUserObjectInformationA
3239	* Purpose : The GetUserObjectInformation function returns information about
3240	* a window station or desktop object.
3241	* Parameters: HANDLE hObj handle of object to get information for
3242	* int nIndex type of information to get
3243	* PVOID pvInfo points to buffer that receives the information
3244	* DWORD nLength size, in bytes, of pvInfo buffer
3245	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
3246	* Variables :
3247	* Result : If the function succeeds, the return value is TRUE.
3248	* If the function fails, the return value is FALSE. To get extended
3249	* error information, call GetLastError.
3250	* Remark :
3251	* Status : UNTESTED STUB
3252	*
3253	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3254	*****************************************************************************/
3255
3256	BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
3257	int nIndex,
3258	PVOID pvInfo,
3259	DWORD nLength,
3260	LPDWORD lpnLengthNeeded)
3261	{
3262	dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
3263	hObj,
3264	nIndex,
3265	pvInfo,
3266	nLength,
3267	lpnLengthNeeded));
3268
3269	return (FALSE);
3270	}
3271
3272
3273	/*****************************************************************************
3274	* Name : BOOL WIN32API GetUserObjectInformationW
3275	* Purpose : The GetUserObjectInformation function returns information about
3276	* a window station or desktop object.
3277	* Parameters: HANDLE hObj handle of object to get information for
3278	* int nIndex type of information to get
3279	* PVOID pvInfo points to buffer that receives the information
3280	* DWORD nLength size, in bytes, of pvInfo buffer
3281	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
3282	* Variables :
3283	* Result : If the function succeeds, the return value is TRUE.
3284	* If the function fails, the return value is FALSE. To get extended
3285	* error information, call GetLastError.
3286	* Remark :
3287	* Status : UNTESTED STUB
3288	*
3289	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3290	*****************************************************************************/
3291
3292	BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
3293	int nIndex,
3294	PVOID pvInfo,
3295	DWORD nLength,
3296	LPDWORD lpnLengthNeeded)
3297	{
3298	dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
3299	hObj,
3300	nIndex,
3301	pvInfo,
3302	nLength,
3303	lpnLengthNeeded));
3304
3305	return (FALSE);
3306	}
3307
3308
3309	/*****************************************************************************
3310	* Name : BOOL WIN32API GetUserObjectSecurity
3311	* Purpose : The GetUserObjectSecurity function retrieves security information
3312	* for the specified user object.
3313	* Parameters: HANDLE hObj handle of user object
3314	* SECURITY_INFORMATION * pSIRequested address of requested security information
3315	* LPSECURITY_DESCRIPTOR pSID address of security descriptor
3316	* DWORD nLength size of buffer for security descriptor
3317	* LPDWORD lpnLengthNeeded address of required size of buffer
3318	* Variables :
3319	* Result : If the function succeeds, the return value is TRUE.
3320	* If the function fails, the return value is FALSE. To get extended
3321	* error information, call GetLastError.
3322	* Remark :
3323	* Status : UNTESTED STUB
3324	*
3325	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3326	*****************************************************************************/
3327
3328	BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
3329	SECURITY_INFORMATION * pSIRequested,
3330	LPSECURITY_DESCRIPTOR pSID,
3331	DWORD nLength,
3332	LPDWORD lpnLengthNeeded)
3333	{
3334	dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
3335	hObj,
3336	pSIRequested,
3337	pSID,
3338	nLength,
3339	lpnLengthNeeded));
3340
3341	return (FALSE);
3342	}
3343
3344
3345
3346	/*****************************************************************************
3347	* Name : int WIN32API GetWindowRgn
3348	* Purpose : The GetWindowRgn function obtains a copy of the window region of a window.
3349	* Parameters: HWND hWnd handle to window whose window region is to be obtained
3350	* HRGN hRgn handle to region that receives a copy of the window region
3351	* Variables :
3352	* Result : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
3353	* Remark :
3354	* Status : UNTESTED STUB
3355	*
3356	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3357	*****************************************************************************/
3358
3359	int WIN32API GetWindowRgn (HWND hWnd,
3360	HRGN hRgn)
3361	{
3362	dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
3363	hWnd,
3364	hRgn));
3365
3366	return (NULLREGION);
3367	}
3368
3369
3370
3371	/*****************************************************************************
3372	* Name : HCURSOR WIN32API LoadCursorFromFileA
3373	* Purpose : The LoadCursorFromFile function creates a cursor based on data
3374	* contained in a file. The file is specified by its name or by a
3375	* system cursor identifier. The function returns a handle to the
3376	* newly created cursor. Files containing cursor data may be in
3377	* either cursor (.CUR) or animated cursor (.ANI) format.
3378	* Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
3379	* Variables :
3380	* Result : If the function is successful, the return value is a handle to
3381	* the new cursor.
3382	* If the function fails, the return value is NULL. To get extended
3383	* error information, call GetLastError. GetLastError may return
3384	* the following
3385	* Remark :
3386	* Status : UNTESTED STUB
3387	*
3388	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3389	*****************************************************************************/
3390
3391	HCURSOR WIN32API LoadCursorFromFileA(LPCTSTR lpFileName)
3392	{
3393	dprintf(("USER32:LoadCursorFromFileA (%s) not implemented.\n",
3394	lpFileName));
3395
3396	return (NULL);
3397	}
3398
3399
3400	/*****************************************************************************
3401	* Name : HCURSOR WIN32API LoadCursorFromFileW
3402	* Purpose : The LoadCursorFromFile function creates a cursor based on data
3403	* contained in a file. The file is specified by its name or by a
3404	* system cursor identifier. The function returns a handle to the
3405	* newly created cursor. Files containing cursor data may be in
3406	* either cursor (.CUR) or animated cursor (.ANI) format.
3407	* Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
3408	* Variables :
3409	* Result : If the function is successful, the return value is a handle to
3410	* the new cursor.
3411	* If the function fails, the return value is NULL. To get extended
3412	* error information, call GetLastError. GetLastError may return
3413	* the following
3414	* Remark :
3415	* Status : UNTESTED STUB
3416	*
3417	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3418	*****************************************************************************/
3419
3420	HCURSOR WIN32API LoadCursorFromFileW(LPCWSTR lpFileName)
3421	{
3422	dprintf(("USER32:LoadCursorFromFileW (%s) not implemented.\n",
3423	lpFileName));
3424
3425	return (NULL);
3426	}
3427
3428
3429	/*****************************************************************************
3430	* Name : HLK WIN32API LoadKeyboardLayoutA
3431	* Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
3432	* the system. Several keyboard layouts can be loaded at a time, but
3433	* only one per process is active at a time. Loading multiple keyboard
3434	* layouts makes it possible to rapidly switch between layouts.
3435	* Parameters:
3436	* Variables :
3437	* Result : If the function succeeds, the return value is the handle of the
3438	* keyboard layout.
3439	* If the function fails, the return value is NULL. To get extended
3440	* error information, call GetLastError.
3441	* Remark :
3442	* Status : UNTESTED STUB
3443	*
3444	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3445	*****************************************************************************/
3446
3447	HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
3448	UINT Flags)
3449	{
3450	dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
3451	pwszKLID,
3452	Flags));
3453
3454	return (NULL);
3455	}
3456
3457
3458	/*****************************************************************************
3459	* Name : HLK WIN32API LoadKeyboardLayoutW
3460	* Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
3461	* the system. Several keyboard layouts can be loaded at a time, but
3462	* only one per process is active at a time. Loading multiple keyboard
3463	* layouts makes it possible to rapidly switch between layouts.
3464	* Parameters:
3465	* Variables :
3466	* Result : If the function succeeds, the return value is the handle of the
3467	* keyboard layout.
3468	* If the function fails, the return value is NULL. To get extended
3469	* error information, call GetLastError.
3470	* Remark :
3471	* Status : UNTESTED STUB
3472	*
3473	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3474	*****************************************************************************/
3475
3476	HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
3477	UINT Flags)
3478	{
3479	dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
3480	pwszKLID,
3481	Flags));
3482
3483	return (NULL);
3484	}
3485
3486
3487	/*****************************************************************************
3488	* Name : UINT WIN32API MapVirtualKeyExA
3489	* Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
3490	* code into a scan code or character value, or translates a scan
3491	* code into a virtual-key code. The function translates the codes
3492	* using the input language and physical keyboard layout identified
3493	* by the given keyboard layout handle.
3494	* Parameters:
3495	* Variables :
3496	* Result : The return value is either a scan code, a virtual-key code, or
3497	* a character value, depending on the value of uCode and uMapType.
3498	* If there is no translation, the return value is zero.
3499	* Remark :
3500	* Status : UNTESTED STUB
3501	*
3502	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3503	*****************************************************************************/
3504
3505	UINT WIN32API MapVirtualKeyExA(UINT uCode,
3506	UINT uMapType,
3507	HKL dwhkl)
3508	{
3509	dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
3510	uCode,
3511	uMapType,
3512	dwhkl));
3513
3514	return (0);
3515	}
3516
3517
3518	/*****************************************************************************
3519	* Name : UINT WIN32API MapVirtualKeyExW
3520	* Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
3521	* code into a scan code or character value, or translates a scan
3522	* code into a virtual-key code. The function translates the codes
3523	* using the input language and physical keyboard layout identified
3524	* by the given keyboard layout handle.
3525	* Parameters:
3526	* Variables :
3527	* Result : The return value is either a scan code, a virtual-key code, or
3528	* a character value, depending on the value of uCode and uMapType.
3529	* If there is no translation, the return value is zero.
3530	* Remark :
3531	* Status : UNTESTED STUB
3532
3533	*
3534	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3535	*****************************************************************************/
3536
3537	UINT WIN32API MapVirtualKeyExW(UINT uCode,
3538	UINT uMapType,
3539	HKL dwhkl)
3540	{
3541	dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
3542	uCode,
3543	uMapType,
3544	dwhkl));
3545
3546	return (0);
3547	}
3548
3549	/*****************************************************************************
3550	* Name : DWORD WIN32API OemKeyScan
3551	* Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
3552	* into the OEM scan codes and shift states. The function provides
3553	* information that allows a program to send OEM text to another
3554	* program by simulating keyboard input.
3555	* Parameters:
3556	* Variables :
3557	* Result :
3558	* Remark :
3559	* Status : UNTESTED STUB
3560	*
3561	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3562	*****************************************************************************/
3563
3564	DWORD WIN32API OemKeyScan(WORD wOemChar)
3565	{
3566	dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
3567	wOemChar));
3568
3569	return (wOemChar);
3570	}
3571
3572
3573	/*****************************************************************************
3574	* Name : HDESK WIN32API OpenDesktopA
3575	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
3576	* A desktop is a secure object contained within a window station
3577	* object. A desktop has a logical display surface and contains
3578	* windows, menus and hooks.
3579	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
3580	* DWORD dwFlags flags to control interaction with other applications
3581	* BOOL fInherit specifies whether returned handle is inheritable
3582	* DWORD dwDesiredAccess specifies access of returned handle
3583	* Variables :
3584	* Result : If the function succeeds, the return value is the handle to the
3585	* opened desktop.
3586	* If the function fails, the return value is NULL. To get extended
3587	* error information, call GetLastError.
3588	* Remark :
3589	* Status : UNTESTED STUB
3590	*
3591	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3592	*****************************************************************************/
3593
3594	HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
3595	DWORD dwFlags,
3596	BOOL fInherit,
3597	DWORD dwDesiredAccess)
3598	{
3599	dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
3600	lpszDesktopName,
3601	dwFlags,
3602	fInherit,
3603	dwDesiredAccess));
3604
3605	return (NULL);
3606	}
3607
3608
3609	/*****************************************************************************
3610	* Name : HDESK WIN32API OpenDesktopW
3611	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
3612	* A desktop is a secure object contained within a window station
3613	* object. A desktop has a logical display surface and contains
3614	* windows, menus and hooks.
3615	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
3616	* DWORD dwFlags flags to control interaction with other applications
3617	* BOOL fInherit specifies whether returned handle is inheritable
3618	* DWORD dwDesiredAccess specifies access of returned handle
3619	* Variables :
3620	* Result : If the function succeeds, the return value is the handle to the
3621	* opened desktop.
3622	* If the function fails, the return value is NULL. To get extended
3623	* error information, call GetLastError.
3624	* Remark :
3625	* Status : UNTESTED STUB
3626	*
3627	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3628	*****************************************************************************/
3629
3630	HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
3631	DWORD dwFlags,
3632	BOOL fInherit,
3633	DWORD dwDesiredAccess)
3634	{
3635	dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
3636	lpszDesktopName,
3637	dwFlags,
3638	fInherit,
3639	dwDesiredAccess));
3640
3641	return (NULL);
3642	}
3643
3644
3645	/*****************************************************************************
3646	* Name : HDESK WIN32API OpenInputDesktop
3647	* Purpose : The OpenInputDesktop function returns a handle to the desktop
3648	* that receives user input. The input desktop is a desktop on the
3649	* window station associated with the logged-on user.
3650	* Parameters: DWORD dwFlags flags to control interaction with other applications
3651	* BOOL fInherit specifies whether returned handle is inheritable
3652	* DWORD dwDesiredAccess specifies access of returned handle
3653	* Variables :
3654	* Result : If the function succeeds, the return value is a handle of the
3655	* desktop that receives user input.
3656	* If the function fails, the return value is NULL. To get extended
3657	* error information, call GetLastError.
3658	* Remark :
3659	* Status : UNTESTED STUB
3660	*
3661	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3662	*****************************************************************************/
3663
3664	HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
3665	BOOL fInherit,
3666	DWORD dwDesiredAccess)
3667	{
3668	dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
3669	dwFlags,
3670	fInherit,
3671	dwDesiredAccess));
3672
3673	return (NULL);
3674	}
3675
3676
3677	/*****************************************************************************
3678	* Name : HWINSTA WIN32API OpenWindowStationA
3679	* Purpose : The OpenWindowStation function returns a handle to an existing
3680	* window station.
3681	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
3682	* BOOL fInherit specifies whether returned handle is inheritable
3683	* DWORD dwDesiredAccess specifies access of returned handle
3684	* Variables :
3685	* Result : If the function succeeds, the return value is the handle to the
3686	* specified window station.
3687	* If the function fails, the return value is NULL. To get extended
3688	* error information, call GetLastError.
3689	* Remark :
3690	* Status : UNTESTED STUB
3691	*
3692	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3693	*****************************************************************************/
3694
3695	HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
3696	BOOL fInherit,
3697	DWORD dwDesiredAccess)
3698	{
3699	dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
3700	lpszWinStaName,
3701	fInherit,
3702	dwDesiredAccess));
3703
3704	return (NULL);
3705	}
3706
3707
3708	/*****************************************************************************
3709	* Name : HWINSTA WIN32API OpenWindowStationW
3710	* Purpose : The OpenWindowStation function returns a handle to an existing
3711	* window station.
3712	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
3713	* BOOL fInherit specifies whether returned handle is inheritable
3714	* DWORD dwDesiredAccess specifies access of returned handle
3715	* Variables :
3716	* Result : If the function succeeds, the return value is the handle to the
3717	* specified window station.
3718	* If the function fails, the return value is NULL. To get extended
3719	* error information, call GetLastError.
3720
3721
3722	* Remark :
3723	* Status : UNTESTED STUB
3724	*
3725	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3726	*****************************************************************************/
3727
3728	HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
3729	BOOL fInherit,
3730	DWORD dwDesiredAccess)
3731	{
3732	dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
3733	lpszWinStaName,
3734	fInherit,
3735	dwDesiredAccess));
3736
3737	return (NULL);
3738	}
3739
3740
3741	/*****************************************************************************
3742	* Name : BOOL WIN32API PaintDesktop
3743	* Purpose : The PaintDesktop function fills the clipping region in the
3744	* specified device context with the desktop pattern or wallpaper.
3745	* The function is provided primarily for shell desktops.
3746	* Parameters:
3747	* Variables :
3748	* Result : If the function succeeds, the return value is TRUE.
3749	* If the function fails, the return value is FALSE.
3750	* Remark :
3751	* Status : UNTESTED STUB
3752	*
3753	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3754	*****************************************************************************/
3755
3756	BOOL WIN32API PaintDesktop(HDC hdc)
3757	{
3758	dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
3759	hdc));
3760
3761	return (FALSE);
3762	}
3763
3764
3765
3766	/*****************************************************************************
3767	* Name : VOID WIN32API SetDebugErrorLevel
3768	* Purpose : The SetDebugErrorLevel function sets the minimum error level at
3769	* which Windows will generate debugging events and pass them to a debugger.
3770	* Parameters: DWORD dwLevel debugging error level
3771	* Variables :
3772	* Result :
3773	* Remark :
3774	* Status : UNTESTED STUB
3775	*
3776	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3777	*****************************************************************************/
3778
3779	VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
3780	{
3781	dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
3782	dwLevel));
3783	}
3784
3785
3786	/*****************************************************************************
3787	* Name : BOOL WIN32API SetProcessWindowStation
3788	* Purpose : The SetProcessWindowStation function assigns a window station
3789	* to the calling process. This enables the process to access
3790	* objects in the window station such as desktops, the clipboard,
3791	* and global atoms. All subsequent operations on the window station
3792	* use the access rights granted to hWinSta.
3793	* Parameters:
3794	* Variables :
3795	* Result : If the function succeeds, the return value is TRUE.
3796	* If the function fails, the return value is FALSE. To get extended
3797	* error information, call GetLastError.
3798	* Remark :
3799	* Status : UNTESTED STUB
3800	*
3801	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3802	*****************************************************************************/
3803
3804	BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
3805	{
3806	dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
3807	hWinSta));
3808
3809	return (FALSE);
3810	}
3811
3812
3813	/*****************************************************************************
3814	* Name : BOOL WIN32API SetSystemCursor
3815	* Purpose : The SetSystemCursor function replaces the contents of the system
3816	* cursor specified by dwCursorId with the contents of the cursor
3817	* specified by hCursor, and then destroys hCursor. This function
3818	* lets an application customize the system cursors.
3819	* Parameters: HCURSOR hCursor set specified system cursor to this cursor's
3820	* contents, then destroy this
3821	* DWORD dwCursorID system cursor specified by its identifier
3822	* Variables :
3823	* Result : If the function succeeds, the return value is TRUE.
3824	* If the function fails, the return value is FALSE. To get extended
3825	* error information, call GetLastError.
3826	* Remark :
3827	* Status : UNTESTED STUB
3828	*
3829	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3830	*****************************************************************************/
3831
3832	BOOL WIN32API SetSystemCursor(HCURSOR hCursor,
3833	DWORD dwCursorId)
3834	{
3835	dprintf(("USER32:SetSystemCursor (%08xh,%08x) not implemented.\n",
3836	hCursor,
3837	dwCursorId));
3838
3839	return (FALSE);
3840	}
3841
3842
3843	/*****************************************************************************
3844	* Name : BOOL WIN32API SetThreadDesktop
3845	* Purpose : The SetThreadDesktop function assigns a desktop to the calling
3846	* thread. All subsequent operations on the desktop use the access
3847	* rights granted to hDesk.
3848	* Parameters: HDESK hDesk handle of the desktop to assign to this thread
3849	* Variables :
3850	* Result : If the function succeeds, the return value is TRUE.
3851	* If the function fails, the return value is FALSE. To get extended
3852	* error information, call GetLastError.
3853	* Remark :
3854	* Status : UNTESTED STUB
3855	*
3856	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3857	*****************************************************************************/
3858
3859	BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
3860	{
3861	dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
3862	hDesktop));
3863
3864	return (FALSE);
3865	}
3866
3867
3868	/*****************************************************************************
3869	* Name : BOOL WIN32API SetUserObjectInformationA
3870	* Purpose : The SetUserObjectInformation function sets information about a
3871	* window station or desktop object.
3872	* Parameters: HANDLE hObject handle of the object for which to set information
3873	* int nIndex type of information to set
3874	* PVOID lpvInfo points to a buffer that contains the information
3875	* DWORD cbInfo size, in bytes, of lpvInfo buffer
3876	* Variables :
3877	* Result : If the function succeeds, the return value is TRUE.
3878	* If the function fails the return value is FALSE. To get extended
3879	* error information, call GetLastError.
3880	* Remark :
3881	* Status : UNTESTED STUB
3882	*
3883	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3884	*****************************************************************************/
3885
3886	BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
3887	int nIndex,
3888	PVOID lpvInfo,
3889	DWORD cbInfo)
3890	{
3891	dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
3892	hObject,
3893	nIndex,
3894	lpvInfo,
3895	cbInfo));
3896
3897	return (FALSE);
3898	}
3899
3900
3901	/*****************************************************************************
3902	* Name : BOOL WIN32API SetUserObjectInformationW
3903	* Purpose : The SetUserObjectInformation function sets information about a
3904	* window station or desktop object.
3905	* Parameters: HANDLE hObject handle of the object for which to set information
3906	* int nIndex type of information to set
3907	* PVOID lpvInfo points to a buffer that contains the information
3908	* DWORD cbInfo size, in bytes, of lpvInfo buffer
3909	* Variables :
3910	* Result : If the function succeeds, the return value is TRUE.
3911	* If the function fails the return value is FALSE. To get extended
3912	* error information, call GetLastError.
3913	* Remark :
3914	* Status : UNTESTED STUB
3915	*
3916	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3917	*****************************************************************************/
3918
3919	BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
3920	int nIndex,
3921	PVOID lpvInfo,
3922	DWORD cbInfo)
3923	{
3924	dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
3925	hObject,
3926	nIndex,
3927	lpvInfo,
3928	cbInfo));
3929
3930	return (FALSE);
3931	}
3932
3933
3934	/*****************************************************************************
3935	* Name : BOOL WIN32API SetUserObjectSecurity
3936	* Purpose : The SetUserObjectSecurity function sets the security of a user
3937	* object. This can be, for example, a window or a DDE conversation
3938	* Parameters: HANDLE hObject handle of user object
3939	* SECURITY_INFORMATION * psi address of security information
3940	* LPSECURITY_DESCRIPTOR psd address of security descriptor
3941	* Variables :
3942	* Result : If the function succeeds, the return value is TRUE.
3943	* If the function fails, the return value is FALSE. To get extended
3944	* error information, call GetLastError.
3945	* Remark :
3946	* Status : UNTESTED STUB
3947	*
3948	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3949	*****************************************************************************/
3950
3951	BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
3952	SECURITY_INFORMATION * psi,
3953	LPSECURITY_DESCRIPTOR psd)
3954	{
3955	dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
3956	hObject,
3957	psi,
3958	psd));
3959
3960	return (FALSE);
3961	}
3962
3963
3964	/*****************************************************************************
3965	* Name : int WIN32API SetWindowRgn
3966	* Purpose : The SetWindowRgn function sets the window region of a window. The
3967	* window region determines the area within the window where the
3968	* operating system permits drawing. The operating system does not
3969	* display any portion of a window that lies outside of the window region
3970	* Parameters: HWND hWnd handle to window whose window region is to be set
3971	* HRGN hRgn handle to region
3972	* BOOL bRedraw window redraw flag
3973	* Variables :
3974	* Result : If the function succeeds, the return value is non-zero.
3975	* If the function fails, the return value is zero.
3976	* Remark :
3977	* Status : UNTESTED STUB
3978	*
3979	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
3980	*****************************************************************************/
3981
3982	int WIN32API SetWindowRgn(HWND hWnd,
3983	HRGN hRgn,
3984	BOOL bRedraw)
3985	{
3986	dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
3987	hWnd,
3988	hRgn,
3989	bRedraw));
3990
3991	return (0);
3992	}
3993
3994
3995	/*****************************************************************************
3996	* Name : BOOL WIN32API SetWindowsHookW
3997	* Purpose : The SetWindowsHook function is not implemented in the Win32 API.
3998	* Win32-based applications should use the SetWindowsHookEx function.
3999	* Parameters:
4000	* Variables :
4001	* Result :
4002	* Remark : ARGH ! MICROSOFT !
4003	* Status : UNTESTED STUB
4004	*
4005	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4006	*****************************************************************************/
4007
4008	HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
4009
4010	{
4011	return (FALSE);
4012	}
4013
4014
4015	/*****************************************************************************
4016	* Name : BOOL WIN32API ShowWindowAsync
4017	* Purpose : The ShowWindowAsync function sets the show state of a window
4018	* created by a different thread.
4019	* Parameters: HWND hwnd handle of window
4020	* int nCmdShow show state of window
4021	* Variables :
4022	* Result : If the window was previously visible, the return value is TRUE.
4023	* If the window was previously hidden, the return value is FALSE.
4024	* Remark :
4025	* Status : UNTESTED STUB
4026	*
4027	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4028	*****************************************************************************/
4029
4030	BOOL WIN32API ShowWindowAsync (HWND hWnd,
4031	int nCmdShow)
4032	{
4033	dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
4034	hWnd,
4035	nCmdShow));
4036
4037	return (FALSE);
4038	}
4039
4040
4041	/*****************************************************************************
4042	* Name : BOOL WIN32API SwitchDesktop
4043	* Purpose : The SwitchDesktop function makes a desktop visible and activates
4044	* it. This enables the desktop to receive input from the user. The
4045	* calling process must have DESKTOP_SWITCHDESKTOP access to the
4046	* desktop for the SwitchDesktop function to succeed.
4047	* Parameters:
4048	* Variables :
4049	* Result : If the function succeeds, the return value is TRUE.
4050	* If the function fails, the return value is FALSE. To get extended
4051	* error information, call GetLastError.
4052	* Remark :
4053	* Status : UNTESTED STUB
4054	*
4055	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4056	*****************************************************************************/
4057
4058	BOOL WIN32API SwitchDesktop(HDESK hDesktop)
4059	{
4060	dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
4061	hDesktop));
4062
4063	return (FALSE);
4064	}
4065
4066
4067	/*****************************************************************************
4068	* Name : WORD WIN32API TileWindows
4069	* Purpose : The TileWindows function tiles the specified windows, or the child
4070	* windows of the specified parent window.
4071	* Parameters: HWND hwndParent handle of parent window
4072	* WORD wFlags types of windows not to arrange
4073	* LPCRECT lpRect rectangle to arrange windows in
4074	* WORD cChildrenb number of windows to arrange
4075	* const HWND *ahwndChildren array of window handles
4076	* Variables :
4077	* Result : If the function succeeds, the return value is the number of
4078	* windows arranged.
4079	* If the function fails, the return value is zero.
4080	* Remark :
4081	* Status : UNTESTED STUB
4082	*
4083	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4084	*****************************************************************************/
4085
4086	WORD WIN32API TileWindows(HWND hwndParent,
4087	UINT wFlags,
4088	const LPRECT lpRect,
4089	UINT cChildrenb,
4090	const HWND *ahwndChildren)
4091	{
4092	dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4093	hwndParent,
4094	wFlags,
4095	lpRect,
4096	cChildrenb,
4097	ahwndChildren));
4098
4099	return (0);
4100	}
4101
4102
4103	/*****************************************************************************
4104	* Name : int WIN32API ToAscii
4105	* Purpose : The ToAscii function translates the specified virtual-key code
4106	* and keyboard state to the corresponding Windows character or characters.
4107	* Parameters: UINT uVirtKey virtual-key code
4108	* UINT uScanCode scan code
4109	* PBYTE lpbKeyState address of key-state array
4110	* LPWORD lpwTransKey buffer for translated key
4111	* UINT fuState active-menu flag
4112	* Variables :
4113	* Result : 0 The specified virtual key has no translation for the current
4114	* state of the keyboard.
4115	* 1 One Windows character was copied to the buffer.
4116	* 2 Two characters were copied to the buffer. This usually happens
4117	* when a dead-key character (accent or diacritic) stored in the
4118	* keyboard layout cannot be composed with the specified virtual
4119	* key to form a single character.
4120	* Remark :
4121	* Status : UNTESTED STUB
4122	*
4123	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4124	*****************************************************************************/
4125
4126	int WIN32API ToAscii(UINT uVirtKey,
4127	UINT uScanCode,
4128	PBYTE lpbKeyState,
4129	LPWORD lpwTransKey,
4130	UINT fuState)
4131	{
4132	dprintf(("USER32:ToAscii (%u,%u,%08xh,%08xh,%u) not implemented.\n",
4133	uVirtKey,
4134	uScanCode,
4135	lpbKeyState,
4136	lpwTransKey,
4137	fuState));
4138
4139	return (0);
4140	}
4141
4142
4143	/*****************************************************************************
4144	* Name : int WIN32API ToAsciiEx
4145	* Purpose : The ToAscii function translates the specified virtual-key code
4146	* and keyboard state to the corresponding Windows character or characters.
4147	* Parameters: UINT uVirtKey virtual-key code
4148	* UINT uScanCode scan code
4149	* PBYTE lpbKeyState address of key-state array
4150	* LPWORD lpwTransKey buffer for translated key
4151	* UINT fuState active-menu flag
4152	* HLK hlk keyboard layout handle
4153	* Variables :
4154	* Result : 0 The specified virtual key has no translation for the current
4155	* state of the keyboard.
4156	* 1 One Windows character was copied to the buffer.
4157	* 2 Two characters were copied to the buffer. This usually happens
4158	* when a dead-key character (accent or diacritic) stored in the
4159	* keyboard layout cannot be composed with the specified virtual
4160	* key to form a single character.
4161	* Remark :
4162	* Status : UNTESTED STUB
4163	*
4164	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4165	*****************************************************************************/
4166
4167	int WIN32API ToAsciiEx(UINT uVirtKey,
4168	UINT uScanCode,
4169	PBYTE lpbKeyState,
4170	LPWORD lpwTransKey,
4171	UINT fuState,
4172	HKL hkl)
4173	{
4174	dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
4175	uVirtKey,
4176	uScanCode,
4177	lpbKeyState,
4178	lpwTransKey,
4179	fuState,
4180	hkl));
4181
4182	return (0);
4183	}
4184
4185
4186	/*****************************************************************************
4187	* Name : int WIN32API ToUnicode
4188	* Purpose : The ToUnicode function translates the specified virtual-key code
4189	* and keyboard state to the corresponding Unicode character or characters.
4190	* Parameters: UINT wVirtKey virtual-key code
4191	* UINT wScanCode scan code
4192	* PBYTE lpKeyState address of key-state array
4193	* LPWSTR pwszBuff buffer for translated key
4194	* int cchBuff size of translated key buffer
4195	* UINT wFlags set of function-conditioning flags
4196	* Variables :
4197	* Result : - 1 The specified virtual key is a dead-key character (accent or
4198	* diacritic). This value is returned regardless of the keyboard
4199	* layout, even if several characters have been typed and are
4200	* stored in the keyboard state. If possible, even with Unicode
4201	* keyboard layouts, the function has written a spacing version of
4202	* the dead-key character to the buffer specified by pwszBuffer.
4203	* For example, the function writes the character SPACING ACUTE
4204	* (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
4205	* 0 The specified virtual key has no translation for the current
4206	* state of the keyboard. Nothing was written to the buffer
4207	* specified by pwszBuffer.
4208	* 1 One character was written to the buffer specified by pwszBuffer.
4209	* 2 or more Two or more characters were written to the buffer specified by
4210	* pwszBuff. The most common cause for this is that a dead-key
4211	* character (accent or diacritic) stored in the keyboard layout
4212	* could not be combined with the specified virtual key to form a
4213	* single character.
4214	* Remark :
4215	* Status : UNTESTED STUB
4216	*
4217	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4218	*****************************************************************************/
4219
4220	int WIN32API ToUnicode(UINT uVirtKey,
4221	UINT uScanCode,
4222	PBYTE lpKeyState,
4223	LPWSTR pwszBuff,
4224	int cchBuff,
4225	UINT wFlags)
4226	{
4227	dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
4228	uVirtKey,
4229	uScanCode,
4230	lpKeyState,
4231	pwszBuff,
4232	cchBuff,
4233	wFlags));
4234
4235	return (0);
4236	}
4237
4238
4239	/*****************************************************************************
4240	* Name : BOOL WIN32API UnloadKeyboardLayout
4241	* Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
4242	* Parameters: HKL hkl handle of keyboard layout
4243	* Variables :
4244	* Result : If the function succeeds, the return value is the handle of the
4245	* keyboard layout; otherwise, it is NULL. To get extended error
4246	* information, use the GetLastError function.
4247	* Remark :
4248	* Status : UNTESTED STUB
4249	*
4250	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4251	*****************************************************************************/
4252
4253	BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
4254	{
4255	dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
4256	hkl));
4257
4258	return (0);
4259	}
4260
4261
4262	/*****************************************************************************
4263	* Name : SHORT WIN32API VkKeyScanExW
4264	* Purpose : The VkKeyScanEx function translates a character to the
4265	* corresponding virtual-key code and shift state. The function
4266	* translates the character using the input language and physical
4267	* keyboard layout identified by the given keyboard layout handle.
4268	* Parameters: UINT uChar character to translate
4269	* HKL hkl keyboard layout handle
4270	* Variables :
4271	* Result : see docs
4272	* Remark :
4273	* Status : UNTESTED STUB
4274	*
4275	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4276	*****************************************************************************/
4277
4278	WORD WIN32API VkKeyScanExW(WCHAR uChar,
4279	HKL hkl)
4280	{
4281	dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
4282	uChar,
4283	hkl));
4284
4285	return (uChar);
4286	}
4287
4288
4289	/*****************************************************************************
4290	* Name : SHORT WIN32API VkKeyScanExA
4291	* Purpose : The VkKeyScanEx function translates a character to the
4292	* corresponding virtual-key code and shift state. The function
4293	* translates the character using the input language and physical
4294	* keyboard layout identified by the given keyboard layout handle.
4295	* Parameters: UINT uChar character to translate
4296	* HKL hkl keyboard layout handle
4297	* Variables :
4298	* Result : see docs
4299	* Remark :
4300	* Status : UNTESTED STUB
4301	*
4302	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4303	*****************************************************************************/
4304
4305	WORD WIN32API VkKeyScanExA(CHAR uChar,
4306	HKL hkl)
4307	{
4308	dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
4309	uChar,
4310	hkl));
4311
4312	return (uChar);
4313	}
4314
4315
4316	/*****************************************************************************
4317	* Name : VOID WIN32API keybd_event
4318	* Purpose : The keybd_event function synthesizes a keystroke. The system
4319	* can use such a synthesized keystroke to generate a WM_KEYUP or
4320	* WM_KEYDOWN message. The keyboard driver's interrupt handler calls
4321	* the keybd_event function.
4322	* Parameters: BYTE bVk virtual-key code
4323
4324	* BYTE bScan hardware scan code
4325	* DWORD dwFlags flags specifying various function options
4326	* DWORD dwExtraInfo additional data associated with keystroke
4327	* Variables :
4328	* Result :
4329	* Remark :
4330	* Status : UNTESTED STUB
4331	*
4332	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4333	*****************************************************************************/
4334
4335	VOID WIN32API keybd_event (BYTE bVk,
4336	BYTE bScan,
4337	DWORD dwFlags,
4338	DWORD dwExtraInfo)
4339	{
4340	dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
4341	bVk,
4342	bScan,
4343	dwFlags,
4344	dwExtraInfo));
4345	}
4346
4347
4348	/*****************************************************************************
4349	* Name : VOID WIN32API mouse_event
4350	* Purpose : The mouse_event function synthesizes mouse motion and button clicks.
4351	* Parameters: DWORD dwFlags flags specifying various motion/click variants
4352	* DWORD dx horizontal mouse position or position change
4353	* DWORD dy vertical mouse position or position change
4354	* DWORD cButtons unused, reserved for future use, set to zero
4355	* DWORD dwExtraInfo 32 bits of application-defined information
4356	* Variables :
4357	* Result :
4358	* Remark :
4359	* Status : UNTESTED STUB
4360	*
4361	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
4362	*****************************************************************************/
4363
4364	VOID WIN32API mouse_event(DWORD dwFlags,
4365	DWORD dx,
4366	DWORD dy,
4367	DWORD cButtons,
4368	DWORD dwExtraInfo)
4369	{
4370	dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
4371	dwFlags,
4372	dx,
4373	dy,
4374	cButtons,
4375	dwExtraInfo));
4376	}
4377
4378
4379	/*****************************************************************************
4380	* Name : BOOL WIN32API SetShellWindow
4381	* Purpose : Unknown
4382	* Parameters: Unknown
4383	* Variables :
4384	* Result :
4385	* Remark :
4386	* Status : UNTESTED UNKNOWN STUB
4387	*
4388	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4389	*****************************************************************************/
4390
4391	BOOL WIN32API SetShellWindow(DWORD x1)
4392	{
4393	dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
4394	x1));
4395
4396	return (FALSE); /* default */
4397	}
4398
4399
4400	/*****************************************************************************
4401	* Name : BOOL WIN32API PlaySoundEvent
4402	* Purpose : Unknown
4403	* Parameters: Unknown
4404	* Variables :
4405	* Result :
4406	* Remark :
4407	* Status : UNTESTED UNKNOWN STUB
4408	*
4409	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4410	*****************************************************************************/
4411
4412	BOOL WIN32API PlaySoundEvent(DWORD x1)
4413	{
4414	dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
4415	x1));
4416
4417	return (FALSE); /* default */
4418	}
4419
4420
4421	/*****************************************************************************
4422	* Name : BOOL WIN32API TileChildWindows
4423	* Purpose : Unknown
4424	* Parameters: Unknown
4425	* Variables :
4426	* Result :
4427	* Remark :
4428	* Status : UNTESTED UNKNOWN STUB
4429	*
4430	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4431	*****************************************************************************/
4432
4433	BOOL WIN32API TileChildWindows(DWORD x1,
4434	DWORD x2)
4435	{
4436	dprintf(("USER32: TileChildWindows(%08xh,%08xh) not implemented.\n",
4437	x1,
4438	x2));
4439
4440	return (FALSE); /* default */
4441	}
4442
4443
4444	/*****************************************************************************
4445	* Name : BOOL WIN32API SetSysColorsTemp
4446	* Purpose : Unknown
4447	* Parameters: Unknown
4448	* Variables :
4449	* Result :
4450	* Remark :
4451	* Status : UNTESTED UNKNOWN STUB
4452	*
4453	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4454	*****************************************************************************/
4455
4456	BOOL WIN32API SetSysColorsTemp(void)
4457	{
4458	dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
4459
4460	return (FALSE); /* default */
4461	}
4462
4463
4464	/*****************************************************************************
4465	* Name : BOOL WIN32API RegisterNetworkCapabilities
4466	* Purpose : Unknown
4467	* Parameters: Unknown
4468	* Variables :
4469	* Result :
4470	* Remark :
4471	* Status : UNTESTED UNKNOWN STUB
4472	*
4473	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4474	*****************************************************************************/
4475
4476	BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
4477	DWORD x2)
4478	{
4479	dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
4480	x1,
4481	x2));
4482
4483	return (FALSE); /* default */
4484	}
4485
4486
4487	/*****************************************************************************
4488	* Name : BOOL WIN32API EndTask
4489	* Purpose : Unknown
4490	* Parameters: Unknown
4491	* Variables :
4492	* Result :
4493	* Remark :
4494	* Status : UNTESTED UNKNOWN STUB
4495	*
4496	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4497	*****************************************************************************/
4498
4499	BOOL WIN32API EndTask(DWORD x1,
4500	DWORD x2,
4501	DWORD x3)
4502	{
4503	dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
4504	x1,
4505	x2,
4506	x3));
4507
4508	return (FALSE); /* default */
4509	}
4510
4511
4512
4513	/*****************************************************************************
4514	* Name : BOOL WIN32API GetNextQueueWindow
4515	* Purpose : Unknown
4516	* Parameters: Unknown
4517	* Variables :
4518	* Result :
4519	* Remark :
4520	* Status : UNTESTED UNKNOWN STUB
4521	*
4522	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4523	*****************************************************************************/
4524
4525	BOOL WIN32API GetNextQueueWindow(DWORD x1,
4526	DWORD x2)
4527	{
4528	dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
4529	x1,
4530	x2));
4531
4532	return (FALSE); /* default */
4533	}
4534
4535
4536	/*****************************************************************************
4537	* Name : BOOL WIN32API YieldTask
4538	* Purpose : Unknown
4539	* Parameters: Unknown
4540	* Variables :
4541	* Result :
4542	* Remark :
4543	* Status : UNTESTED UNKNOWN STUB
4544	*
4545	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4546	*****************************************************************************/
4547
4548	BOOL WIN32API YieldTask(void)
4549	{
4550	dprintf(("USER32: YieldTask() not implemented.\n"));
4551
4552	return (FALSE); /* default */
4553	}
4554
4555
4556	/*****************************************************************************
4557	* Name : BOOL WIN32API WinOldAppHackoMatic
4558	* Purpose : Unknown
4559	* Parameters: Unknown
4560	* Variables :
4561	* Result :
4562	* Remark :
4563	* Status : UNTESTED UNKNOWN STUB
4564	*
4565	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4566	*****************************************************************************/
4567
4568	BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
4569	{
4570	dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
4571	x1));
4572
4573	return (FALSE); /* default */
4574	}
4575
4576
4577	/*****************************************************************************
4578	* Name : BOOL WIN32API DragObject
4579	* Purpose : Unknown
4580	* Parameters: Unknown
4581	* Variables :
4582	* Result :
4583	* Remark :
4584	* Status : UNTESTED UNKNOWN STUB
4585	*
4586	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4587	*****************************************************************************/
4588
4589	DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
4590	{
4591	dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4592	x1,
4593	x2,
4594	x3,
4595	x4,
4596	x5));
4597
4598	return (FALSE); /* default */
4599	}
4600
4601
4602	/*****************************************************************************
4603	* Name : BOOL WIN32API CascadeChildWindows
4604	* Purpose : Unknown
4605	* Parameters: Unknown
4606	* Variables :
4607	* Result :
4608	* Remark :
4609	* Status : UNTESTED UNKNOWN STUB
4610	*
4611	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4612	*****************************************************************************/
4613
4614	BOOL WIN32API CascadeChildWindows(DWORD x1,
4615	DWORD x2)
4616	{
4617	dprintf(("USER32: CascadeChildWindows(%08xh,%08xh) not implemented.\n",
4618	x1,
4619	x2));
4620
4621	return (FALSE); /* default */
4622	}
4623
4624
4625	/*****************************************************************************
4626	* Name : BOOL WIN32API RegisterSystemThread
4627	* Purpose : Unknown
4628	* Parameters: Unknown
4629	* Variables :
4630	* Result :
4631	* Remark :
4632	* Status : UNTESTED UNKNOWN STUB
4633	*
4634	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4635	*****************************************************************************/
4636
4637	BOOL WIN32API RegisterSystemThread(DWORD x1,
4638	DWORD x2)
4639	{
4640	dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
4641	x1,
4642	x2));
4643
4644	return (FALSE); /* default */
4645	}
4646
4647
4648	/*****************************************************************************
4649	* Name : BOOL WIN32API IsHungThread
4650	* Purpose : Unknown
4651	* Parameters: Unknown
4652	* Variables :
4653	* Result :
4654	* Remark :
4655	* Status : UNTESTED UNKNOWN STUB
4656	*
4657	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4658	*****************************************************************************/
4659
4660	BOOL WIN32API IsHungThread(DWORD x1)
4661	{
4662	dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
4663	x1));
4664
4665	return (FALSE); /* default */
4666	}
4667
4668
4669
4670	/*****************************************************************************
4671	* Name : BOOL WIN32API UserSignalProc
4672	* Purpose : Unknown
4673	* Parameters: Unknown
4674	* Variables :
4675	* Result :
4676	* Remark :
4677	* Status : UNTESTED UNKNOWN STUB
4678	*
4679	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4680	*****************************************************************************/
4681
4682	BOOL WIN32API UserSignalProc(DWORD x1,
4683	DWORD x2,
4684	DWORD x3,
4685	DWORD x4)
4686	{
4687	dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4688	x1,
4689	x2,
4690	x3,
4691	x4));
4692
4693	return (FALSE); /* default */
4694	}
4695
4696
4697	/*****************************************************************************
4698	* Name : BOOL WIN32API GetShellWindow
4699	* Purpose : Unknown
4700	* Parameters: Unknown
4701	* Variables :
4702	* Result :
4703	* Remark :
4704	* Status : UNTESTED UNKNOWN STUB
4705	*
4706	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
4707	*****************************************************************************/
4708
4709	HWND WIN32API GetShellWindow(void)
4710	{
4711	dprintf(("USER32: GetShellWindow() not implemented.\n"));
4712
4713	return (0); /* default */
4714	}
4715
4716
4717
4718	/***********************************************************************
4719	* RegisterTasklist32 [USER32.436]
4720	*/
4721	DWORD WIN32API RegisterTasklist (DWORD x)
4722	{
4723	dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
4724	x));
4725
4726	return TRUE;
4727	}
4728
4729

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

Download in other formats: