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

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

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