Context Navigation

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

Visit:

Last change on this file since 319 was 317, checked in by cbratschi, 26 years ago
Button from WINE, first user32.cpp work
File size: 171.8 KB

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

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

Download in other formats: