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

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

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