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

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

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