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

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

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