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

Last change on this file since 6339 was 6339, checked in by sandervl, 24 years ago

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