source: trunk/src/user32/user32.cpp

Last change on this file was 21916, checked in by dmik, 14 years ago

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