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

Last change on this file since 5488 was 5406, checked in by sandervl, 25 years ago

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