source: trunk/src/user32/new/user32.cpp@ 2572

Last change on this file since 2572 was 2408, checked in by sandervl, 26 years ago

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