Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

user32.cpp

Visit:

Last change on this file was 21916, checked in by dmik, 14 years ago
Merge branch gcc-kmk to trunk.
File size: 79.5 KB

Line
1	/* $Id: user32.cpp,v 1.134 2004-03-16 10:06:44 sandervl Exp $ */
2
3	/*
4	* Win32 misc user32 API functions for OS/2
5	*
6	* Copyright 1998 Sander van Leeuwen
7	* Copyright 1998 Patrick Haller
8	* Copyright 1998 Peter Fitzsimmons
9	* Copyright 1999 Christoph Bratschi
10	* Copyright 1999 Daniela Engert (dani@ngrt.de)
11	*
12	* Partly based on Wine code (windows\sysparams.c: SystemParametersInfoA)
13	*
14	* Copyright 1994 Alexandre Julliard
15	*
16	*
17	* Project Odin Software License can be found in LICENSE.TXT
18	*
19	*/
20	/*****************************************************************************
21	* Name : USER32.CPP
22	* Purpose : This module maps all Win32 functions contained in USER32.DLL
23	* to their OS/2-specific counterparts as far as possible.
24	*****************************************************************************/
25
26	//Attention: many functions belong to other subsystems, move them to their
27	// right place!
28
29	#include <odin.h>
30	#include <odinwrap.h>
31	#include <os2sel.h>
32
33	#include <os2win.h>
34	#include <misc.h>
35	#include <winuser32.h>
36
37	#include "user32.h"
38	#include <winicon.h>
39	#include "syscolor.h"
40	#include "pmwindow.h"
41	#include "oslibgdi.h"
42	#include "oslibwin.h"
43	#include "oslibprf.h"
44
45	#include <wchar.h>
46	#include <stdlib.h>
47	#include <string.h>
48	//#include "oslibwin.h"
49	#include <winuser.h>
50	#include "win32wnd.h"
51	#include "initterm.h"
52
53	#define DBG_LOCALLOG DBG_user32
54	#include "dbglocal.h"
55
56	//undocumented stuff
57	// WIN32API ClientThreadConnect
58	// WIN32API DragObject
59	// WIN32API DrawFrame
60	// WIN32API EditWndProc
61	// WIN32API EndTask
62	// WIN32API GetInputDesktop
63	// WIN32API GetNextQueueWindow
64	// WIN32API GetShellWindow
65	// WIN32API InitSharedTable
66	// WIN32API InitTask
67	// WIN32API IsHungThread
68	// WIN32API LockWindowStation
69	// WIN32API ModifyAccess
70	// WIN32API PlaySoundEvent
71	// WIN32API RegisterLogonProcess
72	// WIN32API RegisterNetworkCapabilities
73	// WIN32API RegisterSystemThread
74	// WIN32API SetDeskWallpaper
75	// WIN32API SetDesktopBitmap
76	// WIN32API SetInternalWindowPos
77	// WIN32API SetLogonNotifyWindow
78	// WIN32API SetShellWindow
79	// WIN32API SetSysColorsTemp
80	// WIN32API SetWindowFullScreenState
81	// WIN32API SwitchToThisWindow
82	// WIN32API SysErrorBox
83	// WIN32API UnlockWindowStation
84	// WIN32API UserClientDllInitialize
85	// WIN32API UserSignalProc
86	// WIN32API WinOldAppHackoMatic
87	// WIN32API WNDPROC_CALLBACK
88	// WIN32API YieldTask
89
90	ODINDEBUGCHANNEL(USER32-USER32)
91
92	#ifdef __cplusplus
93	extern "C" {
94	#endif
95
96	/* Coordinate Transformation */
97
98	/* Rectangle Functions - parts from wine/windows/rect.c */
99
100	BOOL WIN32API CopyRect( PRECT lprcDst, const RECT * lprcSrc)
101	{
102	dprintf2(("USER32: CopyRect\n"));
103	if (!lprcDst \|\| !lprcSrc) {
104	SetLastError(ERROR_INVALID_PARAMETER);
105	return FALSE;
106	}
107
108	memcpy(lprcDst,lprcSrc,sizeof(RECT));
109
110	return TRUE;
111	}
112	//******************************************************************************
113	//******************************************************************************
114	BOOL WIN32API EqualRect( const RECT lprc1, const RECT lprc2)
115	{
116	dprintf2(("USER32: EqualRect\n"));
117	if (!lprc1 \|\| !lprc2)
118	{
119	SetLastError(ERROR_INVALID_PARAMETER);
120	return FALSE;
121	}
122
123	dprintf2(("USER32: EqualRect (%d,%d)(%d,%d) (%d,%d)(%d,%d)", lprc1->left, lprc1->top, lprc1->right, lprc1->bottom, lprc2->left, lprc2->top, lprc2->right, lprc2->bottom));
124	return (lprc1->left == lprc2->left &&
125	lprc1->right == lprc2->right &&
126	lprc1->top == lprc2->top &&
127	lprc1->bottom == lprc2->bottom);
128	}
129	//******************************************************************************
130	//******************************************************************************
131	BOOL WIN32API InflateRect( PRECT lprc, int dx, int dy)
132	{
133	dprintf2(("USER32: InflateRect (%d,%d)(%d,%d) %d,%d", lprc->left, lprc->top, lprc->right, lprc->bottom, dx, dy));
134	if (!lprc)
135	{
136	SetLastError(ERROR_INVALID_PARAMETER);
137	return FALSE;
138	}
139
140	lprc->left -= dx;
141	lprc->right += dx;
142	lprc->top -= dy;
143	lprc->bottom += dy;
144
145	return TRUE;
146	}
147	//******************************************************************************
148	//******************************************************************************
149	BOOL WIN32API IntersectRect( PRECT lprcDst, const RECT * lprcSrc1, const RECT * lprcSrc2)
150	{
151	dprintf2(("USER32: IntersectRect (%d,%d)(%d,%d) (%d,%d)(%d,%d)", lprcSrc1->left, lprcSrc1->top, lprcSrc1->right, lprcSrc1->bottom, lprcSrc2->left, lprcSrc2->top, lprcSrc2->right, lprcSrc2->bottom));
152	if (!lprcSrc1 \|\| !lprcSrc2)
153	{
154	SetLastError(ERROR_INVALID_PARAMETER);
155	return FALSE;
156	}
157
158	if (IsRectEmpty(lprcSrc1) \|\| IsRectEmpty(lprcSrc2) \|\|
159	(lprcSrc1->left >= lprcSrc2->right) \|\| (lprcSrc2->left >= lprcSrc1->right) \|\|
160	(lprcSrc1->top >= lprcSrc2->bottom) \|\| (lprcSrc2->top >= lprcSrc1->bottom))
161	{
162	//SvL: NT doesn't set the last error here
163	//SetLastError(ERROR_INVALID_PARAMETER);
164	if (lprcDst) SetRectEmpty(lprcDst);
165	return FALSE;
166	}
167	if (lprcDst)
168	{
169	lprcDst->left = MAX(lprcSrc1->left,lprcSrc2->left);
170	lprcDst->right = MIN(lprcSrc1->right,lprcSrc2->right);
171	lprcDst->top = MAX(lprcSrc1->top,lprcSrc2->top);
172	lprcDst->bottom = MIN(lprcSrc1->bottom,lprcSrc2->bottom);
173	dprintf2(("USER32: IntersectRect result: (%d,%d)(%d,%d)", lprcDst->left, lprcDst->top, lprcDst->right, lprcDst->bottom));
174	}
175
176	return TRUE;
177	}
178	//******************************************************************************
179	//******************************************************************************
180	BOOL WIN32API IsRectEmpty( const RECT * lprc)
181	{
182	if (!lprc)
183	{
184	SetLastError(ERROR_INVALID_PARAMETER);
185	return FALSE;
186	}
187
188	return (lprc->left == lprc->right \|\| lprc->top == lprc->bottom);
189	}
190	//******************************************************************************
191	//******************************************************************************
192	BOOL WIN32API OffsetRect( PRECT lprc, int x, int y)
193	{
194	dprintf2(("USER32: OffsetRect (%d,%d)(%d,%d) %d %d", lprc->left, lprc->top, lprc->right, lprc->bottom, x, y));
195	if (!lprc)
196	{
197	SetLastError(ERROR_INVALID_PARAMETER);
198	return FALSE;
199	}
200
201	lprc->left += x;
202	lprc->right += x;
203	lprc->top += y;
204	lprc->bottom += y;
205
206	return TRUE;
207	}
208	//******************************************************************************
209	//******************************************************************************
210	BOOL WIN32API PtInRect( const RECT *lprc, POINT pt)
211	{
212	dprintf2(("USER32: PtInRect (%d,%d)(%d,%d) (%d,%d)", lprc->left, lprc->top, lprc->right, lprc->bottom, pt.x, pt.y));
213	if (!lprc)
214	{
215	SetLastError(ERROR_INVALID_PARAMETER);
216	return FALSE;
217	}
218
219	return (pt.x >= lprc->left &&
220	pt.x < lprc->right &&
221	pt.y >= lprc->top &&
222	pt.y < lprc->bottom);
223	}
224	//******************************************************************************
225	//******************************************************************************
226	BOOL WIN32API SetRect( PRECT lprc, int nLeft, int nTop, int nRight, int nBottom)
227	{
228	if (!lprc)
229	{
230	SetLastError(ERROR_INVALID_PARAMETER);
231	return FALSE;
232	}
233
234	lprc->left = nLeft;
235	lprc->top = nTop;
236	lprc->right = nRight;
237	lprc->bottom = nBottom;
238
239	return TRUE;
240	}
241	//******************************************************************************
242	//******************************************************************************
243	BOOL WIN32API SetRectEmpty( PRECT lprc)
244	{
245	if (!lprc)
246	{
247	SetLastError(ERROR_INVALID_PARAMETER);
248	return FALSE;
249	}
250
251	lprc->left = lprc->right = lprc->top = lprc->bottom = 0;
252
253	return TRUE;
254	}
255	//******************************************************************************
256	//******************************************************************************
257	BOOL WIN32API SubtractRect( PRECT lprcDest, const RECT * lprcSrc1, const RECT * lprcSrc2)
258	{
259	dprintf2(("USER32: SubtractRect"));
260	RECT tmp;
261
262	if (!lprcDest \|\| !lprcSrc1 \|\| !lprcSrc2)
263	{
264	SetLastError(ERROR_INVALID_PARAMETER);
265	return FALSE;
266	}
267
268	if (IsRectEmpty(lprcSrc1))
269	{
270	SetLastError(ERROR_INVALID_PARAMETER);
271	SetRectEmpty(lprcDest);
272	return FALSE;
273	}
274	lprcDest = lprcSrc1;
275	if (IntersectRect(&tmp,lprcSrc1,lprcSrc2))
276	{
277	if (EqualRect(&tmp,lprcDest))
278	{
279	SetRectEmpty(lprcDest);
280	return FALSE;
281	}
282	if ((tmp.top == lprcDest->top) && (tmp.bottom == lprcDest->bottom))
283	{
284	if (tmp.left == lprcDest->left) lprcDest->left = tmp.right;
285	else if (tmp.right == lprcDest->right) lprcDest->right = tmp.left;
286	}
287	else if ((tmp.left == lprcDest->left) && (tmp.right == lprcDest->right))
288	{
289	if (tmp.top == lprcDest->top) lprcDest->top = tmp.bottom;
290	else if (tmp.bottom == lprcDest->bottom) lprcDest->bottom = tmp.top;
291	}
292	}
293
294	return TRUE;
295	}
296	//******************************************************************************
297	//******************************************************************************
298	BOOL WIN32API UnionRect( PRECT lprcDst, const RECT lprcSrc1, const RECT lprcSrc2)
299	{
300	dprintf2(("USER32: UnionRect\n"));
301	if (!lprcDst \|\| !lprcSrc1 \|\| !lprcSrc2)
302	{
303	SetLastError(ERROR_INVALID_PARAMETER);
304	return FALSE;
305	}
306
307	if (IsRectEmpty(lprcSrc1))
308	{
309	if (IsRectEmpty(lprcSrc2))
310	{
311	SetLastError(ERROR_INVALID_PARAMETER);
312	SetRectEmpty(lprcDst);
313	return FALSE;
314	}
315	else lprcDst = lprcSrc2;
316	}
317	else
318	{
319	if (IsRectEmpty(lprcSrc2)) lprcDst = lprcSrc1;
320	else
321	{
322	lprcDst->left = MIN(lprcSrc1->left,lprcSrc2->left);
323	lprcDst->right = MAX(lprcSrc1->right,lprcSrc2->right);
324	lprcDst->top = MIN(lprcSrc1->top,lprcSrc2->top);
325	lprcDst->bottom = MAX(lprcSrc1->bottom,lprcSrc2->bottom);
326	}
327	}
328
329	return TRUE;
330	}
331
332	/* Mouse Input Functions */
333
334	/* Error Functions */
335
336	/*****************************************************************************
337	* Name : ExitWindowsEx
338	* Purpose : Shutdown System
339	* Parameters: UINT uFlags
340	* DWORD dwReserved
341	* Variables :
342	* Result : TRUE / FALSE
343	* Remark :
344	* Status :
345	*
346	* Author : Patrick Haller [Tue, 1999/10/20 21:24]
347	*****************************************************************************/
348
349	BOOL WIN32API ExitWindowsEx(UINT uFlags, DWORD dwReserved)
350	{
351	int rc = MessageBoxA(HWND_DESKTOP,
352	"Are you sure you want to shutdown the OS/2 system?",
353	"Shutdown ...",
354	MB_YESNOCANCEL \| MB_ICONQUESTION);
355	switch (rc)
356	{
357	case IDCANCEL: return (FALSE);
358	case IDYES: break;
359	case IDNO:
360	dprintf(("no shutdown!\n"));
361	return TRUE;
362	}
363
364	return O32_ExitWindowsEx(uFlags,dwReserved);
365	}
366
367
368	//******************************************************************************
369	//******************************************************************************
370	BOOL WIN32API MessageBeep( UINT uType)
371	{
372	INT flStyle;
373
374	dprintf(("USER32: MessageBeep\n"));
375
376	switch (uType)
377	{
378	case 0xFFFFFFFF:
379	Beep(500,50);
380	return TRUE;
381	case MB_ICONASTERISK:
382	flStyle = WAOS_NOTE;
383	break;
384	case MB_ICONEXCLAMATION:
385	flStyle = WAOS_WARNING;
386	break;
387	case MB_ICONHAND:
388	case MB_ICONQUESTION:
389	case MB_OK:
390	flStyle = WAOS_NOTE;
391	break;
392	default:
393	flStyle = WAOS_ERROR; //CB: should be right
394	break;
395	}
396	return OSLibWinAlarm(OSLIB_HWND_DESKTOP,flStyle);
397	}
398	//******************************************************************************
399	//2nd parameter not used according to SDK (yet?)
400	//******************************************************************************
401	VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
402	{
403	dprintf(("USER32: SetLastErrorEx %x %x", dwErrCode, dwType));
404	SetLastError(dwErrCode);
405	}
406
407	/* Accessibility Functions */
408
409	int WIN32API GetSystemMetrics(int nIndex)
410	{
411	int rc = 0;
412
413	switch(nIndex) {
414	case SM_CXSCREEN:
415	rc = ScreenWidth;
416	break;
417
418	case SM_CYSCREEN:
419	rc = ScreenHeight;
420	break;
421
422	case SM_CXVSCROLL:
423	rc = OSLibWinQuerySysValue(SVOS_CXVSCROLL);
424	break;
425
426	case SM_CYHSCROLL:
427	rc = OSLibWinQuerySysValue(SVOS_CYHSCROLL);
428	break;
429
430	case SM_CYCAPTION:
431	if(fOS2Look) {
432	rc = OSLibWinQuerySysValue(SVOS_CYTITLEBAR);
433	}
434	else rc = 19;
435	break;
436
437	case SM_CXBORDER:
438	case SM_CYBORDER:
439	rc = 1;
440	break;
441
442	case SM_CXDLGFRAME:
443	case SM_CYDLGFRAME:
444	rc = 3;
445	break;
446
447	case SM_CYMENU:
448	case SM_CXMENUSIZE:
449	case SM_CYMENUSIZE:
450	if(fOS2Look) {
451	rc = OSLibWinQuerySysValue(SVOS_CYMENU);
452	}
453	else rc = 19;
454	break;
455
456	case SM_CXSIZE:
457	case SM_CYSIZE:
458	rc = GetSystemMetrics(SM_CYCAPTION)-2;
459	break;
460
461	case SM_CXFRAME:
462	case SM_CYFRAME:
463	rc = 4;
464	break;
465
466	case SM_CXEDGE:
467	case SM_CYEDGE:
468	rc = 2;
469	break;
470
471	case SM_CXMINSPACING:
472	rc = 160;
473	break;
474
475	case SM_CYMINSPACING:
476	rc = 24;
477	break;
478
479	case SM_CXSMICON:
480	case SM_CYSMICON:
481	rc = 16;
482	break;
483
484	case SM_CYSMCAPTION:
485	rc = 16;
486	break;
487
488	case SM_CXSMSIZE:
489	case SM_CYSMSIZE:
490	rc = 15;
491	break;
492
493	//CB: todo: add missing metrics
494
495	case SM_CXICONSPACING: //Size of grid cell for large icons (view in File dialog)
496	rc = 64; //In NT4 it's (90,64)
497	break;
498
499	case SM_CYICONSPACING:
500	//read SM_CXICONSPACING comment
501	rc = 64;
502	break;
503
504	case SM_PENWINDOWS:
505	rc = FALSE;
506	break;
507	case SM_DBCSENABLED:
508	rc = FALSE;
509	break;
510	case SM_CXICON:
511	case SM_CYICON:
512	rc = 32; //CB: Win32: only 32x32, OS/2 32x32/40x40
513	// we must implement 32x32 for all screen resolutions
514	break;
515	case SM_ARRANGE:
516	rc = ARW_BOTTOMLEFT \| ARW_LEFT;
517	break;
518	case SM_CXMINIMIZED:
519	break;
520	case SM_CYMINIMIZED:
521	break;
522
523	case SM_CXMINTRACK:
524	case SM_CXMIN:
525	rc = 112;
526	break;
527
528	case SM_CYMINTRACK:
529	case SM_CYMIN:
530	rc = 27;
531	break;
532
533	case SM_CXMAXTRACK: //max window size
534	case SM_CXMAXIMIZED: //max toplevel window size
535	rc = OSLibWinQuerySysValue(SVOS_CXSCREEN);
536	break;
537
538	case SM_CYMAXTRACK:
539	case SM_CYMAXIMIZED:
540	rc = OSLibWinQuerySysValue(SVOS_CYSCREEN);
541	break;
542
543	case SM_NETWORK:
544	rc = 0x01; //TODO: default = yes
545	break;
546	case SM_CLEANBOOT:
547	rc = 0; //normal boot
548	break;
549	case SM_CXDRAG: //nr of pixels before drag becomes a real one
550	rc = 2;
551	break;
552	case SM_CYDRAG:
553	rc = 2;
554	break;
555	case SM_SHOWSOUNDS: //show instead of play sound
556	rc = FALSE;
557	break;
558	case SM_CXMENUCHECK:
559	rc = 13; //TODO
560	break;
561	case SM_CYMENUCHECK:
562	rc = OSLibWinQuerySysValue(SVOS_CYMENU);
563	break;
564	case SM_SLOWMACHINE:
565	rc = FALSE; //even a slow machine is fast with OS/2 :)
566	break;
567	case SM_MIDEASTENABLED:
568	rc = FALSE;
569	break;
570	case SM_MOUSEWHEELPRESENT:
571	rc = FALSE;
572	break;
573	case SM_XVIRTUALSCREEN:
574	rc = 0;
575	break;
576	case SM_YVIRTUALSCREEN:
577	rc = 0;
578	break;
579
580	case SM_CXVIRTUALSCREEN:
581	rc = OSLibWinQuerySysValue(SVOS_CXSCREEN);
582	break;
583	case SM_CYVIRTUALSCREEN:
584	rc = OSLibWinQuerySysValue(SVOS_CYSCREEN);
585	break;
586	case SM_CMONITORS:
587	rc = 1;
588	break;
589	case SM_SAMEDISPLAYFORMAT:
590	rc = TRUE;
591	break;
592	case SM_CMETRICS:
593	rc = 81;
594	//rc = O32_GetSystemMetrics(44); //Open32 changed this one
595	break;
596	default:
597	//better than nothing
598	rc = O32_GetSystemMetrics(nIndex);
599	break;
600	}
601	dprintf2(("USER32: GetSystemMetrics %d returned %d\n", nIndex, rc));
602	return(rc);
603	}
604	//******************************************************************************
605	/* Not support by Open32 (not included are the new win9x parameters):
606	case SPI_GETFASTTASKSWITCH:
607	case SPI_GETGRIDGRANULARITY:
608	case SPI_GETICONTITLELOGFONT:
609	case SPI_GETICONTITLEWRAP:
610	case SPI_GETMENUDROPALIGNMENT:
611	case SPI_LANGDRIVER:
612	case SPI_SETFASTTASKSWITCH:
613	case SPI_SETGRIDGRANULARITY:
614	case SPI_SETICONTITLELOGFONT:
615	case SPI_SETICONTITLEWRAP:
616	case SPI_SETMENUDROPALIGNMENT:
617	case SPI_GETSCREENSAVEACTIVE:
618	case SPI_GETSCREENSAVETIMEOUT:
619	case SPI_SETDESKPATTERN:
620	case SPI_SETDESKWALLPAPER:
621	case SPI_SETSCREENSAVEACTIVE:
622	case SPI_SETSCREENSAVETIMEOUT:
623	*/
624	static int dwScreenSaveTimeout = 180;
625	static BOOL fScreenSaveActive = FALSE;
626	static int fDragFullWindows = -1;
627	//******************************************************************************
628	BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
629	{
630	BOOL rc = TRUE;
631
632	dprintf(("USER32: SystemParametersInfoA uiAction: %d, uiParam: %d, pvParam: %d, fWinIni: %d\n",
633	uiAction, uiParam, pvParam, fWinIni));
634
635	switch(uiAction) {
636
637	case SPI_GETBEEP:
638	(ULONG)pvParam = OSLibWinQuerySysValue(SVOS_ALARM);
639	break;
640
641	case SPI_GETKEYBOARDDELAY:
642	*(PULONG)pvParam = OSLibPrfQueryProfileInt(OSLIB_HINI_USER, "PM_ControlPanel",
643	"KeyRepeatDelay", 90);
644	break;
645
646	case SPI_GETKEYBOARDSPEED:
647	*(PULONG)pvParam = OSLibPrfQueryProfileInt(OSLIB_HINI_USER, "PM_ControlPanel",
648	"KeyRepeatRate", 19);
649	break;
650
651	#if 0
652	// TODO: Make OSLib a seperate DLL and use it everywhere?
653	case SPI_GETMOUSE:
654	{
655	ULONG retCode;
656	retCode = OSLibDosOpen(
657	break;
658	}
659	#endif
660
661	case SPI_SETBEEP:
662	// we don't do anything here. Win32 apps shouldn't change OS/2 settings
663	dprintf(("USER32: SPI_SETBEEP is ignored!\n"));
664	break;
665
666	case SPI_SETBORDER:
667	// TODO make this for Win32 apps only, Open32 changes OS/2 settings!
668	dprintf(("USER32: SPI_SETBORDER is ignored, implement!\n"));
669	break;
670
671	case SPI_SETDOUBLECLKHEIGHT:
672	// TODO make this for Win32 apps only, Open32 changes OS/2 settings!
673	dprintf(("USER32: SPI_SETDOUBLECLICKHEIGHT is ignored, implement!\n"));
674	break;
675
676	case SPI_SETDOUBLECLKWIDTH:
677	// TODO make this for Win32 apps only, Open32 changes OS/2 settings!
678	dprintf(("USER32: SPI_SETDOUBLECLICKWIDTH is ignored, implement!\n"));
679	break;
680
681	case SPI_SETDOUBLECLICKTIME:
682	// TODO make this for Win32 apps only, Open32 changes OS/2 settings!
683	dprintf(("USER32: SPI_SETDOUBLECLICKTIME is ignored, implement!\n"));
684	break;
685
686	case SPI_SETKEYBOARDDELAY:
687	// TODO make this for Win32 apps only, Open32 changes OS/2 settings!
688	dprintf(("USER32: SPI_SETKEYBOARDDELAY is ignored, implement!\n"));
689	break;
690
691	case SPI_SETKEYBOARDSPEED:
692	// TODO make this for Win32 apps only, Open32 changes OS/2 settings!
693	dprintf(("USER32: SPI_SETKEYBOARDSPEED is ignored, implement!\n"));
694	break;
695
696	case SPI_SETMOUSE:
697	// TODO make this for Win32 apps only, Open32 changes OS/2 settings!
698	dprintf(("USER32: SPI_SETMOUSE is ignored, implement!\n"));
699	break;
700
701	case SPI_SETMOUSESPEED:
702	dprintf(("USER32: SPI_SETMOUSESPEED is ignored, implement!\n"));
703	break;
704
705	case SPI_SETMOUSEBUTTONSWAP:
706	// TODO make this for Win32 apps only, Open32 changes OS/2 settings!
707	dprintf(("USER32: SPI_SETMOUSEBUTTONSWAP is ignored, implement!\n"));
708	break;
709
710	case SPI_SCREENSAVERRUNNING:
711	(BOOL )pvParam = FALSE;
712	break;
713
714	case SPI_GETSCREENSAVETIMEOUT:
715	if(pvParam) {
716	(DWORD )pvParam = dwScreenSaveTimeout;
717	}
718	break;
719
720	case SPI_SETSCREENSAVETIMEOUT:
721	if(pvParam) {
722	dwScreenSaveTimeout = uiParam;
723	}
724	break;
725
726	case SPI_GETSCREENSAVEACTIVE:
727	if(pvParam) {
728	(BOOL )pvParam = fScreenSaveActive;
729	}
730	break;
731
732	case SPI_SETSCREENSAVEACTIVE:
733	if(pvParam) {
734	fScreenSaveActive = uiParam;
735	}
736	break;
737
738	case SPI_GETDRAGFULLWINDOWS:
739	if(fDragFullWindows == -1)
740	{
741	(BOOL )pvParam = OSLibWinQuerySysValue(SVOS_DYNAMICDRAG);
742	}
743	else (BOOL )pvParam = fDragFullWindows;
744
745	break;
746
747	case SPI_SETDRAGFULLWINDOWS:
748	fDragFullWindows = uiParam;
749	break;
750
751	case SPI_ICONHORIZONTALSPACING:
752	(INT )pvParam = 75; //GetSystemMetrics(SM_CXICONSPACING);
753	break;
754
755	case SPI_ICONVERTICALSPACING:
756	(INT )pvParam = 75; //GetSystemMetrics(SM_CYICONSPACING);
757	break;
758
759	case SPI_GETNONCLIENTMETRICS:
760	{
761	LPNONCLIENTMETRICSA lpnm = (LPNONCLIENTMETRICSA)pvParam;
762
763	if (lpnm->cbSize == sizeof(NONCLIENTMETRICSA) \|\| uiParam == sizeof(NONCLIENTMETRICSA))
764	{
765	memset(lpnm, 0, sizeof(NONCLIENTMETRICSA));
766	lpnm->cbSize = sizeof(NONCLIENTMETRICSA);
767
768	SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfCaptionFont),0);
769	lpnm->lfCaptionFont.lfWeight = FW_BOLD;
770	lpnm->iCaptionWidth = GetSystemMetrics(SM_CXSIZE);
771	lpnm->iCaptionHeight = GetSystemMetrics(SM_CYSIZE);
772
773	SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfSmCaptionFont),0);
774	lpnm->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
775	lpnm->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
776
777	LPLOGFONTA lpLogFont = &(lpnm->lfMenuFont);
778	if(fOS2Look) {
779	char fontname[128];
780	char *pszFontName;
781	BOOL fFound = TRUE;
782
783	if(OSLibPrfQueryProfileString(OSLIB_HINI_USER, "PM_SystemFonts", "Menus", "", fontname, sizeof(fontname)) == 1) {
784	if(OSLibPrfQueryProfileString(OSLIB_HINI_USER, "PM_SystemFonts", "DefaultFont", "", fontname, sizeof(fontname)) == 1) {
785	fFound = FALSE;
786	}
787	}
788	if(fFound) {
789	pszFontName = fontname;
790	while(pszFontName != '.' && pszFontName != 0) pszFontName++;
791	if(*pszFontName) {
792	*pszFontName++ = 0;
793
794	strncpy(lpLogFont->lfFaceName, pszFontName, sizeof(lpLogFont->lfFaceName));
795	lpLogFont->lfFaceName[sizeof(lpLogFont->lfFaceName)-1] = 0;
796	lpLogFont->lfWeight = FW_NORMAL;
797
798	// AH 2001-12-26 use the font size returned by the graphics
799	// driver as the font height. This will take font size settings
800	// such as small, medium and large fonts into account
801	//SvL: Must be negative
802	lpLogFont->lfHeight = -CapsCharHeight;
803	}
804	else fFound = FALSE;
805	}
806	if(!fFound) {
807	GetProfileStringA("Desktop", "MenuFont", "WarpSans",
808	lpLogFont->lfFaceName, LF_FACESIZE);
809	lpLogFont->lfWeight = FW_BOLD;
810	// AH 2001-12-26 take graphics driver font size setting
811	lpLogFont->lfHeight = -GetProfileIntA("Desktop","MenuFontSize", CapsCharHeight);
812	}
813	lpLogFont->lfWidth = 0;
814	lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
815	}
816	else {
817	GetProfileStringA("Desktop", "MenuFont", "MS Sans Serif",
818	lpLogFont->lfFaceName, LF_FACESIZE);
819	lpLogFont->lfWeight = FW_NORMAL;
820	lpLogFont->lfHeight = -GetProfileIntA("Desktop","MenuFontSize", 13);
821	lpLogFont->lfWidth = 0;
822	lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
823	}
824	lpLogFont->lfItalic = FALSE;
825	lpLogFont->lfStrikeOut = FALSE;
826	lpLogFont->lfUnderline = FALSE;
827	lpLogFont->lfCharSet = ANSI_CHARSET;
828	lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
829	lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
830	lpLogFont->lfPitchAndFamily = DEFAULT_PITCH \| FF_SWISS;
831
832	SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0,
833	(LPVOID)&(lpnm->lfStatusFont),0);
834	SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0,
835	(LPVOID)&(lpnm->lfMessageFont),0);
836
837	lpnm->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
838	lpnm->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
839	lpnm->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
840	lpnm->iMenuHeight = GetSystemMetrics(SM_CYMENU);
841	lpnm->iMenuWidth = lpnm->iMenuHeight; //TODO
842	}
843	else
844	{
845	dprintf(("SPI_GETNONCLIENTMETRICS: size mismatch !! (is %d; should be %d)\n", lpnm->cbSize, sizeof(NONCLIENTMETRICSA)));
846	/* FIXME: SetLastError? */
847	rc = FALSE;
848	}
849	break;
850	}
851
852	case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
853	{
854	LPICONMETRICSA lpIcon = (LPICONMETRICSA)pvParam;
855	if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
856	{
857	SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0,
858	&lpIcon->iHorzSpacing, FALSE );
859	SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0,
860	&lpIcon->iVertSpacing, FALSE );
861	SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0,
862	&lpIcon->iTitleWrap, FALSE );
863	SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0,
864	&lpIcon->lfFont, FALSE );
865	}
866	else
867	{
868	dprintf(("SPI_GETICONMETRICS: size mismatch !! (is %d; should be %d)\n", lpIcon->cbSize, sizeof(ICONMETRICSA)));
869	/* FIXME: SetLastError? */
870	rc = FALSE;
871	}
872	break;
873	}
874
875	case SPI_GETICONTITLELOGFONT:
876	{
877	LPLOGFONTA lpLogFont = (LPLOGFONTA)pvParam;
878
879	/* from now on we always have an alias for MS Sans Serif */
880	strcpy(lpLogFont->lfFaceName, "MS Sans Serif");
881	lpLogFont->lfHeight = -GetProfileIntA("Desktop","IconTitleSize", /8/12); //CB: 8 is too small
882	lpLogFont->lfWidth = 0;
883	lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
884	lpLogFont->lfWeight = FW_NORMAL;
885	lpLogFont->lfItalic = FALSE;
886	lpLogFont->lfStrikeOut = FALSE;
887	lpLogFont->lfUnderline = FALSE;
888	lpLogFont->lfCharSet = ANSI_CHARSET;
889	lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
890	lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
891	lpLogFont->lfPitchAndFamily = DEFAULT_PITCH \| FF_SWISS;
892	break;
893	}
894	case SPI_GETBORDER:
895	(INT )pvParam = GetSystemMetrics( SM_CXFRAME );
896	break;
897
898	case SPI_GETWORKAREA:
899	SetRect( (RECT *)pvParam, 0, 0,
900	GetSystemMetrics( SM_CXSCREEN ),
901	GetSystemMetrics( SM_CYSCREEN )
902	);
903	break;
904
905	case SPI_GETWHEELSCROLLLINES:
906	//nr of lines scrolled when the mouse wheel is rotated
907	if(pvParam) {
908	(UINT )pvParam = 1;
909	}
910	break;
911
912	default:
913	dprintf(("System parameter value is not supported!\n"));
914	rc = FALSE;
915	// AH: no longer call Open32
916	//rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
917	break;
918	}
919	dprintf(("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc));
920	return(rc);
921	}
922	//******************************************************************************
923	//TODO: Check for more options that have different structs for Unicode!!!!
924	//******************************************************************************
925	BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
926	{
927	BOOL rc = TRUE;
928	NONCLIENTMETRICSW clientMetricsW = (NONCLIENTMETRICSW )pvParam;
929	NONCLIENTMETRICSA clientMetricsA = {0};
930	PVOID pvParamA;
931	UINT uiParamA;
932
933	switch(uiAction) {
934	case SPI_SETNONCLIENTMETRICS:
935	clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
936	clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
937	clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
938	clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
939	clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
940	ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
941	clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
942	clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
943	ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
944	clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
945	clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
946	ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
947	ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
948	ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
949	//no break
950	case SPI_GETNONCLIENTMETRICS:
951	// Fix: set the structure size in any case (SET and GET!)
952	clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
953
954	uiParamA = sizeof(NONCLIENTMETRICSA);
955	pvParamA = &clientMetricsA;
956	break;
957
958	case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
959	{
960	LPICONMETRICSW lpIcon = (LPICONMETRICSW)pvParam;
961	if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
962	{
963	SystemParametersInfoW( SPI_ICONHORIZONTALSPACING, 0,
964	&lpIcon->iHorzSpacing, FALSE );
965	SystemParametersInfoW( SPI_ICONVERTICALSPACING, 0,
966	&lpIcon->iVertSpacing, FALSE );
967	SystemParametersInfoW( SPI_GETICONTITLEWRAP, 0,
968	&lpIcon->iTitleWrap, FALSE );
969	SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0,
970	&lpIcon->lfFont, FALSE );
971	return TRUE;
972	}
973	else
974	{
975	dprintf(("SPI_GETICONMETRICS: size mismatch !! (is %d; should be %d)\n", lpIcon->cbSize, sizeof(ICONMETRICSA)));
976	/* FIXME: SetLastError? */
977	return FALSE;
978	}
979	}
980
981	case SPI_GETICONTITLELOGFONT:
982	{
983	LPLOGFONTW lpLogFont = (LPLOGFONTW)pvParam;
984
985	/* from now on we always have an alias for MS Sans Serif */
986	lstrcpyW(lpLogFont->lfFaceName, (LPCWSTR)L"MS Sans Serif");
987	lpLogFont->lfHeight = -GetProfileIntA("Desktop","IconTitleSize", /8/12); //CB: 8 is too small
988	lpLogFont->lfWidth = 0;
989	lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
990	lpLogFont->lfWeight = FW_NORMAL;
991	lpLogFont->lfItalic = FALSE;
992	lpLogFont->lfStrikeOut = FALSE;
993	lpLogFont->lfUnderline = FALSE;
994	lpLogFont->lfCharSet = ANSI_CHARSET;
995	lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
996	lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
997	lpLogFont->lfPitchAndFamily = DEFAULT_PITCH \| FF_SWISS;
998	return TRUE;
999	}
1000	default:
1001	pvParamA = pvParam;
1002	uiParamA = uiParam;
1003	break;
1004	}
1005	rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
1006
1007	switch(uiAction) {
1008	case SPI_GETNONCLIENTMETRICS:
1009	clientMetricsW->cbSize = sizeof(*clientMetricsW);
1010	clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
1011	clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
1012	clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
1013	clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
1014	clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
1015	ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
1016
1017	clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
1018	clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
1019	ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
1020
1021	clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
1022	clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
1023	ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
1024	ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
1025	ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
1026	break;
1027	}
1028	dprintf(("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc));
1029	return(rc);
1030	}
1031
1032	/* Help Functions */
1033
1034	BOOL WIN32API WinHelpA( HWND hwnd, LPCSTR lpszHelp, UINT uCommand, DWORD dwData)
1035	{
1036	static WORD WM_WINHELP = 0;
1037	HWND hDest;
1038	LPWINHELP lpwh;
1039	HINSTANCE winhelp;
1040	int size,dsize,nlen;
1041	BOOL ret;
1042
1043	dprintf(("USER32: WinHelpA %x %s %d %x", hwnd, lpszHelp, uCommand, dwData));
1044
1045	if(!WM_WINHELP)
1046	{
1047	WM_WINHELP=RegisterWindowMessageA("WM_WINHELP");
1048	if(!WM_WINHELP)
1049	return FALSE;
1050	}
1051
1052	hDest = FindWindowA( "MS_WINHELP", NULL );
1053	if(!hDest)
1054	{
1055	if(uCommand == HELP_QUIT)
1056	return TRUE;
1057	else
1058	winhelp = WinExec ( "winhlp32.exe -x", SW_SHOWNORMAL );
1059	if ( winhelp <= 32 ) return FALSE;
1060	if ( ! ( hDest = FindWindowA ( "MS_WINHELP", NULL ) )) return FALSE;
1061	}
1062
1063	switch(uCommand)
1064	{
1065	case HELP_CONTEXT:
1066	case HELP_SETCONTENTS:
1067	case HELP_CONTENTS:
1068	case HELP_CONTEXTPOPUP:
1069	case HELP_FORCEFILE:
1070	case HELP_HELPONHELP:
1071	case HELP_FINDER:
1072	case HELP_QUIT:
1073	dsize=0;
1074	break;
1075
1076	case HELP_KEY:
1077	case HELP_PARTIALKEY:
1078	case HELP_COMMAND:
1079	dsize = strlen( (LPSTR)dwData )+1;
1080	break;
1081
1082	case HELP_MULTIKEY:
1083	dsize = ((LPMULTIKEYHELP)dwData)->mkSize;
1084	break;
1085
1086	case HELP_SETWINPOS:
1087	dsize = ((LPHELPWININFO)dwData)->wStructSize;
1088	break;
1089
1090	default:
1091	//WARN("Unknown help command %d\n",wCommand);
1092	return FALSE;
1093	}
1094	if(lpszHelp)
1095	nlen = strlen(lpszHelp)+1;
1096	else
1097	nlen = 0;
1098	size = sizeof(WINHELP) + nlen + dsize;
1099
1100	//allocate shared memory
1101	lpwh = (WINHELP*)_smalloc(size);
1102	lpwh->size = size;
1103	lpwh->command = uCommand;
1104	lpwh->data = dwData;
1105	if(nlen)
1106	{
1107	strcpy(((char*)lpwh) + sizeof(WINHELP),lpszHelp);
1108	lpwh->ofsFilename = sizeof(WINHELP);
1109	} else
1110	lpwh->ofsFilename = 0;
1111	if(dsize)
1112	{
1113	memcpy(((char*)lpwh)+sizeof(WINHELP)+nlen,(LPSTR)dwData,dsize);
1114	lpwh->ofsData = sizeof(WINHELP)+nlen;
1115	} else
1116	lpwh->ofsData = 0;
1117
1118	ret = SendMessageA(hDest,WM_WINHELP,hwnd,(LPARAM)lpwh);
1119	free(lpwh);
1120	return ret;
1121	}
1122	//******************************************************************************
1123	//******************************************************************************
1124	BOOL WIN32API WinHelpW( HWND hwnd, LPCWSTR lpszHelp, UINT uCommand, DWORD dwData)
1125	{
1126	char *astring = UnicodeToAsciiString((LPWSTR)lpszHelp);
1127	BOOL rc;
1128
1129	dprintf(("USER32: WinHelpW\n"));
1130
1131	rc = WinHelpA(hwnd,astring,uCommand,dwData);
1132	FreeAsciiString(astring);
1133
1134	return rc;
1135	}
1136
1137
1138	/* Window Functions */
1139
1140	/*****************************************************************************
1141	* Name : BOOL WIN32API PaintDesktop
1142	* Purpose : The PaintDesktop function fills the clipping region in the
1143	* specified device context with the desktop pattern or wallpaper.
1144	* The function is provided primarily for shell desktops.
1145	* Parameters:
1146	* Variables :
1147	* Result : If the function succeeds, the return value is TRUE.
1148	* If the function fails, the return value is FALSE.
1149	* Remark :
1150	* Status : UNTESTED STUB
1151	*
1152	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1153	*****************************************************************************/
1154	BOOL WIN32API PaintDesktop(HDC hdc)
1155	{
1156	dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
1157	hdc));
1158
1159	return (FALSE);
1160	}
1161
1162	/* Filled Shape Functions */
1163
1164
1165
1166	/* System Information Functions */
1167
1168	/* Window Station and Desktop Functions */
1169
1170	/*****************************************************************************
1171	* Name : HDESK WIN32API GetThreadDesktop
1172	* Purpose : The GetThreadDesktop function returns a handle to the desktop
1173	* associated with a specified thread.
1174	* Parameters: DWORD dwThreadId thread identifier
1175	* Variables :
1176	* Result : If the function succeeds, the return value is the handle of the
1177	* desktop associated with the specified thread.
1178	* Remark :
1179	* Status : UNTESTED STUB
1180	*
1181	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1182	*****************************************************************************/
1183	HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
1184	{
1185	dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
1186	dwThreadId));
1187
1188	return (NULL);
1189	}
1190
1191	/*****************************************************************************
1192	* Name : BOOL WIN32API CloseDesktop
1193	* Purpose : The CloseDesktop function closes an open handle of a desktop
1194	* object. A desktop is a secure object contained within a window
1195	* station object. A desktop has a logical display surface and
1196	* contains windows, menus and hooks.
1197	* Parameters: HDESK hDesktop
1198	* Variables :
1199	* Result : If the function succeeds, the return value is TRUE.
1200	* If the functions fails, the return value is FALSE. To get
1201	* extended error information, call GetLastError.
1202	* Remark :
1203	* Status : UNTESTED STUB
1204	*
1205	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1206	*****************************************************************************/
1207	BOOL WIN32API CloseDesktop(HDESK hDesktop)
1208	{
1209	dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
1210	hDesktop));
1211
1212	return (FALSE);
1213	}
1214	/*****************************************************************************
1215	* Name : BOOL WIN32API CloseWindowStation
1216	* Purpose : The CloseWindowStation function closes an open window station handle.
1217	* Parameters: HWINSTA hWinSta
1218	* Variables :
1219	* Result :
1220	* Remark : If the function succeeds, the return value is TRUE.
1221	* If the functions fails, the return value is FALSE. To get
1222	* extended error information, call GetLastError.
1223	* Status : UNTESTED STUB
1224	*
1225	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1226	*****************************************************************************/
1227	BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
1228	{
1229	dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
1230	hWinSta));
1231
1232	return (FALSE);
1233	}
1234	/*****************************************************************************
1235	* Name : HDESK WIN32API CreateDesktopA
1236	* Purpose : The CreateDesktop function creates a new desktop on the window
1237	* station associated with the calling process.
1238	* Parameters: LPCTSTR lpszDesktop name of the new desktop
1239	* LPCTSTR lpszDevice name of display device to assign to the desktop
1240	* LPDEVMODE pDevMode reserved; must be NULL
1241	* DWORD dwFlags flags to control interaction with other applications
1242	* DWORD dwDesiredAccess specifies access of returned handle
1243	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
1244	* Variables :
1245	* Result : If the function succeeds, the return value is a handle of the
1246	* newly created desktop.
1247	* If the function fails, the return value is NULL. To get extended
1248	* error information, call GetLastError.
1249	* Remark :
1250	* Status : UNTESTED STUB
1251	*
1252	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1253	*****************************************************************************/
1254	HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
1255	LPCTSTR lpszDevice,
1256	LPDEVMODEA pDevMode,
1257	DWORD dwFlags,
1258	DWORD dwDesiredAccess,
1259	LPSECURITY_ATTRIBUTES lpsa)
1260	{
1261	dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
1262	lpszDesktop,
1263	lpszDevice,
1264	pDevMode,
1265	dwFlags,
1266	dwDesiredAccess,
1267	lpsa));
1268
1269	return (NULL);
1270	}
1271	/*****************************************************************************
1272	* Name : HDESK WIN32API CreateDesktopW
1273	* Purpose : The CreateDesktop function creates a new desktop on the window
1274	* station associated with the calling process.
1275	* Parameters: LPCTSTR lpszDesktop name of the new desktop
1276	* LPCTSTR lpszDevice name of display device to assign to the desktop
1277	* LPDEVMODE pDevMode reserved; must be NULL
1278	* DWORD dwFlags flags to control interaction with other applications
1279	* DWORD dwDesiredAccess specifies access of returned handle
1280	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
1281	* Variables :
1282	* Result : If the function succeeds, the return value is a handle of the
1283	* newly created desktop.
1284	* If the function fails, the return value is NULL. To get extended
1285	* error information, call GetLastError.
1286	* Remark :
1287	* Status : UNTESTED STUB
1288	*
1289	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1290	*****************************************************************************/
1291	HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
1292	LPCTSTR lpszDevice,
1293	LPDEVMODEW pDevMode,
1294	DWORD dwFlags,
1295	DWORD dwDesiredAccess,
1296	LPSECURITY_ATTRIBUTES lpsa)
1297	{
1298	dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
1299	lpszDesktop,
1300	lpszDevice,
1301	pDevMode,
1302	dwFlags,
1303	dwDesiredAccess,
1304	lpsa));
1305
1306	return (NULL);
1307	}
1308	/*****************************************************************************
1309	* Name : HWINSTA WIN32API CreateWindowStationA
1310	* Purpose : The CreateWindowStation function creates a window station object.
1311	* It returns a handle that can be used to access the window station.
1312	* A window station is a secure object that contains a set of global
1313	* atoms, a clipboard, and a set of desktop objects.
1314	* Parameters: LPTSTR lpwinsta name of the new window station
1315	* DWORD dwReserved reserved; must be NULL
1316	* DWORD dwDesiredAccess specifies access of returned handle
1317	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
1318	* Variables :
1319	* Result : If the function succeeds, the return value is the handle to the
1320	* newly created window station.
1321	* If the function fails, the return value is NULL. To get extended
1322	* error information, call GetLastError.
1323	* Remark :
1324	* Status : UNTESTED STUB
1325	*
1326	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1327	*****************************************************************************/
1328	HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
1329	DWORD dwReserved,
1330	DWORD dwDesiredAccess,
1331	LPSECURITY_ATTRIBUTES lpsa)
1332	{
1333	dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
1334	lpWinSta,
1335	dwReserved,
1336	dwDesiredAccess,
1337	lpsa));
1338
1339	return (NULL);
1340	}
1341	/*****************************************************************************
1342	* Name : HWINSTA WIN32API CreateWindowStationW
1343	* Purpose : The CreateWindowStation function creates a window station object.
1344	* It returns a handle that can be used to access the window station.
1345	* A window station is a secure object that contains a set of global
1346	* atoms, a clipboard, and a set of desktop objects.
1347	* Parameters: LPTSTR lpwinsta name of the new window station
1348	* DWORD dwReserved reserved; must be NULL
1349	* DWORD dwDesiredAccess specifies access of returned handle
1350	* LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
1351	* Variables :
1352	* Result : If the function succeeds, the return value is the handle to the
1353	* newly created window station.
1354	* If the function fails, the return value is NULL. To get extended
1355	* error information, call GetLastError.
1356	* Remark :
1357	* Status : UNTESTED STUB
1358	*
1359	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1360	*****************************************************************************/
1361	HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
1362	DWORD dwReserved,
1363	DWORD dwDesiredAccess,
1364	LPSECURITY_ATTRIBUTES lpsa)
1365	{
1366	dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
1367	lpWinSta,
1368	dwReserved,
1369	dwDesiredAccess,
1370	lpsa));
1371
1372	return (NULL);
1373	}
1374	/*****************************************************************************
1375	* Name : BOOL WIN32API EnumDesktopWindows
1376	* Purpose : The EnumDesktopWindows function enumerates all windows in a
1377	* desktop by passing the handle of each window, in turn, to an
1378	* application-defined callback function.
1379	* Parameters: HDESK hDesktop handle of desktop to enumerate
1380	* WNDENUMPROC lpfn points to application's callback function
1381	* LPARAM lParam 32-bit value to pass to the callback function
1382	* Variables :
1383	* Result : If the function succeeds, the return value is TRUE.
1384	* If the function fails, the return value is FALSE. To get
1385	* extended error information, call GetLastError.
1386	* Remark :
1387	* Status : UNTESTED STUB
1388	*
1389	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1390	*****************************************************************************/
1391	BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
1392	WNDENUMPROC lpfn,
1393	LPARAM lParam)
1394	{
1395	dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
1396	hDesktop,
1397	lpfn,
1398	lParam));
1399
1400	return (FALSE);
1401	}
1402	/*****************************************************************************
1403	* Name : BOOL WIN32API EnumDesktopsA
1404	* Purpose : The EnumDesktops function enumerates all desktops in the window
1405	* station assigned to the calling process. The function does so by
1406	* passing the name of each desktop, in turn, to an application-
1407	* defined callback function.
1408	* Parameters: HWINSTA hwinsta handle of window station to enumerate
1409	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
1410	* LPARAM lParam 32-bit value to pass to the callback function
1411	* Variables :
1412	* Result : If the function succeeds, the return value is TRUE.
1413	* If the function fails, the return value is FALSE. To get extended
1414	* error information, call GetLastError.
1415	* Remark :
1416	* Status : UNTESTED STUB
1417	*
1418	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1419	*****************************************************************************/
1420	BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
1421	DESKTOPENUMPROCA lpEnumFunc,
1422	LPARAM lParam)
1423	{
1424	dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
1425	hWinSta,
1426	lpEnumFunc,
1427	lParam));
1428
1429	return (FALSE);
1430	}
1431	/*****************************************************************************
1432	* Name : BOOL WIN32API EnumDesktopsW
1433	* Purpose : The EnumDesktops function enumerates all desktops in the window
1434	* station assigned to the calling process. The function does so by
1435	* passing the name of each desktop, in turn, to an application-
1436	* defined callback function.
1437	* Parameters: HWINSTA hwinsta handle of window station to enumerate
1438	* DESKTOPENUMPROC lpEnumFunc points to application's callback function
1439	* LPARAM lParam 32-bit value to pass to the callback function
1440	* Variables :
1441	* Result : If the function succeeds, the return value is TRUE.
1442	* If the function fails, the return value is FALSE. To get extended
1443	* error information, call GetLastError.
1444	* Remark :
1445	* Status : UNTESTED STUB
1446	*
1447	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1448	*****************************************************************************/
1449	BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
1450	DESKTOPENUMPROCW lpEnumFunc,
1451	LPARAM lParam)
1452	{
1453	dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
1454	hWinSta,
1455	lpEnumFunc,
1456	lParam));
1457
1458	return (FALSE);
1459	}
1460	/*****************************************************************************
1461	* Name : BOOL WIN32API EnumWindowStationsA
1462	* Purpose : The EnumWindowStations function enumerates all windowstations
1463	* in the system by passing the name of each window station, in
1464	* turn, to an application-defined callback function.
1465	* Parameters:
1466	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
1467	* LPARAM lParam 32-bit value to pass to the callback function
1468	* Result : If the function succeeds, the return value is TRUE.
1469	* If the function fails the return value is FALSE. To get extended
1470	* error information, call GetLastError.
1471	* Remark :
1472	* Status : UNTESTED STUB
1473	*
1474	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1475	*****************************************************************************/
1476	BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
1477	LPARAM lParam)
1478	{
1479	dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
1480	lpEnumFunc,
1481	lParam));
1482
1483	return (FALSE);
1484	}
1485	/*****************************************************************************
1486	* Name : BOOL WIN32API EnumWindowStationsW
1487	* Purpose : The EnumWindowStations function enumerates all windowstations
1488	* in the system by passing the name of each window station, in
1489	* turn, to an application-defined callback function.
1490	* Parameters:
1491	* Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
1492	* LPARAM lParam 32-bit value to pass to the callback function
1493	* Result : If the function succeeds, the return value is TRUE.
1494	* If the function fails the return value is FALSE. To get extended
1495	* error information, call GetLastError.
1496	* Remark :
1497	* Status : UNTESTED STUB
1498	*
1499	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1500	*****************************************************************************/
1501	BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
1502	LPARAM lParam)
1503	{
1504	dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
1505	lpEnumFunc,
1506	lParam));
1507
1508	return (FALSE);
1509	}
1510	/*****************************************************************************
1511	* Name : HWINSTA WIN32API GetProcessWindowStation
1512	* Purpose : The GetProcessWindowStation function returns a handle of the
1513	* window station associated with the calling process.
1514	* Parameters:
1515	* Variables :
1516	* Result : If the function succeeds, the return value is a handle of the
1517	* window station associated with the calling process.
1518	* If the function fails, the return value is NULL. This can occur
1519	* if the calling process is not an application written for Windows
1520	* NT. To get extended error information, call GetLastError.
1521	* Remark :
1522	* Status : UNTESTED STUB
1523	*
1524	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1525	*****************************************************************************/
1526	HWINSTA WIN32API GetProcessWindowStation(VOID)
1527	{
1528	dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
1529
1530	return (NULL);
1531	}
1532	/*****************************************************************************
1533	* Name : BOOL WIN32API GetUserObjectInformationA
1534	* Purpose : The GetUserObjectInformation function returns information about
1535	* a window station or desktop object.
1536	* Parameters: HANDLE hObj handle of object to get information for
1537	* int nIndex type of information to get
1538	* PVOID pvInfo points to buffer that receives the information
1539	* DWORD nLength size, in bytes, of pvInfo buffer
1540	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
1541	* Variables :
1542	* Result : If the function succeeds, the return value is TRUE.
1543	* If the function fails, the return value is FALSE. To get extended
1544	* error information, call GetLastError.
1545	* Remark :
1546	* Status : UNTESTED STUB
1547	*
1548	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1549	*****************************************************************************/
1550	BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
1551	int nIndex,
1552	PVOID pvInfo,
1553	DWORD nLength,
1554	LPDWORD lpnLengthNeeded)
1555	{
1556	dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1557	hObj,
1558	nIndex,
1559	pvInfo,
1560	nLength,
1561	lpnLengthNeeded));
1562
1563	return (FALSE);
1564	}
1565	/*****************************************************************************
1566	* Name : BOOL WIN32API GetUserObjectInformationW
1567	* Purpose : The GetUserObjectInformation function returns information about
1568	* a window station or desktop object.
1569	* Parameters: HANDLE hObj handle of object to get information for
1570	* int nIndex type of information to get
1571	* PVOID pvInfo points to buffer that receives the information
1572	* DWORD nLength size, in bytes, of pvInfo buffer
1573	* LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
1574	* Variables :
1575	* Result : If the function succeeds, the return value is TRUE.
1576	* If the function fails, the return value is FALSE. To get extended
1577	* error information, call GetLastError.
1578	* Remark :
1579	* Status : UNTESTED STUB
1580	*
1581	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1582	*****************************************************************************/
1583	BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
1584	int nIndex,
1585	PVOID pvInfo,
1586	DWORD nLength,
1587	LPDWORD lpnLengthNeeded)
1588	{
1589	dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1590	hObj,
1591	nIndex,
1592	pvInfo,
1593	nLength,
1594	lpnLengthNeeded));
1595
1596	return (FALSE);
1597	}
1598	/*****************************************************************************
1599	* Name : BOOL WIN32API GetUserObjectSecurity
1600	* Purpose : The GetUserObjectSecurity function retrieves security information
1601	* for the specified user object.
1602	* Parameters: HANDLE hObj handle of user object
1603	* SECURITY_INFORMATION * pSIRequested address of requested security information
1604	* LPSECURITY_DESCRIPTOR pSID address of security descriptor
1605	* DWORD nLength size of buffer for security descriptor
1606	* LPDWORD lpnLengthNeeded address of required size of buffer
1607	* Variables :
1608	* Result : If the function succeeds, the return value is TRUE.
1609	* If the function fails, the return value is FALSE. To get extended
1610	* error information, call GetLastError.
1611	* Remark :
1612	* Status : UNTESTED STUB
1613	*
1614	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1615	*****************************************************************************/
1616	BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
1617	PSECURITY_INFORMATION pSIRequested,
1618	PSECURITY_DESCRIPTOR pSID,
1619	DWORD nLength,
1620	LPDWORD lpnLengthNeeded)
1621	{
1622	dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1623	hObj,
1624	pSIRequested,
1625	pSID,
1626	nLength,
1627	lpnLengthNeeded));
1628
1629	return (FALSE);
1630	}
1631	/*****************************************************************************
1632	* Name : HDESK WIN32API OpenDesktopA
1633	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
1634	* A desktop is a secure object contained within a window station
1635	* object. A desktop has a logical display surface and contains
1636	* windows, menus and hooks.
1637	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
1638	* DWORD dwFlags flags to control interaction with other applications
1639	* BOOL fInherit specifies whether returned handle is inheritable
1640	* DWORD dwDesiredAccess specifies access of returned handle
1641	* Variables :
1642	* Result : If the function succeeds, the return value is the handle to the
1643	* opened desktop.
1644	* If the function fails, the return value is NULL. To get extended
1645	* error information, call GetLastError.
1646	* Remark :
1647	* Status : UNTESTED STUB
1648	*
1649	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1650	*****************************************************************************/
1651	HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
1652	DWORD dwFlags,
1653	BOOL fInherit,
1654	DWORD dwDesiredAccess)
1655	{
1656	dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
1657	lpszDesktopName,
1658	dwFlags,
1659	fInherit,
1660	dwDesiredAccess));
1661
1662	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1663	return (NULL);
1664	}
1665	/*****************************************************************************
1666	* Name : HDESK WIN32API OpenDesktopW
1667	* Purpose : The OpenDesktop function returns a handle to an existing desktop.
1668	* A desktop is a secure object contained within a window station
1669	* object. A desktop has a logical display surface and contains
1670	* windows, menus and hooks.
1671	* Parameters: LPCTSTR lpszDesktopName name of the desktop to open
1672	* DWORD dwFlags flags to control interaction with other applications
1673	* BOOL fInherit specifies whether returned handle is inheritable
1674	* DWORD dwDesiredAccess specifies access of returned handle
1675	* Variables :
1676	* Result : If the function succeeds, the return value is the handle to the
1677	* opened desktop.
1678	* If the function fails, the return value is NULL. To get extended
1679	* error information, call GetLastError.
1680	* Remark :
1681	* Status : UNTESTED STUB
1682	*
1683	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1684	*****************************************************************************/
1685	HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
1686	DWORD dwFlags,
1687	BOOL fInherit,
1688	DWORD dwDesiredAccess)
1689	{
1690	dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
1691	lpszDesktopName,
1692	dwFlags,
1693	fInherit,
1694	dwDesiredAccess));
1695
1696	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1697	return (NULL);
1698	}
1699	/*****************************************************************************
1700	* Name : HDESK WIN32API OpenInputDesktop
1701	* Purpose : The OpenInputDesktop function returns a handle to the desktop
1702	* that receives user input. The input desktop is a desktop on the
1703	* window station associated with the logged-on user.
1704	* Parameters: DWORD dwFlags flags to control interaction with other applications
1705	* BOOL fInherit specifies whether returned handle is inheritable
1706	* DWORD dwDesiredAccess specifies access of returned handle
1707	* Variables :
1708	* Result : If the function succeeds, the return value is a handle of the
1709	* desktop that receives user input.
1710	* If the function fails, the return value is NULL. To get extended
1711	* error information, call GetLastError.
1712	* Remark :
1713	* Status : UNTESTED STUB
1714	*
1715	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1716	*****************************************************************************/
1717	HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
1718	BOOL fInherit,
1719	DWORD dwDesiredAccess)
1720	{
1721	dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
1722	dwFlags,
1723	fInherit,
1724	dwDesiredAccess));
1725
1726	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1727	return (NULL);
1728	}
1729	/*****************************************************************************
1730	* Name : HWINSTA WIN32API OpenWindowStationA
1731	* Purpose : The OpenWindowStation function returns a handle to an existing
1732	* window station.
1733	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
1734	* BOOL fInherit specifies whether returned handle is inheritable
1735	* DWORD dwDesiredAccess specifies access of returned handle
1736	* Variables :
1737	* Result : If the function succeeds, the return value is the handle to the
1738	* specified window station.
1739	* If the function fails, the return value is NULL. To get extended
1740	* error information, call GetLastError.
1741	* Remark :
1742	* Status : UNTESTED STUB
1743	*
1744	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1745	*****************************************************************************/
1746	HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
1747	BOOL fInherit,
1748	DWORD dwDesiredAccess)
1749	{
1750	dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
1751	lpszWinStaName,
1752	fInherit,
1753	dwDesiredAccess));
1754
1755	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1756	return (NULL);
1757	}
1758	/*****************************************************************************
1759	* Name : HWINSTA WIN32API OpenWindowStationW
1760	* Purpose : The OpenWindowStation function returns a handle to an existing
1761	* window station.
1762	* Parameters: LPCTSTR lpszWinStaName name of the window station to open
1763	* BOOL fInherit specifies whether returned handle is inheritable
1764	* DWORD dwDesiredAccess specifies access of returned handle
1765	* Variables :
1766	* Result : If the function succeeds, the return value is the handle to the
1767	* specified window station.
1768	* If the function fails, the return value is NULL. To get extended
1769	* error information, call GetLastError.
1770
1771
1772	* Remark :
1773	* Status : UNTESTED STUB
1774	*
1775	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1776	*****************************************************************************/
1777	HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
1778	BOOL fInherit,
1779	DWORD dwDesiredAccess)
1780	{
1781	dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
1782	lpszWinStaName,
1783	fInherit,
1784	dwDesiredAccess));
1785
1786	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1787	return (NULL);
1788	}
1789	/*****************************************************************************
1790	* Name : BOOL WIN32API SetProcessWindowStation
1791	* Purpose : The SetProcessWindowStation function assigns a window station
1792	* to the calling process. This enables the process to access
1793	* objects in the window station such as desktops, the clipboard,
1794	* and global atoms. All subsequent operations on the window station
1795	* use the access rights granted to hWinSta.
1796	* Parameters:
1797	* Variables :
1798	* Result : If the function succeeds, the return value is TRUE.
1799	* If the function fails, the return value is FALSE. To get extended
1800	* error information, call GetLastError.
1801	* Remark :
1802	* Status : UNTESTED STUB
1803	*
1804	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1805	*****************************************************************************/
1806	BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
1807	{
1808	dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
1809	hWinSta));
1810
1811	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1812	return (FALSE);
1813	}
1814	/*****************************************************************************
1815	* Name : BOOL WIN32API SetThreadDesktop
1816	* Purpose : The SetThreadDesktop function assigns a desktop to the calling
1817	* thread. All subsequent operations on the desktop use the access
1818	* rights granted to hDesk.
1819	* Parameters: HDESK hDesk handle of the desktop to assign to this thread
1820	* Variables :
1821	* Result : If the function succeeds, the return value is TRUE.
1822	* If the function fails, the return value is FALSE. To get extended
1823	* error information, call GetLastError.
1824	* Remark :
1825	* Status : UNTESTED STUB
1826	*
1827	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1828	*****************************************************************************/
1829	BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
1830	{
1831	dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
1832	hDesktop));
1833
1834	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1835	return (FALSE);
1836	}
1837	/*****************************************************************************
1838	* Name : BOOL WIN32API SetUserObjectInformationA
1839	* Purpose : The SetUserObjectInformation function sets information about a
1840	* window station or desktop object.
1841	* Parameters: HANDLE hObject handle of the object for which to set information
1842	* int nIndex type of information to set
1843	* PVOID lpvInfo points to a buffer that contains the information
1844	* DWORD cbInfo size, in bytes, of lpvInfo buffer
1845	* Variables :
1846	* Result : If the function succeeds, the return value is TRUE.
1847	* If the function fails the return value is FALSE. To get extended
1848	* error information, call GetLastError.
1849	* Remark :
1850	* Status : UNTESTED STUB
1851	*
1852	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1853	*****************************************************************************/
1854	BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
1855	int nIndex,
1856	PVOID lpvInfo,
1857	DWORD cbInfo)
1858	{
1859	dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
1860	hObject,
1861	nIndex,
1862	lpvInfo,
1863	cbInfo));
1864
1865	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1866	return (FALSE);
1867	}
1868	/*****************************************************************************
1869	* Name : BOOL WIN32API SetUserObjectInformationW
1870	* Purpose : The SetUserObjectInformation function sets information about a
1871	* window station or desktop object.
1872	* Parameters: HANDLE hObject handle of the object for which to set information
1873	* int nIndex type of information to set
1874	* PVOID lpvInfo points to a buffer that contains the information
1875	* DWORD cbInfo size, in bytes, of lpvInfo buffer
1876	* Variables :
1877	* Result : If the function succeeds, the return value is TRUE.
1878	* If the function fails the return value is FALSE. To get extended
1879	* error information, call GetLastError.
1880	* Remark :
1881	* Status : UNTESTED STUB
1882	*
1883	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1884	*****************************************************************************/
1885	BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
1886	int nIndex,
1887	PVOID lpvInfo,
1888	DWORD cbInfo)
1889	{
1890	dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
1891	hObject,
1892	nIndex,
1893	lpvInfo,
1894	cbInfo));
1895
1896	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1897	return (FALSE);
1898	}
1899	/*****************************************************************************
1900	* Name : BOOL WIN32API SetUserObjectSecurity
1901	* Purpose : The SetUserObjectSecurity function sets the security of a user
1902	* object. This can be, for example, a window or a DDE conversation
1903	* Parameters: HANDLE hObject handle of user object
1904	* SECURITY_INFORMATION * psi address of security information
1905	* LPSECURITY_DESCRIPTOR psd address of security descriptor
1906	* Variables :
1907	* Result : If the function succeeds, the return value is TRUE.
1908	* If the function fails, the return value is FALSE. To get extended
1909	* error information, call GetLastError.
1910	* Remark :
1911	* Status : UNTESTED STUB
1912	*
1913	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1914	*****************************************************************************/
1915	BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
1916	PSECURITY_INFORMATION psi,
1917	PSECURITY_DESCRIPTOR psd)
1918	{
1919	dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
1920	hObject,
1921	psi,
1922	psd));
1923
1924	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1925	return (FALSE);
1926	}
1927	/*****************************************************************************
1928	* Name : BOOL WIN32API SwitchDesktop
1929	* Purpose : The SwitchDesktop function makes a desktop visible and activates
1930	* it. This enables the desktop to receive input from the user. The
1931	* calling process must have DESKTOP_SWITCHDESKTOP access to the
1932	* desktop for the SwitchDesktop function to succeed.
1933	* Parameters:
1934	* Variables :
1935	* Result : If the function succeeds, the return value is TRUE.
1936	* If the function fails, the return value is FALSE. To get extended
1937	* error information, call GetLastError.
1938	* Remark :
1939	* Status : UNTESTED STUB
1940	*
1941	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1942	*****************************************************************************/
1943	BOOL WIN32API SwitchDesktop(HDESK hDesktop)
1944	{
1945	dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
1946	hDesktop));
1947
1948	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1949	return (FALSE);
1950	}
1951
1952	/* Debugging Functions */
1953
1954	/*****************************************************************************
1955	* Name : VOID WIN32API SetDebugErrorLevel
1956	* Purpose : The SetDebugErrorLevel function sets the minimum error level at
1957	* which Windows will generate debugging events and pass them to a debugger.
1958	* Parameters: DWORD dwLevel debugging error level
1959	* Variables :
1960	* Result :
1961	* Remark :
1962	* Status : UNTESTED STUB
1963	*
1964	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
1965	*****************************************************************************/
1966	VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
1967	{
1968	dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
1969	dwLevel));
1970	}
1971
1972	/* Drag'n'drop */
1973
1974	/*****************************************************************************
1975	* Name : BOOL WIN32API DragObject
1976	* Purpose : Unknown
1977	* Parameters: Unknown
1978	* Variables :
1979	* Result :
1980	* Remark :
1981	* Status : UNTESTED UNKNOWN STUB
1982	*
1983	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
1984	*****************************************************************************/
1985	DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
1986	{
1987	dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1988	x1,
1989	x2,
1990	x3,
1991	x4,
1992	x5));
1993
1994	return (FALSE); /* default */
1995	}
1996
1997	/* Unknown */
1998
1999	/*****************************************************************************
2000	* Name : BOOL WIN32API SetShellWindow
2001	* Purpose : Unknown
2002	* Parameters: Unknown
2003	* Variables :
2004	* Result :
2005	* Remark :
2006	* Status : UNTESTED UNKNOWN STUB
2007	*
2008	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2009	*****************************************************************************/
2010	BOOL WIN32API SetShellWindow(DWORD x1)
2011	{
2012	dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
2013	x1));
2014
2015	return (FALSE); /* default */
2016	}
2017	/*****************************************************************************
2018	* Name : BOOL WIN32API PlaySoundEvent
2019	* Purpose : Unknown
2020	* Parameters: Unknown
2021	* Variables :
2022	* Result :
2023	* Remark :
2024	* Status : UNTESTED UNKNOWN STUB
2025	*
2026	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2027	*****************************************************************************/
2028	BOOL WIN32API PlaySoundEvent(DWORD x1)
2029	{
2030	dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
2031	x1));
2032
2033	return (FALSE); /* default */
2034	}
2035	/*****************************************************************************
2036	* Name : BOOL WIN32API SetSysColorsTemp
2037	* Purpose : Unknown
2038	* Parameters: Unknown
2039	* Variables :
2040	* Result :
2041	* Remark :
2042	* Status : UNTESTED UNKNOWN STUB
2043	*
2044	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2045	*****************************************************************************/
2046	BOOL WIN32API SetSysColorsTemp(void)
2047	{
2048	dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
2049
2050	return (FALSE); /* default */
2051	}
2052	/*****************************************************************************
2053	* Name : BOOL WIN32API RegisterNetworkCapabilities
2054	* Purpose : Unknown
2055	* Parameters: Unknown
2056	* Variables :
2057	* Result :
2058	* Remark :
2059	* Status : UNTESTED UNKNOWN STUB
2060	*
2061	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2062	*****************************************************************************/
2063	BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
2064	DWORD x2)
2065	{
2066	dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
2067	x1,
2068	x2));
2069
2070	return (FALSE); /* default */
2071	}
2072	/*****************************************************************************
2073	* Name : BOOL WIN32API EndTask
2074	* Purpose : Unknown
2075	* Parameters: Unknown
2076	* Variables :
2077	* Result :
2078	* Remark :
2079	* Status : UNTESTED UNKNOWN STUB
2080	*
2081	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2082	*****************************************************************************/
2083	BOOL WIN32API EndTask(DWORD x1, DWORD x2, DWORD x3)
2084	{
2085	dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
2086	x1,
2087	x2,
2088	x3));
2089
2090	return (FALSE); /* default */
2091	}
2092	/*****************************************************************************
2093	* Name : BOOL WIN32API GetNextQueueWindow
2094	* Purpose : Unknown
2095	* Parameters: Unknown
2096	* Variables :
2097	* Result :
2098	* Remark :
2099	* Status : UNTESTED UNKNOWN STUB
2100	*
2101	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2102	*****************************************************************************/
2103	BOOL WIN32API GetNextQueueWindow(DWORD x1, DWORD x2)
2104	{
2105	dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
2106	x1,
2107	x2));
2108
2109	return (FALSE); /* default */
2110	}
2111	/*****************************************************************************
2112	* Name : BOOL WIN32API YieldTask
2113	* Purpose : Unknown
2114	* Parameters: Unknown
2115	* Variables :
2116	* Result :
2117	* Remark :
2118	* Status : UNTESTED UNKNOWN STUB
2119	*
2120	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2121	*****************************************************************************/
2122	BOOL WIN32API YieldTask(void)
2123	{
2124	dprintf(("USER32: YieldTask() not implemented.\n"));
2125
2126	return (FALSE); /* default */
2127	}
2128	/*****************************************************************************
2129	* Name : BOOL WIN32API WinOldAppHackoMatic
2130	* Purpose : Unknown
2131	* Parameters: Unknown
2132	* Variables :
2133	* Result :
2134	* Remark :
2135	* Status : UNTESTED UNKNOWN STUB
2136	*
2137	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2138	*****************************************************************************/
2139	BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
2140	{
2141	dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
2142	x1));
2143
2144	return (FALSE); /* default */
2145	}
2146	/*****************************************************************************
2147	* Name : BOOL WIN32API RegisterSystemThread
2148	* Purpose : Unknown
2149	* Parameters: Unknown
2150	* Variables :
2151	* Result :
2152	* Remark :
2153	* Status : UNTESTED UNKNOWN STUB
2154	*
2155	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2156	*****************************************************************************/
2157	BOOL WIN32API RegisterSystemThread(DWORD x1,
2158	DWORD x2)
2159	{
2160	dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
2161	x1,
2162	x2));
2163
2164	return (FALSE); /* default */
2165	}
2166	/*****************************************************************************
2167	* Name : BOOL WIN32API IsHungThread
2168	* Purpose : Unknown
2169	* Parameters: Unknown
2170	* Variables :
2171	* Result :
2172	* Remark :
2173	* Status : UNTESTED UNKNOWN STUB
2174	*
2175	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2176	*****************************************************************************/
2177	BOOL WIN32API IsHungThread(DWORD x1)
2178	{
2179	dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
2180	x1));
2181
2182	return (FALSE); /* default */
2183	}
2184	/*****************************************************************************
2185	* Name : BOOL WIN32API UserSignalProc
2186	* Purpose : Unknown
2187	* Parameters: Unknown
2188	* Variables :
2189	* Result :
2190	* Remark :
2191	* Status : UNTESTED UNKNOWN STUB
2192	*
2193	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2194	*****************************************************************************/
2195	BOOL WIN32API UserSignalProc(DWORD x1,
2196	DWORD x2,
2197	DWORD x3,
2198	DWORD x4)
2199	{
2200	dprintf(("USER32: UserSignalProc(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2201	x1,
2202	x2,
2203	x3,
2204	x4));
2205
2206	return (FALSE); /* default */
2207	}
2208	/*****************************************************************************
2209	* Name : BOOL WIN32API GetShellWindow
2210	* Purpose : Unknown
2211	* Parameters: Unknown
2212	* Variables :
2213	* Result :
2214	* Remark :
2215	* Status : UNTESTED UNKNOWN STUB
2216	*
2217	* Author : Patrick Haller [Wed, 1998/06/16 11:55]
2218	*****************************************************************************/
2219	HWND WIN32API GetShellWindow(void)
2220	{
2221	dprintf(("USER32: GetShellWindow() not implemented.\n"));
2222
2223	return (0); /* default */
2224	}
2225	/***********************************************************************
2226	* RegisterTasklist32 [USER32.436]
2227	*/
2228	DWORD WIN32API RegisterTasklist (DWORD x)
2229	{
2230	dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
2231	x));
2232
2233	return TRUE;
2234	}
2235	/***********************************************************************
2236	* SetLogonNotifyWindow (USER32.486)
2237	*/
2238	DWORD WIN32API SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd)
2239	{
2240	dprintf(("USER32: SetLogonNotifyWindow - empty stub!"));
2241
2242	return 1;
2243	}
2244
2245	#ifdef __cplusplus
2246	} // extern "C"
2247	#endif

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

Context Navigation

source: trunk/src/user32/user32.cpp

Download in other formats: