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

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

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