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

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

compile fix
File size: 96.0 KB
Line 
1/* $Id: user32.cpp,v 1.103 2001-06-23 09:14:06 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 hwh = GlobalAlloc(0,size);
1039 lpwh = (WINHELP*)GlobalLock(hwh);
1040 lpwh->size = size;
1041 lpwh->command = uCommand;
1042 lpwh->data = dwData;
1043 if(nlen)
1044 {
1045 strcpy(((char*)lpwh) + sizeof(WINHELP),lpszHelp);
1046 lpwh->ofsFilename = sizeof(WINHELP);
1047 } else
1048 lpwh->ofsFilename = 0;
1049 if(dsize)
1050 {
1051 memcpy(((char*)lpwh)+sizeof(WINHELP)+nlen,(LPSTR)dwData,dsize);
1052 lpwh->ofsData = sizeof(WINHELP)+nlen;
1053 } else
1054 lpwh->ofsData = 0;
1055 GlobalUnlock(hwh);
1056
1057 return SendMessageA(hDest,WM_WINHELP,hwnd,hwh);
1058}
1059//******************************************************************************
1060//******************************************************************************
1061BOOL WIN32API WinHelpW( HWND hwnd, LPCWSTR lpszHelp, UINT uCommand, DWORD dwData)
1062{
1063 char *astring = UnicodeToAsciiString((LPWSTR)lpszHelp);
1064 BOOL rc;
1065
1066 dprintf(("USER32: WinHelpW\n"));
1067
1068 rc = WinHelpA(hwnd,astring,uCommand,dwData);
1069 FreeAsciiString(astring);
1070
1071 return rc;
1072}
1073
1074/* Keyboard and Input Functions */
1075
1076BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
1077{
1078 dprintf(("USER32: ActivateKeyboardLayout, not implemented\n"));
1079 return(TRUE);
1080}
1081/*****************************************************************************
1082 * Name : UINT WIN32API GetKBCodePage
1083 * Purpose : The GetKBCodePage function is provided for compatibility with
1084 * earlier versions of Windows. In the Win32 application programming
1085 * interface (API) it just calls the GetOEMCP function.
1086 * Parameters:
1087 * Variables :
1088 * Result : If the function succeeds, the return value is an OEM code-page
1089 * identifier, or it is the default identifier if the registry
1090 * value is not readable. For a list of OEM code-page identifiers,
1091 * see GetOEMCP.
1092 * Remark :
1093 * Status : COMPLETELY IMPLEMENTED UNTESTED
1094 *
1095 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1096 *****************************************************************************/
1097
1098UINT WIN32API GetKBCodePage(VOID)
1099{
1100 return (GetOEMCP());
1101}
1102//******************************************************************************
1103//******************************************************************************
1104int WIN32API GetKeyNameTextA( LPARAM lParam, LPSTR lpString, int nSize)
1105{
1106 dprintf(("USER32: GetKeyNameTextA\n"));
1107 return O32_GetKeyNameText(lParam,lpString,nSize);
1108}
1109//******************************************************************************
1110//******************************************************************************
1111int WIN32API GetKeyNameTextW( LPARAM lParam, LPWSTR lpString, int nSize)
1112{
1113 dprintf(("USER32: GetKeyNameTextW DOES NOT WORK\n"));
1114 // NOTE: This will not work as is (needs UNICODE support)
1115 return 0;
1116// return O32_GetKeyNameText(arg1, arg2, arg3);
1117}
1118//******************************************************************************
1119//******************************************************************************
1120SHORT WIN32API GetKeyState( int nVirtKey)
1121{
1122 dprintf2(("USER32: GetKeyState %x", nVirtKey));
1123 return O32_GetKeyState(nVirtKey);
1124}
1125//******************************************************************************
1126//******************************************************************************
1127WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1128{
1129 dprintf2(("USER32: GetAsyncKeyState %x", nVirtKey));
1130 return O32_GetAsyncKeyState(nVirtKey);
1131}
1132
1133/*****************************************************************************
1134 * Name : VOID WIN32API keybd_event
1135 * Purpose : The keybd_event function synthesizes a keystroke. The system
1136 * can use such a synthesized keystroke to generate a WM_KEYUP or
1137 * WM_KEYDOWN message. The keyboard driver's interrupt handler calls
1138 * the keybd_event function.
1139 * Parameters: BYTE bVk virtual-key code
1140
1141 * BYTE bScan hardware scan code
1142 * DWORD dwFlags flags specifying various function options
1143 * DWORD dwExtraInfo additional data associated with keystroke
1144 * Variables :
1145 * Result :
1146 * Remark :
1147 * Status : UNTESTED STUB
1148 *
1149 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1150 *****************************************************************************/
1151VOID WIN32API keybd_event (BYTE bVk,
1152 BYTE bScan,
1153 DWORD dwFlags,
1154 DWORD dwExtraInfo)
1155{
1156 dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
1157 bVk,
1158 bScan,
1159 dwFlags,
1160 dwExtraInfo));
1161}
1162/*****************************************************************************
1163 * Name : HLK WIN32API LoadKeyboardLayoutA
1164 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
1165 * the system. Several keyboard layouts can be loaded at a time, but
1166 * only one per process is active at a time. Loading multiple keyboard
1167 * layouts makes it possible to rapidly switch between layouts.
1168 * Parameters:
1169 * Variables :
1170 * Result : If the function succeeds, the return value is the handle of the
1171 * keyboard layout.
1172 * If the function fails, the return value is NULL. To get extended
1173 * error information, call GetLastError.
1174 * Remark :
1175 * Status : UNTESTED STUB
1176 *
1177 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1178 *****************************************************************************/
1179HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
1180 UINT Flags)
1181{
1182 dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
1183 pwszKLID,
1184 Flags));
1185
1186 return (NULL);
1187}
1188/*****************************************************************************
1189 * Name : HLK WIN32API LoadKeyboardLayoutW
1190 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
1191 * the system. Several keyboard layouts can be loaded at a time, but
1192 * only one per process is active at a time. Loading multiple keyboard
1193 * layouts makes it possible to rapidly switch between layouts.
1194 * Parameters:
1195 * Variables :
1196 * Result : If the function succeeds, the return value is the handle of the
1197 * keyboard layout.
1198 * If the function fails, the return value is NULL. To get extended
1199 * error information, call GetLastError.
1200 * Remark :
1201 * Status : UNTESTED STUB
1202 *
1203 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1204 *****************************************************************************/
1205HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
1206 UINT Flags)
1207{
1208 dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
1209 pwszKLID,
1210 Flags));
1211
1212 return (NULL);
1213}
1214//******************************************************************************
1215//******************************************************************************
1216UINT WIN32API MapVirtualKeyA( UINT uCode, UINT uMapType)
1217{
1218 dprintf(("USER32: MapVirtualKeyA\n"));
1219 /* A quick fix for Commandos, very incomplete */
1220 switch (uMapType) {
1221 case 2:
1222 if (uCode >= VK_A && uCode <= VK_Z) {
1223 return 'A' + uCode - VK_A;
1224 }
1225 break;
1226 }
1227 return O32_MapVirtualKey(uCode,uMapType);
1228}
1229//******************************************************************************
1230//******************************************************************************
1231UINT WIN32API MapVirtualKeyW( UINT uCode, UINT uMapType)
1232{
1233 dprintf(("USER32: MapVirtualKeyW\n"));
1234 // NOTE: This will not work as is (needs UNICODE support)
1235 return O32_MapVirtualKey(uCode,uMapType);
1236}
1237/*****************************************************************************
1238 * Name : UINT WIN32API MapVirtualKeyExA
1239 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
1240 * code into a scan code or character value, or translates a scan
1241 * code into a virtual-key code. The function translates the codes
1242 * using the input language and physical keyboard layout identified
1243 * by the given keyboard layout handle.
1244 * Parameters:
1245 * Variables :
1246 * Result : The return value is either a scan code, a virtual-key code, or
1247 * a character value, depending on the value of uCode and uMapType.
1248 * If there is no translation, the return value is zero.
1249 * Remark :
1250 * Status : UNTESTED STUB
1251 *
1252 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1253 *****************************************************************************/
1254UINT WIN32API MapVirtualKeyExA(UINT uCode,
1255 UINT uMapType,
1256 HKL dwhkl)
1257{
1258 dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
1259 uCode,
1260 uMapType,
1261 dwhkl));
1262
1263 return (0);
1264}
1265/*****************************************************************************
1266 * Name : UINT WIN32API MapVirtualKeyExW
1267 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
1268 * code into a scan code or character value, or translates a scan
1269 * code into a virtual-key code. The function translates the codes
1270 * using the input language and physical keyboard layout identified
1271 * by the given keyboard layout handle.
1272 * Parameters:
1273 * Variables :
1274 * Result : The return value is either a scan code, a virtual-key code, or
1275 * a character value, depending on the value of uCode and uMapType.
1276 * If there is no translation, the return value is zero.
1277 * Remark :
1278 * Status : UNTESTED STUB
1279
1280 *
1281 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1282 *****************************************************************************/
1283UINT WIN32API MapVirtualKeyExW(UINT uCode,
1284 UINT uMapType,
1285 HKL dwhkl)
1286{
1287 dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
1288 uCode,
1289 uMapType,
1290 dwhkl));
1291
1292 return (0);
1293}
1294/*****************************************************************************
1295 * Name : DWORD WIN32API OemKeyScan
1296 * Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
1297 * into the OEM scan codes and shift states. The function provides
1298 * information that allows a program to send OEM text to another
1299 * program by simulating keyboard input.
1300 * Parameters:
1301 * Variables :
1302 * Result :
1303 * Remark :
1304 * Status : UNTESTED STUB
1305 *
1306 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1307 *****************************************************************************/
1308DWORD WIN32API OemKeyScan(WORD wOemChar)
1309{
1310 dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
1311 wOemChar));
1312
1313 return (wOemChar);
1314}
1315//******************************************************************************
1316//******************************************************************************
1317BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
1318{
1319 dprintf(("USER32: RegisterHotKey, not implemented\n"));
1320 hwnd = Win32ToOS2Handle(hwnd);
1321 return(TRUE);
1322}
1323/*****************************************************************************
1324 * Name : int WIN32API ToUnicode
1325 * Purpose : The ToUnicode function translates the specified virtual-key code
1326 * and keyboard state to the corresponding Unicode character or characters.
1327 * Parameters: UINT wVirtKey virtual-key code
1328 * UINT wScanCode scan code
1329 * PBYTE lpKeyState address of key-state array
1330 * LPWSTR pwszBuff buffer for translated key
1331 * int cchBuff size of translated key buffer
1332 * UINT wFlags set of function-conditioning flags
1333 * Variables :
1334 * Result : - 1 The specified virtual key is a dead-key character (accent or
1335 * diacritic). This value is returned regardless of the keyboard
1336 * layout, even if several characters have been typed and are
1337 * stored in the keyboard state. If possible, even with Unicode
1338 * keyboard layouts, the function has written a spacing version of
1339 * the dead-key character to the buffer specified by pwszBuffer.
1340 * For example, the function writes the character SPACING ACUTE
1341 * (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
1342 * 0 The specified virtual key has no translation for the current
1343 * state of the keyboard. Nothing was written to the buffer
1344 * specified by pwszBuffer.
1345 * 1 One character was written to the buffer specified by pwszBuffer.
1346 * 2 or more Two or more characters were written to the buffer specified by
1347 * pwszBuff. The most common cause for this is that a dead-key
1348 * character (accent or diacritic) stored in the keyboard layout
1349 * could not be combined with the specified virtual key to form a
1350 * single character.
1351 * Remark :
1352 * Status : UNTESTED STUB
1353 *
1354 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1355 *****************************************************************************/
1356int WIN32API ToUnicode(UINT uVirtKey,
1357 UINT uScanCode,
1358 PBYTE lpKeyState,
1359 LPWSTR pwszBuff,
1360 int cchBuff,
1361 UINT wFlags)
1362{
1363 dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
1364 uVirtKey,
1365 uScanCode,
1366 lpKeyState,
1367 pwszBuff,
1368 cchBuff,
1369 wFlags));
1370
1371 return (0);
1372}
1373/*****************************************************************************
1374 * Name : BOOL WIN32API UnloadKeyboardLayout
1375 * Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
1376 * Parameters: HKL hkl handle of keyboard layout
1377 * Variables :
1378 * Result : If the function succeeds, the return value is the handle of the
1379 * keyboard layout; otherwise, it is NULL. To get extended error
1380 * information, use the GetLastError function.
1381 * Remark :
1382 * Status : UNTESTED STUB
1383 *
1384 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1385 *****************************************************************************/
1386BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
1387{
1388 dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
1389 hkl));
1390
1391 return (0);
1392}
1393//******************************************************************************
1394//******************************************************************************
1395BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
1396{
1397 dprintf(("USER32: UnregisterHotKey, not implemented\n"));
1398 hwnd = Win32ToOS2Handle(hwnd);
1399
1400 return(TRUE);
1401}
1402//******************************************************************************
1403//SvL: 24-6-'97 - Added
1404//******************************************************************************
1405WORD WIN32API VkKeyScanA( char ch)
1406{
1407 dprintf(("USER32: VkKeyScanA %x", ch));
1408 return O32_VkKeyScan(ch);
1409}
1410//******************************************************************************
1411//******************************************************************************
1412WORD WIN32API VkKeyScanW( WCHAR wch)
1413{
1414 dprintf(("USER32: VkKeyScanW %x", wch));
1415 // NOTE: This will not work as is (needs UNICODE support)
1416 return O32_VkKeyScan((char)wch);
1417}
1418/*****************************************************************************
1419 * Name : SHORT WIN32API VkKeyScanExW
1420 * Purpose : The VkKeyScanEx function translates a character to the
1421 * corresponding virtual-key code and shift state. The function
1422 * translates the character using the input language and physical
1423 * keyboard layout identified by the given keyboard layout handle.
1424 * Parameters: UINT uChar character to translate
1425 * HKL hkl keyboard layout handle
1426 * Variables :
1427 * Result : see docs
1428 * Remark :
1429 * Status : UNTESTED STUB
1430 *
1431 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1432 *****************************************************************************/
1433WORD WIN32API VkKeyScanExW(WCHAR uChar,
1434 HKL hkl)
1435{
1436 dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
1437 uChar,
1438 hkl));
1439
1440 return (uChar);
1441}
1442/*****************************************************************************
1443 * Name : SHORT WIN32API VkKeyScanExA
1444 * Purpose : The VkKeyScanEx function translates a character to the
1445 * corresponding virtual-key code and shift state. The function
1446 * translates the character using the input language and physical
1447 * keyboard layout identified by the given keyboard layout handle.
1448 * Parameters: UINT uChar character to translate
1449 * HKL hkl keyboard layout handle
1450 * Variables :
1451 * Result : see docs
1452 * Remark :
1453 * Status : UNTESTED STUB
1454 *
1455 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1456 *****************************************************************************/
1457WORD WIN32API VkKeyScanExA(CHAR uChar,
1458 HKL hkl)
1459{
1460 dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
1461 uChar,
1462 hkl));
1463
1464 return (uChar);
1465}
1466
1467/* Window Functions */
1468
1469/*****************************************************************************
1470 * Name : BOOL WIN32API AnyPopup
1471 * Purpose : The AnyPopup function indicates whether an owned, visible,
1472 * top-level pop-up, or overlapped window exists on the screen. The
1473 * function searches the entire Windows screen, not just the calling
1474 * application's client area.
1475 * Parameters: VOID
1476 * Variables :
1477 * Result : If a pop-up window exists, the return value is TRUE even if the
1478 * pop-up window is completely covered by other windows. Otherwise,
1479 * it is FALSE.
1480 * Remark : AnyPopup is a Windows version 1.x function and is retained for
1481 * compatibility purposes. It is generally not useful.
1482 * Status : UNTESTED STUB
1483 *
1484 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1485 *****************************************************************************/
1486BOOL WIN32API AnyPopup(VOID)
1487{
1488 dprintf(("USER32:AnyPopup() not implemented.\n"));
1489
1490 return (FALSE);
1491}
1492
1493/*****************************************************************************
1494 * Name : BOOL WIN32API PaintDesktop
1495 * Purpose : The PaintDesktop function fills the clipping region in the
1496 * specified device context with the desktop pattern or wallpaper.
1497 * The function is provided primarily for shell desktops.
1498 * Parameters:
1499 * Variables :
1500 * Result : If the function succeeds, the return value is TRUE.
1501 * If the function fails, the return value is FALSE.
1502 * Remark :
1503 * Status : UNTESTED STUB
1504 *
1505 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1506 *****************************************************************************/
1507BOOL WIN32API PaintDesktop(HDC hdc)
1508{
1509 dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
1510 hdc));
1511
1512 return (FALSE);
1513}
1514
1515/* Filled Shape Functions */
1516
1517 /* Last COLOR id */
1518#define COLOR_MAX COLOR_GRADIENTINACTIVECAPTION
1519
1520int WIN32API FillRect(HDC hDC, const RECT * lprc, HBRUSH hbr)
1521{
1522 if (hbr <= (HBRUSH) (COLOR_MAX + 1)) {
1523 hbr = GetSysColorBrush( (INT) hbr - 1 );
1524 }
1525 dprintf(("USER32: FillRect %x (%d,%d)(%d,%d) brush %X", hDC, lprc->left, lprc->top, lprc->right, lprc->bottom, hbr));
1526 return O32_FillRect(hDC,lprc,hbr);
1527}
1528//******************************************************************************
1529//******************************************************************************
1530int WIN32API FrameRect( HDC hDC, const RECT * lprc, HBRUSH hbr)
1531{
1532 dprintf(("USER32: FrameRect %x (%d,%d)(%d,%d) brush %x", hDC, lprc->top, lprc->left, lprc->bottom, lprc->right, hbr));
1533 return O32_FrameRect(hDC,lprc,hbr);
1534}
1535//******************************************************************************
1536//******************************************************************************
1537BOOL WIN32API InvertRect( HDC hDC, const RECT * lprc)
1538{
1539 if(lprc) {
1540 dprintf(("USER32: InvertRect %x (%d,%d)(%d,%d)", hDC, lprc->left, lprc->top, lprc->right, lprc->bottom));
1541 }
1542 else dprintf(("USER32: InvertRect %x NULL", hDC));
1543 return O32_InvertRect(hDC,lprc);
1544}
1545
1546/* System Information Functions */
1547
1548/* Window Station and Desktop Functions */
1549
1550/*****************************************************************************
1551 * Name : HDESK WIN32API GetThreadDesktop
1552 * Purpose : The GetThreadDesktop function returns a handle to the desktop
1553 * associated with a specified thread.
1554 * Parameters: DWORD dwThreadId thread identifier
1555 * Variables :
1556 * Result : If the function succeeds, the return value is the handle of the
1557 * desktop associated with the specified thread.
1558 * Remark :
1559 * Status : UNTESTED STUB
1560 *
1561 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1562 *****************************************************************************/
1563HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
1564{
1565 dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
1566 dwThreadId));
1567
1568 return (NULL);
1569}
1570
1571/*****************************************************************************
1572 * Name : BOOL WIN32API CloseDesktop
1573 * Purpose : The CloseDesktop function closes an open handle of a desktop
1574 * object. A desktop is a secure object contained within a window
1575 * station object. A desktop has a logical display surface and
1576 * contains windows, menus and hooks.
1577 * Parameters: HDESK hDesktop
1578 * Variables :
1579 * Result : If the function succeeds, the return value is TRUE.
1580 * If the functions fails, the return value is FALSE. To get
1581 * extended error information, call GetLastError.
1582 * Remark :
1583 * Status : UNTESTED STUB
1584 *
1585 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1586 *****************************************************************************/
1587BOOL WIN32API CloseDesktop(HDESK hDesktop)
1588{
1589 dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
1590 hDesktop));
1591
1592 return (FALSE);
1593}
1594/*****************************************************************************
1595 * Name : BOOL WIN32API CloseWindowStation
1596 * Purpose : The CloseWindowStation function closes an open window station handle.
1597 * Parameters: HWINSTA hWinSta
1598 * Variables :
1599 * Result :
1600 * Remark : If the function succeeds, the return value is TRUE.
1601 * If the functions fails, the return value is FALSE. To get
1602 * extended error information, call GetLastError.
1603 * Status : UNTESTED STUB
1604 *
1605 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1606 *****************************************************************************/
1607BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
1608{
1609 dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
1610 hWinSta));
1611
1612 return (FALSE);
1613}
1614/*****************************************************************************
1615 * Name : HDESK WIN32API CreateDesktopA
1616 * Purpose : The CreateDesktop function creates a new desktop on the window
1617 * station associated with the calling process.
1618 * Parameters: LPCTSTR lpszDesktop name of the new desktop
1619 * LPCTSTR lpszDevice name of display device to assign to the desktop
1620 * LPDEVMODE pDevMode reserved; must be NULL
1621 * DWORD dwFlags flags to control interaction with other applications
1622 * DWORD dwDesiredAccess specifies access of returned handle
1623 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
1624 * Variables :
1625 * Result : If the function succeeds, the return value is a handle of the
1626 * newly created desktop.
1627 * If the function fails, the return value is NULL. To get extended
1628 * error information, call GetLastError.
1629 * Remark :
1630 * Status : UNTESTED STUB
1631 *
1632 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1633 *****************************************************************************/
1634HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
1635 LPCTSTR lpszDevice,
1636 LPDEVMODEA pDevMode,
1637 DWORD dwFlags,
1638 DWORD dwDesiredAccess,
1639 LPSECURITY_ATTRIBUTES lpsa)
1640{
1641 dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
1642 lpszDesktop,
1643 lpszDevice,
1644 pDevMode,
1645 dwFlags,
1646 dwDesiredAccess,
1647 lpsa));
1648
1649 return (NULL);
1650}
1651/*****************************************************************************
1652 * Name : HDESK WIN32API CreateDesktopW
1653 * Purpose : The CreateDesktop function creates a new desktop on the window
1654 * station associated with the calling process.
1655 * Parameters: LPCTSTR lpszDesktop name of the new desktop
1656 * LPCTSTR lpszDevice name of display device to assign to the desktop
1657 * LPDEVMODE pDevMode reserved; must be NULL
1658 * DWORD dwFlags flags to control interaction with other applications
1659 * DWORD dwDesiredAccess specifies access of returned handle
1660 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
1661 * Variables :
1662 * Result : If the function succeeds, the return value is a handle of the
1663 * newly created desktop.
1664 * If the function fails, the return value is NULL. To get extended
1665 * error information, call GetLastError.
1666 * Remark :
1667 * Status : UNTESTED STUB
1668 *
1669 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1670 *****************************************************************************/
1671HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
1672 LPCTSTR lpszDevice,
1673 LPDEVMODEW pDevMode,
1674 DWORD dwFlags,
1675 DWORD dwDesiredAccess,
1676 LPSECURITY_ATTRIBUTES lpsa)
1677{
1678 dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
1679 lpszDesktop,
1680 lpszDevice,
1681 pDevMode,
1682 dwFlags,
1683 dwDesiredAccess,
1684 lpsa));
1685
1686 return (NULL);
1687}
1688/*****************************************************************************
1689 * Name : HWINSTA WIN32API CreateWindowStationA
1690 * Purpose : The CreateWindowStation function creates a window station object.
1691 * It returns a handle that can be used to access the window station.
1692 * A window station is a secure object that contains a set of global
1693 * atoms, a clipboard, and a set of desktop objects.
1694 * Parameters: LPTSTR lpwinsta name of the new window station
1695 * DWORD dwReserved reserved; must be NULL
1696 * DWORD dwDesiredAccess specifies access of returned handle
1697 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
1698 * Variables :
1699 * Result : If the function succeeds, the return value is the handle to the
1700 * newly created window station.
1701 * If the function fails, the return value is NULL. To get extended
1702 * error information, call GetLastError.
1703 * Remark :
1704 * Status : UNTESTED STUB
1705 *
1706 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1707 *****************************************************************************/
1708HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
1709 DWORD dwReserved,
1710 DWORD dwDesiredAccess,
1711 LPSECURITY_ATTRIBUTES lpsa)
1712{
1713 dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
1714 lpWinSta,
1715 dwReserved,
1716 dwDesiredAccess,
1717 lpsa));
1718
1719 return (NULL);
1720}
1721/*****************************************************************************
1722 * Name : HWINSTA WIN32API CreateWindowStationW
1723 * Purpose : The CreateWindowStation function creates a window station object.
1724 * It returns a handle that can be used to access the window station.
1725 * A window station is a secure object that contains a set of global
1726 * atoms, a clipboard, and a set of desktop objects.
1727 * Parameters: LPTSTR lpwinsta name of the new window station
1728 * DWORD dwReserved reserved; must be NULL
1729 * DWORD dwDesiredAccess specifies access of returned handle
1730 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
1731 * Variables :
1732 * Result : If the function succeeds, the return value is the handle to the
1733 * newly created window station.
1734 * If the function fails, the return value is NULL. To get extended
1735 * error information, call GetLastError.
1736 * Remark :
1737 * Status : UNTESTED STUB
1738 *
1739 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1740 *****************************************************************************/
1741HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
1742 DWORD dwReserved,
1743 DWORD dwDesiredAccess,
1744 LPSECURITY_ATTRIBUTES lpsa)
1745{
1746 dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
1747 lpWinSta,
1748 dwReserved,
1749 dwDesiredAccess,
1750 lpsa));
1751
1752 return (NULL);
1753}
1754/*****************************************************************************
1755 * Name : BOOL WIN32API EnumDesktopWindows
1756 * Purpose : The EnumDesktopWindows function enumerates all windows in a
1757 * desktop by passing the handle of each window, in turn, to an
1758 * application-defined callback function.
1759 * Parameters: HDESK hDesktop handle of desktop to enumerate
1760 * WNDENUMPROC lpfn points to application's callback function
1761 * LPARAM lParam 32-bit value to pass to the callback function
1762 * Variables :
1763 * Result : If the function succeeds, the return value is TRUE.
1764 * If the function fails, the return value is FALSE. To get
1765 * extended error information, call GetLastError.
1766 * Remark :
1767 * Status : UNTESTED STUB
1768 *
1769 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1770 *****************************************************************************/
1771BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
1772 WNDENUMPROC lpfn,
1773 LPARAM lParam)
1774{
1775 dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
1776 hDesktop,
1777 lpfn,
1778 lParam));
1779
1780 return (FALSE);
1781}
1782/*****************************************************************************
1783 * Name : BOOL WIN32API EnumDesktopsA
1784 * Purpose : The EnumDesktops function enumerates all desktops in the window
1785 * station assigned to the calling process. The function does so by
1786 * passing the name of each desktop, in turn, to an application-
1787 * defined callback function.
1788 * Parameters: HWINSTA hwinsta handle of window station to enumerate
1789 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
1790 * LPARAM lParam 32-bit value to pass to the callback function
1791 * Variables :
1792 * Result : If the function succeeds, the return value is TRUE.
1793 * If the function fails, the return value is FALSE. To get extended
1794 * error information, call GetLastError.
1795 * Remark :
1796 * Status : UNTESTED STUB
1797 *
1798 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1799 *****************************************************************************/
1800BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
1801 DESKTOPENUMPROCA lpEnumFunc,
1802 LPARAM lParam)
1803{
1804 dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
1805 hWinSta,
1806 lpEnumFunc,
1807 lParam));
1808
1809 return (FALSE);
1810}
1811/*****************************************************************************
1812 * Name : BOOL WIN32API EnumDesktopsW
1813 * Purpose : The EnumDesktops function enumerates all desktops in the window
1814 * station assigned to the calling process. The function does so by
1815 * passing the name of each desktop, in turn, to an application-
1816 * defined callback function.
1817 * Parameters: HWINSTA hwinsta handle of window station to enumerate
1818 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
1819 * LPARAM lParam 32-bit value to pass to the callback function
1820 * Variables :
1821 * Result : If the function succeeds, the return value is TRUE.
1822 * If the function fails, the return value is FALSE. To get extended
1823 * error information, call GetLastError.
1824 * Remark :
1825 * Status : UNTESTED STUB
1826 *
1827 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1828 *****************************************************************************/
1829BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
1830 DESKTOPENUMPROCW lpEnumFunc,
1831 LPARAM lParam)
1832{
1833 dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
1834 hWinSta,
1835 lpEnumFunc,
1836 lParam));
1837
1838 return (FALSE);
1839}
1840/*****************************************************************************
1841 * Name : BOOL WIN32API EnumWindowStationsA
1842 * Purpose : The EnumWindowStations function enumerates all windowstations
1843 * in the system by passing the name of each window station, in
1844 * turn, to an application-defined callback function.
1845 * Parameters:
1846 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
1847 * LPARAM lParam 32-bit value to pass to the callback function
1848 * Result : If the function succeeds, the return value is TRUE.
1849 * If the function fails the return value is FALSE. To get extended
1850 * error information, call GetLastError.
1851 * Remark :
1852 * Status : UNTESTED STUB
1853 *
1854 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1855 *****************************************************************************/
1856BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
1857 LPARAM lParam)
1858{
1859 dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
1860 lpEnumFunc,
1861 lParam));
1862
1863 return (FALSE);
1864}
1865/*****************************************************************************
1866 * Name : BOOL WIN32API EnumWindowStationsW
1867 * Purpose : The EnumWindowStations function enumerates all windowstations
1868 * in the system by passing the name of each window station, in
1869 * turn, to an application-defined callback function.
1870 * Parameters:
1871 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
1872 * LPARAM lParam 32-bit value to pass to the callback function
1873 * Result : If the function succeeds, the return value is TRUE.
1874 * If the function fails the return value is FALSE. To get extended
1875 * error information, call GetLastError.
1876 * Remark :
1877 * Status : UNTESTED STUB
1878 *
1879 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1880 *****************************************************************************/
1881BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
1882 LPARAM lParam)
1883{
1884 dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
1885 lpEnumFunc,
1886 lParam));
1887
1888 return (FALSE);
1889}
1890/*****************************************************************************
1891 * Name : HWINSTA WIN32API GetProcessWindowStation
1892 * Purpose : The GetProcessWindowStation function returns a handle of the
1893 * window station associated with the calling process.
1894 * Parameters:
1895 * Variables :
1896 * Result : If the function succeeds, the return value is a handle of the
1897 * window station associated with the calling process.
1898 * If the function fails, the return value is NULL. This can occur
1899 * if the calling process is not an application written for Windows
1900 * NT. To get extended error information, call GetLastError.
1901 * Remark :
1902 * Status : UNTESTED STUB
1903 *
1904 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1905 *****************************************************************************/
1906HWINSTA WIN32API GetProcessWindowStation(VOID)
1907{
1908 dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
1909
1910 return (NULL);
1911}
1912/*****************************************************************************
1913 * Name : BOOL WIN32API GetUserObjectInformationA
1914 * Purpose : The GetUserObjectInformation function returns information about
1915 * a window station or desktop object.
1916 * Parameters: HANDLE hObj handle of object to get information for
1917 * int nIndex type of information to get
1918 * PVOID pvInfo points to buffer that receives the information
1919 * DWORD nLength size, in bytes, of pvInfo buffer
1920 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
1921 * Variables :
1922 * Result : If the function succeeds, the return value is TRUE.
1923 * If the function fails, the return value is FALSE. To get extended
1924 * error information, call GetLastError.
1925 * Remark :
1926 * Status : UNTESTED STUB
1927 *
1928 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1929 *****************************************************************************/
1930BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
1931 int nIndex,
1932 PVOID pvInfo,
1933 DWORD nLength,
1934 LPDWORD lpnLengthNeeded)
1935{
1936 dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1937 hObj,
1938 nIndex,
1939 pvInfo,
1940 nLength,
1941 lpnLengthNeeded));
1942
1943 return (FALSE);
1944}
1945/*****************************************************************************
1946 * Name : BOOL WIN32API GetUserObjectInformationW
1947 * Purpose : The GetUserObjectInformation function returns information about
1948 * a window station or desktop object.
1949 * Parameters: HANDLE hObj handle of object to get information for
1950 * int nIndex type of information to get
1951 * PVOID pvInfo points to buffer that receives the information
1952 * DWORD nLength size, in bytes, of pvInfo buffer
1953 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
1954 * Variables :
1955 * Result : If the function succeeds, the return value is TRUE.
1956 * If the function fails, the return value is FALSE. To get extended
1957 * error information, call GetLastError.
1958 * Remark :
1959 * Status : UNTESTED STUB
1960 *
1961 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1962 *****************************************************************************/
1963BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
1964 int nIndex,
1965 PVOID pvInfo,
1966 DWORD nLength,
1967 LPDWORD lpnLengthNeeded)
1968{
1969 dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1970 hObj,
1971 nIndex,
1972 pvInfo,
1973 nLength,
1974 lpnLengthNeeded));
1975
1976 return (FALSE);
1977}
1978/*****************************************************************************
1979 * Name : BOOL WIN32API GetUserObjectSecurity
1980 * Purpose : The GetUserObjectSecurity function retrieves security information
1981 * for the specified user object.
1982 * Parameters: HANDLE hObj handle of user object
1983 * SECURITY_INFORMATION * pSIRequested address of requested security information
1984 * LPSECURITY_DESCRIPTOR pSID address of security descriptor
1985 * DWORD nLength size of buffer for security descriptor
1986 * LPDWORD lpnLengthNeeded address of required size of buffer
1987 * Variables :
1988 * Result : If the function succeeds, the return value is TRUE.
1989 * If the function fails, the return value is FALSE. To get extended
1990 * error information, call GetLastError.
1991 * Remark :
1992 * Status : UNTESTED STUB
1993 *
1994 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1995 *****************************************************************************/
1996BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
1997 PSECURITY_INFORMATION pSIRequested,
1998 PSECURITY_DESCRIPTOR pSID,
1999 DWORD nLength,
2000 LPDWORD lpnLengthNeeded)
2001{
2002 dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
2003 hObj,
2004 pSIRequested,
2005 pSID,
2006 nLength,
2007 lpnLengthNeeded));
2008
2009 return (FALSE);
2010}
2011/*****************************************************************************
2012 * Name : HDESK WIN32API OpenDesktopA
2013 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
2014 * A desktop is a secure object contained within a window station
2015 * object. A desktop has a logical display surface and contains
2016 * windows, menus and hooks.
2017 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
2018 * DWORD dwFlags flags to control interaction with other applications
2019 * BOOL fInherit specifies whether returned handle is inheritable
2020 * DWORD dwDesiredAccess specifies access of returned handle
2021 * Variables :
2022 * Result : If the function succeeds, the return value is the handle to the
2023 * opened desktop.
2024 * If the function fails, the return value is NULL. To get extended
2025 * error information, call GetLastError.
2026 * Remark :
2027 * Status : UNTESTED STUB
2028 *
2029 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2030 *****************************************************************************/
2031HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
2032 DWORD dwFlags,
2033 BOOL fInherit,
2034 DWORD dwDesiredAccess)
2035{
2036 dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
2037 lpszDesktopName,
2038 dwFlags,
2039 fInherit,
2040 dwDesiredAccess));
2041
2042 return (NULL);
2043}
2044/*****************************************************************************
2045 * Name : HDESK WIN32API OpenDesktopW
2046 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
2047 * A desktop is a secure object contained within a window station
2048 * object. A desktop has a logical display surface and contains
2049 * windows, menus and hooks.
2050 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
2051 * DWORD dwFlags flags to control interaction with other applications
2052 * BOOL fInherit specifies whether returned handle is inheritable
2053 * DWORD dwDesiredAccess specifies access of returned handle
2054 * Variables :
2055 * Result : If the function succeeds, the return value is the handle to the
2056 * opened desktop.
2057 * If the function fails, the return value is NULL. To get extended
2058 * error information, call GetLastError.
2059 * Remark :
2060 * Status : UNTESTED STUB
2061 *
2062 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2063 *****************************************************************************/
2064HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
2065 DWORD dwFlags,
2066 BOOL fInherit,
2067 DWORD dwDesiredAccess)
2068{
2069 dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
2070 lpszDesktopName,
2071 dwFlags,
2072 fInherit,
2073 dwDesiredAccess));
2074
2075 return (NULL);
2076}
2077/*****************************************************************************
2078 * Name : HDESK WIN32API OpenInputDesktop
2079 * Purpose : The OpenInputDesktop function returns a handle to the desktop
2080 * that receives user input. The input desktop is a desktop on the
2081 * window station associated with the logged-on user.
2082 * Parameters: DWORD dwFlags flags to control interaction with other applications
2083 * BOOL fInherit specifies whether returned handle is inheritable
2084 * DWORD dwDesiredAccess specifies access of returned handle
2085 * Variables :
2086 * Result : If the function succeeds, the return value is a handle of the
2087 * desktop that receives user input.
2088 * If the function fails, the return value is NULL. To get extended
2089 * error information, call GetLastError.
2090 * Remark :
2091 * Status : UNTESTED STUB
2092 *
2093 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2094 *****************************************************************************/
2095HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
2096 BOOL fInherit,
2097 DWORD dwDesiredAccess)
2098{
2099 dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
2100 dwFlags,
2101 fInherit,
2102 dwDesiredAccess));
2103
2104 return (NULL);
2105}
2106/*****************************************************************************
2107 * Name : HWINSTA WIN32API OpenWindowStationA
2108 * Purpose : The OpenWindowStation function returns a handle to an existing
2109 * window station.
2110 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
2111 * BOOL fInherit specifies whether returned handle is inheritable
2112 * DWORD dwDesiredAccess specifies access of returned handle
2113 * Variables :
2114 * Result : If the function succeeds, the return value is the handle to the
2115 * specified window station.
2116 * If the function fails, the return value is NULL. To get extended
2117 * error information, call GetLastError.
2118 * Remark :
2119 * Status : UNTESTED STUB
2120 *
2121 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2122 *****************************************************************************/
2123HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
2124 BOOL fInherit,
2125 DWORD dwDesiredAccess)
2126{
2127 dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
2128 lpszWinStaName,
2129 fInherit,
2130 dwDesiredAccess));
2131
2132 return (NULL);
2133}
2134/*****************************************************************************
2135 * Name : HWINSTA WIN32API OpenWindowStationW
2136 * Purpose : The OpenWindowStation function returns a handle to an existing
2137 * window station.
2138 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
2139 * BOOL fInherit specifies whether returned handle is inheritable
2140 * DWORD dwDesiredAccess specifies access of returned handle
2141 * Variables :
2142 * Result : If the function succeeds, the return value is the handle to the
2143 * specified window station.
2144 * If the function fails, the return value is NULL. To get extended
2145 * error information, call GetLastError.
2146
2147
2148 * Remark :
2149 * Status : UNTESTED STUB
2150 *
2151 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2152 *****************************************************************************/
2153HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
2154 BOOL fInherit,
2155 DWORD dwDesiredAccess)
2156{
2157 dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
2158 lpszWinStaName,
2159 fInherit,
2160 dwDesiredAccess));
2161
2162 return (NULL);
2163}
2164/*****************************************************************************
2165 * Name : BOOL WIN32API SetProcessWindowStation
2166 * Purpose : The SetProcessWindowStation function assigns a window station
2167 * to the calling process. This enables the process to access
2168 * objects in the window station such as desktops, the clipboard,
2169 * and global atoms. All subsequent operations on the window station
2170 * use the access rights granted to hWinSta.
2171 * Parameters:
2172 * Variables :
2173 * Result : If the function succeeds, the return value is TRUE.
2174 * If the function fails, the return value is FALSE. To get extended
2175 * error information, call GetLastError.
2176 * Remark :
2177 * Status : UNTESTED STUB
2178 *
2179 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2180 *****************************************************************************/
2181BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
2182{
2183 dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
2184 hWinSta));
2185
2186 return (FALSE);
2187}
2188/*****************************************************************************
2189 * Name : BOOL WIN32API SetThreadDesktop
2190 * Purpose : The SetThreadDesktop function assigns a desktop to the calling
2191 * thread. All subsequent operations on the desktop use the access
2192 * rights granted to hDesk.
2193 * Parameters: HDESK hDesk handle of the desktop to assign to this thread
2194 * Variables :
2195 * Result : If the function succeeds, the return value is TRUE.
2196 * If the function fails, the return value is FALSE. To get extended
2197 * error information, call GetLastError.
2198 * Remark :
2199 * Status : UNTESTED STUB
2200 *
2201 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2202 *****************************************************************************/
2203BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
2204{
2205 dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
2206 hDesktop));
2207
2208 return (FALSE);
2209}
2210/*****************************************************************************
2211 * Name : BOOL WIN32API SetUserObjectInformationA
2212 * Purpose : The SetUserObjectInformation function sets information about a
2213 * window station or desktop object.
2214 * Parameters: HANDLE hObject handle of the object for which to set information
2215 * int nIndex type of information to set
2216 * PVOID lpvInfo points to a buffer that contains the information
2217 * DWORD cbInfo size, in bytes, of lpvInfo buffer
2218 * Variables :
2219 * Result : If the function succeeds, the return value is TRUE.
2220 * If the function fails the return value is FALSE. To get extended
2221 * error information, call GetLastError.
2222 * Remark :
2223 * Status : UNTESTED STUB
2224 *
2225 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2226 *****************************************************************************/
2227BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
2228 int nIndex,
2229 PVOID lpvInfo,
2230 DWORD cbInfo)
2231{
2232 dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
2233 hObject,
2234 nIndex,
2235 lpvInfo,
2236 cbInfo));
2237
2238 return (FALSE);
2239}
2240/*****************************************************************************
2241 * Name : BOOL WIN32API SetUserObjectInformationW
2242 * Purpose : The SetUserObjectInformation function sets information about a
2243 * window station or desktop object.
2244 * Parameters: HANDLE hObject handle of the object for which to set information
2245 * int nIndex type of information to set
2246 * PVOID lpvInfo points to a buffer that contains the information
2247 * DWORD cbInfo size, in bytes, of lpvInfo buffer
2248 * Variables :
2249 * Result : If the function succeeds, the return value is TRUE.
2250 * If the function fails the return value is FALSE. To get extended
2251 * error information, call GetLastError.
2252 * Remark :
2253 * Status : UNTESTED STUB
2254 *
2255 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2256 *****************************************************************************/
2257BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
2258 int nIndex,
2259 PVOID lpvInfo,
2260 DWORD cbInfo)
2261{
2262 dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
2263 hObject,
2264 nIndex,
2265 lpvInfo,
2266 cbInfo));
2267
2268 return (FALSE);
2269}
2270/*****************************************************************************
2271 * Name : BOOL WIN32API SetUserObjectSecurity
2272 * Purpose : The SetUserObjectSecurity function sets the security of a user
2273 * object. This can be, for example, a window or a DDE conversation
2274 * Parameters: HANDLE hObject handle of user object
2275 * SECURITY_INFORMATION * psi address of security information
2276 * LPSECURITY_DESCRIPTOR psd address of security descriptor
2277 * Variables :
2278 * Result : If the function succeeds, the return value is TRUE.
2279 * If the function fails, the return value is FALSE. To get extended
2280 * error information, call GetLastError.
2281 * Remark :
2282 * Status : UNTESTED STUB
2283 *
2284 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2285 *****************************************************************************/
2286BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
2287 PSECURITY_INFORMATION psi,
2288 PSECURITY_DESCRIPTOR psd)
2289{
2290 dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
2291 hObject,
2292 psi,
2293 psd));
2294
2295 return (FALSE);
2296}
2297/*****************************************************************************
2298 * Name : BOOL WIN32API SwitchDesktop
2299 * Purpose : The SwitchDesktop function makes a desktop visible and activates
2300 * it. This enables the desktop to receive input from the user. The
2301 * calling process must have DESKTOP_SWITCHDESKTOP access to the
2302 * desktop for the SwitchDesktop function to succeed.
2303 * Parameters:
2304 * Variables :
2305 * Result : If the function succeeds, the return value is TRUE.
2306 * If the function fails, the return value is FALSE. To get extended
2307 * error information, call GetLastError.
2308 * Remark :
2309 * Status : UNTESTED STUB
2310 *
2311 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2312 *****************************************************************************/
2313BOOL WIN32API SwitchDesktop(HDESK hDesktop)
2314{
2315 dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
2316 hDesktop));
2317
2318 return (FALSE);
2319}
2320
2321/* Debugging Functions */
2322
2323/*****************************************************************************
2324 * Name : VOID WIN32API SetDebugErrorLevel
2325 * Purpose : The SetDebugErrorLevel function sets the minimum error level at
2326 * which Windows will generate debugging events and pass them to a debugger.
2327 * Parameters: DWORD dwLevel debugging error level
2328 * Variables :
2329 * Result :
2330 * Remark :
2331 * Status : UNTESTED STUB
2332 *
2333 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2334 *****************************************************************************/
2335VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
2336{
2337 dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
2338 dwLevel));
2339}
2340
2341/* Drag'n'drop */
2342
2343/*****************************************************************************
2344 * Name : BOOL WIN32API DragObject
2345 * Purpose : Unknown
2346 * Parameters: Unknown
2347 * Variables :
2348 * Result :
2349 * Remark :
2350 * Status : UNTESTED UNKNOWN STUB
2351 *
2352 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2353 *****************************************************************************/
2354DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
2355{
2356 dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2357 x1,
2358 x2,
2359 x3,
2360 x4,
2361 x5));
2362
2363 return (FALSE); /* default */
2364}
2365
2366/* Unknown */
2367
2368/*****************************************************************************
2369 * Name : BOOL WIN32API SetShellWindow
2370 * Purpose : Unknown
2371 * Parameters: Unknown
2372 * Variables :
2373 * Result :
2374 * Remark :
2375 * Status : UNTESTED UNKNOWN STUB
2376 *
2377 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2378 *****************************************************************************/
2379BOOL WIN32API SetShellWindow(DWORD x1)
2380{
2381 dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
2382 x1));
2383
2384 return (FALSE); /* default */
2385}
2386/*****************************************************************************
2387 * Name : BOOL WIN32API PlaySoundEvent
2388 * Purpose : Unknown
2389 * Parameters: Unknown
2390 * Variables :
2391 * Result :
2392 * Remark :
2393 * Status : UNTESTED UNKNOWN STUB
2394 *
2395 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2396 *****************************************************************************/
2397BOOL WIN32API PlaySoundEvent(DWORD x1)
2398{
2399 dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
2400 x1));
2401
2402 return (FALSE); /* default */
2403}
2404/*****************************************************************************
2405 * Name : BOOL WIN32API SetSysColorsTemp
2406 * Purpose : Unknown
2407 * Parameters: Unknown
2408 * Variables :
2409 * Result :
2410 * Remark :
2411 * Status : UNTESTED UNKNOWN STUB
2412 *
2413 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2414 *****************************************************************************/
2415BOOL WIN32API SetSysColorsTemp(void)
2416{
2417 dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
2418
2419 return (FALSE); /* default */
2420}
2421/*****************************************************************************
2422 * Name : BOOL WIN32API RegisterNetworkCapabilities
2423 * Purpose : Unknown
2424 * Parameters: Unknown
2425 * Variables :
2426 * Result :
2427 * Remark :
2428 * Status : UNTESTED UNKNOWN STUB
2429 *
2430 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2431 *****************************************************************************/
2432BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
2433 DWORD x2)
2434{
2435 dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
2436 x1,
2437 x2));
2438
2439 return (FALSE); /* default */
2440}
2441/*****************************************************************************
2442 * Name : BOOL WIN32API EndTask
2443 * Purpose : Unknown
2444 * Parameters: Unknown
2445 * Variables :
2446 * Result :
2447 * Remark :
2448 * Status : UNTESTED UNKNOWN STUB
2449 *
2450 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2451 *****************************************************************************/
2452BOOL WIN32API EndTask(DWORD x1,
2453 DWORD x2,
2454 DWORD x3)
2455{
2456 dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
2457 x1,
2458 x2,
2459 x3));
2460
2461 return (FALSE); /* default */
2462}
2463/*****************************************************************************
2464 * Name : BOOL WIN32API GetNextQueueWindow
2465 * Purpose : Unknown
2466 * Parameters: Unknown
2467 * Variables :
2468 * Result :
2469 * Remark :
2470 * Status : UNTESTED UNKNOWN STUB
2471 *
2472 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2473 *****************************************************************************/
2474BOOL WIN32API GetNextQueueWindow(DWORD x1,
2475 DWORD x2)
2476{
2477 dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
2478 x1,
2479 x2));
2480
2481 return (FALSE); /* default */
2482}
2483/*****************************************************************************
2484 * Name : BOOL WIN32API YieldTask
2485 * Purpose : Unknown
2486 * Parameters: Unknown
2487 * Variables :
2488 * Result :
2489 * Remark :
2490 * Status : UNTESTED UNKNOWN STUB
2491 *
2492 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2493 *****************************************************************************/
2494BOOL WIN32API YieldTask(void)
2495{
2496 dprintf(("USER32: YieldTask() not implemented.\n"));
2497
2498 return (FALSE); /* default */
2499}
2500/*****************************************************************************
2501 * Name : BOOL WIN32API WinOldAppHackoMatic
2502 * Purpose : Unknown
2503 * Parameters: Unknown
2504 * Variables :
2505 * Result :
2506 * Remark :
2507 * Status : UNTESTED UNKNOWN STUB
2508 *
2509 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2510 *****************************************************************************/
2511BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
2512{
2513 dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
2514 x1));
2515
2516 return (FALSE); /* default */
2517}
2518/*****************************************************************************
2519 * Name : BOOL WIN32API RegisterSystemThread
2520 * Purpose : Unknown
2521 * Parameters: Unknown
2522 * Variables :
2523 * Result :
2524 * Remark :
2525 * Status : UNTESTED UNKNOWN STUB
2526 *
2527 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2528 *****************************************************************************/
2529BOOL WIN32API RegisterSystemThread(DWORD x1,
2530 DWORD x2)
2531{
2532 dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
2533 x1,
2534 x2));
2535
2536 return (FALSE); /* default */
2537}
2538/*****************************************************************************
2539 * Name : BOOL WIN32API IsHungThread
2540 * Purpose : Unknown
2541 * Parameters: Unknown
2542 * Variables :
2543 * Result :
2544 * Remark :
2545 * Status : UNTESTED UNKNOWN STUB
2546 *
2547 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2548 *****************************************************************************/
2549BOOL WIN32API IsHungThread(DWORD x1)
2550{
2551 dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
2552 x1));
2553
2554 return (FALSE); /* default */
2555}
2556/*****************************************************************************
2557 * Name : BOOL WIN32API UserSignalProc
2558 * Purpose : Unknown
2559 * Parameters: Unknown
2560 * Variables :
2561 * Result :
2562 * Remark :
2563 * Status : UNTESTED UNKNOWN STUB
2564 *
2565 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2566 *****************************************************************************/
2567BOOL WIN32API UserSignalProc(DWORD x1,
2568 DWORD x2,
2569 DWORD x3,
2570 DWORD x4)
2571{
2572 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2573 x1,
2574 x2,
2575 x3,
2576 x4));
2577
2578 return (FALSE); /* default */
2579}
2580/*****************************************************************************
2581 * Name : BOOL WIN32API GetShellWindow
2582 * Purpose : Unknown
2583 * Parameters: Unknown
2584 * Variables :
2585 * Result :
2586 * Remark :
2587 * Status : UNTESTED UNKNOWN STUB
2588 *
2589 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2590 *****************************************************************************/
2591HWND WIN32API GetShellWindow(void)
2592{
2593 dprintf(("USER32: GetShellWindow() not implemented.\n"));
2594
2595 return (0); /* default */
2596}
2597/***********************************************************************
2598 * RegisterTasklist32 [USER32.436]
2599 */
2600DWORD WIN32API RegisterTasklist (DWORD x)
2601{
2602 dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
2603 x));
2604
2605 return TRUE;
2606}
2607/***********************************************************************
2608 * SetLogonNotifyWindow (USER32.486)
2609 */
2610DWORD WIN32API SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd)
2611{
2612 dprintf(("USER32: SetLogonNotifyWindow - empty stub!"));
2613
2614 return 1;
2615}
2616
2617
2618DWORD WIN32API NotifyWinEvent(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4)
2619{
2620 dprintf(("USER32: NotifyWinEvent %x %x %x %x - empty stub!!", arg1, arg2, arg3, arg4));
2621
2622 return 0;
2623}
2624
2625DWORD WIN32API UnhookWinEvent(DWORD arg1)
2626{
2627 dprintf(("USER32: UnhookWinEvent %x - empty stub!!", arg1));
2628
2629 return 0;
2630}
2631
2632DWORD WIN32API SetWinEventHook(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7)
2633{
2634 dprintf(("USER32: SetWinEventHook %x %x %x %x %x %x %x - empty stub!!", arg1, arg2, arg3, arg4, arg5, arg6, arg7));
2635
2636 return 0;
2637}
2638
2639DWORD WIN32API GetGUIThreadInfo(DWORD arg1, DWORD arg2)
2640{
2641 dprintf(("USER32: GetGUIThreadInfo %x %x - empty stub!!", arg1, arg2));
2642
2643 return 0;
2644}
2645
Note: See TracBrowser for help on using the repository browser.