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

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

bugfixes + os/2 look support added
File size: 92.7 KB
Line 
1/* $Id: user32.cpp,v 1.99 2001-06-10 12:05:40 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
1429int WIN32API FillRect(HDC hDC, const RECT * lprc, HBRUSH hbr)
1430{
1431 dprintf(("USER32: FillRect %x (%d,%d)(%d,%d) brush %X", hDC, lprc->left, lprc->top, lprc->right, lprc->bottom, hbr));
1432 return O32_FillRect(hDC,lprc,hbr);
1433}
1434//******************************************************************************
1435//******************************************************************************
1436int WIN32API FrameRect( HDC hDC, const RECT * lprc, HBRUSH hbr)
1437{
1438 dprintf(("USER32: FrameRect %x (%d,%d)(%d,%d) brush %x", hDC, lprc->top, lprc->left, lprc->bottom, lprc->right, hbr));
1439 return O32_FrameRect(hDC,lprc,hbr);
1440}
1441//******************************************************************************
1442//******************************************************************************
1443BOOL WIN32API InvertRect( HDC hDC, const RECT * lprc)
1444{
1445 if(lprc) {
1446 dprintf(("USER32: InvertRect %x (%d,%d)(%d,%d)", hDC, lprc->left, lprc->top, lprc->right, lprc->bottom));
1447 }
1448 else dprintf(("USER32: InvertRect %x NULL", hDC));
1449 return O32_InvertRect(hDC,lprc);
1450}
1451
1452/* System Information Functions */
1453
1454/* Window Station and Desktop Functions */
1455
1456/*****************************************************************************
1457 * Name : HDESK WIN32API GetThreadDesktop
1458 * Purpose : The GetThreadDesktop function returns a handle to the desktop
1459 * associated with a specified thread.
1460 * Parameters: DWORD dwThreadId thread identifier
1461 * Variables :
1462 * Result : If the function succeeds, the return value is the handle of the
1463 * desktop associated with the specified thread.
1464 * Remark :
1465 * Status : UNTESTED STUB
1466 *
1467 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1468 *****************************************************************************/
1469HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
1470{
1471 dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
1472 dwThreadId));
1473
1474 return (NULL);
1475}
1476
1477/*****************************************************************************
1478 * Name : BOOL WIN32API CloseDesktop
1479 * Purpose : The CloseDesktop function closes an open handle of a desktop
1480 * object. A desktop is a secure object contained within a window
1481 * station object. A desktop has a logical display surface and
1482 * contains windows, menus and hooks.
1483 * Parameters: HDESK hDesktop
1484 * Variables :
1485 * Result : If the function succeeds, the return value is TRUE.
1486 * If the functions fails, the return value is FALSE. To get
1487 * extended error information, call GetLastError.
1488 * Remark :
1489 * Status : UNTESTED STUB
1490 *
1491 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1492 *****************************************************************************/
1493BOOL WIN32API CloseDesktop(HDESK hDesktop)
1494{
1495 dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
1496 hDesktop));
1497
1498 return (FALSE);
1499}
1500/*****************************************************************************
1501 * Name : BOOL WIN32API CloseWindowStation
1502 * Purpose : The CloseWindowStation function closes an open window station handle.
1503 * Parameters: HWINSTA hWinSta
1504 * Variables :
1505 * Result :
1506 * Remark : If the function succeeds, the return value is TRUE.
1507 * If the functions fails, the return value is FALSE. To get
1508 * extended error information, call GetLastError.
1509 * Status : UNTESTED STUB
1510 *
1511 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1512 *****************************************************************************/
1513BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
1514{
1515 dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
1516 hWinSta));
1517
1518 return (FALSE);
1519}
1520/*****************************************************************************
1521 * Name : HDESK WIN32API CreateDesktopA
1522 * Purpose : The CreateDesktop function creates a new desktop on the window
1523 * station associated with the calling process.
1524 * Parameters: LPCTSTR lpszDesktop name of the new desktop
1525 * LPCTSTR lpszDevice name of display device to assign to the desktop
1526 * LPDEVMODE pDevMode reserved; must be NULL
1527 * DWORD dwFlags flags to control interaction with other applications
1528 * DWORD dwDesiredAccess specifies access of returned handle
1529 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
1530 * Variables :
1531 * Result : If the function succeeds, the return value is a handle of the
1532 * newly created desktop.
1533 * If the function fails, the return value is NULL. To get extended
1534 * error information, call GetLastError.
1535 * Remark :
1536 * Status : UNTESTED STUB
1537 *
1538 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1539 *****************************************************************************/
1540HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
1541 LPCTSTR lpszDevice,
1542 LPDEVMODEA pDevMode,
1543 DWORD dwFlags,
1544 DWORD dwDesiredAccess,
1545 LPSECURITY_ATTRIBUTES lpsa)
1546{
1547 dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
1548 lpszDesktop,
1549 lpszDevice,
1550 pDevMode,
1551 dwFlags,
1552 dwDesiredAccess,
1553 lpsa));
1554
1555 return (NULL);
1556}
1557/*****************************************************************************
1558 * Name : HDESK WIN32API CreateDesktopW
1559 * Purpose : The CreateDesktop function creates a new desktop on the window
1560 * station associated with the calling process.
1561 * Parameters: LPCTSTR lpszDesktop name of the new desktop
1562 * LPCTSTR lpszDevice name of display device to assign to the desktop
1563 * LPDEVMODE pDevMode reserved; must be NULL
1564 * DWORD dwFlags flags to control interaction with other applications
1565 * DWORD dwDesiredAccess specifies access of returned handle
1566 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
1567 * Variables :
1568 * Result : If the function succeeds, the return value is a handle of the
1569 * newly created desktop.
1570 * If the function fails, the return value is NULL. To get extended
1571 * error information, call GetLastError.
1572 * Remark :
1573 * Status : UNTESTED STUB
1574 *
1575 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1576 *****************************************************************************/
1577HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
1578 LPCTSTR lpszDevice,
1579 LPDEVMODEW pDevMode,
1580 DWORD dwFlags,
1581 DWORD dwDesiredAccess,
1582 LPSECURITY_ATTRIBUTES lpsa)
1583{
1584 dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
1585 lpszDesktop,
1586 lpszDevice,
1587 pDevMode,
1588 dwFlags,
1589 dwDesiredAccess,
1590 lpsa));
1591
1592 return (NULL);
1593}
1594/*****************************************************************************
1595 * Name : HWINSTA WIN32API CreateWindowStationA
1596 * Purpose : The CreateWindowStation function creates a window station object.
1597 * It returns a handle that can be used to access the window station.
1598 * A window station is a secure object that contains a set of global
1599 * atoms, a clipboard, and a set of desktop objects.
1600 * Parameters: LPTSTR lpwinsta name of the new window station
1601 * DWORD dwReserved reserved; must be NULL
1602 * DWORD dwDesiredAccess specifies access of returned handle
1603 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
1604 * Variables :
1605 * Result : If the function succeeds, the return value is the handle to the
1606 * newly created window station.
1607 * If the function fails, the return value is NULL. To get extended
1608 * error information, call GetLastError.
1609 * Remark :
1610 * Status : UNTESTED STUB
1611 *
1612 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1613 *****************************************************************************/
1614HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
1615 DWORD dwReserved,
1616 DWORD dwDesiredAccess,
1617 LPSECURITY_ATTRIBUTES lpsa)
1618{
1619 dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
1620 lpWinSta,
1621 dwReserved,
1622 dwDesiredAccess,
1623 lpsa));
1624
1625 return (NULL);
1626}
1627/*****************************************************************************
1628 * Name : HWINSTA WIN32API CreateWindowStationW
1629 * Purpose : The CreateWindowStation function creates a window station object.
1630 * It returns a handle that can be used to access the window station.
1631 * A window station is a secure object that contains a set of global
1632 * atoms, a clipboard, and a set of desktop objects.
1633 * Parameters: LPTSTR lpwinsta name of the new window station
1634 * DWORD dwReserved reserved; must be NULL
1635 * DWORD dwDesiredAccess specifies access of returned handle
1636 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
1637 * Variables :
1638 * Result : If the function succeeds, the return value is the handle to the
1639 * newly created window station.
1640 * If the function fails, the return value is NULL. To get extended
1641 * error information, call GetLastError.
1642 * Remark :
1643 * Status : UNTESTED STUB
1644 *
1645 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1646 *****************************************************************************/
1647HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
1648 DWORD dwReserved,
1649 DWORD dwDesiredAccess,
1650 LPSECURITY_ATTRIBUTES lpsa)
1651{
1652 dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
1653 lpWinSta,
1654 dwReserved,
1655 dwDesiredAccess,
1656 lpsa));
1657
1658 return (NULL);
1659}
1660/*****************************************************************************
1661 * Name : BOOL WIN32API EnumDesktopWindows
1662 * Purpose : The EnumDesktopWindows function enumerates all windows in a
1663 * desktop by passing the handle of each window, in turn, to an
1664 * application-defined callback function.
1665 * Parameters: HDESK hDesktop handle of desktop to enumerate
1666 * WNDENUMPROC lpfn points to application's callback function
1667 * LPARAM lParam 32-bit value to pass to the callback function
1668 * Variables :
1669 * Result : If the function succeeds, the return value is TRUE.
1670 * If the function fails, the return value is FALSE. To get
1671 * extended error information, call GetLastError.
1672 * Remark :
1673 * Status : UNTESTED STUB
1674 *
1675 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1676 *****************************************************************************/
1677BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
1678 WNDENUMPROC lpfn,
1679 LPARAM lParam)
1680{
1681 dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
1682 hDesktop,
1683 lpfn,
1684 lParam));
1685
1686 return (FALSE);
1687}
1688/*****************************************************************************
1689 * Name : BOOL WIN32API EnumDesktopsA
1690 * Purpose : The EnumDesktops function enumerates all desktops in the window
1691 * station assigned to the calling process. The function does so by
1692 * passing the name of each desktop, in turn, to an application-
1693 * defined callback function.
1694 * Parameters: HWINSTA hwinsta handle of window station to enumerate
1695 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
1696 * LPARAM lParam 32-bit value to pass to the callback function
1697 * Variables :
1698 * Result : If the function succeeds, the return value is TRUE.
1699 * If the function fails, the return value is FALSE. To get extended
1700 * error information, call GetLastError.
1701 * Remark :
1702 * Status : UNTESTED STUB
1703 *
1704 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1705 *****************************************************************************/
1706BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
1707 DESKTOPENUMPROCA lpEnumFunc,
1708 LPARAM lParam)
1709{
1710 dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
1711 hWinSta,
1712 lpEnumFunc,
1713 lParam));
1714
1715 return (FALSE);
1716}
1717/*****************************************************************************
1718 * Name : BOOL WIN32API EnumDesktopsW
1719 * Purpose : The EnumDesktops function enumerates all desktops in the window
1720 * station assigned to the calling process. The function does so by
1721 * passing the name of each desktop, in turn, to an application-
1722 * defined callback function.
1723 * Parameters: HWINSTA hwinsta handle of window station to enumerate
1724 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
1725 * LPARAM lParam 32-bit value to pass to the callback function
1726 * Variables :
1727 * Result : If the function succeeds, the return value is TRUE.
1728 * If the function fails, the return value is FALSE. To get extended
1729 * error information, call GetLastError.
1730 * Remark :
1731 * Status : UNTESTED STUB
1732 *
1733 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1734 *****************************************************************************/
1735BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
1736 DESKTOPENUMPROCW lpEnumFunc,
1737 LPARAM lParam)
1738{
1739 dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
1740 hWinSta,
1741 lpEnumFunc,
1742 lParam));
1743
1744 return (FALSE);
1745}
1746/*****************************************************************************
1747 * Name : BOOL WIN32API EnumWindowStationsA
1748 * Purpose : The EnumWindowStations function enumerates all windowstations
1749 * in the system by passing the name of each window station, in
1750 * turn, to an application-defined callback function.
1751 * Parameters:
1752 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
1753 * LPARAM lParam 32-bit value to pass to the callback function
1754 * Result : If the function succeeds, the return value is TRUE.
1755 * If the function fails the return value is FALSE. To get extended
1756 * error information, call GetLastError.
1757 * Remark :
1758 * Status : UNTESTED STUB
1759 *
1760 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1761 *****************************************************************************/
1762BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
1763 LPARAM lParam)
1764{
1765 dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
1766 lpEnumFunc,
1767 lParam));
1768
1769 return (FALSE);
1770}
1771/*****************************************************************************
1772 * Name : BOOL WIN32API EnumWindowStationsW
1773 * Purpose : The EnumWindowStations function enumerates all windowstations
1774 * in the system by passing the name of each window station, in
1775 * turn, to an application-defined callback function.
1776 * Parameters:
1777 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
1778 * LPARAM lParam 32-bit value to pass to the callback function
1779 * Result : If the function succeeds, the return value is TRUE.
1780 * If the function fails the return value is FALSE. To get extended
1781 * error information, call GetLastError.
1782 * Remark :
1783 * Status : UNTESTED STUB
1784 *
1785 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1786 *****************************************************************************/
1787BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
1788 LPARAM lParam)
1789{
1790 dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
1791 lpEnumFunc,
1792 lParam));
1793
1794 return (FALSE);
1795}
1796/*****************************************************************************
1797 * Name : HWINSTA WIN32API GetProcessWindowStation
1798 * Purpose : The GetProcessWindowStation function returns a handle of the
1799 * window station associated with the calling process.
1800 * Parameters:
1801 * Variables :
1802 * Result : If the function succeeds, the return value is a handle of the
1803 * window station associated with the calling process.
1804 * If the function fails, the return value is NULL. This can occur
1805 * if the calling process is not an application written for Windows
1806 * NT. To get extended error information, call GetLastError.
1807 * Remark :
1808 * Status : UNTESTED STUB
1809 *
1810 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1811 *****************************************************************************/
1812HWINSTA WIN32API GetProcessWindowStation(VOID)
1813{
1814 dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
1815
1816 return (NULL);
1817}
1818/*****************************************************************************
1819 * Name : BOOL WIN32API GetUserObjectInformationA
1820 * Purpose : The GetUserObjectInformation function returns information about
1821 * a window station or desktop object.
1822 * Parameters: HANDLE hObj handle of object to get information for
1823 * int nIndex type of information to get
1824 * PVOID pvInfo points to buffer that receives the information
1825 * DWORD nLength size, in bytes, of pvInfo buffer
1826 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
1827 * Variables :
1828 * Result : If the function succeeds, the return value is TRUE.
1829 * If the function fails, the return value is FALSE. To get extended
1830 * error information, call GetLastError.
1831 * Remark :
1832 * Status : UNTESTED STUB
1833 *
1834 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1835 *****************************************************************************/
1836BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
1837 int nIndex,
1838 PVOID pvInfo,
1839 DWORD nLength,
1840 LPDWORD lpnLengthNeeded)
1841{
1842 dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1843 hObj,
1844 nIndex,
1845 pvInfo,
1846 nLength,
1847 lpnLengthNeeded));
1848
1849 return (FALSE);
1850}
1851/*****************************************************************************
1852 * Name : BOOL WIN32API GetUserObjectInformationW
1853 * Purpose : The GetUserObjectInformation function returns information about
1854 * a window station or desktop object.
1855 * Parameters: HANDLE hObj handle of object to get information for
1856 * int nIndex type of information to get
1857 * PVOID pvInfo points to buffer that receives the information
1858 * DWORD nLength size, in bytes, of pvInfo buffer
1859 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
1860 * Variables :
1861 * Result : If the function succeeds, the return value is TRUE.
1862 * If the function fails, the return value is FALSE. To get extended
1863 * error information, call GetLastError.
1864 * Remark :
1865 * Status : UNTESTED STUB
1866 *
1867 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1868 *****************************************************************************/
1869BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
1870 int nIndex,
1871 PVOID pvInfo,
1872 DWORD nLength,
1873 LPDWORD lpnLengthNeeded)
1874{
1875 dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1876 hObj,
1877 nIndex,
1878 pvInfo,
1879 nLength,
1880 lpnLengthNeeded));
1881
1882 return (FALSE);
1883}
1884/*****************************************************************************
1885 * Name : BOOL WIN32API GetUserObjectSecurity
1886 * Purpose : The GetUserObjectSecurity function retrieves security information
1887 * for the specified user object.
1888 * Parameters: HANDLE hObj handle of user object
1889 * SECURITY_INFORMATION * pSIRequested address of requested security information
1890 * LPSECURITY_DESCRIPTOR pSID address of security descriptor
1891 * DWORD nLength size of buffer for security descriptor
1892 * LPDWORD lpnLengthNeeded address of required size of buffer
1893 * Variables :
1894 * Result : If the function succeeds, the return value is TRUE.
1895 * If the function fails, the return value is FALSE. To get extended
1896 * error information, call GetLastError.
1897 * Remark :
1898 * Status : UNTESTED STUB
1899 *
1900 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1901 *****************************************************************************/
1902BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
1903 PSECURITY_INFORMATION pSIRequested,
1904 PSECURITY_DESCRIPTOR pSID,
1905 DWORD nLength,
1906 LPDWORD lpnLengthNeeded)
1907{
1908 dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1909 hObj,
1910 pSIRequested,
1911 pSID,
1912 nLength,
1913 lpnLengthNeeded));
1914
1915 return (FALSE);
1916}
1917/*****************************************************************************
1918 * Name : HDESK WIN32API OpenDesktopA
1919 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
1920 * A desktop is a secure object contained within a window station
1921 * object. A desktop has a logical display surface and contains
1922 * windows, menus and hooks.
1923 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
1924 * DWORD dwFlags flags to control interaction with other applications
1925 * BOOL fInherit specifies whether returned handle is inheritable
1926 * DWORD dwDesiredAccess specifies access of returned handle
1927 * Variables :
1928 * Result : If the function succeeds, the return value is the handle to the
1929 * opened desktop.
1930 * If the function fails, the return value is NULL. To get extended
1931 * error information, call GetLastError.
1932 * Remark :
1933 * Status : UNTESTED STUB
1934 *
1935 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1936 *****************************************************************************/
1937HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
1938 DWORD dwFlags,
1939 BOOL fInherit,
1940 DWORD dwDesiredAccess)
1941{
1942 dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
1943 lpszDesktopName,
1944 dwFlags,
1945 fInherit,
1946 dwDesiredAccess));
1947
1948 return (NULL);
1949}
1950/*****************************************************************************
1951 * Name : HDESK WIN32API OpenDesktopW
1952 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
1953 * A desktop is a secure object contained within a window station
1954 * object. A desktop has a logical display surface and contains
1955 * windows, menus and hooks.
1956 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
1957 * DWORD dwFlags flags to control interaction with other applications
1958 * BOOL fInherit specifies whether returned handle is inheritable
1959 * DWORD dwDesiredAccess specifies access of returned handle
1960 * Variables :
1961 * Result : If the function succeeds, the return value is the handle to the
1962 * opened desktop.
1963 * If the function fails, the return value is NULL. To get extended
1964 * error information, call GetLastError.
1965 * Remark :
1966 * Status : UNTESTED STUB
1967 *
1968 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1969 *****************************************************************************/
1970HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
1971 DWORD dwFlags,
1972 BOOL fInherit,
1973 DWORD dwDesiredAccess)
1974{
1975 dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
1976 lpszDesktopName,
1977 dwFlags,
1978 fInherit,
1979 dwDesiredAccess));
1980
1981 return (NULL);
1982}
1983/*****************************************************************************
1984 * Name : HDESK WIN32API OpenInputDesktop
1985 * Purpose : The OpenInputDesktop function returns a handle to the desktop
1986 * that receives user input. The input desktop is a desktop on the
1987 * window station associated with the logged-on user.
1988 * Parameters: DWORD dwFlags flags to control interaction with other applications
1989 * BOOL fInherit specifies whether returned handle is inheritable
1990 * DWORD dwDesiredAccess specifies access of returned handle
1991 * Variables :
1992 * Result : If the function succeeds, the return value is a handle of the
1993 * desktop that receives user input.
1994 * If the function fails, the return value is NULL. To get extended
1995 * error information, call GetLastError.
1996 * Remark :
1997 * Status : UNTESTED STUB
1998 *
1999 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2000 *****************************************************************************/
2001HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
2002 BOOL fInherit,
2003 DWORD dwDesiredAccess)
2004{
2005 dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
2006 dwFlags,
2007 fInherit,
2008 dwDesiredAccess));
2009
2010 return (NULL);
2011}
2012/*****************************************************************************
2013 * Name : HWINSTA WIN32API OpenWindowStationA
2014 * Purpose : The OpenWindowStation function returns a handle to an existing
2015 * window station.
2016 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
2017 * BOOL fInherit specifies whether returned handle is inheritable
2018 * DWORD dwDesiredAccess specifies access of returned handle
2019 * Variables :
2020 * Result : If the function succeeds, the return value is the handle to the
2021 * specified window station.
2022 * If the function fails, the return value is NULL. To get extended
2023 * error information, call GetLastError.
2024 * Remark :
2025 * Status : UNTESTED STUB
2026 *
2027 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2028 *****************************************************************************/
2029HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
2030 BOOL fInherit,
2031 DWORD dwDesiredAccess)
2032{
2033 dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
2034 lpszWinStaName,
2035 fInherit,
2036 dwDesiredAccess));
2037
2038 return (NULL);
2039}
2040/*****************************************************************************
2041 * Name : HWINSTA WIN32API OpenWindowStationW
2042 * Purpose : The OpenWindowStation function returns a handle to an existing
2043 * window station.
2044 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
2045 * BOOL fInherit specifies whether returned handle is inheritable
2046 * DWORD dwDesiredAccess specifies access of returned handle
2047 * Variables :
2048 * Result : If the function succeeds, the return value is the handle to the
2049 * specified window station.
2050 * If the function fails, the return value is NULL. To get extended
2051 * error information, call GetLastError.
2052
2053
2054 * Remark :
2055 * Status : UNTESTED STUB
2056 *
2057 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2058 *****************************************************************************/
2059HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
2060 BOOL fInherit,
2061 DWORD dwDesiredAccess)
2062{
2063 dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
2064 lpszWinStaName,
2065 fInherit,
2066 dwDesiredAccess));
2067
2068 return (NULL);
2069}
2070/*****************************************************************************
2071 * Name : BOOL WIN32API SetProcessWindowStation
2072 * Purpose : The SetProcessWindowStation function assigns a window station
2073 * to the calling process. This enables the process to access
2074 * objects in the window station such as desktops, the clipboard,
2075 * and global atoms. All subsequent operations on the window station
2076 * use the access rights granted to hWinSta.
2077 * Parameters:
2078 * Variables :
2079 * Result : If the function succeeds, the return value is TRUE.
2080 * If the function fails, the return value is FALSE. To get extended
2081 * error information, call GetLastError.
2082 * Remark :
2083 * Status : UNTESTED STUB
2084 *
2085 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2086 *****************************************************************************/
2087BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
2088{
2089 dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
2090 hWinSta));
2091
2092 return (FALSE);
2093}
2094/*****************************************************************************
2095 * Name : BOOL WIN32API SetThreadDesktop
2096 * Purpose : The SetThreadDesktop function assigns a desktop to the calling
2097 * thread. All subsequent operations on the desktop use the access
2098 * rights granted to hDesk.
2099 * Parameters: HDESK hDesk handle of the desktop to assign to this thread
2100 * Variables :
2101 * Result : If the function succeeds, the return value is TRUE.
2102 * If the function fails, the return value is FALSE. To get extended
2103 * error information, call GetLastError.
2104 * Remark :
2105 * Status : UNTESTED STUB
2106 *
2107 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2108 *****************************************************************************/
2109BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
2110{
2111 dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
2112 hDesktop));
2113
2114 return (FALSE);
2115}
2116/*****************************************************************************
2117 * Name : BOOL WIN32API SetUserObjectInformationA
2118 * Purpose : The SetUserObjectInformation function sets information about a
2119 * window station or desktop object.
2120 * Parameters: HANDLE hObject handle of the object for which to set information
2121 * int nIndex type of information to set
2122 * PVOID lpvInfo points to a buffer that contains the information
2123 * DWORD cbInfo size, in bytes, of lpvInfo buffer
2124 * Variables :
2125 * Result : If the function succeeds, the return value is TRUE.
2126 * If the function fails the return value is FALSE. To get extended
2127 * error information, call GetLastError.
2128 * Remark :
2129 * Status : UNTESTED STUB
2130 *
2131 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2132 *****************************************************************************/
2133BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
2134 int nIndex,
2135 PVOID lpvInfo,
2136 DWORD cbInfo)
2137{
2138 dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
2139 hObject,
2140 nIndex,
2141 lpvInfo,
2142 cbInfo));
2143
2144 return (FALSE);
2145}
2146/*****************************************************************************
2147 * Name : BOOL WIN32API SetUserObjectInformationW
2148 * Purpose : The SetUserObjectInformation function sets information about a
2149 * window station or desktop object.
2150 * Parameters: HANDLE hObject handle of the object for which to set information
2151 * int nIndex type of information to set
2152 * PVOID lpvInfo points to a buffer that contains the information
2153 * DWORD cbInfo size, in bytes, of lpvInfo buffer
2154 * Variables :
2155 * Result : If the function succeeds, the return value is TRUE.
2156 * If the function fails the return value is FALSE. To get extended
2157 * error information, call GetLastError.
2158 * Remark :
2159 * Status : UNTESTED STUB
2160 *
2161 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2162 *****************************************************************************/
2163BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
2164 int nIndex,
2165 PVOID lpvInfo,
2166 DWORD cbInfo)
2167{
2168 dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
2169 hObject,
2170 nIndex,
2171 lpvInfo,
2172 cbInfo));
2173
2174 return (FALSE);
2175}
2176/*****************************************************************************
2177 * Name : BOOL WIN32API SetUserObjectSecurity
2178 * Purpose : The SetUserObjectSecurity function sets the security of a user
2179 * object. This can be, for example, a window or a DDE conversation
2180 * Parameters: HANDLE hObject handle of user object
2181 * SECURITY_INFORMATION * psi address of security information
2182 * LPSECURITY_DESCRIPTOR psd address of security descriptor
2183 * Variables :
2184 * Result : If the function succeeds, the return value is TRUE.
2185 * If the function fails, the return value is FALSE. To get extended
2186 * error information, call GetLastError.
2187 * Remark :
2188 * Status : UNTESTED STUB
2189 *
2190 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2191 *****************************************************************************/
2192BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
2193 PSECURITY_INFORMATION psi,
2194 PSECURITY_DESCRIPTOR psd)
2195{
2196 dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
2197 hObject,
2198 psi,
2199 psd));
2200
2201 return (FALSE);
2202}
2203/*****************************************************************************
2204 * Name : BOOL WIN32API SwitchDesktop
2205 * Purpose : The SwitchDesktop function makes a desktop visible and activates
2206 * it. This enables the desktop to receive input from the user. The
2207 * calling process must have DESKTOP_SWITCHDESKTOP access to the
2208 * desktop for the SwitchDesktop function to succeed.
2209 * Parameters:
2210 * Variables :
2211 * Result : If the function succeeds, the return value is TRUE.
2212 * If the function fails, the return value is FALSE. To get extended
2213 * error information, call GetLastError.
2214 * Remark :
2215 * Status : UNTESTED STUB
2216 *
2217 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2218 *****************************************************************************/
2219BOOL WIN32API SwitchDesktop(HDESK hDesktop)
2220{
2221 dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
2222 hDesktop));
2223
2224 return (FALSE);
2225}
2226
2227/* Debugging Functions */
2228
2229/*****************************************************************************
2230 * Name : VOID WIN32API SetDebugErrorLevel
2231 * Purpose : The SetDebugErrorLevel function sets the minimum error level at
2232 * which Windows will generate debugging events and pass them to a debugger.
2233 * Parameters: DWORD dwLevel debugging error level
2234 * Variables :
2235 * Result :
2236 * Remark :
2237 * Status : UNTESTED STUB
2238 *
2239 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2240 *****************************************************************************/
2241VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
2242{
2243 dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
2244 dwLevel));
2245}
2246
2247/* Drag'n'drop */
2248
2249/*****************************************************************************
2250 * Name : BOOL WIN32API DragObject
2251 * Purpose : Unknown
2252 * Parameters: Unknown
2253 * Variables :
2254 * Result :
2255 * Remark :
2256 * Status : UNTESTED UNKNOWN STUB
2257 *
2258 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2259 *****************************************************************************/
2260DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
2261{
2262 dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2263 x1,
2264 x2,
2265 x3,
2266 x4,
2267 x5));
2268
2269 return (FALSE); /* default */
2270}
2271
2272/* Unknown */
2273
2274/*****************************************************************************
2275 * Name : BOOL WIN32API SetShellWindow
2276 * Purpose : Unknown
2277 * Parameters: Unknown
2278 * Variables :
2279 * Result :
2280 * Remark :
2281 * Status : UNTESTED UNKNOWN STUB
2282 *
2283 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2284 *****************************************************************************/
2285BOOL WIN32API SetShellWindow(DWORD x1)
2286{
2287 dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
2288 x1));
2289
2290 return (FALSE); /* default */
2291}
2292/*****************************************************************************
2293 * Name : BOOL WIN32API PlaySoundEvent
2294 * Purpose : Unknown
2295 * Parameters: Unknown
2296 * Variables :
2297 * Result :
2298 * Remark :
2299 * Status : UNTESTED UNKNOWN STUB
2300 *
2301 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2302 *****************************************************************************/
2303BOOL WIN32API PlaySoundEvent(DWORD x1)
2304{
2305 dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
2306 x1));
2307
2308 return (FALSE); /* default */
2309}
2310/*****************************************************************************
2311 * Name : BOOL WIN32API SetSysColorsTemp
2312 * Purpose : Unknown
2313 * Parameters: Unknown
2314 * Variables :
2315 * Result :
2316 * Remark :
2317 * Status : UNTESTED UNKNOWN STUB
2318 *
2319 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2320 *****************************************************************************/
2321BOOL WIN32API SetSysColorsTemp(void)
2322{
2323 dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
2324
2325 return (FALSE); /* default */
2326}
2327/*****************************************************************************
2328 * Name : BOOL WIN32API RegisterNetworkCapabilities
2329 * Purpose : Unknown
2330 * Parameters: Unknown
2331 * Variables :
2332 * Result :
2333 * Remark :
2334 * Status : UNTESTED UNKNOWN STUB
2335 *
2336 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2337 *****************************************************************************/
2338BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
2339 DWORD x2)
2340{
2341 dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
2342 x1,
2343 x2));
2344
2345 return (FALSE); /* default */
2346}
2347/*****************************************************************************
2348 * Name : BOOL WIN32API EndTask
2349 * Purpose : Unknown
2350 * Parameters: Unknown
2351 * Variables :
2352 * Result :
2353 * Remark :
2354 * Status : UNTESTED UNKNOWN STUB
2355 *
2356 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2357 *****************************************************************************/
2358BOOL WIN32API EndTask(DWORD x1,
2359 DWORD x2,
2360 DWORD x3)
2361{
2362 dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
2363 x1,
2364 x2,
2365 x3));
2366
2367 return (FALSE); /* default */
2368}
2369/*****************************************************************************
2370 * Name : BOOL WIN32API GetNextQueueWindow
2371 * Purpose : Unknown
2372 * Parameters: Unknown
2373 * Variables :
2374 * Result :
2375 * Remark :
2376 * Status : UNTESTED UNKNOWN STUB
2377 *
2378 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2379 *****************************************************************************/
2380BOOL WIN32API GetNextQueueWindow(DWORD x1,
2381 DWORD x2)
2382{
2383 dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
2384 x1,
2385 x2));
2386
2387 return (FALSE); /* default */
2388}
2389/*****************************************************************************
2390 * Name : BOOL WIN32API YieldTask
2391 * Purpose : Unknown
2392 * Parameters: Unknown
2393 * Variables :
2394 * Result :
2395 * Remark :
2396 * Status : UNTESTED UNKNOWN STUB
2397 *
2398 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2399 *****************************************************************************/
2400BOOL WIN32API YieldTask(void)
2401{
2402 dprintf(("USER32: YieldTask() not implemented.\n"));
2403
2404 return (FALSE); /* default */
2405}
2406/*****************************************************************************
2407 * Name : BOOL WIN32API WinOldAppHackoMatic
2408 * Purpose : Unknown
2409 * Parameters: Unknown
2410 * Variables :
2411 * Result :
2412 * Remark :
2413 * Status : UNTESTED UNKNOWN STUB
2414 *
2415 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2416 *****************************************************************************/
2417BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
2418{
2419 dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
2420 x1));
2421
2422 return (FALSE); /* default */
2423}
2424/*****************************************************************************
2425 * Name : BOOL WIN32API RegisterSystemThread
2426 * Purpose : Unknown
2427 * Parameters: Unknown
2428 * Variables :
2429 * Result :
2430 * Remark :
2431 * Status : UNTESTED UNKNOWN STUB
2432 *
2433 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2434 *****************************************************************************/
2435BOOL WIN32API RegisterSystemThread(DWORD x1,
2436 DWORD x2)
2437{
2438 dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
2439 x1,
2440 x2));
2441
2442 return (FALSE); /* default */
2443}
2444/*****************************************************************************
2445 * Name : BOOL WIN32API IsHungThread
2446 * Purpose : Unknown
2447 * Parameters: Unknown
2448 * Variables :
2449 * Result :
2450 * Remark :
2451 * Status : UNTESTED UNKNOWN STUB
2452 *
2453 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2454 *****************************************************************************/
2455BOOL WIN32API IsHungThread(DWORD x1)
2456{
2457 dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
2458 x1));
2459
2460 return (FALSE); /* default */
2461}
2462/*****************************************************************************
2463 * Name : BOOL WIN32API UserSignalProc
2464 * Purpose : Unknown
2465 * Parameters: Unknown
2466 * Variables :
2467 * Result :
2468 * Remark :
2469 * Status : UNTESTED UNKNOWN STUB
2470 *
2471 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2472 *****************************************************************************/
2473BOOL WIN32API UserSignalProc(DWORD x1,
2474 DWORD x2,
2475 DWORD x3,
2476 DWORD x4)
2477{
2478 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2479 x1,
2480 x2,
2481 x3,
2482 x4));
2483
2484 return (FALSE); /* default */
2485}
2486/*****************************************************************************
2487 * Name : BOOL WIN32API GetShellWindow
2488 * Purpose : Unknown
2489 * Parameters: Unknown
2490 * Variables :
2491 * Result :
2492 * Remark :
2493 * Status : UNTESTED UNKNOWN STUB
2494 *
2495 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2496 *****************************************************************************/
2497HWND WIN32API GetShellWindow(void)
2498{
2499 dprintf(("USER32: GetShellWindow() not implemented.\n"));
2500
2501 return (0); /* default */
2502}
2503/***********************************************************************
2504 * RegisterTasklist32 [USER32.436]
2505 */
2506DWORD WIN32API RegisterTasklist (DWORD x)
2507{
2508 dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
2509 x));
2510
2511 return TRUE;
2512}
2513/***********************************************************************
2514 * SetLogonNotifyWindow (USER32.486)
2515 */
2516DWORD WIN32API SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd)
2517{
2518 dprintf(("USER32: SetLogonNotifyWindow - empty stub!"));
2519
2520 return 1;
2521}
2522
2523
2524DWORD WIN32API NotifyWinEvent(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4)
2525{
2526 dprintf(("USER32: NotifyWinEvent %x %x %x %x - empty stub!!", arg1, arg2, arg3, arg4));
2527
2528 return 0;
2529}
2530
2531DWORD WIN32API UnhookWinEvent(DWORD arg1)
2532{
2533 dprintf(("USER32: UnhookWinEvent %x - empty stub!!", arg1));
2534
2535 return 0;
2536}
2537
2538DWORD WIN32API SetWinEventHook(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7)
2539{
2540 dprintf(("USER32: SetWinEventHook %x %x %x %x %x %x %x - empty stub!!", arg1, arg2, arg3, arg4, arg5, arg6, arg7));
2541
2542 return 0;
2543}
2544
2545DWORD WIN32API GetGUIThreadInfo(DWORD arg1, DWORD arg2)
2546{
2547 dprintf(("USER32: GetGUIThreadInfo %x %x - empty stub!!", arg1, arg2));
2548
2549 return 0;
2550}
2551
Note: See TracBrowser for help on using the repository browser.