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

Last change on this file since 4573 was 4573, checked in by sandervl, 25 years ago

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