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

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

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