source: trunk/src/user32/old/user32.cpp@ 6035

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

frame only user32 version
File size: 92.4 KB
Line 
1/* $Id: user32.cpp,v 1.6 2001-05-11 08:38:40 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
43#include <wchar.h>
44#include <stdlib.h>
45#include <string.h>
46#include <oslibwin.h>
47#include <win32wnd.h>
48#include <winuser.h>
49
50#define DBG_LOCALLOG DBG_user32
51#include "dbglocal.h"
52
53//undocumented stuff
54// WIN32API CalcChildScroll
55// WIN32API CascadeChildWindows
56// WIN32API ClientThreadConnect
57// WIN32API DragObject
58// WIN32API DrawFrame
59// WIN32API EditWndProc
60// WIN32API EndTask
61// WIN32API GetInputDesktop
62// WIN32API GetNextQueueWindow
63// WIN32API GetShellWindow
64// WIN32API InitSharedTable
65// WIN32API InitTask
66// WIN32API IsHungThread
67// WIN32API LockWindowStation
68// WIN32API ModifyAccess
69// WIN32API PlaySoundEvent
70// WIN32API RegisterLogonProcess
71// WIN32API RegisterNetworkCapabilities
72// WIN32API RegisterSystemThread
73// WIN32API SetDeskWallpaper
74// WIN32API SetDesktopBitmap
75// WIN32API SetInternalWindowPos
76// WIN32API SetLogonNotifyWindow
77// WIN32API SetShellWindow
78// WIN32API SetSysColorsTemp
79// WIN32API SetWindowFullScreenState
80// WIN32API SwitchToThisWindow
81// WIN32API SysErrorBox
82// WIN32API TileChildWindows
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 OSLibDosBeep(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 rc = 19;
428 //rc = OSLibWinQuerySysValue(SVOS_CYTITLEBAR);
429 break;
430
431 case SM_CXBORDER:
432 case SM_CYBORDER:
433 rc = 1;
434 break;
435
436 case SM_CXDLGFRAME:
437 case SM_CYDLGFRAME:
438 rc = 3;
439 break;
440
441 case SM_CYMENU:
442 case SM_CXMENUSIZE:
443 case SM_CYMENUSIZE:
444 rc = 19;
445 break;
446
447 case SM_CXSIZE:
448 case SM_CYSIZE:
449 rc = GetSystemMetrics(SM_CYCAPTION)-2;
450 break;
451
452 case SM_CXFRAME:
453 case SM_CYFRAME:
454 rc = 4;
455 break;
456
457 case SM_CXEDGE:
458 case SM_CYEDGE:
459 rc = 2;
460 break;
461
462 case SM_CXMINSPACING:
463 rc = 160;
464 break;
465
466 case SM_CYMINSPACING:
467 rc = 24;
468 break;
469
470 case SM_CXSMICON:
471 case SM_CYSMICON:
472 rc = 16;
473 break;
474
475 case SM_CYSMCAPTION:
476 rc = 16;
477 break;
478
479 case SM_CXSMSIZE:
480 case SM_CYSMSIZE:
481 rc = 15;
482 break;
483
484//CB: todo: add missing metrics
485
486 case SM_CXICONSPACING: //TODO: size of grid cell for large icons
487 rc = OSLibWinQuerySysValue(SVOS_CXICON);
488 //CB: return standard windows icon size?
489 //rc = 32;
490 break;
491 case SM_CYICONSPACING:
492 rc = OSLibWinQuerySysValue(SVOS_CYICON);
493 //read SM_CXICONSPACING comment
494 //rc = 32;
495 break;
496 case SM_PENWINDOWS:
497 rc = FALSE;
498 break;
499 case SM_DBCSENABLED:
500 rc = FALSE;
501 break;
502 case SM_CXICON:
503 case SM_CYICON:
504 rc = 32; //CB: Win32: only 32x32, OS/2 32x32/40x40
505 // we must implement 32x32 for all screen resolutions
506 break;
507 case SM_ARRANGE:
508 rc = ARW_BOTTOMLEFT | ARW_LEFT;
509 break;
510 case SM_CXMINIMIZED:
511 break;
512 case SM_CYMINIMIZED:
513 break;
514
515 case SM_CXMINTRACK:
516 case SM_CXMIN:
517 rc = 112;
518 break;
519
520 case SM_CYMINTRACK:
521 case SM_CYMIN:
522 rc = 27;
523 break;
524
525 case SM_CXMAXTRACK: //max window size
526 case SM_CXMAXIMIZED: //max toplevel window size
527 rc = OSLibWinQuerySysValue(SVOS_CXSCREEN);
528 break;
529
530 case SM_CYMAXTRACK:
531 case SM_CYMAXIMIZED:
532 rc = OSLibWinQuerySysValue(SVOS_CYSCREEN);
533 break;
534
535 case SM_NETWORK:
536 rc = 0x01; //TODO: default = yes
537 break;
538 case SM_CLEANBOOT:
539 rc = 0; //normal boot
540 break;
541 case SM_CXDRAG: //nr of pixels before drag becomes a real one
542 rc = 2;
543 break;
544 case SM_CYDRAG:
545 rc = 2;
546 break;
547 case SM_SHOWSOUNDS: //show instead of play sound
548 rc = FALSE;
549 break;
550 case SM_CXMENUCHECK:
551 rc = 4; //TODO
552 break;
553 case SM_CYMENUCHECK:
554 rc = OSLibWinQuerySysValue(SVOS_CYMENU);
555 break;
556 case SM_SLOWMACHINE:
557 rc = FALSE; //even a slow machine is fast with OS/2 :)
558 break;
559 case SM_MIDEASTENABLED:
560 rc = FALSE;
561 break;
562 case SM_MOUSEWHEELPRESENT:
563 rc = FALSE;
564 break;
565 case SM_XVIRTUALSCREEN:
566 rc = 0;
567 break;
568 case SM_YVIRTUALSCREEN:
569 rc = 0;
570 break;
571
572 case SM_CXVIRTUALSCREEN:
573 rc = OSLibWinQuerySysValue(SVOS_CXSCREEN);
574 break;
575 case SM_CYVIRTUALSCREEN:
576 rc = OSLibWinQuerySysValue(SVOS_CYSCREEN);
577 break;
578 case SM_CMONITORS:
579 rc = 1;
580 break;
581 case SM_SAMEDISPLAYFORMAT:
582 rc = TRUE;
583 break;
584 case SM_CMETRICS:
585 rc = 81;
586 //rc = O32_GetSystemMetrics(44); //Open32 changed this one
587 break;
588 default:
589 //better than nothing
590 rc = O32_GetSystemMetrics(nIndex);
591 break;
592 }
593 dprintf2(("USER32: GetSystemMetrics %d returned %d\n", nIndex, rc));
594 return(rc);
595}
596//******************************************************************************
597/* Not support by Open32 (not included are the new win9x parameters):
598 case SPI_GETFASTTASKSWITCH:
599 case SPI_GETGRIDGRANULARITY:
600 case SPI_GETICONTITLELOGFONT:
601 case SPI_GETICONTITLEWRAP:
602 case SPI_GETMENUDROPALIGNMENT:
603 case SPI_ICONHORIZONTALSPACING:
604 case SPI_ICONVERTICALSPACING:
605 case SPI_LANGDRIVER:
606 case SPI_SETFASTTASKSWITCH:
607 case SPI_SETGRIDGRANULARITY:
608 case SPI_SETICONTITLELOGFONT:
609 case SPI_SETICONTITLEWRAP:
610 case SPI_SETMENUDROPALIGNMENT:
611 case SPI_GETSCREENSAVEACTIVE:
612 case SPI_GETSCREENSAVETIMEOUT:
613 case SPI_SETDESKPATTERN:
614 case SPI_SETDESKWALLPAPER:
615 case SPI_SETSCREENSAVEACTIVE:
616 case SPI_SETSCREENSAVETIMEOUT:
617*/
618//******************************************************************************
619BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
620{
621 BOOL rc = TRUE;
622
623 switch(uiAction) {
624 case SPI_SCREENSAVERRUNNING:
625 *(BOOL *)pvParam = FALSE;
626 break;
627 case SPI_GETDRAGFULLWINDOWS:
628 *(BOOL *)pvParam = FALSE; //CB: where is the Warp 4 setting stored?
629 break;
630 case SPI_GETNONCLIENTMETRICS:
631 {
632 LPNONCLIENTMETRICSA lpnm = (LPNONCLIENTMETRICSA)pvParam;
633
634 if (lpnm->cbSize == sizeof(NONCLIENTMETRICSA))
635 {
636 memset(lpnm, 0, sizeof(NONCLIENTMETRICSA));
637 lpnm->cbSize = sizeof(NONCLIENTMETRICSA);
638
639 SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfCaptionFont),0);
640 lpnm->lfCaptionFont.lfWeight = FW_BOLD;
641 lpnm->iCaptionWidth = 32; //TODO
642 lpnm->iCaptionHeight = 32; //TODO
643
644 SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfSmCaptionFont),0);
645 lpnm->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
646 lpnm->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
647
648 LPLOGFONTA lpLogFont = &(lpnm->lfMenuFont);
649 GetProfileStringA("Desktop", "MenuFont", "MS Sans Serif",
650 lpLogFont->lfFaceName, LF_FACESIZE);
651
652 lpLogFont->lfHeight = -GetProfileIntA("Desktop","MenuFontSize", 13);
653 lpLogFont->lfWidth = 0;
654 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
655 lpLogFont->lfWeight = FW_NORMAL;
656 lpLogFont->lfItalic = FALSE;
657 lpLogFont->lfStrikeOut = FALSE;
658 lpLogFont->lfUnderline = FALSE;
659 lpLogFont->lfCharSet = ANSI_CHARSET;
660 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
661 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
662 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
663
664 SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0,
665 (LPVOID)&(lpnm->lfStatusFont),0);
666 SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0,
667 (LPVOID)&(lpnm->lfMessageFont),0);
668
669 lpnm->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
670 lpnm->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
671 lpnm->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
672 lpnm->iMenuHeight = GetSystemMetrics(SM_CYMENU);
673 lpnm->iMenuWidth = lpnm->iMenuHeight; //TODO
674 }
675 else
676 {
677 dprintf(("SPI_GETNONCLIENTMETRICS: size mismatch !! (is %d; should be %d)\n", lpnm->cbSize, sizeof(NONCLIENTMETRICSA)));
678 /* FIXME: SetLastError? */
679 rc = FALSE;
680 }
681 break;
682 }
683
684 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
685 {
686 LPICONMETRICSA lpIcon = (LPICONMETRICSA)pvParam;
687 if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
688 {
689 SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0,
690 &lpIcon->iHorzSpacing, FALSE );
691 SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0,
692 &lpIcon->iVertSpacing, FALSE );
693 SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0,
694 &lpIcon->iTitleWrap, FALSE );
695 SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0,
696 &lpIcon->lfFont, FALSE );
697 }
698 else
699 {
700 dprintf(("SPI_GETICONMETRICS: size mismatch !! (is %d; should be %d)\n", lpIcon->cbSize, sizeof(ICONMETRICSA)));
701 /* FIXME: SetLastError? */
702 rc = FALSE;
703 }
704 break;
705 }
706
707 case SPI_GETICONTITLELOGFONT:
708 {
709 LPLOGFONTA lpLogFont = (LPLOGFONTA)pvParam;
710
711 /* from now on we always have an alias for MS Sans Serif */
712 strcpy(lpLogFont->lfFaceName, "MS Sans Serif");
713 lpLogFont->lfHeight = -GetProfileIntA("Desktop","IconTitleSize", /*8*/12); //CB: 8 is too small
714 lpLogFont->lfWidth = 0;
715 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
716 lpLogFont->lfWeight = FW_NORMAL;
717 lpLogFont->lfItalic = FALSE;
718 lpLogFont->lfStrikeOut = FALSE;
719 lpLogFont->lfUnderline = FALSE;
720 lpLogFont->lfCharSet = ANSI_CHARSET;
721 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
722 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
723 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
724 break;
725 }
726 case SPI_GETBORDER:
727 *(INT *)pvParam = GetSystemMetrics( SM_CXFRAME );
728 break;
729
730 case SPI_GETWORKAREA:
731 SetRect( (RECT *)pvParam, 0, 0,
732 GetSystemMetrics( SM_CXSCREEN ),
733 GetSystemMetrics( SM_CYSCREEN )
734 );
735 break;
736
737 case SPI_GETWHEELSCROLLLINES: //TODO: Undocumented
738 rc = 16;
739 break;
740
741 default:
742 rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
743 break;
744 }
745 dprintf(("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc));
746 return(rc);
747}
748//******************************************************************************
749//TODO: Check for more options that have different structs for Unicode!!!!
750//******************************************************************************
751BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
752{
753 BOOL rc = TRUE;
754 NONCLIENTMETRICSW *clientMetricsW = (NONCLIENTMETRICSW *)pvParam;
755 NONCLIENTMETRICSA clientMetricsA = {0};
756 PVOID pvParamA;
757 UINT uiParamA;
758
759 switch(uiAction) {
760 case SPI_SETNONCLIENTMETRICS:
761 clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
762 clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
763 clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
764 clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
765 clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
766 clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
767 ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
768 clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
769 clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
770 ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
771 clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
772 clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
773 ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
774 ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
775 ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
776 //no break
777 case SPI_GETNONCLIENTMETRICS:
778 uiParamA = sizeof(NONCLIENTMETRICSA);
779 pvParamA = &clientMetricsA;
780 break;
781
782 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
783 {
784 LPICONMETRICSW lpIcon = (LPICONMETRICSW)pvParam;
785 if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
786 {
787 SystemParametersInfoW( SPI_ICONHORIZONTALSPACING, 0,
788 &lpIcon->iHorzSpacing, FALSE );
789 SystemParametersInfoW( SPI_ICONVERTICALSPACING, 0,
790 &lpIcon->iVertSpacing, FALSE );
791 SystemParametersInfoW( SPI_GETICONTITLEWRAP, 0,
792 &lpIcon->iTitleWrap, FALSE );
793 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0,
794 &lpIcon->lfFont, FALSE );
795 return TRUE;
796 }
797 else
798 {
799 dprintf(("SPI_GETICONMETRICS: size mismatch !! (is %d; should be %d)\n", lpIcon->cbSize, sizeof(ICONMETRICSA)));
800 /* FIXME: SetLastError? */
801 return FALSE;
802 }
803 }
804
805 case SPI_GETICONTITLELOGFONT:
806 {
807 LPLOGFONTW lpLogFont = (LPLOGFONTW)pvParam;
808
809 /* from now on we always have an alias for MS Sans Serif */
810 lstrcpyW(lpLogFont->lfFaceName, (LPCWSTR)L"MS Sans Serif");
811 lpLogFont->lfHeight = -GetProfileIntA("Desktop","IconTitleSize", /*8*/12); //CB: 8 is too small
812 lpLogFont->lfWidth = 0;
813 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
814 lpLogFont->lfWeight = FW_NORMAL;
815 lpLogFont->lfItalic = FALSE;
816 lpLogFont->lfStrikeOut = FALSE;
817 lpLogFont->lfUnderline = FALSE;
818 lpLogFont->lfCharSet = ANSI_CHARSET;
819 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
820 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
821 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
822 return TRUE;
823 }
824 default:
825 pvParamA = pvParam;
826 uiParamA = uiParam;
827 break;
828 }
829 rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
830
831 switch(uiAction) {
832 case SPI_GETNONCLIENTMETRICS:
833 clientMetricsW->cbSize = sizeof(*clientMetricsW);
834 clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
835 clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
836 clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
837 clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
838 clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
839 ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
840
841 clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
842 clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
843 ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
844
845 clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
846 clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
847 ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
848 ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
849 ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
850 break;
851 }
852 dprintf(("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc));
853 return(rc);
854}
855
856/* Process and Thread Functions */
857
858//******************************************************************************
859//DWORD idAttach; /* thread to attach */
860//DWORD idAttachTo; /* thread to attach to */
861//BOOL fAttach; /* attach or detach */
862//******************************************************************************
863BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
864{
865 dprintf(("USER32: AttachThreadInput, not implemented\n"));
866 return(TRUE);
867}
868//******************************************************************************
869//******************************************************************************
870DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
871{
872 dprintf(("USER32: WaitForInputIdle %x %d\n", hProcess, dwTimeOut));
873
874 return O32_WaitForInputIdle(hProcess, dwTimeOut);
875}
876
877/* Help Functions */
878
879BOOL WIN32API WinHelpA( HWND hwnd, LPCSTR lpszHelp, UINT uCommand, DWORD dwData)
880{
881 static WORD WM_WINHELP = 0;
882 HWND hDest;
883 LPWINHELP lpwh;
884 HGLOBAL hwh;
885 HINSTANCE winhelp;
886 int size,dsize,nlen;
887
888 dprintf(("USER32: WinHelpA %s\n", lpszHelp));
889
890 if(!WM_WINHELP)
891 {
892 WM_WINHELP=RegisterWindowMessageA("WM_WINHELP");
893 if(!WM_WINHELP)
894 return FALSE;
895 }
896
897 hDest = FindWindowA( "MS_WINHELP", NULL );
898 if(!hDest)
899 {
900 if(uCommand == HELP_QUIT)
901 return TRUE;
902 else
903 winhelp = WinExec ( "winhlp32.exe -x", SW_SHOWNORMAL );
904 if ( winhelp <= 32 ) return FALSE;
905 if ( ! ( hDest = FindWindowA ( "MS_WINHELP", NULL ) )) return FALSE;
906 }
907
908 switch(uCommand)
909 {
910 case HELP_CONTEXT:
911 case HELP_SETCONTENTS:
912 case HELP_CONTENTS:
913 case HELP_CONTEXTPOPUP:
914 case HELP_FORCEFILE:
915 case HELP_HELPONHELP:
916 case HELP_FINDER:
917 case HELP_QUIT:
918 dsize=0;
919 break;
920
921 case HELP_KEY:
922 case HELP_PARTIALKEY:
923 case HELP_COMMAND:
924 dsize = strlen( (LPSTR)dwData )+1;
925 break;
926
927 case HELP_MULTIKEY:
928 dsize = ((LPMULTIKEYHELP)dwData)->mkSize;
929 break;
930
931 case HELP_SETWINPOS:
932 dsize = ((LPHELPWININFO)dwData)->wStructSize;
933 break;
934
935 default:
936 //WARN("Unknown help command %d\n",wCommand);
937 return FALSE;
938 }
939 if(lpszHelp)
940 nlen = strlen(lpszHelp)+1;
941 else
942 nlen = 0;
943 size = sizeof(WINHELP) + nlen + dsize;
944 hwh = GlobalAlloc(0,size);
945 lpwh = (WINHELP*)GlobalLock(hwh);
946 lpwh->size = size;
947 lpwh->command = uCommand;
948 lpwh->data = dwData;
949 if(nlen)
950 {
951 strcpy(((char*)lpwh) + sizeof(WINHELP),lpszHelp);
952 lpwh->ofsFilename = sizeof(WINHELP);
953 } else
954 lpwh->ofsFilename = 0;
955 if(dsize)
956 {
957 memcpy(((char*)lpwh)+sizeof(WINHELP)+nlen,(LPSTR)dwData,dsize);
958 lpwh->ofsData = sizeof(WINHELP)+nlen;
959 } else
960 lpwh->ofsData = 0;
961 GlobalUnlock(hwh);
962
963 return SendMessageA(hDest,WM_WINHELP,hwnd,hwh);
964}
965//******************************************************************************
966//******************************************************************************
967BOOL WIN32API WinHelpW( HWND hwnd, LPCWSTR lpszHelp, UINT uCommand, DWORD dwData)
968{
969 char *astring = UnicodeToAsciiString((LPWSTR)lpszHelp);
970 BOOL rc;
971
972 dprintf(("USER32: WinHelpW\n"));
973
974 rc = WinHelpA(hwnd,astring,uCommand,dwData);
975 FreeAsciiString(astring);
976
977 return rc;
978}
979
980/* Keyboard and Input Functions */
981
982BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
983{
984 dprintf(("USER32: ActivateKeyboardLayout, not implemented\n"));
985 return(TRUE);
986}
987/*****************************************************************************
988 * Name : UINT WIN32API GetKBCodePage
989 * Purpose : The GetKBCodePage function is provided for compatibility with
990 * earlier versions of Windows. In the Win32 application programming
991 * interface (API) it just calls the GetOEMCP function.
992 * Parameters:
993 * Variables :
994 * Result : If the function succeeds, the return value is an OEM code-page
995 * identifier, or it is the default identifier if the registry
996 * value is not readable. For a list of OEM code-page identifiers,
997 * see GetOEMCP.
998 * Remark :
999 * Status : COMPLETELY IMPLEMENTED UNTESTED
1000 *
1001 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1002 *****************************************************************************/
1003
1004UINT WIN32API GetKBCodePage(VOID)
1005{
1006 return (GetOEMCP());
1007}
1008//******************************************************************************
1009//******************************************************************************
1010int WIN32API GetKeyNameTextA( LPARAM lParam, LPSTR lpString, int nSize)
1011{
1012 dprintf(("USER32: GetKeyNameTextA\n"));
1013 return O32_GetKeyNameText(lParam,lpString,nSize);
1014}
1015//******************************************************************************
1016//******************************************************************************
1017int WIN32API GetKeyNameTextW( LPARAM lParam, LPWSTR lpString, int nSize)
1018{
1019 dprintf(("USER32: GetKeyNameTextW DOES NOT WORK\n"));
1020 // NOTE: This will not work as is (needs UNICODE support)
1021 return 0;
1022// return O32_GetKeyNameText(arg1, arg2, arg3);
1023}
1024//******************************************************************************
1025//******************************************************************************
1026SHORT WIN32API GetKeyState( int nVirtKey)
1027{
1028 dprintf2(("USER32: GetKeyState %x", nVirtKey));
1029 return O32_GetKeyState(nVirtKey);
1030}
1031//******************************************************************************
1032//******************************************************************************
1033WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1034{
1035 dprintf2(("USER32: GetAsyncKeyState %x", nVirtKey));
1036 return O32_GetAsyncKeyState(nVirtKey);
1037}
1038
1039/*****************************************************************************
1040 * Name : VOID WIN32API keybd_event
1041 * Purpose : The keybd_event function synthesizes a keystroke. The system
1042 * can use such a synthesized keystroke to generate a WM_KEYUP or
1043 * WM_KEYDOWN message. The keyboard driver's interrupt handler calls
1044 * the keybd_event function.
1045 * Parameters: BYTE bVk virtual-key code
1046
1047 * BYTE bScan hardware scan code
1048 * DWORD dwFlags flags specifying various function options
1049 * DWORD dwExtraInfo additional data associated with keystroke
1050 * Variables :
1051 * Result :
1052 * Remark :
1053 * Status : UNTESTED STUB
1054 *
1055 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1056 *****************************************************************************/
1057VOID WIN32API keybd_event (BYTE bVk,
1058 BYTE bScan,
1059 DWORD dwFlags,
1060 DWORD dwExtraInfo)
1061{
1062 dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
1063 bVk,
1064 bScan,
1065 dwFlags,
1066 dwExtraInfo));
1067}
1068/*****************************************************************************
1069 * Name : HLK WIN32API LoadKeyboardLayoutA
1070 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
1071 * the system. Several keyboard layouts can be loaded at a time, but
1072 * only one per process is active at a time. Loading multiple keyboard
1073 * layouts makes it possible to rapidly switch between layouts.
1074 * Parameters:
1075 * Variables :
1076 * Result : If the function succeeds, the return value is the handle of the
1077 * keyboard layout.
1078 * If the function fails, the return value is NULL. To get extended
1079 * error information, call GetLastError.
1080 * Remark :
1081 * Status : UNTESTED STUB
1082 *
1083 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1084 *****************************************************************************/
1085HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
1086 UINT Flags)
1087{
1088 dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
1089 pwszKLID,
1090 Flags));
1091
1092 return (NULL);
1093}
1094/*****************************************************************************
1095 * Name : HLK WIN32API LoadKeyboardLayoutW
1096 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
1097 * the system. Several keyboard layouts can be loaded at a time, but
1098 * only one per process is active at a time. Loading multiple keyboard
1099 * layouts makes it possible to rapidly switch between layouts.
1100 * Parameters:
1101 * Variables :
1102 * Result : If the function succeeds, the return value is the handle of the
1103 * keyboard layout.
1104 * If the function fails, the return value is NULL. To get extended
1105 * error information, call GetLastError.
1106 * Remark :
1107 * Status : UNTESTED STUB
1108 *
1109 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1110 *****************************************************************************/
1111HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
1112 UINT Flags)
1113{
1114 dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
1115 pwszKLID,
1116 Flags));
1117
1118 return (NULL);
1119}
1120//******************************************************************************
1121//******************************************************************************
1122UINT WIN32API MapVirtualKeyA( UINT uCode, UINT uMapType)
1123{
1124 dprintf(("USER32: MapVirtualKeyA\n"));
1125 /* A quick fix for Commandos, very incomplete */
1126 switch (uMapType) {
1127 case 2:
1128 if (uCode >= VK_A && uCode <= VK_Z) {
1129 return 'A' + uCode - VK_A;
1130 }
1131 break;
1132 }
1133 return O32_MapVirtualKey(uCode,uMapType);
1134}
1135//******************************************************************************
1136//******************************************************************************
1137UINT WIN32API MapVirtualKeyW( UINT uCode, UINT uMapType)
1138{
1139 dprintf(("USER32: MapVirtualKeyW\n"));
1140 // NOTE: This will not work as is (needs UNICODE support)
1141 return O32_MapVirtualKey(uCode,uMapType);
1142}
1143/*****************************************************************************
1144 * Name : UINT WIN32API MapVirtualKeyExA
1145 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
1146 * code into a scan code or character value, or translates a scan
1147 * code into a virtual-key code. The function translates the codes
1148 * using the input language and physical keyboard layout identified
1149 * by the given keyboard layout handle.
1150 * Parameters:
1151 * Variables :
1152 * Result : The return value is either a scan code, a virtual-key code, or
1153 * a character value, depending on the value of uCode and uMapType.
1154 * If there is no translation, the return value is zero.
1155 * Remark :
1156 * Status : UNTESTED STUB
1157 *
1158 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1159 *****************************************************************************/
1160UINT WIN32API MapVirtualKeyExA(UINT uCode,
1161 UINT uMapType,
1162 HKL dwhkl)
1163{
1164 dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
1165 uCode,
1166 uMapType,
1167 dwhkl));
1168
1169 return (0);
1170}
1171/*****************************************************************************
1172 * Name : UINT WIN32API MapVirtualKeyExW
1173 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
1174 * code into a scan code or character value, or translates a scan
1175 * code into a virtual-key code. The function translates the codes
1176 * using the input language and physical keyboard layout identified
1177 * by the given keyboard layout handle.
1178 * Parameters:
1179 * Variables :
1180 * Result : The return value is either a scan code, a virtual-key code, or
1181 * a character value, depending on the value of uCode and uMapType.
1182 * If there is no translation, the return value is zero.
1183 * Remark :
1184 * Status : UNTESTED STUB
1185
1186 *
1187 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1188 *****************************************************************************/
1189UINT WIN32API MapVirtualKeyExW(UINT uCode,
1190 UINT uMapType,
1191 HKL dwhkl)
1192{
1193 dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
1194 uCode,
1195 uMapType,
1196 dwhkl));
1197
1198 return (0);
1199}
1200/*****************************************************************************
1201 * Name : DWORD WIN32API OemKeyScan
1202 * Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
1203 * into the OEM scan codes and shift states. The function provides
1204 * information that allows a program to send OEM text to another
1205 * program by simulating keyboard input.
1206 * Parameters:
1207 * Variables :
1208 * Result :
1209 * Remark :
1210 * Status : UNTESTED STUB
1211 *
1212 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1213 *****************************************************************************/
1214DWORD WIN32API OemKeyScan(WORD wOemChar)
1215{
1216 dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
1217 wOemChar));
1218
1219 return (wOemChar);
1220}
1221//******************************************************************************
1222//******************************************************************************
1223BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
1224{
1225 dprintf(("USER32: RegisterHotKey, not implemented\n"));
1226 hwnd = Win32ToOS2Handle(hwnd);
1227 return(TRUE);
1228}
1229/*****************************************************************************
1230 * Name : int WIN32API ToUnicode
1231 * Purpose : The ToUnicode function translates the specified virtual-key code
1232 * and keyboard state to the corresponding Unicode character or characters.
1233 * Parameters: UINT wVirtKey virtual-key code
1234 * UINT wScanCode scan code
1235 * PBYTE lpKeyState address of key-state array
1236 * LPWSTR pwszBuff buffer for translated key
1237 * int cchBuff size of translated key buffer
1238 * UINT wFlags set of function-conditioning flags
1239 * Variables :
1240 * Result : - 1 The specified virtual key is a dead-key character (accent or
1241 * diacritic). This value is returned regardless of the keyboard
1242 * layout, even if several characters have been typed and are
1243 * stored in the keyboard state. If possible, even with Unicode
1244 * keyboard layouts, the function has written a spacing version of
1245 * the dead-key character to the buffer specified by pwszBuffer.
1246 * For example, the function writes the character SPACING ACUTE
1247 * (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
1248 * 0 The specified virtual key has no translation for the current
1249 * state of the keyboard. Nothing was written to the buffer
1250 * specified by pwszBuffer.
1251 * 1 One character was written to the buffer specified by pwszBuffer.
1252 * 2 or more Two or more characters were written to the buffer specified by
1253 * pwszBuff. The most common cause for this is that a dead-key
1254 * character (accent or diacritic) stored in the keyboard layout
1255 * could not be combined with the specified virtual key to form a
1256 * single character.
1257 * Remark :
1258 * Status : UNTESTED STUB
1259 *
1260 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1261 *****************************************************************************/
1262int WIN32API ToUnicode(UINT uVirtKey,
1263 UINT uScanCode,
1264 PBYTE lpKeyState,
1265 LPWSTR pwszBuff,
1266 int cchBuff,
1267 UINT wFlags)
1268{
1269 dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
1270 uVirtKey,
1271 uScanCode,
1272 lpKeyState,
1273 pwszBuff,
1274 cchBuff,
1275 wFlags));
1276
1277 return (0);
1278}
1279/*****************************************************************************
1280 * Name : BOOL WIN32API UnloadKeyboardLayout
1281 * Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
1282 * Parameters: HKL hkl handle of keyboard layout
1283 * Variables :
1284 * Result : If the function succeeds, the return value is the handle of the
1285 * keyboard layout; otherwise, it is NULL. To get extended error
1286 * information, use the GetLastError function.
1287 * Remark :
1288 * Status : UNTESTED STUB
1289 *
1290 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1291 *****************************************************************************/
1292BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
1293{
1294 dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
1295 hkl));
1296
1297 return (0);
1298}
1299//******************************************************************************
1300//******************************************************************************
1301BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
1302{
1303 dprintf(("USER32: UnregisterHotKey, not implemented\n"));
1304 hwnd = Win32ToOS2Handle(hwnd);
1305
1306 return(TRUE);
1307}
1308//******************************************************************************
1309//SvL: 24-6-'97 - Added
1310//******************************************************************************
1311WORD WIN32API VkKeyScanA( char ch)
1312{
1313 dprintf(("USER32: VkKeyScanA %x", ch));
1314 return O32_VkKeyScan(ch);
1315}
1316//******************************************************************************
1317//******************************************************************************
1318WORD WIN32API VkKeyScanW( WCHAR wch)
1319{
1320 dprintf(("USER32: VkKeyScanW %x", wch));
1321 // NOTE: This will not work as is (needs UNICODE support)
1322 return O32_VkKeyScan((char)wch);
1323}
1324/*****************************************************************************
1325 * Name : SHORT WIN32API VkKeyScanExW
1326 * Purpose : The VkKeyScanEx function translates a character to the
1327 * corresponding virtual-key code and shift state. The function
1328 * translates the character using the input language and physical
1329 * keyboard layout identified by the given keyboard layout handle.
1330 * Parameters: UINT uChar character to translate
1331 * HKL hkl keyboard layout handle
1332 * Variables :
1333 * Result : see docs
1334 * Remark :
1335 * Status : UNTESTED STUB
1336 *
1337 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1338 *****************************************************************************/
1339WORD WIN32API VkKeyScanExW(WCHAR uChar,
1340 HKL hkl)
1341{
1342 dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
1343 uChar,
1344 hkl));
1345
1346 return (uChar);
1347}
1348/*****************************************************************************
1349 * Name : SHORT WIN32API VkKeyScanExA
1350 * Purpose : The VkKeyScanEx function translates a character to the
1351 * corresponding virtual-key code and shift state. The function
1352 * translates the character using the input language and physical
1353 * keyboard layout identified by the given keyboard layout handle.
1354 * Parameters: UINT uChar character to translate
1355 * HKL hkl keyboard layout handle
1356 * Variables :
1357 * Result : see docs
1358 * Remark :
1359 * Status : UNTESTED STUB
1360 *
1361 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1362 *****************************************************************************/
1363WORD WIN32API VkKeyScanExA(CHAR uChar,
1364 HKL hkl)
1365{
1366 dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
1367 uChar,
1368 hkl));
1369
1370 return (uChar);
1371}
1372
1373/* Window Functions */
1374
1375/*****************************************************************************
1376 * Name : BOOL WIN32API AnyPopup
1377 * Purpose : The AnyPopup function indicates whether an owned, visible,
1378 * top-level pop-up, or overlapped window exists on the screen. The
1379 * function searches the entire Windows screen, not just the calling
1380 * application's client area.
1381 * Parameters: VOID
1382 * Variables :
1383 * Result : If a pop-up window exists, the return value is TRUE even if the
1384 * pop-up window is completely covered by other windows. Otherwise,
1385 * it is FALSE.
1386 * Remark : AnyPopup is a Windows version 1.x function and is retained for
1387 * compatibility purposes. It is generally not useful.
1388 * Status : UNTESTED STUB
1389 *
1390 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1391 *****************************************************************************/
1392BOOL WIN32API AnyPopup(VOID)
1393{
1394 dprintf(("USER32:AnyPopup() not implemented.\n"));
1395
1396 return (FALSE);
1397}
1398
1399/*****************************************************************************
1400 * Name : BOOL WIN32API PaintDesktop
1401 * Purpose : The PaintDesktop function fills the clipping region in the
1402 * specified device context with the desktop pattern or wallpaper.
1403 * The function is provided primarily for shell desktops.
1404 * Parameters:
1405 * Variables :
1406 * Result : If the function succeeds, the return value is TRUE.
1407 * If the function fails, the return value is FALSE.
1408 * Remark :
1409 * Status : UNTESTED STUB
1410 *
1411 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1412 *****************************************************************************/
1413BOOL WIN32API PaintDesktop(HDC hdc)
1414{
1415 dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
1416 hdc));
1417
1418 return (FALSE);
1419}
1420
1421/* Filled Shape Functions */
1422
1423
1424int WIN32API FillRect(HDC hDC, const RECT * lprc, HBRUSH hbr)
1425{
1426 dprintf(("USER32: FillRect %x (%d,%d)(%d,%d) brush %X", hDC, lprc->left, lprc->top, lprc->right, lprc->bottom, hbr));
1427 return O32_FillRect(hDC,lprc,hbr);
1428}
1429//******************************************************************************
1430//******************************************************************************
1431int WIN32API FrameRect( HDC hDC, const RECT * lprc, HBRUSH hbr)
1432{
1433 dprintf(("USER32: FrameRect %x (%d,%d)(%d,%d) brush %x", hDC, lprc->top, lprc->left, lprc->bottom, lprc->right, hbr));
1434 return O32_FrameRect(hDC,lprc,hbr);
1435}
1436//******************************************************************************
1437//******************************************************************************
1438BOOL WIN32API InvertRect( HDC hDC, const RECT * lprc)
1439{
1440 if(lprc) {
1441 dprintf(("USER32: InvertRect %x (%d,%d)(%d,%d)", hDC, lprc->left, lprc->top, lprc->right, lprc->bottom));
1442 }
1443 else dprintf(("USER32: InvertRect %x NULL", hDC));
1444 return O32_InvertRect(hDC,lprc);
1445}
1446
1447/* System Information Functions */
1448
1449/* Window Station and Desktop Functions */
1450
1451/*****************************************************************************
1452 * Name : HDESK WIN32API GetThreadDesktop
1453 * Purpose : The GetThreadDesktop function returns a handle to the desktop
1454 * associated with a specified thread.
1455 * Parameters: DWORD dwThreadId thread identifier
1456 * Variables :
1457 * Result : If the function succeeds, the return value is the handle of the
1458 * desktop associated with the specified thread.
1459 * Remark :
1460 * Status : UNTESTED STUB
1461 *
1462 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1463 *****************************************************************************/
1464HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
1465{
1466 dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
1467 dwThreadId));
1468
1469 return (NULL);
1470}
1471
1472/*****************************************************************************
1473 * Name : BOOL WIN32API CloseDesktop
1474 * Purpose : The CloseDesktop function closes an open handle of a desktop
1475 * object. A desktop is a secure object contained within a window
1476 * station object. A desktop has a logical display surface and
1477 * contains windows, menus and hooks.
1478 * Parameters: HDESK hDesktop
1479 * Variables :
1480 * Result : If the function succeeds, the return value is TRUE.
1481 * If the functions fails, the return value is FALSE. To get
1482 * extended error information, call GetLastError.
1483 * Remark :
1484 * Status : UNTESTED STUB
1485 *
1486 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1487 *****************************************************************************/
1488BOOL WIN32API CloseDesktop(HDESK hDesktop)
1489{
1490 dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
1491 hDesktop));
1492
1493 return (FALSE);
1494}
1495/*****************************************************************************
1496 * Name : BOOL WIN32API CloseWindowStation
1497 * Purpose : The CloseWindowStation function closes an open window station handle.
1498 * Parameters: HWINSTA hWinSta
1499 * Variables :
1500 * Result :
1501 * Remark : If the function succeeds, the return value is TRUE.
1502 * If the functions fails, the return value is FALSE. To get
1503 * extended error information, call GetLastError.
1504 * Status : UNTESTED STUB
1505 *
1506 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1507 *****************************************************************************/
1508BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
1509{
1510 dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
1511 hWinSta));
1512
1513 return (FALSE);
1514}
1515/*****************************************************************************
1516 * Name : HDESK WIN32API CreateDesktopA
1517 * Purpose : The CreateDesktop function creates a new desktop on the window
1518 * station associated with the calling process.
1519 * Parameters: LPCTSTR lpszDesktop name of the new desktop
1520 * LPCTSTR lpszDevice name of display device to assign to the desktop
1521 * LPDEVMODE pDevMode reserved; must be NULL
1522 * DWORD dwFlags flags to control interaction with other applications
1523 * DWORD dwDesiredAccess specifies access of returned handle
1524 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
1525 * Variables :
1526 * Result : If the function succeeds, the return value is a handle of the
1527 * newly created desktop.
1528 * If the function fails, the return value is NULL. To get extended
1529 * error information, call GetLastError.
1530 * Remark :
1531 * Status : UNTESTED STUB
1532 *
1533 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1534 *****************************************************************************/
1535HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
1536 LPCTSTR lpszDevice,
1537 LPDEVMODEA pDevMode,
1538 DWORD dwFlags,
1539 DWORD dwDesiredAccess,
1540 LPSECURITY_ATTRIBUTES lpsa)
1541{
1542 dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
1543 lpszDesktop,
1544 lpszDevice,
1545 pDevMode,
1546 dwFlags,
1547 dwDesiredAccess,
1548 lpsa));
1549
1550 return (NULL);
1551}
1552/*****************************************************************************
1553 * Name : HDESK WIN32API CreateDesktopW
1554 * Purpose : The CreateDesktop function creates a new desktop on the window
1555 * station associated with the calling process.
1556 * Parameters: LPCTSTR lpszDesktop name of the new desktop
1557 * LPCTSTR lpszDevice name of display device to assign to the desktop
1558 * LPDEVMODE pDevMode reserved; must be NULL
1559 * DWORD dwFlags flags to control interaction with other applications
1560 * DWORD dwDesiredAccess specifies access of returned handle
1561 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
1562 * Variables :
1563 * Result : If the function succeeds, the return value is a handle of the
1564 * newly created desktop.
1565 * If the function fails, the return value is NULL. To get extended
1566 * error information, call GetLastError.
1567 * Remark :
1568 * Status : UNTESTED STUB
1569 *
1570 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1571 *****************************************************************************/
1572HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
1573 LPCTSTR lpszDevice,
1574 LPDEVMODEW pDevMode,
1575 DWORD dwFlags,
1576 DWORD dwDesiredAccess,
1577 LPSECURITY_ATTRIBUTES lpsa)
1578{
1579 dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
1580 lpszDesktop,
1581 lpszDevice,
1582 pDevMode,
1583 dwFlags,
1584 dwDesiredAccess,
1585 lpsa));
1586
1587 return (NULL);
1588}
1589/*****************************************************************************
1590 * Name : HWINSTA WIN32API CreateWindowStationA
1591 * Purpose : The CreateWindowStation function creates a window station object.
1592 * It returns a handle that can be used to access the window station.
1593 * A window station is a secure object that contains a set of global
1594 * atoms, a clipboard, and a set of desktop objects.
1595 * Parameters: LPTSTR lpwinsta name of the new window station
1596 * DWORD dwReserved reserved; must be NULL
1597 * DWORD dwDesiredAccess specifies access of returned handle
1598 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
1599 * Variables :
1600 * Result : If the function succeeds, the return value is the handle to the
1601 * newly created window station.
1602 * If the function fails, the return value is NULL. To get extended
1603 * error information, call GetLastError.
1604 * Remark :
1605 * Status : UNTESTED STUB
1606 *
1607 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1608 *****************************************************************************/
1609HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
1610 DWORD dwReserved,
1611 DWORD dwDesiredAccess,
1612 LPSECURITY_ATTRIBUTES lpsa)
1613{
1614 dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
1615 lpWinSta,
1616 dwReserved,
1617 dwDesiredAccess,
1618 lpsa));
1619
1620 return (NULL);
1621}
1622/*****************************************************************************
1623 * Name : HWINSTA WIN32API CreateWindowStationW
1624 * Purpose : The CreateWindowStation function creates a window station object.
1625 * It returns a handle that can be used to access the window station.
1626 * A window station is a secure object that contains a set of global
1627 * atoms, a clipboard, and a set of desktop objects.
1628 * Parameters: LPTSTR lpwinsta name of the new window station
1629 * DWORD dwReserved reserved; must be NULL
1630 * DWORD dwDesiredAccess specifies access of returned handle
1631 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
1632 * Variables :
1633 * Result : If the function succeeds, the return value is the handle to the
1634 * newly created window station.
1635 * If the function fails, the return value is NULL. To get extended
1636 * error information, call GetLastError.
1637 * Remark :
1638 * Status : UNTESTED STUB
1639 *
1640 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1641 *****************************************************************************/
1642HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
1643 DWORD dwReserved,
1644 DWORD dwDesiredAccess,
1645 LPSECURITY_ATTRIBUTES lpsa)
1646{
1647 dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
1648 lpWinSta,
1649 dwReserved,
1650 dwDesiredAccess,
1651 lpsa));
1652
1653 return (NULL);
1654}
1655/*****************************************************************************
1656 * Name : BOOL WIN32API EnumDesktopWindows
1657 * Purpose : The EnumDesktopWindows function enumerates all windows in a
1658 * desktop by passing the handle of each window, in turn, to an
1659 * application-defined callback function.
1660 * Parameters: HDESK hDesktop handle of desktop to enumerate
1661 * WNDENUMPROC lpfn points to application's callback function
1662 * LPARAM lParam 32-bit value to pass to the callback function
1663 * Variables :
1664 * Result : If the function succeeds, the return value is TRUE.
1665 * If the function fails, the return value is FALSE. To get
1666 * extended error information, call GetLastError.
1667 * Remark :
1668 * Status : UNTESTED STUB
1669 *
1670 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1671 *****************************************************************************/
1672BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
1673 WNDENUMPROC lpfn,
1674 LPARAM lParam)
1675{
1676 dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
1677 hDesktop,
1678 lpfn,
1679 lParam));
1680
1681 return (FALSE);
1682}
1683/*****************************************************************************
1684 * Name : BOOL WIN32API EnumDesktopsA
1685 * Purpose : The EnumDesktops function enumerates all desktops in the window
1686 * station assigned to the calling process. The function does so by
1687 * passing the name of each desktop, in turn, to an application-
1688 * defined callback function.
1689 * Parameters: HWINSTA hwinsta handle of window station to enumerate
1690 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
1691 * LPARAM lParam 32-bit value to pass to the callback function
1692 * Variables :
1693 * Result : If the function succeeds, the return value is TRUE.
1694 * If the function fails, the return value is FALSE. To get extended
1695 * error information, call GetLastError.
1696 * Remark :
1697 * Status : UNTESTED STUB
1698 *
1699 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1700 *****************************************************************************/
1701BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
1702 DESKTOPENUMPROCA lpEnumFunc,
1703 LPARAM lParam)
1704{
1705 dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
1706 hWinSta,
1707 lpEnumFunc,
1708 lParam));
1709
1710 return (FALSE);
1711}
1712/*****************************************************************************
1713 * Name : BOOL WIN32API EnumDesktopsW
1714 * Purpose : The EnumDesktops function enumerates all desktops in the window
1715 * station assigned to the calling process. The function does so by
1716 * passing the name of each desktop, in turn, to an application-
1717 * defined callback function.
1718 * Parameters: HWINSTA hwinsta handle of window station to enumerate
1719 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
1720 * LPARAM lParam 32-bit value to pass to the callback function
1721 * Variables :
1722 * Result : If the function succeeds, the return value is TRUE.
1723 * If the function fails, the return value is FALSE. To get extended
1724 * error information, call GetLastError.
1725 * Remark :
1726 * Status : UNTESTED STUB
1727 *
1728 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1729 *****************************************************************************/
1730BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
1731 DESKTOPENUMPROCW lpEnumFunc,
1732 LPARAM lParam)
1733{
1734 dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
1735 hWinSta,
1736 lpEnumFunc,
1737 lParam));
1738
1739 return (FALSE);
1740}
1741/*****************************************************************************
1742 * Name : BOOL WIN32API EnumWindowStationsA
1743 * Purpose : The EnumWindowStations function enumerates all windowstations
1744 * in the system by passing the name of each window station, in
1745 * turn, to an application-defined callback function.
1746 * Parameters:
1747 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
1748 * LPARAM lParam 32-bit value to pass to the callback function
1749 * Result : If the function succeeds, the return value is TRUE.
1750 * If the function fails the return value is FALSE. To get extended
1751 * error information, call GetLastError.
1752 * Remark :
1753 * Status : UNTESTED STUB
1754 *
1755 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1756 *****************************************************************************/
1757BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
1758 LPARAM lParam)
1759{
1760 dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
1761 lpEnumFunc,
1762 lParam));
1763
1764 return (FALSE);
1765}
1766/*****************************************************************************
1767 * Name : BOOL WIN32API EnumWindowStationsW
1768 * Purpose : The EnumWindowStations function enumerates all windowstations
1769 * in the system by passing the name of each window station, in
1770 * turn, to an application-defined callback function.
1771 * Parameters:
1772 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
1773 * LPARAM lParam 32-bit value to pass to the callback function
1774 * Result : If the function succeeds, the return value is TRUE.
1775 * If the function fails the return value is FALSE. To get extended
1776 * error information, call GetLastError.
1777 * Remark :
1778 * Status : UNTESTED STUB
1779 *
1780 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1781 *****************************************************************************/
1782BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
1783 LPARAM lParam)
1784{
1785 dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
1786 lpEnumFunc,
1787 lParam));
1788
1789 return (FALSE);
1790}
1791/*****************************************************************************
1792 * Name : HWINSTA WIN32API GetProcessWindowStation
1793 * Purpose : The GetProcessWindowStation function returns a handle of the
1794 * window station associated with the calling process.
1795 * Parameters:
1796 * Variables :
1797 * Result : If the function succeeds, the return value is a handle of the
1798 * window station associated with the calling process.
1799 * If the function fails, the return value is NULL. This can occur
1800 * if the calling process is not an application written for Windows
1801 * NT. To get extended error information, call GetLastError.
1802 * Remark :
1803 * Status : UNTESTED STUB
1804 *
1805 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1806 *****************************************************************************/
1807HWINSTA WIN32API GetProcessWindowStation(VOID)
1808{
1809 dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
1810
1811 return (NULL);
1812}
1813/*****************************************************************************
1814 * Name : BOOL WIN32API GetUserObjectInformationA
1815 * Purpose : The GetUserObjectInformation function returns information about
1816 * a window station or desktop object.
1817 * Parameters: HANDLE hObj handle of object to get information for
1818 * int nIndex type of information to get
1819 * PVOID pvInfo points to buffer that receives the information
1820 * DWORD nLength size, in bytes, of pvInfo buffer
1821 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo 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 GetUserObjectInformationA(HANDLE hObj,
1832 int nIndex,
1833 PVOID pvInfo,
1834 DWORD nLength,
1835 LPDWORD lpnLengthNeeded)
1836{
1837 dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1838 hObj,
1839 nIndex,
1840 pvInfo,
1841 nLength,
1842 lpnLengthNeeded));
1843
1844 return (FALSE);
1845}
1846/*****************************************************************************
1847 * Name : BOOL WIN32API GetUserObjectInformationW
1848 * Purpose : The GetUserObjectInformation function returns information about
1849 * a window station or desktop object.
1850 * Parameters: HANDLE hObj handle of object to get information for
1851 * int nIndex type of information to get
1852 * PVOID pvInfo points to buffer that receives the information
1853 * DWORD nLength size, in bytes, of pvInfo buffer
1854 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
1855 * Variables :
1856 * Result : If the function succeeds, the return value is TRUE.
1857 * If the function fails, the return value is FALSE. To get extended
1858 * error information, call GetLastError.
1859 * Remark :
1860 * Status : UNTESTED STUB
1861 *
1862 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1863 *****************************************************************************/
1864BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
1865 int nIndex,
1866 PVOID pvInfo,
1867 DWORD nLength,
1868 LPDWORD lpnLengthNeeded)
1869{
1870 dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1871 hObj,
1872 nIndex,
1873 pvInfo,
1874 nLength,
1875 lpnLengthNeeded));
1876
1877 return (FALSE);
1878}
1879/*****************************************************************************
1880 * Name : BOOL WIN32API GetUserObjectSecurity
1881 * Purpose : The GetUserObjectSecurity function retrieves security information
1882 * for the specified user object.
1883 * Parameters: HANDLE hObj handle of user object
1884 * SECURITY_INFORMATION * pSIRequested address of requested security information
1885 * LPSECURITY_DESCRIPTOR pSID address of security descriptor
1886 * DWORD nLength size of buffer for security descriptor
1887 * LPDWORD lpnLengthNeeded address of required size of buffer
1888 * Variables :
1889 * Result : If the function succeeds, the return value is TRUE.
1890 * If the function fails, the return value is FALSE. To get extended
1891 * error information, call GetLastError.
1892 * Remark :
1893 * Status : UNTESTED STUB
1894 *
1895 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1896 *****************************************************************************/
1897BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
1898 PSECURITY_INFORMATION pSIRequested,
1899 PSECURITY_DESCRIPTOR pSID,
1900 DWORD nLength,
1901 LPDWORD lpnLengthNeeded)
1902{
1903 dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1904 hObj,
1905 pSIRequested,
1906 pSID,
1907 nLength,
1908 lpnLengthNeeded));
1909
1910 return (FALSE);
1911}
1912/*****************************************************************************
1913 * Name : HDESK WIN32API OpenDesktopA
1914 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
1915 * A desktop is a secure object contained within a window station
1916 * object. A desktop has a logical display surface and contains
1917 * windows, menus and hooks.
1918 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
1919 * DWORD dwFlags flags to control interaction with other applications
1920 * BOOL fInherit specifies whether returned handle is inheritable
1921 * DWORD dwDesiredAccess specifies access of returned handle
1922 * Variables :
1923 * Result : If the function succeeds, the return value is the handle to the
1924 * opened desktop.
1925 * If the function fails, the return value is NULL. To get extended
1926 * error information, call GetLastError.
1927 * Remark :
1928 * Status : UNTESTED STUB
1929 *
1930 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1931 *****************************************************************************/
1932HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
1933 DWORD dwFlags,
1934 BOOL fInherit,
1935 DWORD dwDesiredAccess)
1936{
1937 dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
1938 lpszDesktopName,
1939 dwFlags,
1940 fInherit,
1941 dwDesiredAccess));
1942
1943 return (NULL);
1944}
1945/*****************************************************************************
1946 * Name : HDESK WIN32API OpenDesktopW
1947 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
1948 * A desktop is a secure object contained within a window station
1949 * object. A desktop has a logical display surface and contains
1950 * windows, menus and hooks.
1951 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
1952 * DWORD dwFlags flags to control interaction with other applications
1953 * BOOL fInherit specifies whether returned handle is inheritable
1954 * DWORD dwDesiredAccess specifies access of returned handle
1955 * Variables :
1956 * Result : If the function succeeds, the return value is the handle to the
1957 * opened desktop.
1958 * If the function fails, the return value is NULL. To get extended
1959 * error information, call GetLastError.
1960 * Remark :
1961 * Status : UNTESTED STUB
1962 *
1963 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1964 *****************************************************************************/
1965HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
1966 DWORD dwFlags,
1967 BOOL fInherit,
1968 DWORD dwDesiredAccess)
1969{
1970 dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
1971 lpszDesktopName,
1972 dwFlags,
1973 fInherit,
1974 dwDesiredAccess));
1975
1976 return (NULL);
1977}
1978/*****************************************************************************
1979 * Name : HDESK WIN32API OpenInputDesktop
1980 * Purpose : The OpenInputDesktop function returns a handle to the desktop
1981 * that receives user input. The input desktop is a desktop on the
1982 * window station associated with the logged-on user.
1983 * Parameters: DWORD dwFlags flags to control interaction with other applications
1984 * BOOL fInherit specifies whether returned handle is inheritable
1985 * DWORD dwDesiredAccess specifies access of returned handle
1986 * Variables :
1987 * Result : If the function succeeds, the return value is a handle of the
1988 * desktop that receives user input.
1989 * If the function fails, the return value is NULL. To get extended
1990 * error information, call GetLastError.
1991 * Remark :
1992 * Status : UNTESTED STUB
1993 *
1994 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1995 *****************************************************************************/
1996HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
1997 BOOL fInherit,
1998 DWORD dwDesiredAccess)
1999{
2000 dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
2001 dwFlags,
2002 fInherit,
2003 dwDesiredAccess));
2004
2005 return (NULL);
2006}
2007/*****************************************************************************
2008 * Name : HWINSTA WIN32API OpenWindowStationA
2009 * Purpose : The OpenWindowStation function returns a handle to an existing
2010 * window station.
2011 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
2012 * BOOL fInherit specifies whether returned handle is inheritable
2013 * DWORD dwDesiredAccess specifies access of returned handle
2014 * Variables :
2015 * Result : If the function succeeds, the return value is the handle to the
2016 * specified window station.
2017 * If the function fails, the return value is NULL. To get extended
2018 * error information, call GetLastError.
2019 * Remark :
2020 * Status : UNTESTED STUB
2021 *
2022 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2023 *****************************************************************************/
2024HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
2025 BOOL fInherit,
2026 DWORD dwDesiredAccess)
2027{
2028 dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
2029 lpszWinStaName,
2030 fInherit,
2031 dwDesiredAccess));
2032
2033 return (NULL);
2034}
2035/*****************************************************************************
2036 * Name : HWINSTA WIN32API OpenWindowStationW
2037 * Purpose : The OpenWindowStation function returns a handle to an existing
2038 * window station.
2039 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
2040 * BOOL fInherit specifies whether returned handle is inheritable
2041 * DWORD dwDesiredAccess specifies access of returned handle
2042 * Variables :
2043 * Result : If the function succeeds, the return value is the handle to the
2044 * specified window station.
2045 * If the function fails, the return value is NULL. To get extended
2046 * error information, call GetLastError.
2047
2048
2049 * Remark :
2050 * Status : UNTESTED STUB
2051 *
2052 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2053 *****************************************************************************/
2054HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
2055 BOOL fInherit,
2056 DWORD dwDesiredAccess)
2057{
2058 dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
2059 lpszWinStaName,
2060 fInherit,
2061 dwDesiredAccess));
2062
2063 return (NULL);
2064}
2065/*****************************************************************************
2066 * Name : BOOL WIN32API SetProcessWindowStation
2067 * Purpose : The SetProcessWindowStation function assigns a window station
2068 * to the calling process. This enables the process to access
2069 * objects in the window station such as desktops, the clipboard,
2070 * and global atoms. All subsequent operations on the window station
2071 * use the access rights granted to hWinSta.
2072 * Parameters:
2073 * Variables :
2074 * Result : If the function succeeds, the return value is TRUE.
2075 * If the function fails, the return value is FALSE. To get extended
2076 * error information, call GetLastError.
2077 * Remark :
2078 * Status : UNTESTED STUB
2079 *
2080 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2081 *****************************************************************************/
2082BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
2083{
2084 dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
2085 hWinSta));
2086
2087 return (FALSE);
2088}
2089/*****************************************************************************
2090 * Name : BOOL WIN32API SetThreadDesktop
2091 * Purpose : The SetThreadDesktop function assigns a desktop to the calling
2092 * thread. All subsequent operations on the desktop use the access
2093 * rights granted to hDesk.
2094 * Parameters: HDESK hDesk handle of the desktop to assign to this thread
2095 * Variables :
2096 * Result : If the function succeeds, the return value is TRUE.
2097 * If the function fails, the return value is FALSE. To get extended
2098 * error information, call GetLastError.
2099 * Remark :
2100 * Status : UNTESTED STUB
2101 *
2102 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2103 *****************************************************************************/
2104BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
2105{
2106 dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
2107 hDesktop));
2108
2109 return (FALSE);
2110}
2111/*****************************************************************************
2112 * Name : BOOL WIN32API SetUserObjectInformationA
2113 * Purpose : The SetUserObjectInformation function sets information about a
2114 * window station or desktop object.
2115 * Parameters: HANDLE hObject handle of the object for which to set information
2116 * int nIndex type of information to set
2117 * PVOID lpvInfo points to a buffer that contains the information
2118 * DWORD cbInfo size, in bytes, of lpvInfo buffer
2119 * Variables :
2120 * Result : If the function succeeds, the return value is TRUE.
2121 * If the function fails the return value is FALSE. To get extended
2122 * error information, call GetLastError.
2123 * Remark :
2124 * Status : UNTESTED STUB
2125 *
2126 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2127 *****************************************************************************/
2128BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
2129 int nIndex,
2130 PVOID lpvInfo,
2131 DWORD cbInfo)
2132{
2133 dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
2134 hObject,
2135 nIndex,
2136 lpvInfo,
2137 cbInfo));
2138
2139 return (FALSE);
2140}
2141/*****************************************************************************
2142 * Name : BOOL WIN32API SetUserObjectInformationW
2143 * Purpose : The SetUserObjectInformation function sets information about a
2144 * window station or desktop object.
2145 * Parameters: HANDLE hObject handle of the object for which to set information
2146 * int nIndex type of information to set
2147 * PVOID lpvInfo points to a buffer that contains the information
2148 * DWORD cbInfo size, in bytes, of lpvInfo buffer
2149 * Variables :
2150 * Result : If the function succeeds, the return value is TRUE.
2151 * If the function fails the return value is FALSE. To get extended
2152 * error information, call GetLastError.
2153 * Remark :
2154 * Status : UNTESTED STUB
2155 *
2156 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2157 *****************************************************************************/
2158BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
2159 int nIndex,
2160 PVOID lpvInfo,
2161 DWORD cbInfo)
2162{
2163 dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
2164 hObject,
2165 nIndex,
2166 lpvInfo,
2167 cbInfo));
2168
2169 return (FALSE);
2170}
2171/*****************************************************************************
2172 * Name : BOOL WIN32API SetUserObjectSecurity
2173 * Purpose : The SetUserObjectSecurity function sets the security of a user
2174 * object. This can be, for example, a window or a DDE conversation
2175 * Parameters: HANDLE hObject handle of user object
2176 * SECURITY_INFORMATION * psi address of security information
2177 * LPSECURITY_DESCRIPTOR psd address of security descriptor
2178 * Variables :
2179 * Result : If the function succeeds, the return value is TRUE.
2180 * If the function fails, the return value is FALSE. To get extended
2181 * error information, call GetLastError.
2182 * Remark :
2183 * Status : UNTESTED STUB
2184 *
2185 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2186 *****************************************************************************/
2187BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
2188 PSECURITY_INFORMATION psi,
2189 PSECURITY_DESCRIPTOR psd)
2190{
2191 dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
2192 hObject,
2193 psi,
2194 psd));
2195
2196 return (FALSE);
2197}
2198/*****************************************************************************
2199 * Name : BOOL WIN32API SwitchDesktop
2200 * Purpose : The SwitchDesktop function makes a desktop visible and activates
2201 * it. This enables the desktop to receive input from the user. The
2202 * calling process must have DESKTOP_SWITCHDESKTOP access to the
2203 * desktop for the SwitchDesktop function to succeed.
2204 * Parameters:
2205 * Variables :
2206 * Result : If the function succeeds, the return value is TRUE.
2207 * If the function fails, the return value is FALSE. To get extended
2208 * error information, call GetLastError.
2209 * Remark :
2210 * Status : UNTESTED STUB
2211 *
2212 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2213 *****************************************************************************/
2214BOOL WIN32API SwitchDesktop(HDESK hDesktop)
2215{
2216 dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
2217 hDesktop));
2218
2219 return (FALSE);
2220}
2221
2222/* Debugging Functions */
2223
2224/*****************************************************************************
2225 * Name : VOID WIN32API SetDebugErrorLevel
2226 * Purpose : The SetDebugErrorLevel function sets the minimum error level at
2227 * which Windows will generate debugging events and pass them to a debugger.
2228 * Parameters: DWORD dwLevel debugging error level
2229 * Variables :
2230 * Result :
2231 * Remark :
2232 * Status : UNTESTED STUB
2233 *
2234 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2235 *****************************************************************************/
2236VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
2237{
2238 dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
2239 dwLevel));
2240}
2241
2242/* Drag'n'drop */
2243
2244/*****************************************************************************
2245 * Name : BOOL WIN32API DragObject
2246 * Purpose : Unknown
2247 * Parameters: Unknown
2248 * Variables :
2249 * Result :
2250 * Remark :
2251 * Status : UNTESTED UNKNOWN STUB
2252 *
2253 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2254 *****************************************************************************/
2255DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
2256{
2257 dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2258 x1,
2259 x2,
2260 x3,
2261 x4,
2262 x5));
2263
2264 return (FALSE); /* default */
2265}
2266
2267/* Unknown */
2268
2269/*****************************************************************************
2270 * Name : BOOL WIN32API SetShellWindow
2271 * Purpose : Unknown
2272 * Parameters: Unknown
2273 * Variables :
2274 * Result :
2275 * Remark :
2276 * Status : UNTESTED UNKNOWN STUB
2277 *
2278 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2279 *****************************************************************************/
2280BOOL WIN32API SetShellWindow(DWORD x1)
2281{
2282 dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
2283 x1));
2284
2285 return (FALSE); /* default */
2286}
2287/*****************************************************************************
2288 * Name : BOOL WIN32API PlaySoundEvent
2289 * Purpose : Unknown
2290 * Parameters: Unknown
2291 * Variables :
2292 * Result :
2293 * Remark :
2294 * Status : UNTESTED UNKNOWN STUB
2295 *
2296 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2297 *****************************************************************************/
2298BOOL WIN32API PlaySoundEvent(DWORD x1)
2299{
2300 dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
2301 x1));
2302
2303 return (FALSE); /* default */
2304}
2305/*****************************************************************************
2306 * Name : BOOL WIN32API SetSysColorsTemp
2307 * Purpose : Unknown
2308 * Parameters: Unknown
2309 * Variables :
2310 * Result :
2311 * Remark :
2312 * Status : UNTESTED UNKNOWN STUB
2313 *
2314 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2315 *****************************************************************************/
2316BOOL WIN32API SetSysColorsTemp(void)
2317{
2318 dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
2319
2320 return (FALSE); /* default */
2321}
2322/*****************************************************************************
2323 * Name : BOOL WIN32API RegisterNetworkCapabilities
2324 * Purpose : Unknown
2325 * Parameters: Unknown
2326 * Variables :
2327 * Result :
2328 * Remark :
2329 * Status : UNTESTED UNKNOWN STUB
2330 *
2331 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2332 *****************************************************************************/
2333BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
2334 DWORD x2)
2335{
2336 dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
2337 x1,
2338 x2));
2339
2340 return (FALSE); /* default */
2341}
2342/*****************************************************************************
2343 * Name : BOOL WIN32API EndTask
2344 * Purpose : Unknown
2345 * Parameters: Unknown
2346 * Variables :
2347 * Result :
2348 * Remark :
2349 * Status : UNTESTED UNKNOWN STUB
2350 *
2351 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2352 *****************************************************************************/
2353BOOL WIN32API EndTask(DWORD x1,
2354 DWORD x2,
2355 DWORD x3)
2356{
2357 dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
2358 x1,
2359 x2,
2360 x3));
2361
2362 return (FALSE); /* default */
2363}
2364/*****************************************************************************
2365 * Name : BOOL WIN32API GetNextQueueWindow
2366 * Purpose : Unknown
2367 * Parameters: Unknown
2368 * Variables :
2369 * Result :
2370 * Remark :
2371 * Status : UNTESTED UNKNOWN STUB
2372 *
2373 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2374 *****************************************************************************/
2375BOOL WIN32API GetNextQueueWindow(DWORD x1,
2376 DWORD x2)
2377{
2378 dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
2379 x1,
2380 x2));
2381
2382 return (FALSE); /* default */
2383}
2384/*****************************************************************************
2385 * Name : BOOL WIN32API YieldTask
2386 * Purpose : Unknown
2387 * Parameters: Unknown
2388 * Variables :
2389 * Result :
2390 * Remark :
2391 * Status : UNTESTED UNKNOWN STUB
2392 *
2393 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2394 *****************************************************************************/
2395BOOL WIN32API YieldTask(void)
2396{
2397 dprintf(("USER32: YieldTask() not implemented.\n"));
2398
2399 return (FALSE); /* default */
2400}
2401/*****************************************************************************
2402 * Name : BOOL WIN32API WinOldAppHackoMatic
2403 * Purpose : Unknown
2404 * Parameters: Unknown
2405 * Variables :
2406 * Result :
2407 * Remark :
2408 * Status : UNTESTED UNKNOWN STUB
2409 *
2410 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2411 *****************************************************************************/
2412BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
2413{
2414 dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
2415 x1));
2416
2417 return (FALSE); /* default */
2418}
2419/*****************************************************************************
2420 * Name : BOOL WIN32API RegisterSystemThread
2421 * Purpose : Unknown
2422 * Parameters: Unknown
2423 * Variables :
2424 * Result :
2425 * Remark :
2426 * Status : UNTESTED UNKNOWN STUB
2427 *
2428 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2429 *****************************************************************************/
2430BOOL WIN32API RegisterSystemThread(DWORD x1,
2431 DWORD x2)
2432{
2433 dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
2434 x1,
2435 x2));
2436
2437 return (FALSE); /* default */
2438}
2439/*****************************************************************************
2440 * Name : BOOL WIN32API IsHungThread
2441 * Purpose : Unknown
2442 * Parameters: Unknown
2443 * Variables :
2444 * Result :
2445 * Remark :
2446 * Status : UNTESTED UNKNOWN STUB
2447 *
2448 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2449 *****************************************************************************/
2450BOOL WIN32API IsHungThread(DWORD x1)
2451{
2452 dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
2453 x1));
2454
2455 return (FALSE); /* default */
2456}
2457/*****************************************************************************
2458 * Name : BOOL WIN32API UserSignalProc
2459 * Purpose : Unknown
2460 * Parameters: Unknown
2461 * Variables :
2462 * Result :
2463 * Remark :
2464 * Status : UNTESTED UNKNOWN STUB
2465 *
2466 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2467 *****************************************************************************/
2468BOOL WIN32API UserSignalProc(DWORD x1,
2469 DWORD x2,
2470 DWORD x3,
2471 DWORD x4)
2472{
2473 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2474 x1,
2475 x2,
2476 x3,
2477 x4));
2478
2479 return (FALSE); /* default */
2480}
2481/*****************************************************************************
2482 * Name : BOOL WIN32API GetShellWindow
2483 * Purpose : Unknown
2484 * Parameters: Unknown
2485 * Variables :
2486 * Result :
2487 * Remark :
2488 * Status : UNTESTED UNKNOWN STUB
2489 *
2490 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2491 *****************************************************************************/
2492HWND WIN32API GetShellWindow(void)
2493{
2494 dprintf(("USER32: GetShellWindow() not implemented.\n"));
2495
2496 return (0); /* default */
2497}
2498/***********************************************************************
2499 * RegisterTasklist32 [USER32.436]
2500 */
2501DWORD WIN32API RegisterTasklist (DWORD x)
2502{
2503 dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
2504 x));
2505
2506 return TRUE;
2507}
2508/***********************************************************************
2509 * SetLogonNotifyWindow (USER32.486)
2510 */
2511DWORD WIN32API SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd)
2512{
2513 dprintf(("USER32: SetLogonNotifyWindow - empty stub!"));
2514
2515 return 1;
2516}
2517
2518
2519DWORD WIN32API NotifyWinEvent(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4)
2520{
2521 dprintf(("USER32: NotifyWinEvent %x %x %x %x - empty stub!!", arg1, arg2, arg3, arg4));
2522
2523 return 0;
2524}
2525
2526DWORD WIN32API UnhookWinEvent(DWORD arg1)
2527{
2528 dprintf(("USER32: UnhookWinEvent %x - empty stub!!", arg1));
2529
2530 return 0;
2531}
2532
2533DWORD WIN32API SetWinEventHook(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7)
2534{
2535 dprintf(("USER32: SetWinEventHook %x %x %x %x %x %x %x - empty stub!!", arg1, arg2, arg3, arg4, arg5, arg6, arg7));
2536
2537 return 0;
2538}
Note: See TracBrowser for help on using the repository browser.