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

Last change on this file since 10197 was 10197, checked in by sandervl, 22 years ago

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