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

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

OS/2 looks changes + fixes
File size: 93.3 KB
Line 
1/* $Id: user32.cpp,v 1.101 2001-06-13 10:29:45 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
636 case SPI_GETNONCLIENTMETRICS:
637 {
638 LPNONCLIENTMETRICSA lpnm = (LPNONCLIENTMETRICSA)pvParam;
639
640 if (lpnm->cbSize == sizeof(NONCLIENTMETRICSA))
641 {
642 memset(lpnm, 0, sizeof(NONCLIENTMETRICSA));
643 lpnm->cbSize = sizeof(NONCLIENTMETRICSA);
644
645 SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfCaptionFont),0);
646 lpnm->lfCaptionFont.lfWeight = FW_BOLD;
647 lpnm->iCaptionWidth = 32; //TODO
648 lpnm->iCaptionHeight = 32; //TODO
649
650 SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfSmCaptionFont),0);
651 lpnm->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
652 lpnm->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
653
654 LPLOGFONTA lpLogFont = &(lpnm->lfMenuFont);
655 if(fOS2Look) {
656 GetProfileStringA("Desktop", "MenuFont", "WarpSans",
657 lpLogFont->lfFaceName, LF_FACESIZE);
658 lpLogFont->lfWeight = FW_BOLD;
659 lpLogFont->lfHeight = -GetProfileIntA("Desktop","MenuFontSize", 16);
660 lpLogFont->lfWidth = 0;
661 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
662 }
663 else {
664 GetProfileStringA("Desktop", "MenuFont", "MS Sans Serif",
665 lpLogFont->lfFaceName, LF_FACESIZE);
666 lpLogFont->lfWeight = FW_NORMAL;
667 lpLogFont->lfHeight = -GetProfileIntA("Desktop","MenuFontSize", 13);
668 lpLogFont->lfWidth = 0;
669 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
670 }
671 lpLogFont->lfItalic = FALSE;
672 lpLogFont->lfStrikeOut = FALSE;
673 lpLogFont->lfUnderline = FALSE;
674 lpLogFont->lfCharSet = ANSI_CHARSET;
675 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
676 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
677 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
678
679 SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0,
680 (LPVOID)&(lpnm->lfStatusFont),0);
681 SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0,
682 (LPVOID)&(lpnm->lfMessageFont),0);
683
684 lpnm->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
685 lpnm->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
686 lpnm->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
687 lpnm->iMenuHeight = GetSystemMetrics(SM_CYMENU);
688 lpnm->iMenuWidth = lpnm->iMenuHeight; //TODO
689 }
690 else
691 {
692 dprintf(("SPI_GETNONCLIENTMETRICS: size mismatch !! (is %d; should be %d)\n", lpnm->cbSize, sizeof(NONCLIENTMETRICSA)));
693 /* FIXME: SetLastError? */
694 rc = FALSE;
695 }
696 break;
697 }
698
699 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
700 {
701 LPICONMETRICSA lpIcon = (LPICONMETRICSA)pvParam;
702 if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
703 {
704 SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0,
705 &lpIcon->iHorzSpacing, FALSE );
706 SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0,
707 &lpIcon->iVertSpacing, FALSE );
708 SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0,
709 &lpIcon->iTitleWrap, FALSE );
710 SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0,
711 &lpIcon->lfFont, FALSE );
712 }
713 else
714 {
715 dprintf(("SPI_GETICONMETRICS: size mismatch !! (is %d; should be %d)\n", lpIcon->cbSize, sizeof(ICONMETRICSA)));
716 /* FIXME: SetLastError? */
717 rc = FALSE;
718 }
719 break;
720 }
721
722 case SPI_GETICONTITLELOGFONT:
723 {
724 LPLOGFONTA lpLogFont = (LPLOGFONTA)pvParam;
725
726 /* from now on we always have an alias for MS Sans Serif */
727 strcpy(lpLogFont->lfFaceName, "MS Sans Serif");
728 lpLogFont->lfHeight = -GetProfileIntA("Desktop","IconTitleSize", /*8*/12); //CB: 8 is too small
729 lpLogFont->lfWidth = 0;
730 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
731 lpLogFont->lfWeight = FW_NORMAL;
732 lpLogFont->lfItalic = FALSE;
733 lpLogFont->lfStrikeOut = FALSE;
734 lpLogFont->lfUnderline = FALSE;
735 lpLogFont->lfCharSet = ANSI_CHARSET;
736 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
737 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
738 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
739 break;
740 }
741 case SPI_GETBORDER:
742 *(INT *)pvParam = GetSystemMetrics( SM_CXFRAME );
743 break;
744
745 case SPI_GETWORKAREA:
746 SetRect( (RECT *)pvParam, 0, 0,
747 GetSystemMetrics( SM_CXSCREEN ),
748 GetSystemMetrics( SM_CYSCREEN )
749 );
750 break;
751
752 case SPI_GETWHEELSCROLLLINES: //TODO: Undocumented
753 rc = 16;
754 break;
755
756 default:
757 rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
758 break;
759 }
760 dprintf(("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc));
761 return(rc);
762}
763//******************************************************************************
764//TODO: Check for more options that have different structs for Unicode!!!!
765//******************************************************************************
766BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
767{
768 BOOL rc = TRUE;
769 NONCLIENTMETRICSW *clientMetricsW = (NONCLIENTMETRICSW *)pvParam;
770 NONCLIENTMETRICSA clientMetricsA = {0};
771 PVOID pvParamA;
772 UINT uiParamA;
773
774 switch(uiAction) {
775 case SPI_SETNONCLIENTMETRICS:
776 clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
777 clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
778 clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
779 clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
780 clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
781 clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
782 ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
783 clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
784 clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
785 ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
786 clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
787 clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
788 ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
789 ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
790 ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
791 //no break
792 case SPI_GETNONCLIENTMETRICS:
793 uiParamA = sizeof(NONCLIENTMETRICSA);
794 pvParamA = &clientMetricsA;
795 break;
796
797 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
798 {
799 LPICONMETRICSW lpIcon = (LPICONMETRICSW)pvParam;
800 if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
801 {
802 SystemParametersInfoW( SPI_ICONHORIZONTALSPACING, 0,
803 &lpIcon->iHorzSpacing, FALSE );
804 SystemParametersInfoW( SPI_ICONVERTICALSPACING, 0,
805 &lpIcon->iVertSpacing, FALSE );
806 SystemParametersInfoW( SPI_GETICONTITLEWRAP, 0,
807 &lpIcon->iTitleWrap, FALSE );
808 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0,
809 &lpIcon->lfFont, FALSE );
810 return TRUE;
811 }
812 else
813 {
814 dprintf(("SPI_GETICONMETRICS: size mismatch !! (is %d; should be %d)\n", lpIcon->cbSize, sizeof(ICONMETRICSA)));
815 /* FIXME: SetLastError? */
816 return FALSE;
817 }
818 }
819
820 case SPI_GETICONTITLELOGFONT:
821 {
822 LPLOGFONTW lpLogFont = (LPLOGFONTW)pvParam;
823
824 /* from now on we always have an alias for MS Sans Serif */
825 lstrcpyW(lpLogFont->lfFaceName, (LPCWSTR)L"MS Sans Serif");
826 lpLogFont->lfHeight = -GetProfileIntA("Desktop","IconTitleSize", /*8*/12); //CB: 8 is too small
827 lpLogFont->lfWidth = 0;
828 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
829 lpLogFont->lfWeight = FW_NORMAL;
830 lpLogFont->lfItalic = FALSE;
831 lpLogFont->lfStrikeOut = FALSE;
832 lpLogFont->lfUnderline = FALSE;
833 lpLogFont->lfCharSet = ANSI_CHARSET;
834 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
835 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
836 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
837 return TRUE;
838 }
839 default:
840 pvParamA = pvParam;
841 uiParamA = uiParam;
842 break;
843 }
844 rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
845
846 switch(uiAction) {
847 case SPI_GETNONCLIENTMETRICS:
848 clientMetricsW->cbSize = sizeof(*clientMetricsW);
849 clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
850 clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
851 clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
852 clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
853 clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
854 ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
855
856 clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
857 clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
858 ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
859
860 clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
861 clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
862 ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
863 ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
864 ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
865 break;
866 }
867 dprintf(("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc));
868 return(rc);
869}
870
871/* Process and Thread Functions */
872
873//******************************************************************************
874//DWORD idAttach; /* thread to attach */
875//DWORD idAttachTo; /* thread to attach to */
876//BOOL fAttach; /* attach or detach */
877//******************************************************************************
878BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
879{
880 dprintf(("USER32: AttachThreadInput, not implemented\n"));
881 return(TRUE);
882}
883//******************************************************************************
884//******************************************************************************
885DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
886{
887 dprintf(("USER32: WaitForInputIdle %x %d\n", hProcess, dwTimeOut));
888
889 return O32_WaitForInputIdle(hProcess, dwTimeOut);
890}
891
892/* Help Functions */
893
894BOOL WIN32API WinHelpA( HWND hwnd, LPCSTR lpszHelp, UINT uCommand, DWORD dwData)
895{
896 static WORD WM_WINHELP = 0;
897 HWND hDest;
898 LPWINHELP lpwh;
899 HGLOBAL hwh;
900 HINSTANCE winhelp;
901 int size,dsize,nlen;
902
903 dprintf(("USER32: WinHelpA %s\n", lpszHelp));
904
905 if(!WM_WINHELP)
906 {
907 WM_WINHELP=RegisterWindowMessageA("WM_WINHELP");
908 if(!WM_WINHELP)
909 return FALSE;
910 }
911
912 hDest = FindWindowA( "MS_WINHELP", NULL );
913 if(!hDest)
914 {
915 if(uCommand == HELP_QUIT)
916 return TRUE;
917 else
918 winhelp = WinExec ( "winhlp32.exe -x", SW_SHOWNORMAL );
919 if ( winhelp <= 32 ) return FALSE;
920 if ( ! ( hDest = FindWindowA ( "MS_WINHELP", NULL ) )) return FALSE;
921 }
922
923 switch(uCommand)
924 {
925 case HELP_CONTEXT:
926 case HELP_SETCONTENTS:
927 case HELP_CONTENTS:
928 case HELP_CONTEXTPOPUP:
929 case HELP_FORCEFILE:
930 case HELP_HELPONHELP:
931 case HELP_FINDER:
932 case HELP_QUIT:
933 dsize=0;
934 break;
935
936 case HELP_KEY:
937 case HELP_PARTIALKEY:
938 case HELP_COMMAND:
939 dsize = strlen( (LPSTR)dwData )+1;
940 break;
941
942 case HELP_MULTIKEY:
943 dsize = ((LPMULTIKEYHELP)dwData)->mkSize;
944 break;
945
946 case HELP_SETWINPOS:
947 dsize = ((LPHELPWININFO)dwData)->wStructSize;
948 break;
949
950 default:
951 //WARN("Unknown help command %d\n",wCommand);
952 return FALSE;
953 }
954 if(lpszHelp)
955 nlen = strlen(lpszHelp)+1;
956 else
957 nlen = 0;
958 size = sizeof(WINHELP) + nlen + dsize;
959 hwh = GlobalAlloc(0,size);
960 lpwh = (WINHELP*)GlobalLock(hwh);
961 lpwh->size = size;
962 lpwh->command = uCommand;
963 lpwh->data = dwData;
964 if(nlen)
965 {
966 strcpy(((char*)lpwh) + sizeof(WINHELP),lpszHelp);
967 lpwh->ofsFilename = sizeof(WINHELP);
968 } else
969 lpwh->ofsFilename = 0;
970 if(dsize)
971 {
972 memcpy(((char*)lpwh)+sizeof(WINHELP)+nlen,(LPSTR)dwData,dsize);
973 lpwh->ofsData = sizeof(WINHELP)+nlen;
974 } else
975 lpwh->ofsData = 0;
976 GlobalUnlock(hwh);
977
978 return SendMessageA(hDest,WM_WINHELP,hwnd,hwh);
979}
980//******************************************************************************
981//******************************************************************************
982BOOL WIN32API WinHelpW( HWND hwnd, LPCWSTR lpszHelp, UINT uCommand, DWORD dwData)
983{
984 char *astring = UnicodeToAsciiString((LPWSTR)lpszHelp);
985 BOOL rc;
986
987 dprintf(("USER32: WinHelpW\n"));
988
989 rc = WinHelpA(hwnd,astring,uCommand,dwData);
990 FreeAsciiString(astring);
991
992 return rc;
993}
994
995/* Keyboard and Input Functions */
996
997BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
998{
999 dprintf(("USER32: ActivateKeyboardLayout, not implemented\n"));
1000 return(TRUE);
1001}
1002/*****************************************************************************
1003 * Name : UINT WIN32API GetKBCodePage
1004 * Purpose : The GetKBCodePage function is provided for compatibility with
1005 * earlier versions of Windows. In the Win32 application programming
1006 * interface (API) it just calls the GetOEMCP function.
1007 * Parameters:
1008 * Variables :
1009 * Result : If the function succeeds, the return value is an OEM code-page
1010 * identifier, or it is the default identifier if the registry
1011 * value is not readable. For a list of OEM code-page identifiers,
1012 * see GetOEMCP.
1013 * Remark :
1014 * Status : COMPLETELY IMPLEMENTED UNTESTED
1015 *
1016 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1017 *****************************************************************************/
1018
1019UINT WIN32API GetKBCodePage(VOID)
1020{
1021 return (GetOEMCP());
1022}
1023//******************************************************************************
1024//******************************************************************************
1025int WIN32API GetKeyNameTextA( LPARAM lParam, LPSTR lpString, int nSize)
1026{
1027 dprintf(("USER32: GetKeyNameTextA\n"));
1028 return O32_GetKeyNameText(lParam,lpString,nSize);
1029}
1030//******************************************************************************
1031//******************************************************************************
1032int WIN32API GetKeyNameTextW( LPARAM lParam, LPWSTR lpString, int nSize)
1033{
1034 dprintf(("USER32: GetKeyNameTextW DOES NOT WORK\n"));
1035 // NOTE: This will not work as is (needs UNICODE support)
1036 return 0;
1037// return O32_GetKeyNameText(arg1, arg2, arg3);
1038}
1039//******************************************************************************
1040//******************************************************************************
1041SHORT WIN32API GetKeyState( int nVirtKey)
1042{
1043 dprintf2(("USER32: GetKeyState %x", nVirtKey));
1044 return O32_GetKeyState(nVirtKey);
1045}
1046//******************************************************************************
1047//******************************************************************************
1048WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1049{
1050 dprintf2(("USER32: GetAsyncKeyState %x", nVirtKey));
1051 return O32_GetAsyncKeyState(nVirtKey);
1052}
1053
1054/*****************************************************************************
1055 * Name : VOID WIN32API keybd_event
1056 * Purpose : The keybd_event function synthesizes a keystroke. The system
1057 * can use such a synthesized keystroke to generate a WM_KEYUP or
1058 * WM_KEYDOWN message. The keyboard driver's interrupt handler calls
1059 * the keybd_event function.
1060 * Parameters: BYTE bVk virtual-key code
1061
1062 * BYTE bScan hardware scan code
1063 * DWORD dwFlags flags specifying various function options
1064 * DWORD dwExtraInfo additional data associated with keystroke
1065 * Variables :
1066 * Result :
1067 * Remark :
1068 * Status : UNTESTED STUB
1069 *
1070 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1071 *****************************************************************************/
1072VOID WIN32API keybd_event (BYTE bVk,
1073 BYTE bScan,
1074 DWORD dwFlags,
1075 DWORD dwExtraInfo)
1076{
1077 dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
1078 bVk,
1079 bScan,
1080 dwFlags,
1081 dwExtraInfo));
1082}
1083/*****************************************************************************
1084 * Name : HLK WIN32API LoadKeyboardLayoutA
1085 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
1086 * the system. Several keyboard layouts can be loaded at a time, but
1087 * only one per process is active at a time. Loading multiple keyboard
1088 * layouts makes it possible to rapidly switch between layouts.
1089 * Parameters:
1090 * Variables :
1091 * Result : If the function succeeds, the return value is the handle of the
1092 * keyboard layout.
1093 * If the function fails, the return value is NULL. To get extended
1094 * error information, call GetLastError.
1095 * Remark :
1096 * Status : UNTESTED STUB
1097 *
1098 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1099 *****************************************************************************/
1100HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
1101 UINT Flags)
1102{
1103 dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
1104 pwszKLID,
1105 Flags));
1106
1107 return (NULL);
1108}
1109/*****************************************************************************
1110 * Name : HLK WIN32API LoadKeyboardLayoutW
1111 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
1112 * the system. Several keyboard layouts can be loaded at a time, but
1113 * only one per process is active at a time. Loading multiple keyboard
1114 * layouts makes it possible to rapidly switch between layouts.
1115 * Parameters:
1116 * Variables :
1117 * Result : If the function succeeds, the return value is the handle of the
1118 * keyboard layout.
1119 * If the function fails, the return value is NULL. To get extended
1120 * error information, call GetLastError.
1121 * Remark :
1122 * Status : UNTESTED STUB
1123 *
1124 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1125 *****************************************************************************/
1126HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
1127 UINT Flags)
1128{
1129 dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
1130 pwszKLID,
1131 Flags));
1132
1133 return (NULL);
1134}
1135//******************************************************************************
1136//******************************************************************************
1137UINT WIN32API MapVirtualKeyA( UINT uCode, UINT uMapType)
1138{
1139 dprintf(("USER32: MapVirtualKeyA\n"));
1140 /* A quick fix for Commandos, very incomplete */
1141 switch (uMapType) {
1142 case 2:
1143 if (uCode >= VK_A && uCode <= VK_Z) {
1144 return 'A' + uCode - VK_A;
1145 }
1146 break;
1147 }
1148 return O32_MapVirtualKey(uCode,uMapType);
1149}
1150//******************************************************************************
1151//******************************************************************************
1152UINT WIN32API MapVirtualKeyW( UINT uCode, UINT uMapType)
1153{
1154 dprintf(("USER32: MapVirtualKeyW\n"));
1155 // NOTE: This will not work as is (needs UNICODE support)
1156 return O32_MapVirtualKey(uCode,uMapType);
1157}
1158/*****************************************************************************
1159 * Name : UINT WIN32API MapVirtualKeyExA
1160 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
1161 * code into a scan code or character value, or translates a scan
1162 * code into a virtual-key code. The function translates the codes
1163 * using the input language and physical keyboard layout identified
1164 * by the given keyboard layout handle.
1165 * Parameters:
1166 * Variables :
1167 * Result : The return value is either a scan code, a virtual-key code, or
1168 * a character value, depending on the value of uCode and uMapType.
1169 * If there is no translation, the return value is zero.
1170 * Remark :
1171 * Status : UNTESTED STUB
1172 *
1173 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1174 *****************************************************************************/
1175UINT WIN32API MapVirtualKeyExA(UINT uCode,
1176 UINT uMapType,
1177 HKL dwhkl)
1178{
1179 dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
1180 uCode,
1181 uMapType,
1182 dwhkl));
1183
1184 return (0);
1185}
1186/*****************************************************************************
1187 * Name : UINT WIN32API MapVirtualKeyExW
1188 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
1189 * code into a scan code or character value, or translates a scan
1190 * code into a virtual-key code. The function translates the codes
1191 * using the input language and physical keyboard layout identified
1192 * by the given keyboard layout handle.
1193 * Parameters:
1194 * Variables :
1195 * Result : The return value is either a scan code, a virtual-key code, or
1196 * a character value, depending on the value of uCode and uMapType.
1197 * If there is no translation, the return value is zero.
1198 * Remark :
1199 * Status : UNTESTED STUB
1200
1201 *
1202 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1203 *****************************************************************************/
1204UINT WIN32API MapVirtualKeyExW(UINT uCode,
1205 UINT uMapType,
1206 HKL dwhkl)
1207{
1208 dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
1209 uCode,
1210 uMapType,
1211 dwhkl));
1212
1213 return (0);
1214}
1215/*****************************************************************************
1216 * Name : DWORD WIN32API OemKeyScan
1217 * Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
1218 * into the OEM scan codes and shift states. The function provides
1219 * information that allows a program to send OEM text to another
1220 * program by simulating keyboard input.
1221 * Parameters:
1222 * Variables :
1223 * Result :
1224 * Remark :
1225 * Status : UNTESTED STUB
1226 *
1227 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1228 *****************************************************************************/
1229DWORD WIN32API OemKeyScan(WORD wOemChar)
1230{
1231 dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
1232 wOemChar));
1233
1234 return (wOemChar);
1235}
1236//******************************************************************************
1237//******************************************************************************
1238BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
1239{
1240 dprintf(("USER32: RegisterHotKey, not implemented\n"));
1241 hwnd = Win32ToOS2Handle(hwnd);
1242 return(TRUE);
1243}
1244/*****************************************************************************
1245 * Name : int WIN32API ToUnicode
1246 * Purpose : The ToUnicode function translates the specified virtual-key code
1247 * and keyboard state to the corresponding Unicode character or characters.
1248 * Parameters: UINT wVirtKey virtual-key code
1249 * UINT wScanCode scan code
1250 * PBYTE lpKeyState address of key-state array
1251 * LPWSTR pwszBuff buffer for translated key
1252 * int cchBuff size of translated key buffer
1253 * UINT wFlags set of function-conditioning flags
1254 * Variables :
1255 * Result : - 1 The specified virtual key is a dead-key character (accent or
1256 * diacritic). This value is returned regardless of the keyboard
1257 * layout, even if several characters have been typed and are
1258 * stored in the keyboard state. If possible, even with Unicode
1259 * keyboard layouts, the function has written a spacing version of
1260 * the dead-key character to the buffer specified by pwszBuffer.
1261 * For example, the function writes the character SPACING ACUTE
1262 * (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
1263 * 0 The specified virtual key has no translation for the current
1264 * state of the keyboard. Nothing was written to the buffer
1265 * specified by pwszBuffer.
1266 * 1 One character was written to the buffer specified by pwszBuffer.
1267 * 2 or more Two or more characters were written to the buffer specified by
1268 * pwszBuff. The most common cause for this is that a dead-key
1269 * character (accent or diacritic) stored in the keyboard layout
1270 * could not be combined with the specified virtual key to form a
1271 * single character.
1272 * Remark :
1273 * Status : UNTESTED STUB
1274 *
1275 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1276 *****************************************************************************/
1277int WIN32API ToUnicode(UINT uVirtKey,
1278 UINT uScanCode,
1279 PBYTE lpKeyState,
1280 LPWSTR pwszBuff,
1281 int cchBuff,
1282 UINT wFlags)
1283{
1284 dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
1285 uVirtKey,
1286 uScanCode,
1287 lpKeyState,
1288 pwszBuff,
1289 cchBuff,
1290 wFlags));
1291
1292 return (0);
1293}
1294/*****************************************************************************
1295 * Name : BOOL WIN32API UnloadKeyboardLayout
1296 * Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
1297 * Parameters: HKL hkl handle of keyboard layout
1298 * Variables :
1299 * Result : If the function succeeds, the return value is the handle of the
1300 * keyboard layout; otherwise, it is NULL. To get extended error
1301 * information, use the GetLastError function.
1302 * Remark :
1303 * Status : UNTESTED STUB
1304 *
1305 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1306 *****************************************************************************/
1307BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
1308{
1309 dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
1310 hkl));
1311
1312 return (0);
1313}
1314//******************************************************************************
1315//******************************************************************************
1316BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
1317{
1318 dprintf(("USER32: UnregisterHotKey, not implemented\n"));
1319 hwnd = Win32ToOS2Handle(hwnd);
1320
1321 return(TRUE);
1322}
1323//******************************************************************************
1324//SvL: 24-6-'97 - Added
1325//******************************************************************************
1326WORD WIN32API VkKeyScanA( char ch)
1327{
1328 dprintf(("USER32: VkKeyScanA %x", ch));
1329 return O32_VkKeyScan(ch);
1330}
1331//******************************************************************************
1332//******************************************************************************
1333WORD WIN32API VkKeyScanW( WCHAR wch)
1334{
1335 dprintf(("USER32: VkKeyScanW %x", wch));
1336 // NOTE: This will not work as is (needs UNICODE support)
1337 return O32_VkKeyScan((char)wch);
1338}
1339/*****************************************************************************
1340 * Name : SHORT WIN32API VkKeyScanExW
1341 * Purpose : The VkKeyScanEx function translates a character to the
1342 * corresponding virtual-key code and shift state. The function
1343 * translates the character using the input language and physical
1344 * keyboard layout identified by the given keyboard layout handle.
1345 * Parameters: UINT uChar character to translate
1346 * HKL hkl keyboard layout handle
1347 * Variables :
1348 * Result : see docs
1349 * Remark :
1350 * Status : UNTESTED STUB
1351 *
1352 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1353 *****************************************************************************/
1354WORD WIN32API VkKeyScanExW(WCHAR uChar,
1355 HKL hkl)
1356{
1357 dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
1358 uChar,
1359 hkl));
1360
1361 return (uChar);
1362}
1363/*****************************************************************************
1364 * Name : SHORT WIN32API VkKeyScanExA
1365 * Purpose : The VkKeyScanEx function translates a character to the
1366 * corresponding virtual-key code and shift state. The function
1367 * translates the character using the input language and physical
1368 * keyboard layout identified by the given keyboard layout handle.
1369 * Parameters: UINT uChar character to translate
1370 * HKL hkl keyboard layout handle
1371 * Variables :
1372 * Result : see docs
1373 * Remark :
1374 * Status : UNTESTED STUB
1375 *
1376 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1377 *****************************************************************************/
1378WORD WIN32API VkKeyScanExA(CHAR uChar,
1379 HKL hkl)
1380{
1381 dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
1382 uChar,
1383 hkl));
1384
1385 return (uChar);
1386}
1387
1388/* Window Functions */
1389
1390/*****************************************************************************
1391 * Name : BOOL WIN32API AnyPopup
1392 * Purpose : The AnyPopup function indicates whether an owned, visible,
1393 * top-level pop-up, or overlapped window exists on the screen. The
1394 * function searches the entire Windows screen, not just the calling
1395 * application's client area.
1396 * Parameters: VOID
1397 * Variables :
1398 * Result : If a pop-up window exists, the return value is TRUE even if the
1399 * pop-up window is completely covered by other windows. Otherwise,
1400 * it is FALSE.
1401 * Remark : AnyPopup is a Windows version 1.x function and is retained for
1402 * compatibility purposes. It is generally not useful.
1403 * Status : UNTESTED STUB
1404 *
1405 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1406 *****************************************************************************/
1407BOOL WIN32API AnyPopup(VOID)
1408{
1409 dprintf(("USER32:AnyPopup() not implemented.\n"));
1410
1411 return (FALSE);
1412}
1413
1414/*****************************************************************************
1415 * Name : BOOL WIN32API PaintDesktop
1416 * Purpose : The PaintDesktop function fills the clipping region in the
1417 * specified device context with the desktop pattern or wallpaper.
1418 * The function is provided primarily for shell desktops.
1419 * Parameters:
1420 * Variables :
1421 * Result : If the function succeeds, the return value is TRUE.
1422 * If the function fails, the return value is FALSE.
1423 * Remark :
1424 * Status : UNTESTED STUB
1425 *
1426 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1427 *****************************************************************************/
1428BOOL WIN32API PaintDesktop(HDC hdc)
1429{
1430 dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
1431 hdc));
1432
1433 return (FALSE);
1434}
1435
1436/* Filled Shape Functions */
1437
1438 /* Last COLOR id */
1439#define COLOR_MAX COLOR_GRADIENTINACTIVECAPTION
1440
1441int WIN32API FillRect(HDC hDC, const RECT * lprc, HBRUSH hbr)
1442{
1443 if (hbr <= (HBRUSH) (COLOR_MAX + 1)) {
1444 hbr = GetSysColorBrush( (INT) hbr - 1 );
1445 }
1446 dprintf(("USER32: FillRect %x (%d,%d)(%d,%d) brush %X", hDC, lprc->left, lprc->top, lprc->right, lprc->bottom, hbr));
1447 return O32_FillRect(hDC,lprc,hbr);
1448}
1449//******************************************************************************
1450//******************************************************************************
1451int WIN32API FrameRect( HDC hDC, const RECT * lprc, HBRUSH hbr)
1452{
1453 dprintf(("USER32: FrameRect %x (%d,%d)(%d,%d) brush %x", hDC, lprc->top, lprc->left, lprc->bottom, lprc->right, hbr));
1454 return O32_FrameRect(hDC,lprc,hbr);
1455}
1456//******************************************************************************
1457//******************************************************************************
1458BOOL WIN32API InvertRect( HDC hDC, const RECT * lprc)
1459{
1460 if(lprc) {
1461 dprintf(("USER32: InvertRect %x (%d,%d)(%d,%d)", hDC, lprc->left, lprc->top, lprc->right, lprc->bottom));
1462 }
1463 else dprintf(("USER32: InvertRect %x NULL", hDC));
1464 return O32_InvertRect(hDC,lprc);
1465}
1466
1467/* System Information Functions */
1468
1469/* Window Station and Desktop Functions */
1470
1471/*****************************************************************************
1472 * Name : HDESK WIN32API GetThreadDesktop
1473 * Purpose : The GetThreadDesktop function returns a handle to the desktop
1474 * associated with a specified thread.
1475 * Parameters: DWORD dwThreadId thread identifier
1476 * Variables :
1477 * Result : If the function succeeds, the return value is the handle of the
1478 * desktop associated with the specified thread.
1479 * Remark :
1480 * Status : UNTESTED STUB
1481 *
1482 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1483 *****************************************************************************/
1484HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
1485{
1486 dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
1487 dwThreadId));
1488
1489 return (NULL);
1490}
1491
1492/*****************************************************************************
1493 * Name : BOOL WIN32API CloseDesktop
1494 * Purpose : The CloseDesktop function closes an open handle of a desktop
1495 * object. A desktop is a secure object contained within a window
1496 * station object. A desktop has a logical display surface and
1497 * contains windows, menus and hooks.
1498 * Parameters: HDESK hDesktop
1499 * Variables :
1500 * Result : If the function succeeds, the return value is TRUE.
1501 * If the functions fails, the return value is FALSE. To get
1502 * extended error information, call GetLastError.
1503 * Remark :
1504 * Status : UNTESTED STUB
1505 *
1506 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1507 *****************************************************************************/
1508BOOL WIN32API CloseDesktop(HDESK hDesktop)
1509{
1510 dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
1511 hDesktop));
1512
1513 return (FALSE);
1514}
1515/*****************************************************************************
1516 * Name : BOOL WIN32API CloseWindowStation
1517 * Purpose : The CloseWindowStation function closes an open window station handle.
1518 * Parameters: HWINSTA hWinSta
1519 * Variables :
1520 * Result :
1521 * Remark : If the function succeeds, the return value is TRUE.
1522 * If the functions fails, the return value is FALSE. To get
1523 * extended error information, call GetLastError.
1524 * Status : UNTESTED STUB
1525 *
1526 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1527 *****************************************************************************/
1528BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
1529{
1530 dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
1531 hWinSta));
1532
1533 return (FALSE);
1534}
1535/*****************************************************************************
1536 * Name : HDESK WIN32API CreateDesktopA
1537 * Purpose : The CreateDesktop function creates a new desktop on the window
1538 * station associated with the calling process.
1539 * Parameters: LPCTSTR lpszDesktop name of the new desktop
1540 * LPCTSTR lpszDevice name of display device to assign to the desktop
1541 * LPDEVMODE pDevMode reserved; must be NULL
1542 * DWORD dwFlags flags to control interaction with other applications
1543 * DWORD dwDesiredAccess specifies access of returned handle
1544 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
1545 * Variables :
1546 * Result : If the function succeeds, the return value is a handle of the
1547 * newly created desktop.
1548 * If the function fails, the return value is NULL. To get extended
1549 * error information, call GetLastError.
1550 * Remark :
1551 * Status : UNTESTED STUB
1552 *
1553 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1554 *****************************************************************************/
1555HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
1556 LPCTSTR lpszDevice,
1557 LPDEVMODEA pDevMode,
1558 DWORD dwFlags,
1559 DWORD dwDesiredAccess,
1560 LPSECURITY_ATTRIBUTES lpsa)
1561{
1562 dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
1563 lpszDesktop,
1564 lpszDevice,
1565 pDevMode,
1566 dwFlags,
1567 dwDesiredAccess,
1568 lpsa));
1569
1570 return (NULL);
1571}
1572/*****************************************************************************
1573 * Name : HDESK WIN32API CreateDesktopW
1574 * Purpose : The CreateDesktop function creates a new desktop on the window
1575 * station associated with the calling process.
1576 * Parameters: LPCTSTR lpszDesktop name of the new desktop
1577 * LPCTSTR lpszDevice name of display device to assign to the desktop
1578 * LPDEVMODE pDevMode reserved; must be NULL
1579 * DWORD dwFlags flags to control interaction with other applications
1580 * DWORD dwDesiredAccess specifies access of returned handle
1581 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
1582 * Variables :
1583 * Result : If the function succeeds, the return value is a handle of the
1584 * newly created desktop.
1585 * If the function fails, the return value is NULL. To get extended
1586 * error information, call GetLastError.
1587 * Remark :
1588 * Status : UNTESTED STUB
1589 *
1590 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1591 *****************************************************************************/
1592HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
1593 LPCTSTR lpszDevice,
1594 LPDEVMODEW pDevMode,
1595 DWORD dwFlags,
1596 DWORD dwDesiredAccess,
1597 LPSECURITY_ATTRIBUTES lpsa)
1598{
1599 dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
1600 lpszDesktop,
1601 lpszDevice,
1602 pDevMode,
1603 dwFlags,
1604 dwDesiredAccess,
1605 lpsa));
1606
1607 return (NULL);
1608}
1609/*****************************************************************************
1610 * Name : HWINSTA WIN32API CreateWindowStationA
1611 * Purpose : The CreateWindowStation function creates a window station object.
1612 * It returns a handle that can be used to access the window station.
1613 * A window station is a secure object that contains a set of global
1614 * atoms, a clipboard, and a set of desktop objects.
1615 * Parameters: LPTSTR lpwinsta name of the new window station
1616 * DWORD dwReserved reserved; must be NULL
1617 * DWORD dwDesiredAccess specifies access of returned handle
1618 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
1619 * Variables :
1620 * Result : If the function succeeds, the return value is the handle to the
1621 * newly created window station.
1622 * If the function fails, the return value is NULL. To get extended
1623 * error information, call GetLastError.
1624 * Remark :
1625 * Status : UNTESTED STUB
1626 *
1627 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1628 *****************************************************************************/
1629HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
1630 DWORD dwReserved,
1631 DWORD dwDesiredAccess,
1632 LPSECURITY_ATTRIBUTES lpsa)
1633{
1634 dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
1635 lpWinSta,
1636 dwReserved,
1637 dwDesiredAccess,
1638 lpsa));
1639
1640 return (NULL);
1641}
1642/*****************************************************************************
1643 * Name : HWINSTA WIN32API CreateWindowStationW
1644 * Purpose : The CreateWindowStation function creates a window station object.
1645 * It returns a handle that can be used to access the window station.
1646 * A window station is a secure object that contains a set of global
1647 * atoms, a clipboard, and a set of desktop objects.
1648 * Parameters: LPTSTR lpwinsta name of the new window station
1649 * DWORD dwReserved reserved; must be NULL
1650 * DWORD dwDesiredAccess specifies access of returned handle
1651 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
1652 * Variables :
1653 * Result : If the function succeeds, the return value is the handle to the
1654 * newly created window station.
1655 * If the function fails, the return value is NULL. To get extended
1656 * error information, call GetLastError.
1657 * Remark :
1658 * Status : UNTESTED STUB
1659 *
1660 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1661 *****************************************************************************/
1662HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
1663 DWORD dwReserved,
1664 DWORD dwDesiredAccess,
1665 LPSECURITY_ATTRIBUTES lpsa)
1666{
1667 dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
1668 lpWinSta,
1669 dwReserved,
1670 dwDesiredAccess,
1671 lpsa));
1672
1673 return (NULL);
1674}
1675/*****************************************************************************
1676 * Name : BOOL WIN32API EnumDesktopWindows
1677 * Purpose : The EnumDesktopWindows function enumerates all windows in a
1678 * desktop by passing the handle of each window, in turn, to an
1679 * application-defined callback function.
1680 * Parameters: HDESK hDesktop handle of desktop to enumerate
1681 * WNDENUMPROC lpfn points to application's callback function
1682 * LPARAM lParam 32-bit value to pass to the callback function
1683 * Variables :
1684 * Result : If the function succeeds, the return value is TRUE.
1685 * If the function fails, the return value is FALSE. To get
1686 * extended error information, call GetLastError.
1687 * Remark :
1688 * Status : UNTESTED STUB
1689 *
1690 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1691 *****************************************************************************/
1692BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
1693 WNDENUMPROC lpfn,
1694 LPARAM lParam)
1695{
1696 dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
1697 hDesktop,
1698 lpfn,
1699 lParam));
1700
1701 return (FALSE);
1702}
1703/*****************************************************************************
1704 * Name : BOOL WIN32API EnumDesktopsA
1705 * Purpose : The EnumDesktops function enumerates all desktops in the window
1706 * station assigned to the calling process. The function does so by
1707 * passing the name of each desktop, in turn, to an application-
1708 * defined callback function.
1709 * Parameters: HWINSTA hwinsta handle of window station to enumerate
1710 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
1711 * LPARAM lParam 32-bit value to pass to the callback function
1712 * Variables :
1713 * Result : If the function succeeds, the return value is TRUE.
1714 * If the function fails, the return value is FALSE. To get extended
1715 * error information, call GetLastError.
1716 * Remark :
1717 * Status : UNTESTED STUB
1718 *
1719 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1720 *****************************************************************************/
1721BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
1722 DESKTOPENUMPROCA lpEnumFunc,
1723 LPARAM lParam)
1724{
1725 dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
1726 hWinSta,
1727 lpEnumFunc,
1728 lParam));
1729
1730 return (FALSE);
1731}
1732/*****************************************************************************
1733 * Name : BOOL WIN32API EnumDesktopsW
1734 * Purpose : The EnumDesktops function enumerates all desktops in the window
1735 * station assigned to the calling process. The function does so by
1736 * passing the name of each desktop, in turn, to an application-
1737 * defined callback function.
1738 * Parameters: HWINSTA hwinsta handle of window station to enumerate
1739 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
1740 * LPARAM lParam 32-bit value to pass to the callback function
1741 * Variables :
1742 * Result : If the function succeeds, the return value is TRUE.
1743 * If the function fails, the return value is FALSE. To get extended
1744 * error information, call GetLastError.
1745 * Remark :
1746 * Status : UNTESTED STUB
1747 *
1748 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1749 *****************************************************************************/
1750BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
1751 DESKTOPENUMPROCW lpEnumFunc,
1752 LPARAM lParam)
1753{
1754 dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
1755 hWinSta,
1756 lpEnumFunc,
1757 lParam));
1758
1759 return (FALSE);
1760}
1761/*****************************************************************************
1762 * Name : BOOL WIN32API EnumWindowStationsA
1763 * Purpose : The EnumWindowStations function enumerates all windowstations
1764 * in the system by passing the name of each window station, in
1765 * turn, to an application-defined callback function.
1766 * Parameters:
1767 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
1768 * LPARAM lParam 32-bit value to pass to the callback function
1769 * Result : If the function succeeds, the return value is TRUE.
1770 * If the function fails the return value is FALSE. To get extended
1771 * error information, call GetLastError.
1772 * Remark :
1773 * Status : UNTESTED STUB
1774 *
1775 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1776 *****************************************************************************/
1777BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
1778 LPARAM lParam)
1779{
1780 dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
1781 lpEnumFunc,
1782 lParam));
1783
1784 return (FALSE);
1785}
1786/*****************************************************************************
1787 * Name : BOOL WIN32API EnumWindowStationsW
1788 * Purpose : The EnumWindowStations function enumerates all windowstations
1789 * in the system by passing the name of each window station, in
1790 * turn, to an application-defined callback function.
1791 * Parameters:
1792 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
1793 * LPARAM lParam 32-bit value to pass to the callback function
1794 * Result : If the function succeeds, the return value is TRUE.
1795 * If the function fails the return value is FALSE. To get extended
1796 * error information, call GetLastError.
1797 * Remark :
1798 * Status : UNTESTED STUB
1799 *
1800 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1801 *****************************************************************************/
1802BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
1803 LPARAM lParam)
1804{
1805 dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
1806 lpEnumFunc,
1807 lParam));
1808
1809 return (FALSE);
1810}
1811/*****************************************************************************
1812 * Name : HWINSTA WIN32API GetProcessWindowStation
1813 * Purpose : The GetProcessWindowStation function returns a handle of the
1814 * window station associated with the calling process.
1815 * Parameters:
1816 * Variables :
1817 * Result : If the function succeeds, the return value is a handle of the
1818 * window station associated with the calling process.
1819 * If the function fails, the return value is NULL. This can occur
1820 * if the calling process is not an application written for Windows
1821 * NT. To get extended error information, call GetLastError.
1822 * Remark :
1823 * Status : UNTESTED STUB
1824 *
1825 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1826 *****************************************************************************/
1827HWINSTA WIN32API GetProcessWindowStation(VOID)
1828{
1829 dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
1830
1831 return (NULL);
1832}
1833/*****************************************************************************
1834 * Name : BOOL WIN32API GetUserObjectInformationA
1835 * Purpose : The GetUserObjectInformation function returns information about
1836 * a window station or desktop object.
1837 * Parameters: HANDLE hObj handle of object to get information for
1838 * int nIndex type of information to get
1839 * PVOID pvInfo points to buffer that receives the information
1840 * DWORD nLength size, in bytes, of pvInfo buffer
1841 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
1842 * Variables :
1843 * Result : If the function succeeds, the return value is TRUE.
1844 * If the function fails, the return value is FALSE. To get extended
1845 * error information, call GetLastError.
1846 * Remark :
1847 * Status : UNTESTED STUB
1848 *
1849 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1850 *****************************************************************************/
1851BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
1852 int nIndex,
1853 PVOID pvInfo,
1854 DWORD nLength,
1855 LPDWORD lpnLengthNeeded)
1856{
1857 dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1858 hObj,
1859 nIndex,
1860 pvInfo,
1861 nLength,
1862 lpnLengthNeeded));
1863
1864 return (FALSE);
1865}
1866/*****************************************************************************
1867 * Name : BOOL WIN32API GetUserObjectInformationW
1868 * Purpose : The GetUserObjectInformation function returns information about
1869 * a window station or desktop object.
1870 * Parameters: HANDLE hObj handle of object to get information for
1871 * int nIndex type of information to get
1872 * PVOID pvInfo points to buffer that receives the information
1873 * DWORD nLength size, in bytes, of pvInfo buffer
1874 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
1875 * Variables :
1876 * Result : If the function succeeds, the return value is TRUE.
1877 * If the function fails, the return value is FALSE. To get extended
1878 * error information, call GetLastError.
1879 * Remark :
1880 * Status : UNTESTED STUB
1881 *
1882 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1883 *****************************************************************************/
1884BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
1885 int nIndex,
1886 PVOID pvInfo,
1887 DWORD nLength,
1888 LPDWORD lpnLengthNeeded)
1889{
1890 dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1891 hObj,
1892 nIndex,
1893 pvInfo,
1894 nLength,
1895 lpnLengthNeeded));
1896
1897 return (FALSE);
1898}
1899/*****************************************************************************
1900 * Name : BOOL WIN32API GetUserObjectSecurity
1901 * Purpose : The GetUserObjectSecurity function retrieves security information
1902 * for the specified user object.
1903 * Parameters: HANDLE hObj handle of user object
1904 * SECURITY_INFORMATION * pSIRequested address of requested security information
1905 * LPSECURITY_DESCRIPTOR pSID address of security descriptor
1906 * DWORD nLength size of buffer for security descriptor
1907 * LPDWORD lpnLengthNeeded address of required size of buffer
1908 * Variables :
1909 * Result : If the function succeeds, the return value is TRUE.
1910 * If the function fails, the return value is FALSE. To get extended
1911 * error information, call GetLastError.
1912 * Remark :
1913 * Status : UNTESTED STUB
1914 *
1915 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1916 *****************************************************************************/
1917BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
1918 PSECURITY_INFORMATION pSIRequested,
1919 PSECURITY_DESCRIPTOR pSID,
1920 DWORD nLength,
1921 LPDWORD lpnLengthNeeded)
1922{
1923 dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
1924 hObj,
1925 pSIRequested,
1926 pSID,
1927 nLength,
1928 lpnLengthNeeded));
1929
1930 return (FALSE);
1931}
1932/*****************************************************************************
1933 * Name : HDESK WIN32API OpenDesktopA
1934 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
1935 * A desktop is a secure object contained within a window station
1936 * object. A desktop has a logical display surface and contains
1937 * windows, menus and hooks.
1938 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
1939 * DWORD dwFlags flags to control interaction with other applications
1940 * BOOL fInherit specifies whether returned handle is inheritable
1941 * DWORD dwDesiredAccess specifies access of returned handle
1942 * Variables :
1943 * Result : If the function succeeds, the return value is the handle to the
1944 * opened desktop.
1945 * If the function fails, the return value is NULL. To get extended
1946 * error information, call GetLastError.
1947 * Remark :
1948 * Status : UNTESTED STUB
1949 *
1950 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1951 *****************************************************************************/
1952HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
1953 DWORD dwFlags,
1954 BOOL fInherit,
1955 DWORD dwDesiredAccess)
1956{
1957 dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
1958 lpszDesktopName,
1959 dwFlags,
1960 fInherit,
1961 dwDesiredAccess));
1962
1963 return (NULL);
1964}
1965/*****************************************************************************
1966 * Name : HDESK WIN32API OpenDesktopW
1967 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
1968 * A desktop is a secure object contained within a window station
1969 * object. A desktop has a logical display surface and contains
1970 * windows, menus and hooks.
1971 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
1972 * DWORD dwFlags flags to control interaction with other applications
1973 * BOOL fInherit specifies whether returned handle is inheritable
1974 * DWORD dwDesiredAccess specifies access of returned handle
1975 * Variables :
1976 * Result : If the function succeeds, the return value is the handle to the
1977 * opened desktop.
1978 * If the function fails, the return value is NULL. To get extended
1979 * error information, call GetLastError.
1980 * Remark :
1981 * Status : UNTESTED STUB
1982 *
1983 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1984 *****************************************************************************/
1985HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
1986 DWORD dwFlags,
1987 BOOL fInherit,
1988 DWORD dwDesiredAccess)
1989{
1990 dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
1991 lpszDesktopName,
1992 dwFlags,
1993 fInherit,
1994 dwDesiredAccess));
1995
1996 return (NULL);
1997}
1998/*****************************************************************************
1999 * Name : HDESK WIN32API OpenInputDesktop
2000 * Purpose : The OpenInputDesktop function returns a handle to the desktop
2001 * that receives user input. The input desktop is a desktop on the
2002 * window station associated with the logged-on user.
2003 * Parameters: DWORD dwFlags flags to control interaction with other applications
2004 * BOOL fInherit specifies whether returned handle is inheritable
2005 * DWORD dwDesiredAccess specifies access of returned handle
2006 * Variables :
2007 * Result : If the function succeeds, the return value is a handle of the
2008 * desktop that receives user input.
2009 * If the function fails, the return value is NULL. To get extended
2010 * error information, call GetLastError.
2011 * Remark :
2012 * Status : UNTESTED STUB
2013 *
2014 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2015 *****************************************************************************/
2016HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
2017 BOOL fInherit,
2018 DWORD dwDesiredAccess)
2019{
2020 dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
2021 dwFlags,
2022 fInherit,
2023 dwDesiredAccess));
2024
2025 return (NULL);
2026}
2027/*****************************************************************************
2028 * Name : HWINSTA WIN32API OpenWindowStationA
2029 * Purpose : The OpenWindowStation function returns a handle to an existing
2030 * window station.
2031 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
2032 * BOOL fInherit specifies whether returned handle is inheritable
2033 * DWORD dwDesiredAccess specifies access of returned handle
2034 * Variables :
2035 * Result : If the function succeeds, the return value is the handle to the
2036 * specified window station.
2037 * If the function fails, the return value is NULL. To get extended
2038 * error information, call GetLastError.
2039 * Remark :
2040 * Status : UNTESTED STUB
2041 *
2042 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2043 *****************************************************************************/
2044HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
2045 BOOL fInherit,
2046 DWORD dwDesiredAccess)
2047{
2048 dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
2049 lpszWinStaName,
2050 fInherit,
2051 dwDesiredAccess));
2052
2053 return (NULL);
2054}
2055/*****************************************************************************
2056 * Name : HWINSTA WIN32API OpenWindowStationW
2057 * Purpose : The OpenWindowStation function returns a handle to an existing
2058 * window station.
2059 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
2060 * BOOL fInherit specifies whether returned handle is inheritable
2061 * DWORD dwDesiredAccess specifies access of returned handle
2062 * Variables :
2063 * Result : If the function succeeds, the return value is the handle to the
2064 * specified window station.
2065 * If the function fails, the return value is NULL. To get extended
2066 * error information, call GetLastError.
2067
2068
2069 * Remark :
2070 * Status : UNTESTED STUB
2071 *
2072 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2073 *****************************************************************************/
2074HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
2075 BOOL fInherit,
2076 DWORD dwDesiredAccess)
2077{
2078 dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
2079 lpszWinStaName,
2080 fInherit,
2081 dwDesiredAccess));
2082
2083 return (NULL);
2084}
2085/*****************************************************************************
2086 * Name : BOOL WIN32API SetProcessWindowStation
2087 * Purpose : The SetProcessWindowStation function assigns a window station
2088 * to the calling process. This enables the process to access
2089 * objects in the window station such as desktops, the clipboard,
2090 * and global atoms. All subsequent operations on the window station
2091 * use the access rights granted to hWinSta.
2092 * Parameters:
2093 * Variables :
2094 * Result : If the function succeeds, the return value is TRUE.
2095 * If the function fails, the return value is FALSE. To get extended
2096 * error information, call GetLastError.
2097 * Remark :
2098 * Status : UNTESTED STUB
2099 *
2100 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2101 *****************************************************************************/
2102BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
2103{
2104 dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
2105 hWinSta));
2106
2107 return (FALSE);
2108}
2109/*****************************************************************************
2110 * Name : BOOL WIN32API SetThreadDesktop
2111 * Purpose : The SetThreadDesktop function assigns a desktop to the calling
2112 * thread. All subsequent operations on the desktop use the access
2113 * rights granted to hDesk.
2114 * Parameters: HDESK hDesk handle of the desktop to assign to this thread
2115 * Variables :
2116 * Result : If the function succeeds, the return value is TRUE.
2117 * If the function fails, the return value is FALSE. To get extended
2118 * error information, call GetLastError.
2119 * Remark :
2120 * Status : UNTESTED STUB
2121 *
2122 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2123 *****************************************************************************/
2124BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
2125{
2126 dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
2127 hDesktop));
2128
2129 return (FALSE);
2130}
2131/*****************************************************************************
2132 * Name : BOOL WIN32API SetUserObjectInformationA
2133 * Purpose : The SetUserObjectInformation function sets information about a
2134 * window station or desktop object.
2135 * Parameters: HANDLE hObject handle of the object for which to set information
2136 * int nIndex type of information to set
2137 * PVOID lpvInfo points to a buffer that contains the information
2138 * DWORD cbInfo size, in bytes, of lpvInfo buffer
2139 * Variables :
2140 * Result : If the function succeeds, the return value is TRUE.
2141 * If the function fails the return value is FALSE. To get extended
2142 * error information, call GetLastError.
2143 * Remark :
2144 * Status : UNTESTED STUB
2145 *
2146 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2147 *****************************************************************************/
2148BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
2149 int nIndex,
2150 PVOID lpvInfo,
2151 DWORD cbInfo)
2152{
2153 dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
2154 hObject,
2155 nIndex,
2156 lpvInfo,
2157 cbInfo));
2158
2159 return (FALSE);
2160}
2161/*****************************************************************************
2162 * Name : BOOL WIN32API SetUserObjectInformationW
2163 * Purpose : The SetUserObjectInformation function sets information about a
2164 * window station or desktop object.
2165 * Parameters: HANDLE hObject handle of the object for which to set information
2166 * int nIndex type of information to set
2167 * PVOID lpvInfo points to a buffer that contains the information
2168 * DWORD cbInfo size, in bytes, of lpvInfo buffer
2169 * Variables :
2170 * Result : If the function succeeds, the return value is TRUE.
2171 * If the function fails the return value is FALSE. To get extended
2172 * error information, call GetLastError.
2173 * Remark :
2174 * Status : UNTESTED STUB
2175 *
2176 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2177 *****************************************************************************/
2178BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
2179 int nIndex,
2180 PVOID lpvInfo,
2181 DWORD cbInfo)
2182{
2183 dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
2184 hObject,
2185 nIndex,
2186 lpvInfo,
2187 cbInfo));
2188
2189 return (FALSE);
2190}
2191/*****************************************************************************
2192 * Name : BOOL WIN32API SetUserObjectSecurity
2193 * Purpose : The SetUserObjectSecurity function sets the security of a user
2194 * object. This can be, for example, a window or a DDE conversation
2195 * Parameters: HANDLE hObject handle of user object
2196 * SECURITY_INFORMATION * psi address of security information
2197 * LPSECURITY_DESCRIPTOR psd address of security descriptor
2198 * Variables :
2199 * Result : If the function succeeds, the return value is TRUE.
2200 * If the function fails, the return value is FALSE. To get extended
2201 * error information, call GetLastError.
2202 * Remark :
2203 * Status : UNTESTED STUB
2204 *
2205 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2206 *****************************************************************************/
2207BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
2208 PSECURITY_INFORMATION psi,
2209 PSECURITY_DESCRIPTOR psd)
2210{
2211 dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
2212 hObject,
2213 psi,
2214 psd));
2215
2216 return (FALSE);
2217}
2218/*****************************************************************************
2219 * Name : BOOL WIN32API SwitchDesktop
2220 * Purpose : The SwitchDesktop function makes a desktop visible and activates
2221 * it. This enables the desktop to receive input from the user. The
2222 * calling process must have DESKTOP_SWITCHDESKTOP access to the
2223 * desktop for the SwitchDesktop function to succeed.
2224 * Parameters:
2225 * Variables :
2226 * Result : If the function succeeds, the return value is TRUE.
2227 * If the function fails, the return value is FALSE. To get extended
2228 * error information, call GetLastError.
2229 * Remark :
2230 * Status : UNTESTED STUB
2231 *
2232 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2233 *****************************************************************************/
2234BOOL WIN32API SwitchDesktop(HDESK hDesktop)
2235{
2236 dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
2237 hDesktop));
2238
2239 return (FALSE);
2240}
2241
2242/* Debugging Functions */
2243
2244/*****************************************************************************
2245 * Name : VOID WIN32API SetDebugErrorLevel
2246 * Purpose : The SetDebugErrorLevel function sets the minimum error level at
2247 * which Windows will generate debugging events and pass them to a debugger.
2248 * Parameters: DWORD dwLevel debugging error level
2249 * Variables :
2250 * Result :
2251 * Remark :
2252 * Status : UNTESTED STUB
2253 *
2254 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2255 *****************************************************************************/
2256VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
2257{
2258 dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
2259 dwLevel));
2260}
2261
2262/* Drag'n'drop */
2263
2264/*****************************************************************************
2265 * Name : BOOL WIN32API DragObject
2266 * Purpose : Unknown
2267 * Parameters: Unknown
2268 * Variables :
2269 * Result :
2270 * Remark :
2271 * Status : UNTESTED UNKNOWN STUB
2272 *
2273 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2274 *****************************************************************************/
2275DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
2276{
2277 dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2278 x1,
2279 x2,
2280 x3,
2281 x4,
2282 x5));
2283
2284 return (FALSE); /* default */
2285}
2286
2287/* Unknown */
2288
2289/*****************************************************************************
2290 * Name : BOOL WIN32API SetShellWindow
2291 * Purpose : Unknown
2292 * Parameters: Unknown
2293 * Variables :
2294 * Result :
2295 * Remark :
2296 * Status : UNTESTED UNKNOWN STUB
2297 *
2298 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2299 *****************************************************************************/
2300BOOL WIN32API SetShellWindow(DWORD x1)
2301{
2302 dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
2303 x1));
2304
2305 return (FALSE); /* default */
2306}
2307/*****************************************************************************
2308 * Name : BOOL WIN32API PlaySoundEvent
2309 * Purpose : Unknown
2310 * Parameters: Unknown
2311 * Variables :
2312 * Result :
2313 * Remark :
2314 * Status : UNTESTED UNKNOWN STUB
2315 *
2316 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2317 *****************************************************************************/
2318BOOL WIN32API PlaySoundEvent(DWORD x1)
2319{
2320 dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
2321 x1));
2322
2323 return (FALSE); /* default */
2324}
2325/*****************************************************************************
2326 * Name : BOOL WIN32API SetSysColorsTemp
2327 * Purpose : Unknown
2328 * Parameters: Unknown
2329 * Variables :
2330 * Result :
2331 * Remark :
2332 * Status : UNTESTED UNKNOWN STUB
2333 *
2334 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2335 *****************************************************************************/
2336BOOL WIN32API SetSysColorsTemp(void)
2337{
2338 dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
2339
2340 return (FALSE); /* default */
2341}
2342/*****************************************************************************
2343 * Name : BOOL WIN32API RegisterNetworkCapabilities
2344 * Purpose : Unknown
2345 * Parameters: Unknown
2346 * Variables :
2347 * Result :
2348 * Remark :
2349 * Status : UNTESTED UNKNOWN STUB
2350 *
2351 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2352 *****************************************************************************/
2353BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
2354 DWORD x2)
2355{
2356 dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
2357 x1,
2358 x2));
2359
2360 return (FALSE); /* default */
2361}
2362/*****************************************************************************
2363 * Name : BOOL WIN32API EndTask
2364 * Purpose : Unknown
2365 * Parameters: Unknown
2366 * Variables :
2367 * Result :
2368 * Remark :
2369 * Status : UNTESTED UNKNOWN STUB
2370 *
2371 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2372 *****************************************************************************/
2373BOOL WIN32API EndTask(DWORD x1,
2374 DWORD x2,
2375 DWORD x3)
2376{
2377 dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
2378 x1,
2379 x2,
2380 x3));
2381
2382 return (FALSE); /* default */
2383}
2384/*****************************************************************************
2385 * Name : BOOL WIN32API GetNextQueueWindow
2386 * Purpose : Unknown
2387 * Parameters: Unknown
2388 * Variables :
2389 * Result :
2390 * Remark :
2391 * Status : UNTESTED UNKNOWN STUB
2392 *
2393 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2394 *****************************************************************************/
2395BOOL WIN32API GetNextQueueWindow(DWORD x1,
2396 DWORD x2)
2397{
2398 dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
2399 x1,
2400 x2));
2401
2402 return (FALSE); /* default */
2403}
2404/*****************************************************************************
2405 * Name : BOOL WIN32API YieldTask
2406 * Purpose : Unknown
2407 * Parameters: Unknown
2408 * Variables :
2409 * Result :
2410 * Remark :
2411 * Status : UNTESTED UNKNOWN STUB
2412 *
2413 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2414 *****************************************************************************/
2415BOOL WIN32API YieldTask(void)
2416{
2417 dprintf(("USER32: YieldTask() not implemented.\n"));
2418
2419 return (FALSE); /* default */
2420}
2421/*****************************************************************************
2422 * Name : BOOL WIN32API WinOldAppHackoMatic
2423 * Purpose : Unknown
2424 * Parameters: Unknown
2425 * Variables :
2426 * Result :
2427 * Remark :
2428 * Status : UNTESTED UNKNOWN STUB
2429 *
2430 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2431 *****************************************************************************/
2432BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
2433{
2434 dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
2435 x1));
2436
2437 return (FALSE); /* default */
2438}
2439/*****************************************************************************
2440 * Name : BOOL WIN32API RegisterSystemThread
2441 * Purpose : Unknown
2442 * Parameters: Unknown
2443 * Variables :
2444 * Result :
2445 * Remark :
2446 * Status : UNTESTED UNKNOWN STUB
2447 *
2448 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2449 *****************************************************************************/
2450BOOL WIN32API RegisterSystemThread(DWORD x1,
2451 DWORD x2)
2452{
2453 dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
2454 x1,
2455 x2));
2456
2457 return (FALSE); /* default */
2458}
2459/*****************************************************************************
2460 * Name : BOOL WIN32API IsHungThread
2461 * Purpose : Unknown
2462 * Parameters: Unknown
2463 * Variables :
2464 * Result :
2465 * Remark :
2466 * Status : UNTESTED UNKNOWN STUB
2467 *
2468 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2469 *****************************************************************************/
2470BOOL WIN32API IsHungThread(DWORD x1)
2471{
2472 dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
2473 x1));
2474
2475 return (FALSE); /* default */
2476}
2477/*****************************************************************************
2478 * Name : BOOL WIN32API UserSignalProc
2479 * Purpose : Unknown
2480 * Parameters: Unknown
2481 * Variables :
2482 * Result :
2483 * Remark :
2484 * Status : UNTESTED UNKNOWN STUB
2485 *
2486 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2487 *****************************************************************************/
2488BOOL WIN32API UserSignalProc(DWORD x1,
2489 DWORD x2,
2490 DWORD x3,
2491 DWORD x4)
2492{
2493 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2494 x1,
2495 x2,
2496 x3,
2497 x4));
2498
2499 return (FALSE); /* default */
2500}
2501/*****************************************************************************
2502 * Name : BOOL WIN32API GetShellWindow
2503 * Purpose : Unknown
2504 * Parameters: Unknown
2505 * Variables :
2506 * Result :
2507 * Remark :
2508 * Status : UNTESTED UNKNOWN STUB
2509 *
2510 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2511 *****************************************************************************/
2512HWND WIN32API GetShellWindow(void)
2513{
2514 dprintf(("USER32: GetShellWindow() not implemented.\n"));
2515
2516 return (0); /* default */
2517}
2518/***********************************************************************
2519 * RegisterTasklist32 [USER32.436]
2520 */
2521DWORD WIN32API RegisterTasklist (DWORD x)
2522{
2523 dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
2524 x));
2525
2526 return TRUE;
2527}
2528/***********************************************************************
2529 * SetLogonNotifyWindow (USER32.486)
2530 */
2531DWORD WIN32API SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd)
2532{
2533 dprintf(("USER32: SetLogonNotifyWindow - empty stub!"));
2534
2535 return 1;
2536}
2537
2538
2539DWORD WIN32API NotifyWinEvent(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4)
2540{
2541 dprintf(("USER32: NotifyWinEvent %x %x %x %x - empty stub!!", arg1, arg2, arg3, arg4));
2542
2543 return 0;
2544}
2545
2546DWORD WIN32API UnhookWinEvent(DWORD arg1)
2547{
2548 dprintf(("USER32: UnhookWinEvent %x - empty stub!!", arg1));
2549
2550 return 0;
2551}
2552
2553DWORD WIN32API SetWinEventHook(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7)
2554{
2555 dprintf(("USER32: SetWinEventHook %x %x %x %x %x %x %x - empty stub!!", arg1, arg2, arg3, arg4, arg5, arg6, arg7));
2556
2557 return 0;
2558}
2559
2560DWORD WIN32API GetGUIThreadInfo(DWORD arg1, DWORD arg2)
2561{
2562 dprintf(("USER32: GetGUIThreadInfo %x %x - empty stub!!", arg1, arg2));
2563
2564 return 0;
2565}
2566
Note: See TracBrowser for help on using the repository browser.