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

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

updates
File size: 80.2 KB
Line 
1/* $Id: user32.cpp,v 1.110 2001-07-28 18:02:50 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/* Help Functions */
976
977BOOL WIN32API WinHelpA( HWND hwnd, LPCSTR lpszHelp, UINT uCommand, DWORD dwData)
978{
979 static WORD WM_WINHELP = 0;
980 HWND hDest;
981 LPWINHELP lpwh;
982 HINSTANCE winhelp;
983 int size,dsize,nlen;
984 BOOL ret;
985
986 dprintf(("USER32: WinHelpA %x %s %d %x", hwnd, lpszHelp, uCommand, dwData));
987
988 if(!WM_WINHELP)
989 {
990 WM_WINHELP=RegisterWindowMessageA("WM_WINHELP");
991 if(!WM_WINHELP)
992 return FALSE;
993 }
994
995 hDest = FindWindowA( "MS_WINHELP", NULL );
996 if(!hDest)
997 {
998 if(uCommand == HELP_QUIT)
999 return TRUE;
1000 else
1001 winhelp = WinExec ( "winhlp32.exe -x", SW_SHOWNORMAL );
1002 if ( winhelp <= 32 ) return FALSE;
1003 if ( ! ( hDest = FindWindowA ( "MS_WINHELP", NULL ) )) return FALSE;
1004 }
1005
1006 switch(uCommand)
1007 {
1008 case HELP_CONTEXT:
1009 case HELP_SETCONTENTS:
1010 case HELP_CONTENTS:
1011 case HELP_CONTEXTPOPUP:
1012 case HELP_FORCEFILE:
1013 case HELP_HELPONHELP:
1014 case HELP_FINDER:
1015 case HELP_QUIT:
1016 dsize=0;
1017 break;
1018
1019 case HELP_KEY:
1020 case HELP_PARTIALKEY:
1021 case HELP_COMMAND:
1022 dsize = strlen( (LPSTR)dwData )+1;
1023 break;
1024
1025 case HELP_MULTIKEY:
1026 dsize = ((LPMULTIKEYHELP)dwData)->mkSize;
1027 break;
1028
1029 case HELP_SETWINPOS:
1030 dsize = ((LPHELPWININFO)dwData)->wStructSize;
1031 break;
1032
1033 default:
1034 //WARN("Unknown help command %d\n",wCommand);
1035 return FALSE;
1036 }
1037 if(lpszHelp)
1038 nlen = strlen(lpszHelp)+1;
1039 else
1040 nlen = 0;
1041 size = sizeof(WINHELP) + nlen + dsize;
1042
1043 //allocate shared memory
1044 lpwh = (WINHELP*)_smalloc(size);
1045 lpwh->size = size;
1046 lpwh->command = uCommand;
1047 lpwh->data = dwData;
1048 if(nlen)
1049 {
1050 strcpy(((char*)lpwh) + sizeof(WINHELP),lpszHelp);
1051 lpwh->ofsFilename = sizeof(WINHELP);
1052 } else
1053 lpwh->ofsFilename = 0;
1054 if(dsize)
1055 {
1056 memcpy(((char*)lpwh)+sizeof(WINHELP)+nlen,(LPSTR)dwData,dsize);
1057 lpwh->ofsData = sizeof(WINHELP)+nlen;
1058 } else
1059 lpwh->ofsData = 0;
1060
1061 ret = SendMessageA(hDest,WM_WINHELP,hwnd,(LPARAM)lpwh);
1062 free(lpwh);
1063 return ret;
1064}
1065//******************************************************************************
1066//******************************************************************************
1067BOOL WIN32API WinHelpW( HWND hwnd, LPCWSTR lpszHelp, UINT uCommand, DWORD dwData)
1068{
1069 char *astring = UnicodeToAsciiString((LPWSTR)lpszHelp);
1070 BOOL rc;
1071
1072 dprintf(("USER32: WinHelpW\n"));
1073
1074 rc = WinHelpA(hwnd,astring,uCommand,dwData);
1075 FreeAsciiString(astring);
1076
1077 return rc;
1078}
1079
1080
1081/* Window Functions */
1082
1083/*****************************************************************************
1084 * Name : BOOL WIN32API AnyPopup
1085 * Purpose : The AnyPopup function indicates whether an owned, visible,
1086 * top-level pop-up, or overlapped window exists on the screen. The
1087 * function searches the entire Windows screen, not just the calling
1088 * application's client area.
1089 * Parameters: VOID
1090 * Variables :
1091 * Result : If a pop-up window exists, the return value is TRUE even if the
1092 * pop-up window is completely covered by other windows. Otherwise,
1093 * it is FALSE.
1094 * Remark : AnyPopup is a Windows version 1.x function and is retained for
1095 * compatibility purposes. It is generally not useful.
1096 * Status : UNTESTED STUB
1097 *
1098 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1099 *****************************************************************************/
1100BOOL WIN32API AnyPopup(VOID)
1101{
1102 dprintf(("USER32:AnyPopup() not implemented.\n"));
1103
1104 return (FALSE);
1105}
1106
1107/*****************************************************************************
1108 * Name : BOOL WIN32API PaintDesktop
1109 * Purpose : The PaintDesktop function fills the clipping region in the
1110 * specified device context with the desktop pattern or wallpaper.
1111 * The function is provided primarily for shell desktops.
1112 * Parameters:
1113 * Variables :
1114 * Result : If the function succeeds, the return value is TRUE.
1115 * If the function fails, the return value is FALSE.
1116 * Remark :
1117 * Status : UNTESTED STUB
1118 *
1119 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1120 *****************************************************************************/
1121BOOL WIN32API PaintDesktop(HDC hdc)
1122{
1123 dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
1124 hdc));
1125
1126 return (FALSE);
1127}
1128
1129/* Filled Shape Functions */
1130
1131 /* Last COLOR id */
1132#define COLOR_MAX COLOR_GRADIENTINACTIVECAPTION
1133
1134int WIN32API FillRect(HDC hDC, const RECT * lprc, HBRUSH hbr)
1135{
1136 if (hbr <= (HBRUSH) (COLOR_MAX + 1)) {
1137 hbr = GetSysColorBrush( (INT) hbr - 1 );
1138 }
1139 dprintf(("USER32: FillRect %x (%d,%d)(%d,%d) brush %X", hDC, lprc->left, lprc->top, lprc->right, lprc->bottom, hbr));
1140 return O32_FillRect(hDC,lprc,hbr);
1141}
1142//******************************************************************************
1143//******************************************************************************
1144int WIN32API FrameRect( HDC hDC, const RECT * lprc, HBRUSH hbr)
1145{
1146 dprintf(("USER32: FrameRect %x (%d,%d)(%d,%d) brush %x", hDC, lprc->top, lprc->left, lprc->bottom, lprc->right, hbr));
1147 return O32_FrameRect(hDC,lprc,hbr);
1148}
1149//******************************************************************************
1150//******************************************************************************
1151BOOL WIN32API InvertRect( HDC hDC, const RECT * lprc)
1152{
1153 if(lprc) {
1154 dprintf(("USER32: InvertRect %x (%d,%d)(%d,%d)", hDC, lprc->left, lprc->top, lprc->right, lprc->bottom));
1155 }
1156 else dprintf(("USER32: InvertRect %x NULL", hDC));
1157 return O32_InvertRect(hDC,lprc);
1158}
1159
1160/* System Information Functions */
1161
1162/* Window Station and Desktop Functions */
1163
1164/*****************************************************************************
1165 * Name : HDESK WIN32API GetThreadDesktop
1166 * Purpose : The GetThreadDesktop function returns a handle to the desktop
1167 * associated with a specified thread.
1168 * Parameters: DWORD dwThreadId thread identifier
1169 * Variables :
1170 * Result : If the function succeeds, the return value is the handle of the
1171 * desktop associated with the specified thread.
1172 * Remark :
1173 * Status : UNTESTED STUB
1174 *
1175 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1176 *****************************************************************************/
1177HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
1178{
1179 dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
1180 dwThreadId));
1181
1182 return (NULL);
1183}
1184
1185/*****************************************************************************
1186 * Name : BOOL WIN32API CloseDesktop
1187 * Purpose : The CloseDesktop function closes an open handle of a desktop
1188 * object. A desktop is a secure object contained within a window
1189 * station object. A desktop has a logical display surface and
1190 * contains windows, menus and hooks.
1191 * Parameters: HDESK hDesktop
1192 * Variables :
1193 * Result : If the function succeeds, the return value is TRUE.
1194 * If the functions fails, the return value is FALSE. To get
1195 * extended error information, call GetLastError.
1196 * Remark :
1197 * Status : UNTESTED STUB
1198 *
1199 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1200 *****************************************************************************/
1201BOOL WIN32API CloseDesktop(HDESK hDesktop)
1202{
1203 dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
1204 hDesktop));
1205
1206 return (FALSE);
1207}
1208/*****************************************************************************
1209 * Name : BOOL WIN32API CloseWindowStation
1210 * Purpose : The CloseWindowStation function closes an open window station handle.
1211 * Parameters: HWINSTA hWinSta
1212 * Variables :
1213 * Result :
1214 * Remark : If the function succeeds, the return value is TRUE.
1215 * If the functions fails, the return value is FALSE. To get
1216 * extended error information, call GetLastError.
1217 * Status : UNTESTED STUB
1218 *
1219 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1220 *****************************************************************************/
1221BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
1222{
1223 dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
1224 hWinSta));
1225
1226 return (FALSE);
1227}
1228/*****************************************************************************
1229 * Name : HDESK WIN32API CreateDesktopA
1230 * Purpose : The CreateDesktop function creates a new desktop on the window
1231 * station associated with the calling process.
1232 * Parameters: LPCTSTR lpszDesktop name of the new desktop
1233 * LPCTSTR lpszDevice name of display device to assign to the desktop
1234 * LPDEVMODE pDevMode reserved; must be NULL
1235 * DWORD dwFlags flags to control interaction with other applications
1236 * DWORD dwDesiredAccess specifies access of returned handle
1237 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
1238 * Variables :
1239 * Result : If the function succeeds, the return value is a handle of the
1240 * newly created desktop.
1241 * If the function fails, the return value is NULL. To get extended
1242 * error information, call GetLastError.
1243 * Remark :
1244 * Status : UNTESTED STUB
1245 *
1246 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1247 *****************************************************************************/
1248HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
1249 LPCTSTR lpszDevice,
1250 LPDEVMODEA pDevMode,
1251 DWORD dwFlags,
1252 DWORD dwDesiredAccess,
1253 LPSECURITY_ATTRIBUTES lpsa)
1254{
1255 dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
1256 lpszDesktop,
1257 lpszDevice,
1258 pDevMode,
1259 dwFlags,
1260 dwDesiredAccess,
1261 lpsa));
1262
1263 return (NULL);
1264}
1265/*****************************************************************************
1266 * Name : HDESK WIN32API CreateDesktopW
1267 * Purpose : The CreateDesktop function creates a new desktop on the window
1268 * station associated with the calling process.
1269 * Parameters: LPCTSTR lpszDesktop name of the new desktop
1270 * LPCTSTR lpszDevice name of display device to assign to the desktop
1271 * LPDEVMODE pDevMode reserved; must be NULL
1272 * DWORD dwFlags flags to control interaction with other applications
1273 * DWORD dwDesiredAccess specifies access of returned handle
1274 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
1275 * Variables :
1276 * Result : If the function succeeds, the return value is a handle of the
1277 * newly created desktop.
1278 * If the function fails, the return value is NULL. To get extended
1279 * error information, call GetLastError.
1280 * Remark :
1281 * Status : UNTESTED STUB
1282 *
1283 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1284 *****************************************************************************/
1285HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
1286 LPCTSTR lpszDevice,
1287 LPDEVMODEW pDevMode,
1288 DWORD dwFlags,
1289 DWORD dwDesiredAccess,
1290 LPSECURITY_ATTRIBUTES lpsa)
1291{
1292 dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
1293 lpszDesktop,
1294 lpszDevice,
1295 pDevMode,
1296 dwFlags,
1297 dwDesiredAccess,
1298 lpsa));
1299
1300 return (NULL);
1301}
1302/*****************************************************************************
1303 * Name : HWINSTA WIN32API CreateWindowStationA
1304 * Purpose : The CreateWindowStation function creates a window station object.
1305 * It returns a handle that can be used to access the window station.
1306 * A window station is a secure object that contains a set of global
1307 * atoms, a clipboard, and a set of desktop objects.
1308 * Parameters: LPTSTR lpwinsta name of the new window station
1309 * DWORD dwReserved reserved; must be NULL
1310 * DWORD dwDesiredAccess specifies access of returned handle
1311 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
1312 * Variables :
1313 * Result : If the function succeeds, the return value is the handle to the
1314 * newly created window station.
1315 * If the function fails, the return value is NULL. To get extended
1316 * error information, call GetLastError.
1317 * Remark :
1318 * Status : UNTESTED STUB
1319 *
1320 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1321 *****************************************************************************/
1322HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
1323 DWORD dwReserved,
1324 DWORD dwDesiredAccess,
1325 LPSECURITY_ATTRIBUTES lpsa)
1326{
1327 dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
1328 lpWinSta,
1329 dwReserved,
1330 dwDesiredAccess,
1331 lpsa));
1332
1333 return (NULL);
1334}
1335/*****************************************************************************
1336 * Name : HWINSTA WIN32API CreateWindowStationW
1337 * Purpose : The CreateWindowStation function creates a window station object.
1338 * It returns a handle that can be used to access the window station.
1339 * A window station is a secure object that contains a set of global
1340 * atoms, a clipboard, and a set of desktop objects.
1341 * Parameters: LPTSTR lpwinsta name of the new window station
1342 * DWORD dwReserved reserved; must be NULL
1343 * DWORD dwDesiredAccess specifies access of returned handle
1344 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
1345 * Variables :
1346 * Result : If the function succeeds, the return value is the handle to the
1347 * newly created window station.
1348 * If the function fails, the return value is NULL. To get extended
1349 * error information, call GetLastError.
1350 * Remark :
1351 * Status : UNTESTED STUB
1352 *
1353 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1354 *****************************************************************************/
1355HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
1356 DWORD dwReserved,
1357 DWORD dwDesiredAccess,
1358 LPSECURITY_ATTRIBUTES lpsa)
1359{
1360 dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
1361 lpWinSta,
1362 dwReserved,
1363 dwDesiredAccess,
1364 lpsa));
1365
1366 return (NULL);
1367}
1368/*****************************************************************************
1369 * Name : BOOL WIN32API EnumDesktopWindows
1370 * Purpose : The EnumDesktopWindows function enumerates all windows in a
1371 * desktop by passing the handle of each window, in turn, to an
1372 * application-defined callback function.
1373 * Parameters: HDESK hDesktop handle of desktop to enumerate
1374 * WNDENUMPROC lpfn points to application's callback function
1375 * LPARAM lParam 32-bit value to pass to the callback function
1376 * Variables :
1377 * Result : If the function succeeds, the return value is TRUE.
1378 * If the function fails, the return value is FALSE. To get
1379 * extended error information, call GetLastError.
1380 * Remark :
1381 * Status : UNTESTED STUB
1382 *
1383 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1384 *****************************************************************************/
1385BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
1386 WNDENUMPROC lpfn,
1387 LPARAM lParam)
1388{
1389 dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
1390 hDesktop,
1391 lpfn,
1392 lParam));
1393
1394 return (FALSE);
1395}
1396/*****************************************************************************
1397 * Name : BOOL WIN32API EnumDesktopsA
1398 * Purpose : The EnumDesktops function enumerates all desktops in the window
1399 * station assigned to the calling process. The function does so by
1400 * passing the name of each desktop, in turn, to an application-
1401 * defined callback function.
1402 * Parameters: HWINSTA hwinsta handle of window station to enumerate
1403 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
1404 * LPARAM lParam 32-bit value to pass to the callback function
1405 * Variables :
1406 * Result : If the function succeeds, the return value is TRUE.
1407 * If the function fails, the return value is FALSE. To get extended
1408 * error information, call GetLastError.
1409 * Remark :
1410 * Status : UNTESTED STUB
1411 *
1412 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1413 *****************************************************************************/
1414BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
1415 DESKTOPENUMPROCA lpEnumFunc,
1416 LPARAM lParam)
1417{
1418 dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
1419 hWinSta,
1420 lpEnumFunc,
1421 lParam));
1422
1423 return (FALSE);
1424}
1425/*****************************************************************************
1426 * Name : BOOL WIN32API EnumDesktopsW
1427 * Purpose : The EnumDesktops function enumerates all desktops in the window
1428 * station assigned to the calling process. The function does so by
1429 * passing the name of each desktop, in turn, to an application-
1430 * defined callback function.
1431 * Parameters: HWINSTA hwinsta handle of window station to enumerate
1432 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
1433 * LPARAM lParam 32-bit value to pass to the callback function
1434 * Variables :
1435 * Result : If the function succeeds, the return value is TRUE.
1436 * If the function fails, the return value is FALSE. To get extended
1437 * error information, call GetLastError.
1438 * Remark :
1439 * Status : UNTESTED STUB
1440 *
1441 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1442 *****************************************************************************/
1443BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
1444 DESKTOPENUMPROCW lpEnumFunc,
1445 LPARAM lParam)
1446{
1447 dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
1448 hWinSta,
1449 lpEnumFunc,
1450 lParam));
1451
1452 return (FALSE);
1453}
1454/*****************************************************************************
1455 * Name : BOOL WIN32API EnumWindowStationsA
1456 * Purpose : The EnumWindowStations function enumerates all windowstations
1457 * in the system by passing the name of each window station, in
1458 * turn, to an application-defined callback function.
1459 * Parameters:
1460 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
1461 * LPARAM lParam 32-bit value to pass to the callback function
1462 * Result : If the function succeeds, the return value is TRUE.
1463 * If the function fails the return value is FALSE. To get extended
1464 * error information, call GetLastError.
1465 * Remark :
1466 * Status : UNTESTED STUB
1467 *
1468 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1469 *****************************************************************************/
1470BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
1471 LPARAM lParam)
1472{
1473 dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
1474 lpEnumFunc,
1475 lParam));
1476
1477 return (FALSE);
1478}
1479/*****************************************************************************
1480 * Name : BOOL WIN32API EnumWindowStationsW
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 EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
1496 LPARAM lParam)
1497{
1498 dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
1499 lpEnumFunc,
1500 lParam));
1501
1502 return (FALSE);
1503}
1504/*****************************************************************************
1505 * Name : HWINSTA WIN32API GetProcessWindowStation
1506 * Purpose : The GetProcessWindowStation function returns a handle of the
1507 * window station associated with the calling process.
1508 * Parameters:
1509 * Variables :
1510 * Result : If the function succeeds, the return value is a handle of the
1511 * window station associated with the calling process.
1512 * If the function fails, the return value is NULL. This can occur
1513 * if the calling process is not an application written for Windows
1514 * NT. To get extended error information, call GetLastError.
1515 * Remark :
1516 * Status : UNTESTED STUB
1517 *
1518 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1519 *****************************************************************************/
1520HWINSTA WIN32API GetProcessWindowStation(VOID)
1521{
1522 dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
1523
1524 return (NULL);
1525}
1526/*****************************************************************************
1527 * Name : BOOL WIN32API GetUserObjectInformationA
1528 * Purpose : The GetUserObjectInformation function returns information about
1529 * a window station or desktop object.
1530 * Parameters: HANDLE hObj handle of object to get information for
1531 * int nIndex type of information to get
1532 * PVOID pvInfo points to buffer that receives the information
1533 * DWORD nLength size, in bytes, of pvInfo buffer
1534 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
1535 * Variables :
1536 * Result : If the function succeeds, the return value is TRUE.
1537 * If the function fails, the return value is FALSE. To get extended
1538 * error information, call GetLastError.
1539 * Remark :
1540 * Status : UNTESTED STUB
1541 *
1542 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1543 *****************************************************************************/
1544BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
1545 int nIndex,
1546 PVOID pvInfo,
1547 DWORD nLength,
1548 LPDWORD lpnLengthNeeded)
1549{
1550 dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1551 hObj,
1552 nIndex,
1553 pvInfo,
1554 nLength,
1555 lpnLengthNeeded));
1556
1557 return (FALSE);
1558}
1559/*****************************************************************************
1560 * Name : BOOL WIN32API GetUserObjectInformationW
1561 * Purpose : The GetUserObjectInformation function returns information about
1562 * a window station or desktop object.
1563 * Parameters: HANDLE hObj handle of object to get information for
1564 * int nIndex type of information to get
1565 * PVOID pvInfo points to buffer that receives the information
1566 * DWORD nLength size, in bytes, of pvInfo buffer
1567 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
1568 * Variables :
1569 * Result : If the function succeeds, the return value is TRUE.
1570 * If the function fails, the return value is FALSE. To get extended
1571 * error information, call GetLastError.
1572 * Remark :
1573 * Status : UNTESTED STUB
1574 *
1575 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1576 *****************************************************************************/
1577BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
1578 int nIndex,
1579 PVOID pvInfo,
1580 DWORD nLength,
1581 LPDWORD lpnLengthNeeded)
1582{
1583 dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1584 hObj,
1585 nIndex,
1586 pvInfo,
1587 nLength,
1588 lpnLengthNeeded));
1589
1590 return (FALSE);
1591}
1592/*****************************************************************************
1593 * Name : BOOL WIN32API GetUserObjectSecurity
1594 * Purpose : The GetUserObjectSecurity function retrieves security information
1595 * for the specified user object.
1596 * Parameters: HANDLE hObj handle of user object
1597 * SECURITY_INFORMATION * pSIRequested address of requested security information
1598 * LPSECURITY_DESCRIPTOR pSID address of security descriptor
1599 * DWORD nLength size of buffer for security descriptor
1600 * LPDWORD lpnLengthNeeded address of required size of buffer
1601 * Variables :
1602 * Result : If the function succeeds, the return value is TRUE.
1603 * If the function fails, the return value is FALSE. To get extended
1604 * error information, call GetLastError.
1605 * Remark :
1606 * Status : UNTESTED STUB
1607 *
1608 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1609 *****************************************************************************/
1610BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
1611 PSECURITY_INFORMATION pSIRequested,
1612 PSECURITY_DESCRIPTOR pSID,
1613 DWORD nLength,
1614 LPDWORD lpnLengthNeeded)
1615{
1616 dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1617 hObj,
1618 pSIRequested,
1619 pSID,
1620 nLength,
1621 lpnLengthNeeded));
1622
1623 return (FALSE);
1624}
1625/*****************************************************************************
1626 * Name : HDESK WIN32API OpenDesktopA
1627 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
1628 * A desktop is a secure object contained within a window station
1629 * object. A desktop has a logical display surface and contains
1630 * windows, menus and hooks.
1631 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
1632 * DWORD dwFlags flags to control interaction with other applications
1633 * BOOL fInherit specifies whether returned handle is inheritable
1634 * DWORD dwDesiredAccess specifies access of returned handle
1635 * Variables :
1636 * Result : If the function succeeds, the return value is the handle to the
1637 * opened desktop.
1638 * If the function fails, the return value is NULL. To get extended
1639 * error information, call GetLastError.
1640 * Remark :
1641 * Status : UNTESTED STUB
1642 *
1643 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1644 *****************************************************************************/
1645HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
1646 DWORD dwFlags,
1647 BOOL fInherit,
1648 DWORD dwDesiredAccess)
1649{
1650 dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
1651 lpszDesktopName,
1652 dwFlags,
1653 fInherit,
1654 dwDesiredAccess));
1655
1656 return (NULL);
1657}
1658/*****************************************************************************
1659 * Name : HDESK WIN32API OpenDesktopW
1660 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
1661 * A desktop is a secure object contained within a window station
1662 * object. A desktop has a logical display surface and contains
1663 * windows, menus and hooks.
1664 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
1665 * DWORD dwFlags flags to control interaction with other applications
1666 * BOOL fInherit specifies whether returned handle is inheritable
1667 * DWORD dwDesiredAccess specifies access of returned handle
1668 * Variables :
1669 * Result : If the function succeeds, the return value is the handle to the
1670 * opened desktop.
1671 * If the function fails, the return value is NULL. To get extended
1672 * error information, call GetLastError.
1673 * Remark :
1674 * Status : UNTESTED STUB
1675 *
1676 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1677 *****************************************************************************/
1678HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
1679 DWORD dwFlags,
1680 BOOL fInherit,
1681 DWORD dwDesiredAccess)
1682{
1683 dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
1684 lpszDesktopName,
1685 dwFlags,
1686 fInherit,
1687 dwDesiredAccess));
1688
1689 return (NULL);
1690}
1691/*****************************************************************************
1692 * Name : HDESK WIN32API OpenInputDesktop
1693 * Purpose : The OpenInputDesktop function returns a handle to the desktop
1694 * that receives user input. The input desktop is a desktop on the
1695 * window station associated with the logged-on user.
1696 * Parameters: DWORD dwFlags flags to control interaction with other applications
1697 * BOOL fInherit specifies whether returned handle is inheritable
1698 * DWORD dwDesiredAccess specifies access of returned handle
1699 * Variables :
1700 * Result : If the function succeeds, the return value is a handle of the
1701 * desktop that receives user input.
1702 * If the function fails, the return value is NULL. To get extended
1703 * error information, call GetLastError.
1704 * Remark :
1705 * Status : UNTESTED STUB
1706 *
1707 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1708 *****************************************************************************/
1709HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
1710 BOOL fInherit,
1711 DWORD dwDesiredAccess)
1712{
1713 dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
1714 dwFlags,
1715 fInherit,
1716 dwDesiredAccess));
1717
1718 return (NULL);
1719}
1720/*****************************************************************************
1721 * Name : HWINSTA WIN32API OpenWindowStationA
1722 * Purpose : The OpenWindowStation function returns a handle to an existing
1723 * window station.
1724 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
1725 * BOOL fInherit specifies whether returned handle is inheritable
1726 * DWORD dwDesiredAccess specifies access of returned handle
1727 * Variables :
1728 * Result : If the function succeeds, the return value is the handle to the
1729 * specified window station.
1730 * If the function fails, the return value is NULL. To get extended
1731 * error information, call GetLastError.
1732 * Remark :
1733 * Status : UNTESTED STUB
1734 *
1735 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1736 *****************************************************************************/
1737HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
1738 BOOL fInherit,
1739 DWORD dwDesiredAccess)
1740{
1741 dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
1742 lpszWinStaName,
1743 fInherit,
1744 dwDesiredAccess));
1745
1746 return (NULL);
1747}
1748/*****************************************************************************
1749 * Name : HWINSTA WIN32API OpenWindowStationW
1750 * Purpose : The OpenWindowStation function returns a handle to an existing
1751 * window station.
1752 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
1753 * BOOL fInherit specifies whether returned handle is inheritable
1754 * DWORD dwDesiredAccess specifies access of returned handle
1755 * Variables :
1756 * Result : If the function succeeds, the return value is the handle to the
1757 * specified window station.
1758 * If the function fails, the return value is NULL. To get extended
1759 * error information, call GetLastError.
1760
1761
1762 * Remark :
1763 * Status : UNTESTED STUB
1764 *
1765 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1766 *****************************************************************************/
1767HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
1768 BOOL fInherit,
1769 DWORD dwDesiredAccess)
1770{
1771 dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
1772 lpszWinStaName,
1773 fInherit,
1774 dwDesiredAccess));
1775
1776 return (NULL);
1777}
1778/*****************************************************************************
1779 * Name : BOOL WIN32API SetProcessWindowStation
1780 * Purpose : The SetProcessWindowStation function assigns a window station
1781 * to the calling process. This enables the process to access
1782 * objects in the window station such as desktops, the clipboard,
1783 * and global atoms. All subsequent operations on the window station
1784 * use the access rights granted to hWinSta.
1785 * Parameters:
1786 * Variables :
1787 * Result : If the function succeeds, the return value is TRUE.
1788 * If the function fails, the return value is FALSE. To get extended
1789 * error information, call GetLastError.
1790 * Remark :
1791 * Status : UNTESTED STUB
1792 *
1793 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1794 *****************************************************************************/
1795BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
1796{
1797 dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
1798 hWinSta));
1799
1800 return (FALSE);
1801}
1802/*****************************************************************************
1803 * Name : BOOL WIN32API SetThreadDesktop
1804 * Purpose : The SetThreadDesktop function assigns a desktop to the calling
1805 * thread. All subsequent operations on the desktop use the access
1806 * rights granted to hDesk.
1807 * Parameters: HDESK hDesk handle of the desktop to assign to this thread
1808 * Variables :
1809 * Result : If the function succeeds, the return value is TRUE.
1810 * If the function fails, the return value is FALSE. To get extended
1811 * error information, call GetLastError.
1812 * Remark :
1813 * Status : UNTESTED STUB
1814 *
1815 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1816 *****************************************************************************/
1817BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
1818{
1819 dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
1820 hDesktop));
1821
1822 return (FALSE);
1823}
1824/*****************************************************************************
1825 * Name : BOOL WIN32API SetUserObjectInformationA
1826 * Purpose : The SetUserObjectInformation function sets information about a
1827 * window station or desktop object.
1828 * Parameters: HANDLE hObject handle of the object for which to set information
1829 * int nIndex type of information to set
1830 * PVOID lpvInfo points to a buffer that contains the information
1831 * DWORD cbInfo size, in bytes, of lpvInfo buffer
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 SetUserObjectInformationA(HANDLE hObject,
1842 int nIndex,
1843 PVOID lpvInfo,
1844 DWORD cbInfo)
1845{
1846 dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
1847 hObject,
1848 nIndex,
1849 lpvInfo,
1850 cbInfo));
1851
1852 return (FALSE);
1853}
1854/*****************************************************************************
1855 * Name : BOOL WIN32API SetUserObjectInformationW
1856 * Purpose : The SetUserObjectInformation function sets information about a
1857 * window station or desktop object.
1858 * Parameters: HANDLE hObject handle of the object for which to set information
1859 * int nIndex type of information to set
1860 * PVOID lpvInfo points to a buffer that contains the information
1861 * DWORD cbInfo size, in bytes, of lpvInfo buffer
1862 * Variables :
1863 * Result : If the function succeeds, the return value is TRUE.
1864 * If the function fails the return value is FALSE. To get extended
1865 * error information, call GetLastError.
1866 * Remark :
1867 * Status : UNTESTED STUB
1868 *
1869 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1870 *****************************************************************************/
1871BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
1872 int nIndex,
1873 PVOID lpvInfo,
1874 DWORD cbInfo)
1875{
1876 dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
1877 hObject,
1878 nIndex,
1879 lpvInfo,
1880 cbInfo));
1881
1882 return (FALSE);
1883}
1884/*****************************************************************************
1885 * Name : BOOL WIN32API SetUserObjectSecurity
1886 * Purpose : The SetUserObjectSecurity function sets the security of a user
1887 * object. This can be, for example, a window or a DDE conversation
1888 * Parameters: HANDLE hObject handle of user object
1889 * SECURITY_INFORMATION * psi address of security information
1890 * LPSECURITY_DESCRIPTOR psd address of security descriptor
1891 * Variables :
1892 * Result : If the function succeeds, the return value is TRUE.
1893 * If the function fails, the return value is FALSE. To get extended
1894 * error information, call GetLastError.
1895 * Remark :
1896 * Status : UNTESTED STUB
1897 *
1898 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1899 *****************************************************************************/
1900BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
1901 PSECURITY_INFORMATION psi,
1902 PSECURITY_DESCRIPTOR psd)
1903{
1904 dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
1905 hObject,
1906 psi,
1907 psd));
1908
1909 return (FALSE);
1910}
1911/*****************************************************************************
1912 * Name : BOOL WIN32API SwitchDesktop
1913 * Purpose : The SwitchDesktop function makes a desktop visible and activates
1914 * it. This enables the desktop to receive input from the user. The
1915 * calling process must have DESKTOP_SWITCHDESKTOP access to the
1916 * desktop for the SwitchDesktop function to succeed.
1917 * Parameters:
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 SwitchDesktop(HDESK hDesktop)
1928{
1929 dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
1930 hDesktop));
1931
1932 return (FALSE);
1933}
1934
1935/* Debugging Functions */
1936
1937/*****************************************************************************
1938 * Name : VOID WIN32API SetDebugErrorLevel
1939 * Purpose : The SetDebugErrorLevel function sets the minimum error level at
1940 * which Windows will generate debugging events and pass them to a debugger.
1941 * Parameters: DWORD dwLevel debugging error level
1942 * Variables :
1943 * Result :
1944 * Remark :
1945 * Status : UNTESTED STUB
1946 *
1947 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1948 *****************************************************************************/
1949VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
1950{
1951 dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
1952 dwLevel));
1953}
1954
1955/* Drag'n'drop */
1956
1957/*****************************************************************************
1958 * Name : BOOL WIN32API DragObject
1959 * Purpose : Unknown
1960 * Parameters: Unknown
1961 * Variables :
1962 * Result :
1963 * Remark :
1964 * Status : UNTESTED UNKNOWN STUB
1965 *
1966 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
1967 *****************************************************************************/
1968DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
1969{
1970 dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1971 x1,
1972 x2,
1973 x3,
1974 x4,
1975 x5));
1976
1977 return (FALSE); /* default */
1978}
1979
1980/* Unknown */
1981
1982/*****************************************************************************
1983 * Name : BOOL WIN32API SetShellWindow
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 *****************************************************************************/
1993BOOL WIN32API SetShellWindow(DWORD x1)
1994{
1995 dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
1996 x1));
1997
1998 return (FALSE); /* default */
1999}
2000/*****************************************************************************
2001 * Name : BOOL WIN32API PlaySoundEvent
2002 * Purpose : Unknown
2003 * Parameters: Unknown
2004 * Variables :
2005 * Result :
2006 * Remark :
2007 * Status : UNTESTED UNKNOWN STUB
2008 *
2009 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2010 *****************************************************************************/
2011BOOL WIN32API PlaySoundEvent(DWORD x1)
2012{
2013 dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
2014 x1));
2015
2016 return (FALSE); /* default */
2017}
2018/*****************************************************************************
2019 * Name : BOOL WIN32API SetSysColorsTemp
2020 * Purpose : Unknown
2021 * Parameters: Unknown
2022 * Variables :
2023 * Result :
2024 * Remark :
2025 * Status : UNTESTED UNKNOWN STUB
2026 *
2027 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2028 *****************************************************************************/
2029BOOL WIN32API SetSysColorsTemp(void)
2030{
2031 dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
2032
2033 return (FALSE); /* default */
2034}
2035/*****************************************************************************
2036 * Name : BOOL WIN32API RegisterNetworkCapabilities
2037 * Purpose : Unknown
2038 * Parameters: Unknown
2039 * Variables :
2040 * Result :
2041 * Remark :
2042 * Status : UNTESTED UNKNOWN STUB
2043 *
2044 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2045 *****************************************************************************/
2046BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
2047 DWORD x2)
2048{
2049 dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
2050 x1,
2051 x2));
2052
2053 return (FALSE); /* default */
2054}
2055/*****************************************************************************
2056 * Name : BOOL WIN32API EndTask
2057 * Purpose : Unknown
2058 * Parameters: Unknown
2059 * Variables :
2060 * Result :
2061 * Remark :
2062 * Status : UNTESTED UNKNOWN STUB
2063 *
2064 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2065 *****************************************************************************/
2066BOOL WIN32API EndTask(DWORD x1,
2067 DWORD x2,
2068 DWORD x3)
2069{
2070 dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
2071 x1,
2072 x2,
2073 x3));
2074
2075 return (FALSE); /* default */
2076}
2077/*****************************************************************************
2078 * Name : BOOL WIN32API GetNextQueueWindow
2079 * Purpose : Unknown
2080 * Parameters: Unknown
2081 * Variables :
2082 * Result :
2083 * Remark :
2084 * Status : UNTESTED UNKNOWN STUB
2085 *
2086 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2087 *****************************************************************************/
2088BOOL WIN32API GetNextQueueWindow(DWORD x1,
2089 DWORD x2)
2090{
2091 dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
2092 x1,
2093 x2));
2094
2095 return (FALSE); /* default */
2096}
2097/*****************************************************************************
2098 * Name : BOOL WIN32API YieldTask
2099 * Purpose : Unknown
2100 * Parameters: Unknown
2101 * Variables :
2102 * Result :
2103 * Remark :
2104 * Status : UNTESTED UNKNOWN STUB
2105 *
2106 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2107 *****************************************************************************/
2108BOOL WIN32API YieldTask(void)
2109{
2110 dprintf(("USER32: YieldTask() not implemented.\n"));
2111
2112 return (FALSE); /* default */
2113}
2114/*****************************************************************************
2115 * Name : BOOL WIN32API WinOldAppHackoMatic
2116 * Purpose : Unknown
2117 * Parameters: Unknown
2118 * Variables :
2119 * Result :
2120 * Remark :
2121 * Status : UNTESTED UNKNOWN STUB
2122 *
2123 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2124 *****************************************************************************/
2125BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
2126{
2127 dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
2128 x1));
2129
2130 return (FALSE); /* default */
2131}
2132/*****************************************************************************
2133 * Name : BOOL WIN32API RegisterSystemThread
2134 * Purpose : Unknown
2135 * Parameters: Unknown
2136 * Variables :
2137 * Result :
2138 * Remark :
2139 * Status : UNTESTED UNKNOWN STUB
2140 *
2141 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2142 *****************************************************************************/
2143BOOL WIN32API RegisterSystemThread(DWORD x1,
2144 DWORD x2)
2145{
2146 dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
2147 x1,
2148 x2));
2149
2150 return (FALSE); /* default */
2151}
2152/*****************************************************************************
2153 * Name : BOOL WIN32API IsHungThread
2154 * Purpose : Unknown
2155 * Parameters: Unknown
2156 * Variables :
2157 * Result :
2158 * Remark :
2159 * Status : UNTESTED UNKNOWN STUB
2160 *
2161 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2162 *****************************************************************************/
2163BOOL WIN32API IsHungThread(DWORD x1)
2164{
2165 dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
2166 x1));
2167
2168 return (FALSE); /* default */
2169}
2170/*****************************************************************************
2171 * Name : BOOL WIN32API UserSignalProc
2172 * Purpose : Unknown
2173 * Parameters: Unknown
2174 * Variables :
2175 * Result :
2176 * Remark :
2177 * Status : UNTESTED UNKNOWN STUB
2178 *
2179 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2180 *****************************************************************************/
2181BOOL WIN32API UserSignalProc(DWORD x1,
2182 DWORD x2,
2183 DWORD x3,
2184 DWORD x4)
2185{
2186 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2187 x1,
2188 x2,
2189 x3,
2190 x4));
2191
2192 return (FALSE); /* default */
2193}
2194/*****************************************************************************
2195 * Name : BOOL WIN32API GetShellWindow
2196 * Purpose : Unknown
2197 * Parameters: Unknown
2198 * Variables :
2199 * Result :
2200 * Remark :
2201 * Status : UNTESTED UNKNOWN STUB
2202 *
2203 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2204 *****************************************************************************/
2205HWND WIN32API GetShellWindow(void)
2206{
2207 dprintf(("USER32: GetShellWindow() not implemented.\n"));
2208
2209 return (0); /* default */
2210}
2211/***********************************************************************
2212 * RegisterTasklist32 [USER32.436]
2213 */
2214DWORD WIN32API RegisterTasklist (DWORD x)
2215{
2216 dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
2217 x));
2218
2219 return TRUE;
2220}
2221/***********************************************************************
2222 * SetLogonNotifyWindow (USER32.486)
2223 */
2224DWORD WIN32API SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd)
2225{
2226 dprintf(("USER32: SetLogonNotifyWindow - empty stub!"));
2227
2228 return 1;
2229}
2230
2231
2232DWORD WIN32API NotifyWinEvent(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4)
2233{
2234 dprintf(("USER32: NotifyWinEvent %x %x %x %x - empty stub!!", arg1, arg2, arg3, arg4));
2235
2236 return 0;
2237}
2238
2239DWORD WIN32API UnhookWinEvent(DWORD arg1)
2240{
2241 dprintf(("USER32: UnhookWinEvent %x - empty stub!!", arg1));
2242
2243 return 0;
2244}
2245
2246DWORD WIN32API SetWinEventHook(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7)
2247{
2248 dprintf(("USER32: SetWinEventHook %x %x %x %x %x %x %x - empty stub!!", arg1, arg2, arg3, arg4, arg5, arg6, arg7));
2249
2250 return 0;
2251}
2252
2253DWORD WIN32API GetGUIThreadInfo(DWORD arg1, DWORD arg2)
2254{
2255 dprintf(("USER32: GetGUIThreadInfo %x %x - empty stub!!", arg1, arg2));
2256
2257 return 0;
2258}
2259
Note: See TracBrowser for help on using the repository browser.