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

Last change on this file since 326 was 325, checked in by sandervl, 26 years ago

Lots of changes
File size: 154.4 KB
Line 
1/* $Id: user32.cpp,v 1.5 1999-07-18 10:39:51 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 *
11 *
12 * Project Odin Software License can be found in LICENSE.TXT
13 *
14 */
15/*****************************************************************************
16 * Name : USER32.CPP
17 * Purpose : This module maps all Win32 functions contained in USER32.DLL
18 * to their OS/2-specific counterparts as far as possible.
19 *****************************************************************************/
20
21#include <os2win.h>
22#include "misc.h"
23
24#include "user32.h"
25#include "icon.h"
26#include "usrcall.h"
27#include "syscolor.h"
28
29#include <wchar.h>
30#include <stdlib.h>
31#include <string.h>
32#include <oslibwin.h>
33
34//undocumented stuff
35// WIN32API CalcChildScroll
36// WIN32API CascadeChildWindows
37// WIN32API ClientThreadConnect
38// WIN32API DragObject
39// WIN32API DrawFrame
40// WIN32API EditWndProc
41// WIN32API EndTask
42// WIN32API GetInputDesktop
43// WIN32API GetNextQueueWindow
44// WIN32API GetShellWindow
45// WIN32API InitSharedTable
46// WIN32API InitTask
47// WIN32API IsHungThread
48// WIN32API LockWindowStation
49// WIN32API ModifyAccess
50// WIN32API PlaySoundEvent
51// WIN32API RegisterLogonProcess
52// WIN32API RegisterNetworkCapabilities
53// WIN32API RegisterSystemThread
54// WIN32API SetDeskWallpaper
55// WIN32API SetDesktopBitmap
56// WIN32API SetInternalWindowPos
57// WIN32API SetLogonNotifyWindow
58// WIN32API SetShellWindow
59// WIN32API SetSysColorsTemp
60// WIN32API SetWindowFullScreenState
61// WIN32API SwitchToThisWindow
62// WIN32API SysErrorBox
63// WIN32API TileChildWindows
64// WIN32API UnlockWindowStation
65// WIN32API UserClientDllInitialize
66// WIN32API UserSignalProc
67// WIN32API WinOldAppHackoMatic
68// WIN32API WNDPROC_CALLBACK
69// WIN32API YieldTask
70
71
72
73
74//******************************************************************************
75//******************************************************************************
76int __cdecl wsprintfA(char *lpOut, LPCSTR lpFmt, ...)
77{
78 int rc;
79 va_list argptr;
80
81#ifdef DEBUG
82 WriteLog("USER32: wsprintfA\n");
83 WriteLog("USER32: %s\n", lpFmt);
84#endif
85 va_start(argptr, lpFmt);
86 rc = O32_wvsprintf(lpOut, (char *)lpFmt, argptr);
87 va_end(argptr);
88#ifdef DEBUG
89 WriteLog("USER32: %s\n", lpOut);
90#endif
91 return(rc);
92}
93//******************************************************************************
94//******************************************************************************
95int __cdecl wsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, ...)
96{
97 int rc;
98 char *lpFmtA;
99 char szOut[512];
100 va_list argptr;
101
102 dprintf(("USER32: wsprintfW(%08xh,%08xh).\n",
103 lpOut,
104 lpFmt));
105
106 lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
107
108 /* @@@PH 98/07/13 transform "%s" to "%ls" does the unicode magic */
109 {
110 PCHAR pszTemp;
111 PCHAR pszTemp1;
112 ULONG ulStrings;
113 ULONG ulIndex; /* temporary string counter */
114
115 for (ulStrings = 0, /* determine number of placeholders */
116 pszTemp = lpFmtA;
117
118 (pszTemp != NULL) &&
119 (*pszTemp != 0);
120
121 ulStrings++)
122 {
123 pszTemp = strstr(pszTemp,
124 "%s");
125 if (pszTemp != NULL) /* skip 2 characters */
126 {
127 pszTemp++;
128 pszTemp++;
129 }
130 else
131 break; /* leave loop immediately */
132 }
133
134 if (ulStrings != 0) /* transformation required ? */
135 {
136 /* now reallocate lpFmt */
137 ulStrings += strlen(lpFmtA); /* calculate total string length */
138 pszTemp = lpFmtA; /* save string pointer */
139 pszTemp1 = lpFmtA; /* save string pointer */
140
141 /* @@@PH allocation has to be compatible to FreeAsciiString !!! */
142 lpFmtA = (char *)malloc(ulStrings + 1);
143 if (lpFmtA == NULL) /* check proper allocation */
144 return (0); /* raise error condition */
145
146 for (ulIndex = 0;
147 ulIndex <= ulStrings;
148 ulIndex++,
149 pszTemp++)
150 {
151 if ((pszTemp[0] == '%') &&
152 (pszTemp[1] == 's') )
153 {
154 /* replace %s by %ls */
155 lpFmtA[ulIndex++] = '%';
156 lpFmtA[ulIndex ] = 'l';
157 lpFmtA[ulIndex+1] = 's';
158 }
159 else
160 lpFmtA[ulIndex] = *pszTemp; /* just copy over the character */
161 }
162
163 lpFmtA[ulStrings] = 0; /* string termination */
164
165 FreeAsciiString(pszTemp1); /* the original string is obsolete */
166 }
167 }
168
169 dprintf(("USER32: wsprintfW (%s).\n",
170 lpFmt));
171
172 va_start(argptr,
173 lpFmt);
174
175 rc = O32_wvsprintf(szOut,
176 lpFmtA,
177 argptr);
178
179 AsciiToUnicode(szOut,
180 lpOut);
181
182 FreeAsciiString(lpFmtA);
183 return(rc);
184}
185//******************************************************************************
186//******************************************************************************
187BOOL WIN32API MessageBeep( UINT arg1)
188{
189 INT flStyle;
190
191#ifdef DEBUG
192 WriteLog("USER32: MessageBeep\n");
193#endif
194
195 switch (arg1)
196 {
197 case 0xFFFFFFFF:
198 OSLibDosBeep(500,50);
199 return TRUE;
200 case MB_ICONASTERISK:
201 flStyle = WA_NOTE;
202 break;
203 case MB_ICONEXCLAMATION:
204 flStyle = WA_WARNING;
205 break;
206 case MB_ICONHAND:
207 case MB_ICONQUESTION:
208 case MB_OK:
209 flStyle = WA_NOTE;
210 break;
211 default:
212 flStyle = WA_ERROR; //CB: should be right
213 break;
214 }
215 return OSLibWinAlarm(HWND_DESKTOP,flStyle);
216}
217//******************************************************************************
218
219/*******************************************************************
220 * InternalGetWindowText (USER32.326)
221 */
222int WIN32API InternalGetWindowText(HWND hwnd,
223 LPWSTR lpString,
224 INT nMaxCount )
225{
226 dprintf(("USER32: InternalGetWindowText(%08xh,%08xh,%08xh) not properly implemented.\n",
227 hwnd,
228 lpString,
229 nMaxCount));
230
231 return GetWindowTextW(hwnd,lpString,nMaxCount);
232}
233
234
235//******************************************************************************
236//******************************************************************************
237//******************************************************************************
238HWND WIN32API GetFocus(void)
239{
240// dprintf(("USER32: GetFocus\n"));
241 //return OS2LibWinQueryFocus(HWND_DESKTOP);
242 return O32_GetFocus();
243}
244//******************************************************************************
245//******************************************************************************
246HWND WIN32API GetDesktopWindow(void)
247{
248 dprintf(("USER32: GetDesktopWindow\n"));
249 //return HWND_DESKTOP //CB: WinQueryDesktopWindow();, hab and hdc not available!
250 return O32_GetDesktopWindow();
251}
252//******************************************************************************
253//******************************************************************************
254BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
255{
256 BOOL rc;
257 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
258
259 dprintf(("USER32: EnumThreadWindows\n"));
260 //replace
261 rc = O32_EnumThreadWindows(dwThreadId, callback->GetOS2Callback(), (LPARAM)callback);
262 if(callback)
263 delete callback;
264 return(rc);
265}
266//******************************************************************************
267//******************************************************************************
268BOOL WIN32API OffsetRect( PRECT lprc, int x, int y)
269{
270#ifdef DEBUG
271//// WriteLog("USER32: OffsetRect\n");
272#endif
273 //CB: inc values
274 if (lprc)
275 {
276 lprc->left += x;
277 lprc->right += x;
278 lprc->top += y;
279 lprc->bottom += y;
280
281 return TRUE;
282 } else return FALSE;
283}
284//******************************************************************************
285//******************************************************************************
286BOOL WIN32API CopyRect( PRECT lprcDst, const RECT * lprcSrc)
287{
288// ddprintf(("USER32: CopyRect\n"));
289 if (!lprcDst || !lprcSrc) return FALSE;
290
291 memcpy(lprcDst,lprcSrc,sizeof(RECT));
292
293 return TRUE;
294}
295//******************************************************************************
296//******************************************************************************
297HWND WIN32API SetFocus( HWND arg1)
298{
299 dprintf(("USER32: SetFocus\n"));
300 //return OSLibWinSetFocus(HWND_DESKTOP,arg1);
301 return O32_SetFocus(arg1);
302}
303//******************************************************************************
304//******************************************************************************
305BOOL WIN32API InvalidateRect(HWND arg1, const RECT *arg2, BOOL arg3)
306{
307#ifdef DEBUG
308 if(arg2)
309 WriteLog("USER32: InvalidateRect for window %X (%d,%d)(%d,%d) %d\n", arg1, arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
310 else WriteLog("USER32: InvalidateRect for window %X NULL, %d\n", arg1, arg3);
311#endif
312 //return OSLibWinInvalidateRect(arg1,arg2,arg3);
313 return O32_InvalidateRect(arg1, arg2, arg3);
314}
315//******************************************************************************
316//******************************************************************************
317BOOL WIN32API GetUpdateRect( HWND arg1, PRECT arg2, BOOL arg3)
318{
319#ifdef DEBUG
320 WriteLog("USER32: GetUpdateRect\n");
321#endif
322 // OSLibWinQueryUpdateRect(arg1,arg2);
323 // translate top,bottom
324 return O32_GetUpdateRect(arg1, arg2, arg3);
325}
326//******************************************************************************
327//******************************************************************************
328//******************************************************************************
329//******************************************************************************
330int WIN32API GetSystemMetrics(int arg1)
331{
332 int rc;
333
334 switch(arg1) {
335 case SM_CXICONSPACING: //TODO: size of grid cell for large icons
336 //rc = OSLibWinQuerySysValue(HWND_DESKTOP,SV_CXICON);
337 //CB: better: return standard windows icon size
338 rc = 32;
339 break;
340 case SM_CYICONSPACING:
341 //read SM_CXICONSPACING comment
342 rc = 32;
343 break;
344 case SM_PENWINDOWS:
345 rc = FALSE;
346 break;
347 case SM_DBCSENABLED:
348 rc = FALSE;
349 break;
350 case SM_CXEDGE: //size of 3D window edge (not supported)
351 rc = 1;
352 break;
353 case SM_CYEDGE:
354 rc = 1;
355 break;
356 case SM_CXMINSPACING: //can be SM_CXMINIMIZED or larger
357 rc = O32_GetSystemMetrics(SM_CXMINIMIZED);
358 break;
359 case SM_CYMINSPACING:
360 rc = GetSystemMetrics(SM_CYMINIMIZED);
361 break;
362 case SM_CXSMICON: //recommended size of small icons (TODO: adjust to screen res.)
363 rc = 16;
364 break;
365 case SM_CYSMICON:
366 rc = 16;
367 break;
368 case SM_CYSMCAPTION: //size in pixels of a small caption (TODO: ????)
369 rc = 8;
370 break;
371 case SM_CXSMSIZE: //size of small caption buttons (pixels) (TODO: implement properly)
372 rc = 16;
373 break;
374 case SM_CYSMSIZE:
375 rc = 16;
376 break;
377 case SM_CXMENUSIZE: //TODO: size of menu bar buttons (such as MDI window close)
378 rc = 16;
379 break;
380 case SM_CYMENUSIZE:
381 rc = 16;
382 break;
383 case SM_ARRANGE:
384 rc = ARW_BOTTOMLEFT | ARW_LEFT;
385 break;
386 case SM_CXMINIMIZED:
387 break;
388 case SM_CYMINIMIZED:
389 break;
390 case SM_CXMAXTRACK: //max window size
391 case SM_CXMAXIMIZED: //max toplevel window size
392 rc = O32_GetSystemMetrics(SM_CXSCREEN);
393 break;
394 case SM_CYMAXTRACK:
395 case SM_CYMAXIMIZED:
396 rc = O32_GetSystemMetrics(SM_CYSCREEN);
397 break;
398 case SM_NETWORK:
399 rc = 0x01; //TODO: default = yes
400 break;
401 case SM_CLEANBOOT:
402 rc = 0; //normal boot
403 break;
404 case SM_CXDRAG: //nr of pixels before drag becomes a real one
405 rc = 2;
406 break;
407 case SM_CYDRAG:
408 rc = 2;
409 break;
410 case SM_SHOWSOUNDS: //show instead of play sound
411 rc = FALSE;
412 break;
413 case SM_CXMENUCHECK:
414 rc = 4; //TODO
415 break;
416 case SM_CYMENUCHECK:
417 rc = O32_GetSystemMetrics(SM_CYMENU);
418 break;
419 case SM_SLOWMACHINE:
420 rc = FALSE; //even a slow machine is fast with OS/2 :)
421 break;
422 case SM_MIDEASTENABLED:
423 rc = FALSE;
424 break;
425 case SM_CMETRICS:
426 rc = O32_GetSystemMetrics(44); //Open32 changed this one
427 break;
428 default:
429 rc = O32_GetSystemMetrics(arg1);
430 break;
431 }
432#ifdef DEBUG
433 WriteLog("USER32: GetSystemMetrics %d returned %d\n", arg1, rc);
434#endif
435 return(rc);
436}
437//******************************************************************************
438//******************************************************************************
439UINT WIN32API SetTimer( HWND arg1, UINT arg2, UINT arg3, TIMERPROC arg4)
440{
441#ifdef DEBUG
442 WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
443#endif
444 //SvL: Write callback handler class for this one
445 return O32_SetTimer(arg1, arg2, arg3, (TIMERPROC_O32)arg4);
446}
447//******************************************************************************
448//******************************************************************************
449BOOL WIN32API KillTimer(HWND arg1, UINT arg2)
450{
451#ifdef DEBUG
452 WriteLog("USER32: KillTimer\n");
453#endif
454 //WinStopTimer
455 return O32_KillTimer(arg1, arg2);
456}
457//******************************************************************************
458//******************************************************************************
459BOOL WIN32API InflateRect( PRECT arg1, int arg2, int arg3)
460{
461#ifdef DEBUG
462 WriteLog("USER32: InflateRect\n");
463#endif
464 //don't know how Win32 handles this
465 return O32_InflateRect(arg1, arg2, arg3);
466}
467//******************************************************************************
468//TODO:How can we emulate this one in OS/2???
469//******************************************************************************
470DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
471{
472#ifdef DEBUG
473 WriteLog("USER32: WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
474#endif
475
476 if(dwTimeOut == INFINITE) return(0);
477
478// DosSleep(dwTimeOut/16);
479 return(0);
480}
481//******************************************************************************
482//******************************************************************************
483int WIN32API ShowCursor( BOOL arg1)
484{
485#ifdef DEBUG
486 WriteLog("USER32: ShowCursor\n");
487#endif
488 //WinShowCursor(HWND_DESKTOP,arg1); //not the same
489 return O32_ShowCursor(arg1);
490}
491//******************************************************************************
492//******************************************************************************
493BOOL WIN32API SetRect( PRECT lprc, int nLeft, int nTop, int nRight, int nBottom)
494{
495#ifdef DEBUG
496 WriteLog("USER32: SetRect\n");
497#endif
498
499 lprc->left = nLeft;
500 lprc->top = nTop;
501 lprc->right = nRight;
502 lprc->bottom = nBottom;
503
504 return TRUE;
505}
506//******************************************************************************
507//******************************************************************************
508BOOL WIN32API WinHelpA( HWND arg1, LPCSTR arg2, UINT arg3, DWORD arg4)
509{
510#ifdef DEBUG
511 WriteLog("USER32: WinHelp not implemented %s\n", arg2);
512#endif
513// return O32_WinHelp(arg1, arg2, arg3, arg4);
514 return(TRUE);
515}
516//******************************************************************************
517//******************************************************************************
518int WIN32API TranslateAcceleratorA(HWND arg1, HACCEL arg2, LPMSG arg3)
519{
520#ifdef DEBUG
521//// WriteLog("USER32: TranslateAccelerator\n");
522#endif
523 //WinTranslateAccel();
524 //get hab, translate
525 return O32_TranslateAccelerator(arg1, arg2, arg3);
526}
527//******************************************************************************
528//******************************************************************************
529BOOL WIN32API SubtractRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
530{
531#ifdef DEBUG
532 WriteLog("USER32: SubtractRect");
533#endif
534 // how?
535 return O32_SubtractRect(arg1, arg2, arg3);
536}
537//******************************************************************************
538//SvL: 24-6-'97 - Added
539//******************************************************************************
540BOOL WIN32API ClipCursor(const RECT * arg1)
541{
542#ifdef DEBUG
543 WriteLog("USER32: ClipCursor\n");
544#endif
545 return O32_ClipCursor(arg1);
546}
547//******************************************************************************
548//SvL: 24-6-'97 - Added
549//TODO: Not implemented
550//******************************************************************************
551WORD WIN32API GetAsyncKeyState(INT nVirtKey)
552{
553#ifdef DEBUG
554//// WriteLog("USER32: GetAsyncKeyState Not implemented\n");
555#endif
556 return 0;
557}
558//******************************************************************************
559//SvL: 24-6-'97 - Added
560//******************************************************************************
561HCURSOR WIN32API GetCursor(void)
562{
563#ifdef DEBUG
564//// WriteLog("USER32: GetCursor\n");
565#endif
566 return O32_GetCursor();
567}
568//******************************************************************************
569//SvL: 24-6-'97 - Added
570//******************************************************************************
571BOOL WIN32API GetCursorPos( PPOINT arg1)
572{
573#ifdef DEBUG
574//// WriteLog("USER32: GetCursorPos\n");
575#endif
576 return O32_GetCursorPos(arg1);
577}
578//******************************************************************************
579//SvL: 24-6-'97 - Added
580//******************************************************************************
581WORD WIN32API VkKeyScanA( char arg1)
582{
583#ifdef DEBUG
584 WriteLog("USER32: VkKeyScanA\n");
585#endif
586 return O32_VkKeyScan(arg1);
587}
588//******************************************************************************
589//SvL: 24-6-'97 - Added
590//******************************************************************************
591SHORT WIN32API GetKeyState( int arg1)
592{
593#ifdef DEBUG
594 WriteLog("USER32: GetKeyState %d\n", arg1);
595#endif
596 return O32_GetKeyState(arg1);
597}
598//******************************************************************************
599//******************************************************************************
600HCURSOR WIN32API SetCursor( HCURSOR arg1)
601{
602#ifdef DEBUG
603 WriteLog("USER32: SetCursor\n");
604#endif
605 return O32_SetCursor(arg1);
606}
607//******************************************************************************
608//******************************************************************************
609BOOL WIN32API SetCursorPos( int arg1, int arg2)
610{
611#ifdef DEBUG
612 WriteLog("USER32: SetCursorPos\n");
613#endif
614 return O32_SetCursorPos(arg1, arg2);
615}
616//******************************************************************************
617//******************************************************************************
618BOOL WIN32API EnableScrollBar( HWND arg1, INT arg2, UINT arg3)
619{
620#ifdef DEBUG
621 WriteLog("USER32: EnableScrollBar\n");
622#endif
623 return O32_EnableScrollBar(arg1, arg2, arg3);
624}
625//******************************************************************************
626//******************************************************************************
627HWND WIN32API SetCapture( HWND arg1)
628{
629#ifdef DEBUG
630 WriteLog("USER32: SetCapture\n");
631#endif
632 return O32_SetCapture(arg1);
633}
634//******************************************************************************
635//******************************************************************************
636BOOL WIN32API ReleaseCapture(void)
637{
638#ifdef DEBUG
639 WriteLog("USER32: ReleaseCapture\n");
640#endif
641 return O32_ReleaseCapture();
642}
643//******************************************************************************
644//******************************************************************************
645DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD arg5)
646{
647#ifdef DEBUG
648 WriteLog("USER32: MsgWaitForMultipleObjects\n");
649#endif
650 return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
651}
652//******************************************************************************
653//******************************************************************************
654BOOL WIN32API ChangeClipboardChain( HWND arg1, HWND arg2)
655{
656#ifdef DEBUG
657 WriteLog("USER32: ChangeClipboardChain\n");
658#endif
659 return O32_ChangeClipboardChain(arg1, arg2);
660}
661//******************************************************************************
662//******************************************************************************
663UINT WIN32API ArrangeIconicWindows( HWND arg1)
664{
665#ifdef DEBUG
666 WriteLog("USER32: ArrangeIconicWindows\n");
667#endif
668 return O32_ArrangeIconicWindows(arg1);
669}
670//******************************************************************************
671//******************************************************************************
672BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT arg4)
673{
674#ifdef DEBUG
675 WriteLog("USER32: CheckRadioButton\n");
676#endif
677 //CB: check radio buttons in interval
678 if (arg2 > arg3) return (FALSE);
679 for (UINT x=arg2;x <= arg3;x++)
680 {
681 SendDlgItemMessageA(arg1,x,BM_SETCHECK,(x == arg4) ? BST_CHECKED : BST_UNCHECKED,0);
682 }
683 return (TRUE);
684}
685//******************************************************************************
686//******************************************************************************
687BOOL WIN32API CloseClipboard(void)
688{
689#ifdef DEBUG
690 WriteLog("USER32: CloseClipboard\n");
691#endif
692 return O32_CloseClipboard();
693}
694//******************************************************************************
695//******************************************************************************
696HICON WIN32API CopyIcon( HICON arg1)
697{
698#ifdef DEBUG
699 WriteLog("USER32: CopyIcon\n");
700#endif
701 return O32_CopyIcon(arg1);
702}
703//******************************************************************************
704//******************************************************************************
705int WIN32API CountClipboardFormats(void)
706{
707#ifdef DEBUG
708 WriteLog("USER32: CountClipboardFormats\n");
709#endif
710 return O32_CountClipboardFormats();
711}
712//******************************************************************************
713//******************************************************************************
714HACCEL WIN32API CreateAcceleratorTableA( LPACCEL arg1, int arg2)
715{
716#ifdef DEBUG
717 WriteLog("USER32: CreateAcceleratorTableA\n");
718#endif
719 return O32_CreateAcceleratorTable(arg1, arg2);
720}
721//******************************************************************************
722//******************************************************************************
723HACCEL WIN32API CreateAcceleratorTableW( LPACCEL arg1, int arg2)
724{
725#ifdef DEBUG
726 WriteLog("USER32: CreateAcceleratorTableW\n");
727#endif
728 // NOTE: This will not work as is (needs UNICODE support)
729 return O32_CreateAcceleratorTable(arg1, arg2);
730}
731//******************************************************************************
732//******************************************************************************
733BOOL WIN32API CreateCaret( HWND arg1, HBITMAP arg2, int arg3, int arg4)
734{
735#ifdef DEBUG
736 WriteLog("USER32: CreateCaret\n");
737#endif
738 return O32_CreateCaret(arg1, arg2, arg3, arg4);
739}
740//******************************************************************************
741//******************************************************************************
742HCURSOR WIN32API CreateCursor( HINSTANCE arg1, int arg2, int arg3, int arg4, int arg5, const VOID * arg6, const VOID * arg7)
743{
744#ifdef DEBUG
745 WriteLog("USER32: CreateCursor\n");
746#endif
747 return O32_CreateCursor(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
748}
749//******************************************************************************
750//******************************************************************************
751HICON WIN32API CreateIcon( HINSTANCE arg1, INT arg2, INT arg3, BYTE arg4, BYTE arg5, LPCVOID arg6, LPCVOID arg7)
752{
753#ifdef DEBUG
754 WriteLog("USER32: CreateIcon\n");
755#endif
756 return O32_CreateIcon(arg1, arg2, arg3, arg4, arg5, (const BYTE *)arg6, (const BYTE *)arg7);
757}
758//******************************************************************************
759//ASSERT dwVer == win31 (ok according to SDK docs)
760//******************************************************************************
761HICON WIN32API CreateIconFromResource(PBYTE presbits, UINT dwResSize,
762 BOOL fIcon, DWORD dwVer)
763{
764 HICON hicon;
765 DWORD OS2ResSize = 0;
766 PBYTE OS2Icon = ConvertWin32Icon(presbits, dwResSize, &OS2ResSize);
767
768 hicon = O32_CreateIconFromResource(OS2Icon, OS2ResSize, fIcon, dwVer);
769#ifdef DEBUG
770 WriteLog("USER32: CreateIconFromResource returned %X (%X)\n", hicon, GetLastError());
771#endif
772 if(OS2Icon)
773 FreeIcon(OS2Icon);
774
775 return(hicon);
776}
777//******************************************************************************
778//******************************************************************************
779HICON WIN32API CreateIconFromResourceEx(PBYTE presbits, UINT dwResSize,
780 BOOL fIcon, DWORD dwVer,
781 int cxDesired, int cyDesired,
782 UINT Flags)
783{
784#ifdef DEBUG
785 WriteLog("USER32: CreateIconFromResourceEx %X %d %d %X %d %d %X, not completely supported!\n", presbits, dwResSize, fIcon, dwVer, cxDesired, cyDesired, Flags);
786#endif
787 return CreateIconFromResource(presbits, dwResSize, fIcon, dwVer);
788}
789//******************************************************************************
790//******************************************************************************
791HICON WIN32API CreateIconIndirect(LPICONINFO arg1)
792{
793#ifdef DEBUG
794 WriteLog("USER32: CreateIconIndirect\n");
795#endif
796 return O32_CreateIconIndirect(arg1);
797}
798//******************************************************************************
799//******************************************************************************
800//******************************************************************************
801//******************************************************************************
802BOOL WIN32API DestroyAcceleratorTable( HACCEL arg1)
803{
804#ifdef DEBUG
805 WriteLog("USER32: DestroyAcceleratorTable\n");
806#endif
807 return O32_DestroyAcceleratorTable(arg1);
808}
809//******************************************************************************
810//******************************************************************************
811BOOL WIN32API DestroyCaret(void)
812{
813#ifdef DEBUG
814 WriteLog("USER32: DestroyCaret\n");
815#endif
816 return O32_DestroyCaret();
817}
818//******************************************************************************
819//******************************************************************************
820BOOL WIN32API DestroyCursor( HCURSOR arg1)
821{
822#ifdef DEBUG
823 WriteLog("USER32: DestroyCursor\n");
824#endif
825 return O32_DestroyCursor(arg1);
826}
827//******************************************************************************
828//******************************************************************************
829BOOL WIN32API DestroyIcon( HICON arg1)
830{
831#ifdef DEBUG
832 WriteLog("USER32: DestroyIcon\n");
833#endif
834 return O32_DestroyIcon(arg1);
835}
836//******************************************************************************
837//******************************************************************************
838BOOL WIN32API EmptyClipboard(void)
839{
840#ifdef DEBUG
841 WriteLog("USER32: EmptyClipboard\n");
842#endif
843 return O32_EmptyClipboard();
844}
845//******************************************************************************
846//******************************************************************************
847BOOL WIN32API EndDeferWindowPos( HDWP arg1)
848{
849#ifdef DEBUG
850 WriteLog("USER32: EndDeferWindowPos\n");
851#endif
852 return O32_EndDeferWindowPos(arg1);
853}
854//******************************************************************************
855//******************************************************************************
856BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
857{
858 BOOL rc;
859 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
860
861#ifdef DEBUG
862 WriteLog("USER32: EnumChildWindows\n");
863#endif
864 rc = O32_EnumChildWindows(hwnd, callback->GetOS2Callback(), (LPARAM)callback);
865 if(callback)
866 delete callback;
867 return(rc);
868}
869//******************************************************************************
870//******************************************************************************
871UINT WIN32API EnumClipboardFormats(UINT arg1)
872{
873#ifdef DEBUG
874 WriteLog("USER32: EnumClipboardFormats\n");
875#endif
876 return O32_EnumClipboardFormats(arg1);
877}
878//******************************************************************************
879//******************************************************************************
880BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
881{
882 BOOL rc;
883 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
884
885#ifdef DEBUG
886 WriteLog("USER32: EnumWindows\n");
887#endif
888 rc = O32_EnumWindows(callback->GetOS2Callback(), (LPARAM)callback);
889 if(callback)
890 delete callback;
891 return(rc);
892}
893//******************************************************************************
894//******************************************************************************
895BOOL WIN32API EqualRect( const RECT * arg1, const RECT * arg2)
896{
897#ifdef DEBUG
898 WriteLog("USER32: EqualRect\n");
899#endif
900 return O32_EqualRect(arg1, arg2);
901}
902//******************************************************************************
903//******************************************************************************
904BOOL WIN32API ExcludeUpdateRgn( HDC arg1, HWND arg2)
905{
906#ifdef DEBUG
907 WriteLog("USER32: ExcludeUpdateRgn\n");
908#endif
909 return O32_ExcludeUpdateRgn(arg1, arg2);
910}
911//******************************************************************************
912//******************************************************************************
913BOOL WIN32API ExitWindowsEx( UINT arg1, DWORD arg2)
914{
915#ifdef DEBUG
916 WriteLog("USER32: ExitWindowsEx\n");
917#endif
918 return O32_ExitWindowsEx(arg1, arg2);
919}
920//******************************************************************************
921//******************************************************************************
922int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
923{
924#ifdef DEBUG
925 WriteLog("USER32: FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
926#endif
927 return O32_FillRect(arg1, arg2, arg3);
928}
929//******************************************************************************
930//******************************************************************************
931HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
932{
933 char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
934 char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
935 HWND rc;
936
937#ifdef DEBUG
938 WriteLog("USER32: FindWindowW\n");
939#endif
940 rc = O32_FindWindow(astring1, astring2);
941 FreeAsciiString(astring1);
942 FreeAsciiString(astring2);
943 return rc;
944}
945//******************************************************************************
946//******************************************************************************
947int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH arg3)
948{
949#ifdef DEBUG
950 WriteLog("USER32: FrameRect\n");
951#endif
952 return O32_FrameRect(arg1, arg2, arg3);
953}
954//******************************************************************************
955//******************************************************************************
956HWND WIN32API GetCapture(void)
957{
958#ifdef DEBUG
959 WriteLog("USER32: GetCapture\n");
960#endif
961 return O32_GetCapture();
962}
963//******************************************************************************
964//******************************************************************************
965UINT WIN32API GetCaretBlinkTime(void)
966{
967#ifdef DEBUG
968 WriteLog("USER32: GetCaretBlinkTime\n");
969#endif
970 return O32_GetCaretBlinkTime();
971}
972//******************************************************************************
973//******************************************************************************
974BOOL WIN32API GetCaretPos( PPOINT arg1)
975{
976#ifdef DEBUG
977 WriteLog("USER32: GetCaretPos\n");
978#endif
979 return O32_GetCaretPos(arg1);
980}
981//******************************************************************************
982//******************************************************************************
983BOOL WIN32API GetClipCursor( PRECT arg1)
984{
985#ifdef DEBUG
986 WriteLog("USER32: GetClipCursor\n");
987#endif
988 return O32_GetClipCursor(arg1);
989}
990//******************************************************************************
991//******************************************************************************
992HANDLE WIN32API GetClipboardData( UINT arg1)
993{
994#ifdef DEBUG
995 WriteLog("USER32: GetClipboardData\n");
996#endif
997 return O32_GetClipboardData(arg1);
998}
999//******************************************************************************
1000//******************************************************************************
1001int WIN32API GetClipboardFormatNameA( UINT arg1, LPSTR arg2, int arg3)
1002{
1003#ifdef DEBUG
1004 WriteLog("USER32: GetClipboardFormatNameA %s\n", arg2);
1005#endif
1006 return O32_GetClipboardFormatName(arg1, arg2, arg3);
1007}
1008//******************************************************************************
1009//******************************************************************************
1010int WIN32API GetClipboardFormatNameW(UINT arg1, LPWSTR arg2, int arg3)
1011{
1012 int rc;
1013 char *astring = UnicodeToAsciiString(arg2);
1014
1015#ifdef DEBUG
1016 WriteLog("USER32: GetClipboardFormatNameW %s\n", astring);
1017#endif
1018 rc = O32_GetClipboardFormatName(arg1, astring, arg3);
1019 FreeAsciiString(astring);
1020 return(rc);
1021}
1022//******************************************************************************
1023//******************************************************************************
1024HWND WIN32API GetClipboardOwner(void)
1025{
1026#ifdef DEBUG
1027 WriteLog("USER32: GetClipboardOwner\n");
1028#endif
1029 return O32_GetClipboardOwner();
1030}
1031//******************************************************************************
1032//******************************************************************************
1033HWND WIN32API GetClipboardViewer(void)
1034{
1035#ifdef DEBUG
1036 WriteLog("USER32: GetClipboardViewer\n");
1037#endif
1038 return O32_GetClipboardViewer();
1039}
1040//******************************************************************************
1041//******************************************************************************
1042UINT WIN32API GetDoubleClickTime(void)
1043{
1044#ifdef DEBUG
1045 WriteLog("USER32: GetDoubleClickTime\n");
1046#endif
1047 return O32_GetDoubleClickTime();
1048}
1049//******************************************************************************
1050//******************************************************************************
1051HWND WIN32API GetForegroundWindow(void)
1052{
1053#ifdef DEBUG
1054 WriteLog("USER32: GetForegroundWindow\n");
1055#endif
1056 return O32_GetForegroundWindow();
1057}
1058//******************************************************************************
1059//******************************************************************************
1060BOOL WIN32API GetIconInfo( HICON arg1, LPICONINFO arg2)
1061{
1062#ifdef DEBUG
1063 WriteLog("USER32: GetIconInfo\n");
1064#endif
1065 return O32_GetIconInfo(arg1, arg2);
1066}
1067//******************************************************************************
1068//******************************************************************************
1069int WIN32API GetKeyNameTextA( LPARAM arg1, LPSTR arg2, int arg3)
1070{
1071#ifdef DEBUG
1072 WriteLog("USER32: GetKeyNameTextA\n");
1073#endif
1074 return O32_GetKeyNameText(arg1, arg2, arg3);
1075}
1076//******************************************************************************
1077//******************************************************************************
1078int WIN32API GetKeyNameTextW( LPARAM arg1, LPWSTR arg2, int arg3)
1079{
1080#ifdef DEBUG
1081 WriteLog("USER32: GetKeyNameTextW DOES NOT WORK\n");
1082#endif
1083 // NOTE: This will not work as is (needs UNICODE support)
1084 return 0;
1085// return O32_GetKeyNameText(arg1, arg2, arg3);
1086}
1087//******************************************************************************
1088//******************************************************************************
1089int WIN32API GetKeyboardType( int arg1)
1090{
1091#ifdef DEBUG
1092 WriteLog("USER32: GetKeyboardType\n");
1093#endif
1094 return O32_GetKeyboardType(arg1);
1095}
1096//******************************************************************************
1097//******************************************************************************
1098HWND WIN32API GetLastActivePopup( HWND arg1)
1099{
1100#ifdef DEBUG
1101 WriteLog("USER32: GetLastActivePopup\n");
1102#endif
1103 return O32_GetLastActivePopup(arg1);
1104}
1105//******************************************************************************
1106//******************************************************************************
1107//******************************************************************************
1108//******************************************************************************
1109HWND WIN32API GetOpenClipboardWindow(void)
1110{
1111#ifdef DEBUG
1112 WriteLog("USER32: GetOpenClipboardWindow\n");
1113#endif
1114 return O32_GetOpenClipboardWindow();
1115}
1116//******************************************************************************
1117//******************************************************************************
1118int WIN32API GetPriorityClipboardFormat( PUINT arg1, int arg2)
1119{
1120#ifdef DEBUG
1121 WriteLog("USER32: GetPriorityClipboardFormat\n");
1122#endif
1123 return O32_GetPriorityClipboardFormat(arg1, arg2);
1124}
1125//******************************************************************************
1126//******************************************************************************
1127DWORD WIN32API GetQueueStatus( UINT arg1)
1128{
1129#ifdef DEBUG
1130 WriteLog("USER32: GetQueueStatus\n");
1131#endif
1132 return O32_GetQueueStatus(arg1);
1133}
1134//******************************************************************************
1135//******************************************************************************
1136int WIN32API GetScrollPos(HWND hwnd, int fnBar)
1137{
1138 int pos;
1139
1140 pos = O32_GetScrollPos(hwnd, fnBar);
1141#ifdef DEBUG
1142 WriteLog("USER32: GetScrollPos of %X type %d returned %d\n", hwnd, fnBar, pos);
1143#endif
1144 return(pos);
1145}
1146//******************************************************************************
1147//******************************************************************************
1148BOOL WIN32API GetScrollRange( HWND arg1, int arg2, int * arg3, int * arg4)
1149{
1150#ifdef DEBUG
1151 WriteLog("USER32: GetScrollRange\n");
1152#endif
1153 return O32_GetScrollRange(arg1, arg2, arg3, arg4);
1154}
1155//******************************************************************************
1156//******************************************************************************
1157DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
1158{
1159#ifdef DEBUG
1160 WriteLog("USER32: GetTabbedTextExtentA\n");
1161#endif
1162 return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
1163}
1164//******************************************************************************
1165//******************************************************************************
1166DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
1167{
1168 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1169 DWORD rc;
1170
1171#ifdef DEBUG
1172 WriteLog("USER32: GetTabbedTextExtentW\n");
1173#endif
1174 rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
1175 FreeAsciiString(astring);
1176 return rc;
1177}
1178//******************************************************************************
1179//******************************************************************************
1180int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL arg3)
1181{
1182#ifdef DEBUG
1183 WriteLog("USER32: GetUpdateRgn\n");
1184#endif
1185 return O32_GetUpdateRgn(arg1, arg2, arg3);
1186}
1187//******************************************************************************
1188//******************************************************************************
1189BOOL WIN32API GetWindowPlacement( HWND arg1, LPWINDOWPLACEMENT arg2)
1190{
1191#ifdef DEBUG
1192 WriteLog("USER32: GetWindowPlacement\n");
1193#endif
1194 return O32_GetWindowPlacement(arg1, arg2);
1195}
1196//******************************************************************************
1197
1198
1199//******************************************************************************
1200int WIN32API GetWindowTextLengthW( HWND arg1)
1201{
1202#ifdef DEBUG
1203 WriteLog("USER32: GetWindowTextLengthW\n");
1204#endif
1205 return O32_GetWindowTextLength(arg1);
1206}
1207//******************************************************************************
1208//******************************************************************************
1209int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
1210{
1211 char title[128];
1212 int rc;
1213
1214 rc = O32_GetWindowText(hwnd, title, sizeof(title));
1215#ifdef DEBUG
1216 WriteLog("USER32: GetWindowTextW returned %s\n", title);
1217#endif
1218 if(rc > cch) {
1219 title[cch-1] = 0;
1220 rc = cch;
1221 }
1222 AsciiToUnicode(title, lpsz);
1223 return(rc);
1224}
1225//******************************************************************************
1226//******************************************************************************
1227DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD arg2)
1228{
1229#ifdef DEBUG
1230 WriteLog("USER32: GetWindowThreadProcessId\n");
1231#endif
1232 return O32_GetWindowThreadProcessId(arg1, arg2);
1233}
1234//******************************************************************************
1235//******************************************************************************
1236BOOL WIN32API HideCaret( HWND arg1)
1237{
1238#ifdef DEBUG
1239 WriteLog("USER32: HideCaret\n");
1240#endif
1241 return O32_HideCaret(arg1);
1242}
1243//******************************************************************************
1244//******************************************************************************
1245BOOL WIN32API IntersectRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
1246{
1247#ifdef DEBUG
1248//// WriteLog("USER32: IntersectRect\n");
1249#endif
1250 return O32_IntersectRect(arg1, arg2, arg3);
1251}
1252//******************************************************************************
1253//******************************************************************************
1254BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL arg3)
1255{
1256#ifdef DEBUG
1257 WriteLog("USER32: InvalidateRgn\n");
1258#endif
1259 return O32_InvalidateRgn(arg1, arg2, arg3);
1260}
1261//******************************************************************************
1262//******************************************************************************
1263BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
1264{
1265#ifdef DEBUG
1266 WriteLog("USER32: InvertRect\n");
1267#endif
1268 return O32_InvertRect(arg1, arg2);
1269}
1270//******************************************************************************
1271//******************************************************************************
1272BOOL WIN32API IsClipboardFormatAvailable( UINT arg1)
1273{
1274#ifdef DEBUG
1275 WriteLog("USER32: IsClipboardFormatAvailable\n");
1276#endif
1277 return O32_IsClipboardFormatAvailable(arg1);
1278}
1279//******************************************************************************
1280//******************************************************************************
1281BOOL WIN32API IsRectEmpty( const RECT * arg1)
1282{
1283#ifdef DEBUG
1284 WriteLog("USER32: IsRectEmpty\n");
1285#endif
1286 return O32_IsRectEmpty(arg1);
1287}
1288//******************************************************************************
1289//******************************************************************************
1290BOOL WIN32API MapDialogRect( HWND arg1, PRECT arg2)
1291{
1292#ifdef DEBUG
1293 WriteLog("USER32: MapDialogRect\n");
1294#endif
1295 return O32_MapDialogRect(arg1, arg2);
1296}
1297//******************************************************************************
1298//******************************************************************************
1299UINT WIN32API MapVirtualKeyA( UINT arg1, UINT arg2)
1300{
1301#ifdef DEBUG
1302 WriteLog("USER32: MapVirtualKeyA\n");
1303#endif
1304 return O32_MapVirtualKey(arg1, arg2);
1305}
1306//******************************************************************************
1307//******************************************************************************
1308UINT WIN32API MapVirtualKeyW( UINT arg1, UINT arg2)
1309{
1310#ifdef DEBUG
1311 WriteLog("USER32: MapVirtualKeyW\n");
1312#endif
1313 // NOTE: This will not work as is (needs UNICODE support)
1314 return O32_MapVirtualKey(arg1, arg2);
1315}
1316//******************************************************************************
1317//******************************************************************************
1318int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
1319{
1320#ifdef DEBUG
1321 WriteLog("USER32: MapWindowPoints\n");
1322#endif
1323 return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
1324}
1325//******************************************************************************
1326//******************************************************************************
1327BOOL WIN32API OpenClipboard( HWND arg1)
1328{
1329#ifdef DEBUG
1330 WriteLog("USER32: OpenClipboard\n");
1331#endif
1332 return O32_OpenClipboard(arg1);
1333}
1334//******************************************************************************
1335//******************************************************************************
1336BOOL WIN32API PtInRect( const RECT * arg1, POINT arg2)
1337{
1338#ifdef DEBUG1
1339 WriteLog("USER32: PtInRect\n");
1340#endif
1341 return O32_PtInRect(arg1, arg2);
1342}
1343//******************************************************************************
1344//******************************************************************************
1345UINT WIN32API RegisterClipboardFormatA( LPCSTR arg1)
1346{
1347#ifdef DEBUG
1348 WriteLog("USER32: RegisterClipboardFormatA\n");
1349#endif
1350 return O32_RegisterClipboardFormat(arg1);
1351}
1352//******************************************************************************
1353//******************************************************************************
1354UINT WIN32API RegisterClipboardFormatW(LPCWSTR arg1)
1355{
1356 UINT rc;
1357 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
1358
1359#ifdef DEBUG
1360 WriteLog("USER32: RegisterClipboardFormatW %s\n", astring);
1361#endif
1362 rc = O32_RegisterClipboardFormat(astring);
1363 FreeAsciiString(astring);
1364#ifdef DEBUG
1365 WriteLog("USER32: RegisterClipboardFormatW returned %d\n", rc);
1366#endif
1367 return(rc);
1368}
1369//******************************************************************************
1370//******************************************************************************
1371BOOL WIN32API ScreenToClient( HWND arg1, LPPOINT arg2)
1372{
1373#ifdef DEBUG
1374 WriteLog("USER32: ScreenToClient\n");
1375#endif
1376 return O32_ScreenToClient(arg1, arg2);
1377}
1378//******************************************************************************
1379//******************************************************************************
1380BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7)
1381{
1382#ifdef DEBUG
1383 WriteLog("USER32: ScrollDC\n");
1384#endif
1385 return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1386}
1387//******************************************************************************
1388//******************************************************************************
1389BOOL WIN32API ScrollWindow( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5)
1390{
1391#ifdef DEBUG
1392 WriteLog("USER32: ScrollWindow\n");
1393#endif
1394 return O32_ScrollWindow(arg1, arg2, arg3, arg4, arg5);
1395}
1396//******************************************************************************
1397//******************************************************************************
1398BOOL WIN32API ScrollWindowEx( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7, UINT arg8)
1399{
1400#ifdef DEBUG
1401 WriteLog("USER32: ScrollWindowEx\n");
1402#endif
1403 return O32_ScrollWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1404}
1405//******************************************************************************
1406//******************************************************************************
1407BOOL WIN32API SetCaretBlinkTime( UINT arg1)
1408{
1409#ifdef DEBUG
1410 WriteLog("USER32: SetCaretBlinkTime\n");
1411#endif
1412 return O32_SetCaretBlinkTime(arg1);
1413}
1414//******************************************************************************
1415//******************************************************************************
1416BOOL WIN32API SetCaretPos( int arg1, int arg2)
1417{
1418 dprintf(("USER32: SetCaretPos\n"));
1419 return O32_SetCaretPos(arg1, arg2);
1420}
1421//******************************************************************************
1422//******************************************************************************
1423HANDLE WIN32API SetClipboardData( UINT arg1, HANDLE arg2)
1424{
1425 dprintf(("USER32: SetClipboardData\n"));
1426 return O32_SetClipboardData(arg1, arg2);
1427}
1428//******************************************************************************
1429//******************************************************************************
1430HWND WIN32API SetClipboardViewer( HWND arg1)
1431{
1432 dprintf(("USER32: SetClipboardViewer\n"));
1433 return O32_SetClipboardViewer(arg1);
1434}
1435//******************************************************************************
1436//******************************************************************************
1437BOOL WIN32API SetDoubleClickTime( UINT arg1)
1438{
1439#ifdef DEBUG
1440 WriteLog("USER32: SetDoubleClickTime\n");
1441#endif
1442 return O32_SetDoubleClickTime(arg1);
1443}
1444//******************************************************************************
1445//******************************************************************************
1446BOOL WIN32API SetRectEmpty( PRECT arg1)
1447{
1448#ifdef DEBUG
1449 WriteLog("USER32: SetRectEmpty\n");
1450#endif
1451 return O32_SetRectEmpty(arg1);
1452}
1453//******************************************************************************
1454//******************************************************************************
1455int WIN32API SetScrollPos( HWND arg1, int arg2, int arg3, BOOL arg4)
1456{
1457#ifdef DEBUG
1458 WriteLog("USER32: SetScrollPos\n");
1459#endif
1460 return O32_SetScrollPos(arg1, arg2, arg3, arg4);
1461}
1462//******************************************************************************
1463//******************************************************************************
1464BOOL WIN32API SetScrollRange( HWND arg1, int arg2, int arg3, int arg4, BOOL arg5)
1465{
1466#ifdef DEBUG
1467 WriteLog("USER32: SetScrollRange\n");
1468#endif
1469 return O32_SetScrollRange(arg1, arg2, arg3, arg4, arg5);
1470}
1471//******************************************************************************
1472//******************************************************************************
1473BOOL WIN32API SetWindowPlacement( HWND arg1, const WINDOWPLACEMENT * arg2)
1474{
1475 dprintf(("USER32: SetWindowPlacement\n"));
1476 return O32_SetWindowPlacement(arg1, arg2);
1477}
1478//******************************************************************************
1479//******************************************************************************
1480BOOL WIN32API ShowCaret( HWND arg1)
1481{
1482 dprintf(("USER32: ShowCaret\n"));
1483 return O32_ShowCaret(arg1);
1484}
1485//******************************************************************************
1486//******************************************************************************
1487BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
1488{
1489 dprintf(("USER32: ShowOwnedPopups\n"));
1490 return O32_ShowOwnedPopups(arg1, arg2);
1491}
1492//******************************************************************************
1493//******************************************************************************
1494BOOL WIN32API ShowScrollBar( HWND arg1, int arg2, BOOL arg3)
1495{
1496#ifdef DEBUG
1497 WriteLog("USER32: ShowScrollBar\n");
1498#endif
1499 return O32_ShowScrollBar(arg1, arg2, arg3);
1500}
1501//******************************************************************************
1502//******************************************************************************
1503BOOL WIN32API SwapMouseButton( BOOL arg1)
1504{
1505#ifdef DEBUG
1506 WriteLog("USER32: SwapMouseButton\n");
1507#endif
1508 return O32_SwapMouseButton(arg1);
1509}
1510//******************************************************************************
1511//******************************************************************************
1512BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
1513{
1514 BOOL rc;
1515 NONCLIENTMETRICSA *cmetric = (NONCLIENTMETRICSA *)pvParam;
1516
1517 switch(uiAction) {
1518 case SPI_SCREENSAVERRUNNING:
1519 *(BOOL *)pvParam = FALSE;
1520 rc = TRUE;
1521 break;
1522 case SPI_GETDRAGFULLWINDOWS:
1523 *(BOOL *)pvParam = FALSE;
1524 rc = TRUE;
1525 break;
1526 case SPI_GETNONCLIENTMETRICS:
1527 memset(cmetric, 0, sizeof(NONCLIENTMETRICSA));
1528 cmetric->cbSize = sizeof(NONCLIENTMETRICSA);
1529 //CB: font info not valid, needs improvements
1530 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfCaptionFont),0);
1531 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMenuFont),0);
1532 //CB: experimental change for statusbar (and tooltips)
1533
1534 //O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfStatusFont),0);
1535 lstrcpyA(cmetric->lfStatusFont.lfFaceName,"WarpSans");
1536 cmetric->lfStatusFont.lfHeight = 9;
1537
1538 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMessageFont),0);
1539 cmetric->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
1540 cmetric->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
1541 cmetric->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
1542 cmetric->iCaptionWidth = 32; //TODO
1543 cmetric->iCaptionHeight = 16; //TODO
1544 cmetric->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
1545 cmetric->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
1546 cmetric->iMenuWidth = 32; //TODO
1547 cmetric->iMenuHeight = GetSystemMetrics(SM_CYMENU);
1548 rc = TRUE;
1549 break;
1550 case 104: //TODO: Undocumented
1551 rc = 16;
1552 break;
1553 default:
1554 rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
1555 break;
1556 }
1557#ifdef DEBUG
1558 WriteLog("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc);
1559#endif
1560 return(rc);
1561}
1562//******************************************************************************
1563//TODO: Check for more options that have different structs for Unicode!!!!
1564//******************************************************************************
1565BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
1566{
1567 BOOL rc;
1568 NONCLIENTMETRICSW *clientMetricsW = (NONCLIENTMETRICSW *)pvParam;
1569 NONCLIENTMETRICSA clientMetricsA = {0};
1570 PVOID pvParamA;
1571 UINT uiParamA;
1572
1573 switch(uiAction) {
1574 case SPI_SETNONCLIENTMETRICS:
1575 clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
1576 clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
1577 clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
1578 clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
1579 clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
1580 clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
1581 ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
1582 clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
1583 clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
1584 ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
1585 clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
1586 clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
1587 ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
1588 ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
1589 ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
1590 //no break
1591 case SPI_GETNONCLIENTMETRICS:
1592 uiParamA = sizeof(NONCLIENTMETRICSA);
1593 pvParamA = &clientMetricsA;
1594 break;
1595 default:
1596 pvParamA = pvParam;
1597 uiParamA = uiParam;
1598 break;
1599 }
1600 rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
1601
1602 switch(uiAction) {
1603 case SPI_GETNONCLIENTMETRICS:
1604 clientMetricsW->cbSize = sizeof(*clientMetricsW);
1605 clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
1606 clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
1607 clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
1608 clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
1609 clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
1610 ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
1611
1612 clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
1613 clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
1614 ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
1615
1616 clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
1617 clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
1618 ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
1619 ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
1620 ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
1621 break;
1622 }
1623#ifdef DEBUG
1624 WriteLog("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc);
1625#endif
1626 return(rc);
1627}
1628//******************************************************************************
1629//******************************************************************************
1630LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int arg8)
1631{
1632#ifdef DEBUG
1633 WriteLog("USER32: TabbedTextOutA\n");
1634#endif
1635 return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1636}
1637//******************************************************************************
1638//******************************************************************************
1639LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int arg8)
1640{
1641 char *astring = UnicodeToAsciiString((LPWSTR)arg4);
1642 LONG rc;
1643
1644#ifdef DEBUG
1645 WriteLog("USER32: TabbedTextOutW\n");
1646#endif
1647 rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
1648 FreeAsciiString(astring);
1649 return rc;
1650}
1651//******************************************************************************
1652//******************************************************************************
1653int WIN32API TranslateAccelerator( HWND arg1, HACCEL arg2, LPMSG arg3)
1654{
1655#ifdef DEBUG
1656 WriteLog("USER32: TranslateAccelerator\n");
1657#endif
1658 return O32_TranslateAccelerator(arg1, arg2, arg3);
1659}
1660//******************************************************************************
1661//******************************************************************************
1662int WIN32API TranslateAcceleratorW( HWND arg1, HACCEL arg2, LPMSG arg3)
1663{
1664#ifdef DEBUG
1665 WriteLog("USER32: TranslateAcceleratorW\n");
1666#endif
1667 // NOTE: This will not work as is (needs UNICODE support)
1668 return O32_TranslateAccelerator(arg1, arg2, arg3);
1669}
1670//******************************************************************************
1671//******************************************************************************
1672BOOL WIN32API TranslateMDISysAccel( HWND arg1, LPMSG arg2)
1673{
1674#ifdef DEBUG
1675//// WriteLog("USER32: TranslateMDISysAccel\n");
1676#endif
1677 return O32_TranslateMDISysAccel(arg1, arg2);
1678}
1679//******************************************************************************
1680//******************************************************************************
1681BOOL WIN32API UnionRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
1682{
1683#ifdef DEBUG
1684 WriteLog("USER32: UnionRect\n");
1685#endif
1686 return O32_UnionRect(arg1, arg2, arg3);
1687}
1688//******************************************************************************
1689//******************************************************************************
1690BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
1691{
1692#ifdef DEBUG
1693 WriteLog("USER32: ValidateRect\n");
1694#endif
1695 return O32_ValidateRect(arg1, arg2);
1696}
1697//******************************************************************************
1698//******************************************************************************
1699BOOL WIN32API ValidateRgn( HWND arg1, HRGN arg2)
1700{
1701#ifdef DEBUG
1702 WriteLog("USER32: ValidateRgn\n");
1703#endif
1704 return O32_ValidateRgn(arg1, arg2);
1705}
1706//******************************************************************************
1707//******************************************************************************
1708WORD WIN32API VkKeyScanW( WCHAR arg1)
1709{
1710#ifdef DEBUG
1711 WriteLog("USER32: VkKeyScanW\n");
1712#endif
1713 // NOTE: This will not work as is (needs UNICODE support)
1714 return O32_VkKeyScan((char)arg1);
1715}
1716//******************************************************************************
1717//******************************************************************************
1718BOOL WIN32API WinHelpW( HWND arg1, LPCWSTR arg2, UINT arg3, DWORD arg4)
1719{
1720 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1721 BOOL rc;
1722
1723#ifdef DEBUG
1724 WriteLog("USER32: WinHelpW\n");
1725#endif
1726 rc = WinHelpA(arg1, astring, arg3, arg4);
1727 FreeAsciiString(astring);
1728 return rc;
1729}
1730//******************************************************************************
1731//******************************************************************************
1732int WIN32API wvsprintfA( LPSTR arg1, LPCSTR arg2, va_list arg3)
1733{
1734#ifdef DEBUG
1735 WriteLog("USER32: wvsprintfA\n");
1736#endif
1737 return O32_wvsprintf(arg1, arg2, (LPCVOID *)arg3);
1738}
1739//******************************************************************************
1740//******************************************************************************
1741int WIN32API wvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, va_list argptr)
1742{
1743 int rc;
1744 char szOut[256];
1745 char *lpFmtA;
1746
1747 lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
1748#ifdef DEBUG
1749 WriteLog("USER32: wvsprintfW, DOES NOT HANDLE UNICODE STRINGS!\n");
1750 WriteLog("USER32: %s\n", lpFmt);
1751#endif
1752 rc = O32_wvsprintf(szOut, lpFmtA, (LPCVOID)argptr);
1753
1754 AsciiToUnicode(szOut, lpOut);
1755#ifdef DEBUG
1756 WriteLog("USER32: %s\n", lpOut);
1757#endif
1758 FreeAsciiString(lpFmtA);
1759 return(rc);
1760}
1761//******************************************************************************
1762//TODO: Not complete
1763//******************************************************************************
1764BOOL WIN32API GetScrollInfo(HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
1765{
1766#ifdef DEBUG
1767 WriteLog("USER32: GetScrollInfo\n");
1768#endif
1769 if(lpsi == NULL)
1770 return(FALSE);
1771
1772 if(lpsi->fMask & SIF_POS)
1773 lpsi->nPos = GetScrollPos(hwnd, fnBar);
1774 if(lpsi->fMask & SIF_RANGE)
1775 GetScrollRange(hwnd, fnBar, &lpsi->nMin, &lpsi->nMax);
1776 if(lpsi->fMask & SIF_PAGE) {
1777#ifdef DEBUG
1778 WriteLog("USER32: GetScrollInfo, page info not implemented\n");
1779#endif
1780 lpsi->nPage = 25;
1781 }
1782 return(TRUE);
1783}
1784//******************************************************************************
1785//TODO: Not complete
1786//******************************************************************************
1787INT WIN32API SetScrollInfo(HWND hwnd, INT fnBar, const SCROLLINFO *lpsi, BOOL fRedraw)
1788{
1789 int smin, smax;
1790
1791#ifdef DEBUG
1792 WriteLog("USER32: SetScrollInfo\n");
1793#endif
1794 if(lpsi == NULL)
1795 return(FALSE);
1796
1797 if(lpsi->fMask & SIF_POS)
1798 SetScrollPos(hwnd, fnBar, lpsi->nPos, fRedraw);
1799 if(lpsi->fMask & SIF_RANGE)
1800 SetScrollRange(hwnd, fnBar, lpsi->nMin, lpsi->nMax, fRedraw);
1801 if(lpsi->fMask & SIF_PAGE) {
1802#ifdef DEBUG
1803 WriteLog("USER32: GetScrollInfo, page info not implemented\n");
1804#endif
1805 }
1806 if(lpsi->fMask & SIF_DISABLENOSCROLL) {
1807#ifdef DEBUG
1808 WriteLog("USER32: GetScrollInfo, disable scrollbar not yet implemented\n");
1809#endif
1810 }
1811 return(TRUE);
1812}
1813//******************************************************************************
1814//******************************************************************************
1815BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
1816 LPARAM lpData, int nCount, int X, int Y, int nWidth,
1817 int nHeight)
1818{
1819 BOOL rc;
1820 COLORREF curclr;
1821
1822#ifdef DEBUG
1823 WriteLog("USER32: GrayStringA, not completely implemented\n");
1824#endif
1825 if(lpOutputFunc == NULL && lpData == NULL) {
1826#ifdef DEBUG
1827 WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
1828#endif
1829 return(FALSE);
1830 }
1831 if(lpOutputFunc) {
1832 return(lpOutputFunc(hdc, lpData, nCount));
1833 }
1834 curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
1835 rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
1836 SetTextColor(hdc, curclr);
1837
1838 return(rc);
1839}
1840//******************************************************************************
1841//******************************************************************************
1842BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
1843 LPARAM lpData, int nCount, int X, int Y, int nWidth,
1844 int nHeight)
1845{
1846 BOOL rc;
1847 char *astring;
1848 COLORREF curclr;
1849
1850#ifdef DEBUG
1851 WriteLog("USER32: GrayStringW, not completely implemented\n");
1852#endif
1853
1854 if(lpOutputFunc == NULL && lpData == NULL) {
1855#ifdef DEBUG
1856 WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
1857#endif
1858 return(FALSE);
1859 }
1860 if(nCount == 0)
1861 nCount = UniStrlen((UniChar*)lpData);
1862
1863 if(lpOutputFunc) {
1864 return(lpOutputFunc(hdc, lpData, nCount));
1865 }
1866 astring = UnicodeToAsciiString((LPWSTR)lpData);
1867
1868 curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
1869 rc = TextOutA(hdc, X, Y, astring, nCount);
1870 SetTextColor(hdc, curclr);
1871
1872 FreeAsciiString(astring);
1873 return(rc);
1874}
1875//******************************************************************************
1876//TODO:
1877//******************************************************************************
1878int WIN32API CopyAcceleratorTableA(HACCEL hAccelSrc, LPACCEL lpAccelDest,
1879 int cAccelEntries)
1880{
1881#ifdef DEBUG
1882 WriteLog("USER32: CopyAcceleratorTableA, not implemented\n");
1883#endif
1884 return(0);
1885}
1886//******************************************************************************
1887//TODO:
1888//******************************************************************************
1889int WIN32API CopyAcceleratorTableW(HACCEL hAccelSrc, LPACCEL lpAccelDest,
1890 int cAccelEntries)
1891{
1892#ifdef DEBUG
1893 WriteLog("USER32: CopyAcceleratorTableW, not implemented\n");
1894#endif
1895 return(0);
1896}
1897//******************************************************************************
1898//******************************************************************************
1899HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
1900{
1901#ifdef DEBUG
1902 WriteLog("USER32: CopyImage, not implemented\n");
1903#endif
1904 switch(uType) {
1905 case IMAGE_BITMAP:
1906 case IMAGE_CURSOR:
1907 case IMAGE_ICON:
1908 default:
1909#ifdef DEBUG
1910 WriteLog("USER32: CopyImage, unknown type\n");
1911#endif
1912 return(NULL);
1913 }
1914 return(NULL);
1915}
1916//******************************************************************************
1917//******************************************************************************
1918BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
1919{
1920#ifdef DEBUG
1921 WriteLog("USER32: GetKeyboardState, not properly implemented\n");
1922#endif
1923 memset(lpKeyState, 0, 256);
1924 return(TRUE);
1925}
1926//******************************************************************************
1927//******************************************************************************
1928BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
1929{
1930#ifdef DEBUG
1931 WriteLog("USER32: SetKeyboardState, not implemented\n");
1932#endif
1933 return(TRUE);
1934}
1935//******************************************************************************
1936//2nd parameter not used according to SDK (yet?)
1937//******************************************************************************
1938VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
1939{
1940#ifdef DEBUG
1941 WriteLog("USER32: SetLastErrorEx\n");
1942#endif
1943 SetLastError(dwErrCode);
1944}
1945//******************************************************************************
1946//******************************************************************************
1947BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
1948{
1949#ifdef DEBUG
1950 WriteLog("USER32: ActivateKeyboardLayout, not implemented\n");
1951#endif
1952 return(TRUE);
1953}
1954//******************************************************************************
1955//******************************************************************************
1956int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
1957{
1958#ifdef DEBUG
1959 WriteLog("USER32: GetKeyboardLayoutList, not implemented\n");
1960#endif
1961 return(0);
1962}
1963//******************************************************************************
1964//******************************************************************************
1965HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
1966{
1967#ifdef DEBUG
1968 WriteLog("USER32: GetKeyboardLayout, not implemented\n");
1969#endif
1970 return(0);
1971}
1972//******************************************************************************
1973//******************************************************************************
1974int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
1975{
1976#ifdef DEBUG
1977 WriteLog("USER32: LookupIconIdFromDirectory, not implemented\n");
1978#endif
1979 return(0);
1980}
1981//******************************************************************************
1982//******************************************************************************
1983int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL fIcon,
1984 int cxDesired, int cyDesired,
1985 UINT Flags)
1986{
1987#ifdef DEBUG
1988 WriteLog("USER32: LookupIconIdFromDirectoryEx, not implemented\n");
1989#endif
1990 return(0);
1991}
1992//******************************************************************************
1993//DWORD idAttach; /* thread to attach */
1994//DWORD idAttachTo; /* thread to attach to */
1995//BOOL fAttach; /* attach or detach */
1996//******************************************************************************
1997BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
1998{
1999#ifdef DEBUG
2000 WriteLog("USER32: AttachThreadInput, not implemented\n");
2001#endif
2002 return(TRUE);
2003}
2004//******************************************************************************
2005//******************************************************************************
2006BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
2007{
2008#ifdef DEBUG
2009 WriteLog("USER32: RegisterHotKey, not implemented\n");
2010#endif
2011 return(TRUE);
2012}
2013//******************************************************************************
2014//******************************************************************************
2015BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
2016{
2017#ifdef DEBUG
2018 WriteLog("USER32: UnregisterHotKey, not implemented\n");
2019#endif
2020 return(TRUE);
2021}
2022//******************************************************************************
2023//******************************************************************************
2024BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
2025{
2026#ifdef DEBUG
2027 WriteLog("USER32: SetWindowContextHelpId, not implemented\n");
2028#endif
2029 return(TRUE);
2030}
2031//******************************************************************************
2032//******************************************************************************
2033DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
2034{
2035#ifdef DEBUG
2036 WriteLog("USER32: GetWindowContextHelpId, not implemented\n");
2037#endif
2038 return(0);
2039}
2040//******************************************************************************
2041//restores iconized window to previous size/position
2042//******************************************************************************
2043BOOL WIN32API OpenIcon(HWND hwnd)
2044{
2045#ifdef DEBUG
2046 WriteLog("USER32: OpenIcon\n");
2047#endif
2048 if(!IsIconic(hwnd))
2049 return FALSE;
2050 ShowWindow(hwnd, SW_SHOWNORMAL);
2051 return TRUE;
2052}
2053//******************************************************************************
2054//******************************************************************************
2055BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
2056{
2057#ifdef DEBUG
2058 WriteLog("USER32: GetMonitorInfoA not supported!!\n");
2059#endif
2060 return(FALSE);
2061}
2062//******************************************************************************
2063//******************************************************************************
2064BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
2065{
2066#ifdef DEBUG
2067 WriteLog("USER32: GetMonitorInfoW not supported!!\n");
2068#endif
2069 return(FALSE);
2070}
2071//******************************************************************************
2072//******************************************************************************
2073HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
2074{
2075#ifdef DEBUG
2076 WriteLog("USER32: MonitorFromWindow not correctly supported??\n");
2077#endif
2078 return(0);
2079}
2080//******************************************************************************
2081//******************************************************************************
2082HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
2083{
2084#ifdef DEBUG
2085 WriteLog("USER32: MonitorFromRect not correctly supported??\n");
2086#endif
2087 return(0);
2088}
2089//******************************************************************************
2090//******************************************************************************
2091HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
2092{
2093#ifdef DEBUG
2094 WriteLog("USER32: MonitorFromPoint not correctly supported??\n");
2095#endif
2096 return(0);
2097}
2098//******************************************************************************
2099//******************************************************************************
2100BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
2101{
2102#ifdef DEBUG
2103 WriteLog("USER32: EnumDisplayMonitors not supported??\n");
2104#endif
2105 return(FALSE);
2106}
2107//******************************************************************************
2108//******************************************************************************
2109BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
2110 LPDEVMODEA lpDevMode)
2111{
2112#ifdef DEBUG
2113 WriteLog("USER32: EnumDisplaySettingsA FAKED\n");
2114#endif
2115 switch(iModeNum) {
2116 case 0:
2117 lpDevMode->dmBitsPerPel = 16;
2118 lpDevMode->dmPelsWidth = 768;
2119 lpDevMode->dmPelsHeight = 1024;
2120 lpDevMode->dmDisplayFlags = 0;
2121 lpDevMode->dmDisplayFrequency = 70;
2122 break;
2123 case 1:
2124 lpDevMode->dmBitsPerPel = 16;
2125 lpDevMode->dmPelsWidth = 640;
2126 lpDevMode->dmPelsHeight = 480;
2127 lpDevMode->dmDisplayFlags = 0;
2128 lpDevMode->dmDisplayFrequency = 70;
2129 break;
2130 default:
2131 return(FALSE);
2132 }
2133 return(TRUE);
2134}
2135//******************************************************************************
2136//******************************************************************************
2137LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA lpDevMode, DWORD dwFlags)
2138{
2139#ifdef DEBUG
2140 if(lpDevMode) {
2141 WriteLog("USER32: ChangeDisplaySettingsA FAKED %X\n", dwFlags);
2142 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
2143 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsWidth %d\n", lpDevMode->dmPelsWidth);
2144 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
2145 }
2146#endif
2147 return(DISP_CHANGE_SUCCESSFUL);
2148}
2149//******************************************************************************
2150//******************************************************************************
2151
2152
2153/*****************************************************************************
2154 * Name : BOOL WIN32API AnyPopup
2155 * Purpose : The AnyPopup function indicates whether an owned, visible,
2156 * top-level pop-up, or overlapped window exists on the screen. The
2157 * function searches the entire Windows screen, not just the calling
2158 * application's client area.
2159 * Parameters: VOID
2160 * Variables :
2161 * Result : If a pop-up window exists, the return value is TRUE even if the
2162 * pop-up window is completely covered by other windows. Otherwise,
2163 * it is FALSE.
2164 * Remark : AnyPopup is a Windows version 1.x function and is retained for
2165 * compatibility purposes. It is generally not useful.
2166 * Status : UNTESTED STUB
2167 *
2168 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2169 *****************************************************************************/
2170
2171BOOL WIN32API AnyPopup(VOID)
2172{
2173 dprintf(("USER32:AnyPopup() not implemented.\n"));
2174
2175 return (FALSE);
2176}
2177
2178
2179/*****************************************************************************
2180 * Name : long WIN32API BroadcastSystemMessage
2181 * Purpose : The BroadcastSystemMessage function sends a message to the given
2182 * recipients. The recipients can be applications, installable
2183 * drivers, Windows-based network drivers, system-level device
2184 * drivers, or any combination of these system components.
2185 * Parameters: DWORD dwFlags,
2186 LPDWORD lpdwRecipients,
2187 UINT uiMessage,
2188 WPARAM wParam,
2189 LPARAM lParam
2190 * Variables :
2191 * Result : If the function succeeds, the return value is a positive value.
2192 * If the function is unable to broadcast the message, the return value is -1.
2193 * If the dwFlags parameter is BSF_QUERY and at least one recipient returned FALSE to the corresponding message, the return value is zero.
2194 * Remark :
2195 * Status : UNTESTED STUB
2196 *
2197 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2198 *****************************************************************************/
2199
2200long WIN32API BroadcastSystemMessage(DWORD dwFlags,
2201 LPDWORD lpdwRecipients,
2202 UINT uiMessage,
2203 WPARAM wParam,
2204 LPARAM lParam)
2205{
2206 dprintf(("USER32:BroadcastSystemMessage(%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
2207 dwFlags,
2208 lpdwRecipients,
2209 uiMessage,
2210 wParam,
2211 lParam));
2212
2213 return (-1);
2214}
2215
2216
2217
2218
2219/*****************************************************************************
2220 * Name : LONG WIN32API ChangeDisplaySettingsW
2221 * Purpose : The ChangeDisplaySettings function changes the display settings
2222 * to the specified graphics mode.
2223 * Parameters: LPDEVMODEW lpDevModeW
2224 * DWORD dwFlags
2225 * Variables :
2226 * Result : DISP_CHANGE_SUCCESSFUL The settings change was successful.
2227 * DISP_CHANGE_RESTART The computer must be restarted in order for the graphics mode to work.
2228 * DISP_CHANGE_BADFLAGS An invalid set of flags was passed in.
2229 * DISP_CHANGE_FAILED The display driver failed the specified graphics mode.
2230 * DISP_CHANGE_BADMODE The graphics mode is not supported.
2231 * DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
2232 * Remark :
2233 * Status : UNTESTED STUB
2234 *
2235 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2236 *****************************************************************************/
2237
2238LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
2239 DWORD dwFlags)
2240{
2241 dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
2242 lpDevMode,
2243 dwFlags));
2244
2245 return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
2246 dwFlags));
2247}
2248
2249/*****************************************************************************
2250 * Name : BOOL WIN32API CloseDesktop
2251 * Purpose : The CloseDesktop function closes an open handle of a desktop
2252 * object. A desktop is a secure object contained within a window
2253 * station object. A desktop has a logical display surface and
2254 * contains windows, menus and hooks.
2255 * Parameters: HDESK hDesktop
2256 * Variables :
2257 * Result : If the function succeeds, the return value is TRUE.
2258 * If the functions fails, the return value is FALSE. To get
2259 * extended error information, call GetLastError.
2260 * Remark :
2261 * Status : UNTESTED STUB
2262 *
2263 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2264 *****************************************************************************/
2265
2266BOOL WIN32API CloseDesktop(HDESK hDesktop)
2267{
2268 dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
2269 hDesktop));
2270
2271 return (FALSE);
2272}
2273
2274
2275/*****************************************************************************
2276 * Name : BOOL WIN32API CloseWindowStation
2277 * Purpose : The CloseWindowStation function closes an open window station handle.
2278 * Parameters: HWINSTA hWinSta
2279 * Variables :
2280 * Result :
2281 * Remark : If the function succeeds, the return value is TRUE.
2282 * If the functions fails, the return value is FALSE. To get
2283 * extended error information, call GetLastError.
2284 * Status : UNTESTED STUB
2285 *
2286 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2287 *****************************************************************************/
2288
2289BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
2290{
2291 dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
2292 hWinSta));
2293
2294 return (FALSE);
2295}
2296
2297
2298/*****************************************************************************
2299 * Name : HDESK WIN32API CreateDesktopA
2300 * Purpose : The CreateDesktop function creates a new desktop on the window
2301 * station associated with the calling process.
2302 * Parameters: LPCTSTR lpszDesktop name of the new desktop
2303 * LPCTSTR lpszDevice name of display device to assign to the desktop
2304 * LPDEVMODE pDevMode reserved; must be NULL
2305 * DWORD dwFlags flags to control interaction with other applications
2306 * DWORD dwDesiredAccess specifies access of returned handle
2307 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
2308 * Variables :
2309 * Result : If the function succeeds, the return value is a handle of the
2310 * newly created desktop.
2311 * If the function fails, the return value is NULL. To get extended
2312 * error information, call GetLastError.
2313 * Remark :
2314 * Status : UNTESTED STUB
2315 *
2316 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2317 *****************************************************************************/
2318
2319HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
2320 LPCTSTR lpszDevice,
2321 LPDEVMODEA pDevMode,
2322 DWORD dwFlags,
2323 DWORD dwDesiredAccess,
2324 LPSECURITY_ATTRIBUTES lpsa)
2325{
2326 dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
2327 lpszDesktop,
2328 lpszDevice,
2329 pDevMode,
2330 dwFlags,
2331 dwDesiredAccess,
2332 lpsa));
2333
2334 return (NULL);
2335}
2336
2337
2338/*****************************************************************************
2339 * Name : HDESK WIN32API CreateDesktopW
2340 * Purpose : The CreateDesktop function creates a new desktop on the window
2341 * station associated with the calling process.
2342 * Parameters: LPCTSTR lpszDesktop name of the new desktop
2343 * LPCTSTR lpszDevice name of display device to assign to the desktop
2344 * LPDEVMODE pDevMode reserved; must be NULL
2345 * DWORD dwFlags flags to control interaction with other applications
2346 * DWORD dwDesiredAccess specifies access of returned handle
2347 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
2348 * Variables :
2349 * Result : If the function succeeds, the return value is a handle of the
2350 * newly created desktop.
2351 * If the function fails, the return value is NULL. To get extended
2352 * error information, call GetLastError.
2353 * Remark :
2354 * Status : UNTESTED STUB
2355 *
2356 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2357 *****************************************************************************/
2358
2359HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
2360 LPCTSTR lpszDevice,
2361 LPDEVMODEW pDevMode,
2362 DWORD dwFlags,
2363 DWORD dwDesiredAccess,
2364 LPSECURITY_ATTRIBUTES lpsa)
2365{
2366 dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
2367 lpszDesktop,
2368 lpszDevice,
2369 pDevMode,
2370 dwFlags,
2371 dwDesiredAccess,
2372 lpsa));
2373
2374 return (NULL);
2375}
2376
2377
2378/*****************************************************************************
2379 * Name : HWINSTA WIN32API CreateWindowStationA
2380 * Purpose : The CreateWindowStation function creates a window station object.
2381 * It returns a handle that can be used to access the window station.
2382 * A window station is a secure object that contains a set of global
2383 * atoms, a clipboard, and a set of desktop objects.
2384 * Parameters: LPTSTR lpwinsta name of the new window station
2385 * DWORD dwReserved reserved; must be NULL
2386 * DWORD dwDesiredAccess specifies access of returned handle
2387 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
2388 * Variables :
2389 * Result : If the function succeeds, the return value is the handle to the
2390 * newly created window station.
2391 * If the function fails, the return value is NULL. To get extended
2392 * error information, call GetLastError.
2393 * Remark :
2394 * Status : UNTESTED STUB
2395 *
2396 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2397 *****************************************************************************/
2398
2399HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
2400 DWORD dwReserved,
2401 DWORD dwDesiredAccess,
2402 LPSECURITY_ATTRIBUTES lpsa)
2403{
2404 dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
2405 lpWinSta,
2406 dwReserved,
2407 dwDesiredAccess,
2408 lpsa));
2409
2410 return (NULL);
2411}
2412
2413
2414/*****************************************************************************
2415 * Name : HWINSTA WIN32API CreateWindowStationW
2416 * Purpose : The CreateWindowStation function creates a window station object.
2417 * It returns a handle that can be used to access the window station.
2418 * A window station is a secure object that contains a set of global
2419 * atoms, a clipboard, and a set of desktop objects.
2420 * Parameters: LPTSTR lpwinsta name of the new window station
2421 * DWORD dwReserved reserved; must be NULL
2422 * DWORD dwDesiredAccess specifies access of returned handle
2423 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
2424 * Variables :
2425 * Result : If the function succeeds, the return value is the handle to the
2426 * newly created window station.
2427 * If the function fails, the return value is NULL. To get extended
2428 * error information, call GetLastError.
2429 * Remark :
2430 * Status : UNTESTED STUB
2431 *
2432 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2433 *****************************************************************************/
2434
2435HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
2436 DWORD dwReserved,
2437 DWORD dwDesiredAccess,
2438 LPSECURITY_ATTRIBUTES lpsa)
2439{
2440 dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
2441 lpWinSta,
2442 dwReserved,
2443 dwDesiredAccess,
2444 lpsa));
2445
2446 return (NULL);
2447}
2448
2449/*****************************************************************************
2450 * Name : BOOL WIN32API DragDetect
2451 * Purpose : The DragDetect function captures the mouse and tracks its movement
2452 * Parameters: HWND hwnd
2453 * POINT pt
2454 * Variables :
2455 * Result : If the user moved the mouse outside of the drag rectangle while
2456 * holding the left button down, the return value is TRUE.
2457 * If the user did not move the mouse outside of the drag rectangle
2458 * while holding the left button down, the return value is FALSE.
2459 * Remark :
2460 * Status : UNTESTED STUB
2461 *
2462 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2463 *****************************************************************************/
2464
2465BOOL WIN32API DragDetect(HWND hwnd,
2466 POINT pt)
2467{
2468 dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
2469 hwnd));
2470
2471 return (FALSE);
2472}
2473
2474
2475
2476/*****************************************************************************
2477 * Name : BOOL WIN32API EnumDesktopWindows
2478 * Purpose : The EnumDesktopWindows function enumerates all windows in a
2479 * desktop by passing the handle of each window, in turn, to an
2480 * application-defined callback function.
2481 * Parameters: HDESK hDesktop handle of desktop to enumerate
2482 * WNDENUMPROC lpfn points to application's callback function
2483 * LPARAM lParam 32-bit value to pass to the callback function
2484 * Variables :
2485 * Result : If the function succeeds, the return value is TRUE.
2486 * If the function fails, the return value is FALSE. To get
2487 * extended error information, call GetLastError.
2488 * Remark :
2489 * Status : UNTESTED STUB
2490 *
2491 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2492 *****************************************************************************/
2493
2494BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
2495 WNDENUMPROC lpfn,
2496 LPARAM lParam)
2497{
2498 dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
2499 hDesktop,
2500 lpfn,
2501 lParam));
2502
2503 return (FALSE);
2504}
2505
2506
2507/*****************************************************************************
2508 * Name : BOOL WIN32API EnumDesktopsA
2509 * Purpose : The EnumDesktops function enumerates all desktops in the window
2510 * station assigned to the calling process. The function does so by
2511 * passing the name of each desktop, in turn, to an application-
2512 * defined callback function.
2513 * Parameters: HWINSTA hwinsta handle of window station to enumerate
2514 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
2515 * LPARAM lParam 32-bit value to pass to the callback function
2516 * Variables :
2517 * Result : If the function succeeds, the return value is TRUE.
2518 * If the function fails, the return value is FALSE. To get extended
2519 * error information, call GetLastError.
2520 * Remark :
2521 * Status : UNTESTED STUB
2522 *
2523 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2524 *****************************************************************************/
2525
2526BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
2527 DESKTOPENUMPROCA lpEnumFunc,
2528 LPARAM lParam)
2529{
2530 dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
2531 hWinSta,
2532 lpEnumFunc,
2533 lParam));
2534
2535 return (FALSE);
2536}
2537
2538
2539/*****************************************************************************
2540 * Name : BOOL WIN32API EnumDesktopsW
2541 * Purpose : The EnumDesktops function enumerates all desktops in the window
2542 * station assigned to the calling process. The function does so by
2543 * passing the name of each desktop, in turn, to an application-
2544 * defined callback function.
2545 * Parameters: HWINSTA hwinsta handle of window station to enumerate
2546 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
2547 * LPARAM lParam 32-bit value to pass to the callback function
2548 * Variables :
2549 * Result : If the function succeeds, the return value is TRUE.
2550 * If the function fails, the return value is FALSE. To get extended
2551 * error information, call GetLastError.
2552 * Remark :
2553 * Status : UNTESTED STUB
2554 *
2555 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2556 *****************************************************************************/
2557
2558BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
2559 DESKTOPENUMPROCW lpEnumFunc,
2560 LPARAM lParam)
2561{
2562 dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
2563 hWinSta,
2564 lpEnumFunc,
2565 lParam));
2566
2567 return (FALSE);
2568}
2569
2570
2571
2572/*****************************************************************************
2573 * Name : BOOL WIN32API EnumDisplaySettingsW
2574 * Purpose : The EnumDisplaySettings function obtains information about one
2575 * of a display device's graphics modes. You can obtain information
2576 * for all of a display device's graphics modes by making a series
2577 * of calls to this function.
2578 * Parameters: LPCTSTR lpszDeviceName specifies the display device
2579 * DWORD iModeNum specifies the graphics mode
2580 * LPDEVMODE lpDevMode points to structure to receive settings
2581 * Variables :
2582 * Result : If the function succeeds, the return value is TRUE.
2583 * If the function fails, the return value is FALSE.
2584 * Remark :
2585 * Status : UNTESTED STUB
2586 *
2587 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2588 *****************************************************************************/
2589
2590BOOL WIN32API EnumDisplaySettingsW(LPCSTR lpszDeviceName,
2591 DWORD iModeNum,
2592 LPDEVMODEW lpDevMode)
2593{
2594 dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
2595 lpszDeviceName,
2596 iModeNum,
2597 lpDevMode));
2598
2599 return (EnumDisplaySettingsA(lpszDeviceName,
2600 iModeNum,
2601 (LPDEVMODEA)lpDevMode));
2602}
2603
2604
2605/*****************************************************************************
2606 * Name : BOOL WIN32API EnumWindowStationsA
2607 * Purpose : The EnumWindowStations function enumerates all windowstations
2608 * in the system by passing the name of each window station, in
2609 * turn, to an application-defined callback function.
2610 * Parameters:
2611 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
2612 * LPARAM lParam 32-bit value to pass to the callback function
2613 * Result : If the function succeeds, the return value is TRUE.
2614 * If the function fails the return value is FALSE. To get extended
2615 * error information, call GetLastError.
2616 * Remark :
2617 * Status : UNTESTED STUB
2618 *
2619 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2620 *****************************************************************************/
2621
2622BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
2623 LPARAM lParam)
2624{
2625 dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
2626 lpEnumFunc,
2627 lParam));
2628
2629 return (FALSE);
2630}
2631
2632
2633/*****************************************************************************
2634 * Name : BOOL WIN32API EnumWindowStationsW
2635 * Purpose : The EnumWindowStations function enumerates all windowstations
2636 * in the system by passing the name of each window station, in
2637 * turn, to an application-defined callback function.
2638 * Parameters:
2639 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
2640 * LPARAM lParam 32-bit value to pass to the callback function
2641 * Result : If the function succeeds, the return value is TRUE.
2642 * If the function fails the return value is FALSE. To get extended
2643 * error information, call GetLastError.
2644 * Remark :
2645 * Status : UNTESTED STUB
2646 *
2647 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2648 *****************************************************************************/
2649
2650BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
2651 LPARAM lParam)
2652{
2653 dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
2654 lpEnumFunc,
2655 lParam));
2656
2657 return (FALSE);
2658}
2659
2660
2661
2662/*****************************************************************************
2663 * Name : BOOL WIN32API GetInputState
2664 * Purpose : The GetInputState function determines whether there are
2665 * mouse-button or keyboard messages in the calling thread's message queue.
2666 * Parameters:
2667 * Variables :
2668 * Result : If the queue contains one or more new mouse-button or keyboard
2669 * messages, the return value is TRUE.
2670 * If the function fails, the return value is FALSE.
2671 * Remark :
2672 * Status : UNTESTED STUB
2673 *
2674 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2675 *****************************************************************************/
2676
2677BOOL WIN32API GetInputState(VOID)
2678{
2679 dprintf(("USER32:GetInputState () not implemented.\n"));
2680
2681 return (FALSE);
2682}
2683
2684
2685/*****************************************************************************
2686 * Name : UINT WIN32API GetKBCodePage
2687 * Purpose : The GetKBCodePage function is provided for compatibility with
2688 * earlier versions of Windows. In the Win32 application programming
2689 * interface (API) it just calls the GetOEMCP function.
2690 * Parameters:
2691 * Variables :
2692 * Result : If the function succeeds, the return value is an OEM code-page
2693 * identifier, or it is the default identifier if the registry
2694 * value is not readable. For a list of OEM code-page identifiers,
2695 * see GetOEMCP.
2696 * Remark :
2697 * Status : UNTESTED
2698 *
2699 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2700 *****************************************************************************/
2701
2702UINT WIN32API GetKBCodePage(VOID)
2703{
2704 return (GetOEMCP());
2705}
2706
2707
2708/*****************************************************************************
2709 * Name : BOOL WIN32API GetKeyboardLayoutNameA
2710 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
2711 * active keyboard layout.
2712 * Parameters: LPTSTR pwszKLID address of buffer for layout name
2713 * Variables :
2714 * Result : If the function succeeds, the return value is TRUE.
2715 * If the function fails, the return value is FALSE. To get extended
2716 * error information, call GetLastError.
2717 * Remark :
2718 * Status : UNTESTED STUB
2719 *
2720 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2721 *****************************************************************************/
2722
2723BOOL WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
2724{
2725 dprintf(("USER32:GetKeyboardLayoutNameA (%08x) not implemented.",
2726 pwszKLID));
2727
2728 return(FALSE);
2729}
2730
2731
2732/*****************************************************************************
2733 * Name : BOOL WIN32API GetKeyboardLayoutNameW
2734 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
2735 * active keyboard layout.
2736 * Parameters: LPTSTR pwszKLID address of buffer for layout name
2737 * Variables :
2738 * Result : If the function succeeds, the return value is TRUE.
2739 * If the function fails, the return value is FALSE. To get extended
2740 * error information, call GetLastError.
2741 * Remark :
2742 * Status : UNTESTED STUB
2743 *
2744 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2745 *****************************************************************************/
2746
2747BOOL WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
2748{
2749 dprintf(("USER32:GetKeyboardLayoutNameW (%08x) not implemented.",
2750 pwszKLID));
2751
2752 return(FALSE);
2753}
2754
2755
2756
2757
2758/*****************************************************************************
2759 * Name : HWINSTA WIN32API GetProcessWindowStation
2760 * Purpose : The GetProcessWindowStation function returns a handle of the
2761 * window station associated with the calling process.
2762 * Parameters:
2763 * Variables :
2764 * Result : If the function succeeds, the return value is a handle of the
2765 * window station associated with the calling process.
2766 * If the function fails, the return value is NULL. This can occur
2767 * if the calling process is not an application written for Windows
2768 * NT. To get extended error information, call GetLastError.
2769 * Remark :
2770 * Status : UNTESTED STUB
2771 *
2772 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2773 *****************************************************************************/
2774
2775HWINSTA WIN32API GetProcessWindowStation(VOID)
2776{
2777 dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
2778
2779 return (NULL);
2780}
2781
2782
2783
2784/*****************************************************************************
2785 * Name : HDESK WIN32API GetThreadDesktop
2786 * Purpose : The GetThreadDesktop function returns a handle to the desktop
2787 * associated with a specified thread.
2788 * Parameters: DWORD dwThreadId thread identifier
2789 * Variables :
2790 * Result : If the function succeeds, the return value is the handle of the
2791 * desktop associated with the specified thread.
2792 * Remark :
2793 * Status : UNTESTED STUB
2794 *
2795 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2796 *****************************************************************************/
2797
2798HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
2799{
2800 dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
2801 dwThreadId));
2802
2803 return (NULL);
2804}
2805
2806
2807/*****************************************************************************
2808 * Name : BOOL WIN32API GetUserObjectInformationA
2809 * Purpose : The GetUserObjectInformation function returns information about
2810 * a window station or desktop object.
2811 * Parameters: HANDLE hObj handle of object to get information for
2812 * int nIndex type of information to get
2813 * PVOID pvInfo points to buffer that receives the information
2814 * DWORD nLength size, in bytes, of pvInfo buffer
2815 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
2816 * Variables :
2817 * Result : If the function succeeds, the return value is TRUE.
2818 * If the function fails, the return value is FALSE. To get extended
2819 * error information, call GetLastError.
2820 * Remark :
2821 * Status : UNTESTED STUB
2822 *
2823 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2824 *****************************************************************************/
2825
2826BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
2827 int nIndex,
2828 PVOID pvInfo,
2829 DWORD nLength,
2830 LPDWORD lpnLengthNeeded)
2831{
2832 dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
2833 hObj,
2834 nIndex,
2835 pvInfo,
2836 nLength,
2837 lpnLengthNeeded));
2838
2839 return (FALSE);
2840}
2841
2842
2843/*****************************************************************************
2844 * Name : BOOL WIN32API GetUserObjectInformationW
2845 * Purpose : The GetUserObjectInformation function returns information about
2846 * a window station or desktop object.
2847 * Parameters: HANDLE hObj handle of object to get information for
2848 * int nIndex type of information to get
2849 * PVOID pvInfo points to buffer that receives the information
2850 * DWORD nLength size, in bytes, of pvInfo buffer
2851 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
2852 * Variables :
2853 * Result : If the function succeeds, the return value is TRUE.
2854 * If the function fails, the return value is FALSE. To get extended
2855 * error information, call GetLastError.
2856 * Remark :
2857 * Status : UNTESTED STUB
2858 *
2859 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2860 *****************************************************************************/
2861
2862BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
2863 int nIndex,
2864 PVOID pvInfo,
2865 DWORD nLength,
2866 LPDWORD lpnLengthNeeded)
2867{
2868 dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
2869 hObj,
2870 nIndex,
2871 pvInfo,
2872 nLength,
2873 lpnLengthNeeded));
2874
2875 return (FALSE);
2876}
2877
2878
2879/*****************************************************************************
2880 * Name : BOOL WIN32API GetUserObjectSecurity
2881 * Purpose : The GetUserObjectSecurity function retrieves security information
2882 * for the specified user object.
2883 * Parameters: HANDLE hObj handle of user object
2884 * SECURITY_INFORMATION * pSIRequested address of requested security information
2885 * LPSECURITY_DESCRIPTOR pSID address of security descriptor
2886 * DWORD nLength size of buffer for security descriptor
2887 * LPDWORD lpnLengthNeeded address of required size of buffer
2888 * Variables :
2889 * Result : If the function succeeds, the return value is TRUE.
2890 * If the function fails, the return value is FALSE. To get extended
2891 * error information, call GetLastError.
2892 * Remark :
2893 * Status : UNTESTED STUB
2894 *
2895 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2896 *****************************************************************************/
2897
2898BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
2899 SECURITY_INFORMATION * pSIRequested,
2900 LPSECURITY_DESCRIPTOR pSID,
2901 DWORD nLength,
2902 LPDWORD lpnLengthNeeded)
2903{
2904 dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
2905 hObj,
2906 pSIRequested,
2907 pSID,
2908 nLength,
2909 lpnLengthNeeded));
2910
2911 return (FALSE);
2912}
2913
2914
2915
2916/*****************************************************************************
2917 * Name : int WIN32API GetWindowRgn
2918 * Purpose : The GetWindowRgn function obtains a copy of the window region of a window.
2919 * Parameters: HWND hWnd handle to window whose window region is to be obtained
2920 * HRGN hRgn handle to region that receives a copy of the window region
2921 * Variables :
2922 * Result : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
2923 * Remark :
2924 * Status : UNTESTED STUB
2925 *
2926 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2927 *****************************************************************************/
2928
2929int WIN32API GetWindowRgn (HWND hWnd,
2930 HRGN hRgn)
2931{
2932 dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
2933 hWnd,
2934 hRgn));
2935
2936 return (NULLREGION);
2937}
2938
2939
2940
2941/*****************************************************************************
2942 * Name : HCURSOR WIN32API LoadCursorFromFileA
2943 * Purpose : The LoadCursorFromFile function creates a cursor based on data
2944 * contained in a file. The file is specified by its name or by a
2945 * system cursor identifier. The function returns a handle to the
2946 * newly created cursor. Files containing cursor data may be in
2947 * either cursor (.CUR) or animated cursor (.ANI) format.
2948 * Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
2949 * Variables :
2950 * Result : If the function is successful, the return value is a handle to
2951 * the new cursor.
2952 * If the function fails, the return value is NULL. To get extended
2953 * error information, call GetLastError. GetLastError may return
2954 * the following
2955 * Remark :
2956 * Status : UNTESTED STUB
2957 *
2958 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2959 *****************************************************************************/
2960
2961HCURSOR WIN32API LoadCursorFromFileA(LPCTSTR lpFileName)
2962{
2963 dprintf(("USER32:LoadCursorFromFileA (%s) not implemented.\n",
2964 lpFileName));
2965
2966 return (NULL);
2967}
2968
2969
2970/*****************************************************************************
2971 * Name : HCURSOR WIN32API LoadCursorFromFileW
2972 * Purpose : The LoadCursorFromFile function creates a cursor based on data
2973 * contained in a file. The file is specified by its name or by a
2974 * system cursor identifier. The function returns a handle to the
2975 * newly created cursor. Files containing cursor data may be in
2976 * either cursor (.CUR) or animated cursor (.ANI) format.
2977 * Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
2978 * Variables :
2979 * Result : If the function is successful, the return value is a handle to
2980 * the new cursor.
2981 * If the function fails, the return value is NULL. To get extended
2982 * error information, call GetLastError. GetLastError may return
2983 * the following
2984 * Remark :
2985 * Status : UNTESTED STUB
2986 *
2987 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2988 *****************************************************************************/
2989
2990HCURSOR WIN32API LoadCursorFromFileW(LPCWSTR lpFileName)
2991{
2992 dprintf(("USER32:LoadCursorFromFileW (%s) not implemented.\n",
2993 lpFileName));
2994
2995 return (NULL);
2996}
2997
2998
2999/*****************************************************************************
3000 * Name : HLK WIN32API LoadKeyboardLayoutA
3001 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
3002 * the system. Several keyboard layouts can be loaded at a time, but
3003 * only one per process is active at a time. Loading multiple keyboard
3004 * layouts makes it possible to rapidly switch between layouts.
3005 * Parameters:
3006 * Variables :
3007 * Result : If the function succeeds, the return value is the handle of the
3008 * keyboard layout.
3009 * If the function fails, the return value is NULL. To get extended
3010 * error information, call GetLastError.
3011 * Remark :
3012 * Status : UNTESTED STUB
3013 *
3014 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3015 *****************************************************************************/
3016
3017HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
3018 UINT Flags)
3019{
3020 dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
3021 pwszKLID,
3022 Flags));
3023
3024 return (NULL);
3025}
3026
3027
3028/*****************************************************************************
3029 * Name : HLK WIN32API LoadKeyboardLayoutW
3030 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
3031 * the system. Several keyboard layouts can be loaded at a time, but
3032 * only one per process is active at a time. Loading multiple keyboard
3033 * layouts makes it possible to rapidly switch between layouts.
3034 * Parameters:
3035 * Variables :
3036 * Result : If the function succeeds, the return value is the handle of the
3037 * keyboard layout.
3038 * If the function fails, the return value is NULL. To get extended
3039 * error information, call GetLastError.
3040 * Remark :
3041 * Status : UNTESTED STUB
3042 *
3043 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3044 *****************************************************************************/
3045
3046HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
3047 UINT Flags)
3048{
3049 dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
3050 pwszKLID,
3051 Flags));
3052
3053 return (NULL);
3054}
3055
3056
3057/*****************************************************************************
3058 * Name : UINT WIN32API MapVirtualKeyExA
3059 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
3060 * code into a scan code or character value, or translates a scan
3061 * code into a virtual-key code. The function translates the codes
3062 * using the input language and physical keyboard layout identified
3063 * by the given keyboard layout handle.
3064 * Parameters:
3065 * Variables :
3066 * Result : The return value is either a scan code, a virtual-key code, or
3067 * a character value, depending on the value of uCode and uMapType.
3068 * If there is no translation, the return value is zero.
3069 * Remark :
3070 * Status : UNTESTED STUB
3071 *
3072 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3073 *****************************************************************************/
3074
3075UINT WIN32API MapVirtualKeyExA(UINT uCode,
3076 UINT uMapType,
3077 HKL dwhkl)
3078{
3079 dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
3080 uCode,
3081 uMapType,
3082 dwhkl));
3083
3084 return (0);
3085}
3086
3087
3088/*****************************************************************************
3089 * Name : UINT WIN32API MapVirtualKeyExW
3090 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
3091 * code into a scan code or character value, or translates a scan
3092 * code into a virtual-key code. The function translates the codes
3093 * using the input language and physical keyboard layout identified
3094 * by the given keyboard layout handle.
3095 * Parameters:
3096 * Variables :
3097 * Result : The return value is either a scan code, a virtual-key code, or
3098 * a character value, depending on the value of uCode and uMapType.
3099 * If there is no translation, the return value is zero.
3100 * Remark :
3101 * Status : UNTESTED STUB
3102
3103 *
3104 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3105 *****************************************************************************/
3106
3107UINT WIN32API MapVirtualKeyExW(UINT uCode,
3108 UINT uMapType,
3109 HKL dwhkl)
3110{
3111 dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
3112 uCode,
3113 uMapType,
3114 dwhkl));
3115
3116 return (0);
3117}
3118
3119/*****************************************************************************
3120 * Name : DWORD WIN32API OemKeyScan
3121 * Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
3122 * into the OEM scan codes and shift states. The function provides
3123 * information that allows a program to send OEM text to another
3124 * program by simulating keyboard input.
3125 * Parameters:
3126 * Variables :
3127 * Result :
3128 * Remark :
3129 * Status : UNTESTED STUB
3130 *
3131 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3132 *****************************************************************************/
3133
3134DWORD WIN32API OemKeyScan(WORD wOemChar)
3135{
3136 dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
3137 wOemChar));
3138
3139 return (wOemChar);
3140}
3141
3142
3143/*****************************************************************************
3144 * Name : HDESK WIN32API OpenDesktopA
3145 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
3146 * A desktop is a secure object contained within a window station
3147 * object. A desktop has a logical display surface and contains
3148 * windows, menus and hooks.
3149 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
3150 * DWORD dwFlags flags to control interaction with other applications
3151 * BOOL fInherit specifies whether returned handle is inheritable
3152 * DWORD dwDesiredAccess specifies access of returned handle
3153 * Variables :
3154 * Result : If the function succeeds, the return value is the handle to the
3155 * opened desktop.
3156 * If the function fails, the return value is NULL. To get extended
3157 * error information, call GetLastError.
3158 * Remark :
3159 * Status : UNTESTED STUB
3160 *
3161 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3162 *****************************************************************************/
3163
3164HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
3165 DWORD dwFlags,
3166 BOOL fInherit,
3167 DWORD dwDesiredAccess)
3168{
3169 dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
3170 lpszDesktopName,
3171 dwFlags,
3172 fInherit,
3173 dwDesiredAccess));
3174
3175 return (NULL);
3176}
3177
3178
3179/*****************************************************************************
3180 * Name : HDESK WIN32API OpenDesktopW
3181 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
3182 * A desktop is a secure object contained within a window station
3183 * object. A desktop has a logical display surface and contains
3184 * windows, menus and hooks.
3185 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
3186 * DWORD dwFlags flags to control interaction with other applications
3187 * BOOL fInherit specifies whether returned handle is inheritable
3188 * DWORD dwDesiredAccess specifies access of returned handle
3189 * Variables :
3190 * Result : If the function succeeds, the return value is the handle to the
3191 * opened desktop.
3192 * If the function fails, the return value is NULL. To get extended
3193 * error information, call GetLastError.
3194 * Remark :
3195 * Status : UNTESTED STUB
3196 *
3197 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3198 *****************************************************************************/
3199
3200HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
3201 DWORD dwFlags,
3202 BOOL fInherit,
3203 DWORD dwDesiredAccess)
3204{
3205 dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
3206 lpszDesktopName,
3207 dwFlags,
3208 fInherit,
3209 dwDesiredAccess));
3210
3211 return (NULL);
3212}
3213
3214
3215/*****************************************************************************
3216 * Name : HDESK WIN32API OpenInputDesktop
3217 * Purpose : The OpenInputDesktop function returns a handle to the desktop
3218 * that receives user input. The input desktop is a desktop on the
3219 * window station associated with the logged-on user.
3220 * Parameters: DWORD dwFlags flags to control interaction with other applications
3221 * BOOL fInherit specifies whether returned handle is inheritable
3222 * DWORD dwDesiredAccess specifies access of returned handle
3223 * Variables :
3224 * Result : If the function succeeds, the return value is a handle of the
3225 * desktop that receives user input.
3226 * If the function fails, the return value is NULL. To get extended
3227 * error information, call GetLastError.
3228 * Remark :
3229 * Status : UNTESTED STUB
3230 *
3231 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3232 *****************************************************************************/
3233
3234HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
3235 BOOL fInherit,
3236 DWORD dwDesiredAccess)
3237{
3238 dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
3239 dwFlags,
3240 fInherit,
3241 dwDesiredAccess));
3242
3243 return (NULL);
3244}
3245
3246
3247/*****************************************************************************
3248 * Name : HWINSTA WIN32API OpenWindowStationA
3249 * Purpose : The OpenWindowStation function returns a handle to an existing
3250 * window station.
3251 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
3252 * BOOL fInherit specifies whether returned handle is inheritable
3253 * DWORD dwDesiredAccess specifies access of returned handle
3254 * Variables :
3255 * Result : If the function succeeds, the return value is the handle to the
3256 * specified window station.
3257 * If the function fails, the return value is NULL. To get extended
3258 * error information, call GetLastError.
3259 * Remark :
3260 * Status : UNTESTED STUB
3261 *
3262 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3263 *****************************************************************************/
3264
3265HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
3266 BOOL fInherit,
3267 DWORD dwDesiredAccess)
3268{
3269 dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
3270 lpszWinStaName,
3271 fInherit,
3272 dwDesiredAccess));
3273
3274 return (NULL);
3275}
3276
3277
3278/*****************************************************************************
3279 * Name : HWINSTA WIN32API OpenWindowStationW
3280 * Purpose : The OpenWindowStation function returns a handle to an existing
3281 * window station.
3282 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
3283 * BOOL fInherit specifies whether returned handle is inheritable
3284 * DWORD dwDesiredAccess specifies access of returned handle
3285 * Variables :
3286 * Result : If the function succeeds, the return value is the handle to the
3287 * specified window station.
3288 * If the function fails, the return value is NULL. To get extended
3289 * error information, call GetLastError.
3290
3291
3292 * Remark :
3293 * Status : UNTESTED STUB
3294 *
3295 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3296 *****************************************************************************/
3297
3298HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
3299 BOOL fInherit,
3300 DWORD dwDesiredAccess)
3301{
3302 dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
3303 lpszWinStaName,
3304 fInherit,
3305 dwDesiredAccess));
3306
3307 return (NULL);
3308}
3309
3310
3311/*****************************************************************************
3312 * Name : BOOL WIN32API PaintDesktop
3313 * Purpose : The PaintDesktop function fills the clipping region in the
3314 * specified device context with the desktop pattern or wallpaper.
3315 * The function is provided primarily for shell desktops.
3316 * Parameters:
3317 * Variables :
3318 * Result : If the function succeeds, the return value is TRUE.
3319 * If the function fails, the return value is FALSE.
3320 * Remark :
3321 * Status : UNTESTED STUB
3322 *
3323 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3324 *****************************************************************************/
3325
3326BOOL WIN32API PaintDesktop(HDC hdc)
3327{
3328 dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
3329 hdc));
3330
3331 return (FALSE);
3332}
3333
3334
3335
3336/*****************************************************************************
3337 * Name : VOID WIN32API SetDebugErrorLevel
3338 * Purpose : The SetDebugErrorLevel function sets the minimum error level at
3339 * which Windows will generate debugging events and pass them to a debugger.
3340 * Parameters: DWORD dwLevel debugging error level
3341 * Variables :
3342 * Result :
3343 * Remark :
3344 * Status : UNTESTED STUB
3345 *
3346 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3347 *****************************************************************************/
3348
3349VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
3350{
3351 dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
3352 dwLevel));
3353}
3354
3355
3356/*****************************************************************************
3357 * Name : BOOL WIN32API SetProcessWindowStation
3358 * Purpose : The SetProcessWindowStation function assigns a window station
3359 * to the calling process. This enables the process to access
3360 * objects in the window station such as desktops, the clipboard,
3361 * and global atoms. All subsequent operations on the window station
3362 * use the access rights granted to hWinSta.
3363 * Parameters:
3364 * Variables :
3365 * Result : If the function succeeds, the return value is TRUE.
3366 * If the function fails, the return value is FALSE. To get extended
3367 * error information, call GetLastError.
3368 * Remark :
3369 * Status : UNTESTED STUB
3370 *
3371 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3372 *****************************************************************************/
3373
3374BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
3375{
3376 dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
3377 hWinSta));
3378
3379 return (FALSE);
3380}
3381
3382
3383/*****************************************************************************
3384 * Name : BOOL WIN32API SetSystemCursor
3385 * Purpose : The SetSystemCursor function replaces the contents of the system
3386 * cursor specified by dwCursorId with the contents of the cursor
3387 * specified by hCursor, and then destroys hCursor. This function
3388 * lets an application customize the system cursors.
3389 * Parameters: HCURSOR hCursor set specified system cursor to this cursor's
3390 * contents, then destroy this
3391 * DWORD dwCursorID system cursor specified by its identifier
3392 * Variables :
3393 * Result : If the function succeeds, the return value is TRUE.
3394 * If the function fails, the return value is FALSE. To get extended
3395 * error information, call GetLastError.
3396 * Remark :
3397 * Status : UNTESTED STUB
3398 *
3399 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3400 *****************************************************************************/
3401
3402BOOL WIN32API SetSystemCursor(HCURSOR hCursor,
3403 DWORD dwCursorId)
3404{
3405 dprintf(("USER32:SetSystemCursor (%08xh,%08x) not implemented.\n",
3406 hCursor,
3407 dwCursorId));
3408
3409 return (FALSE);
3410}
3411
3412
3413/*****************************************************************************
3414 * Name : BOOL WIN32API SetThreadDesktop
3415 * Purpose : The SetThreadDesktop function assigns a desktop to the calling
3416 * thread. All subsequent operations on the desktop use the access
3417 * rights granted to hDesk.
3418 * Parameters: HDESK hDesk handle of the desktop to assign to this thread
3419 * Variables :
3420 * Result : If the function succeeds, the return value is TRUE.
3421 * If the function fails, the return value is FALSE. To get extended
3422 * error information, call GetLastError.
3423 * Remark :
3424 * Status : UNTESTED STUB
3425 *
3426 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3427 *****************************************************************************/
3428
3429BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
3430{
3431 dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
3432 hDesktop));
3433
3434 return (FALSE);
3435}
3436
3437
3438/*****************************************************************************
3439 * Name : BOOL WIN32API SetUserObjectInformationA
3440 * Purpose : The SetUserObjectInformation function sets information about a
3441 * window station or desktop object.
3442 * Parameters: HANDLE hObject handle of the object for which to set information
3443 * int nIndex type of information to set
3444 * PVOID lpvInfo points to a buffer that contains the information
3445 * DWORD cbInfo size, in bytes, of lpvInfo buffer
3446 * Variables :
3447 * Result : If the function succeeds, the return value is TRUE.
3448 * If the function fails the return value is FALSE. To get extended
3449 * error information, call GetLastError.
3450 * Remark :
3451 * Status : UNTESTED STUB
3452 *
3453 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3454 *****************************************************************************/
3455
3456BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
3457 int nIndex,
3458 PVOID lpvInfo,
3459 DWORD cbInfo)
3460{
3461 dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
3462 hObject,
3463 nIndex,
3464 lpvInfo,
3465 cbInfo));
3466
3467 return (FALSE);
3468}
3469
3470
3471/*****************************************************************************
3472 * Name : BOOL WIN32API SetUserObjectInformationW
3473 * Purpose : The SetUserObjectInformation function sets information about a
3474 * window station or desktop object.
3475 * Parameters: HANDLE hObject handle of the object for which to set information
3476 * int nIndex type of information to set
3477 * PVOID lpvInfo points to a buffer that contains the information
3478 * DWORD cbInfo size, in bytes, of lpvInfo buffer
3479 * Variables :
3480 * Result : If the function succeeds, the return value is TRUE.
3481 * If the function fails the return value is FALSE. To get extended
3482 * error information, call GetLastError.
3483 * Remark :
3484 * Status : UNTESTED STUB
3485 *
3486 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3487 *****************************************************************************/
3488
3489BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
3490 int nIndex,
3491 PVOID lpvInfo,
3492 DWORD cbInfo)
3493{
3494 dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
3495 hObject,
3496 nIndex,
3497 lpvInfo,
3498 cbInfo));
3499
3500 return (FALSE);
3501}
3502
3503
3504/*****************************************************************************
3505 * Name : BOOL WIN32API SetUserObjectSecurity
3506 * Purpose : The SetUserObjectSecurity function sets the security of a user
3507 * object. This can be, for example, a window or a DDE conversation
3508 * Parameters: HANDLE hObject handle of user object
3509 * SECURITY_INFORMATION * psi address of security information
3510 * LPSECURITY_DESCRIPTOR psd address of security descriptor
3511 * Variables :
3512 * Result : If the function succeeds, the return value is TRUE.
3513 * If the function fails, the return value is FALSE. To get extended
3514 * error information, call GetLastError.
3515 * Remark :
3516 * Status : UNTESTED STUB
3517 *
3518 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3519 *****************************************************************************/
3520
3521BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
3522 SECURITY_INFORMATION * psi,
3523 LPSECURITY_DESCRIPTOR psd)
3524{
3525 dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
3526 hObject,
3527 psi,
3528 psd));
3529
3530 return (FALSE);
3531}
3532
3533
3534/*****************************************************************************
3535 * Name : int WIN32API SetWindowRgn
3536 * Purpose : The SetWindowRgn function sets the window region of a window. The
3537 * window region determines the area within the window where the
3538 * operating system permits drawing. The operating system does not
3539 * display any portion of a window that lies outside of the window region
3540 * Parameters: HWND hWnd handle to window whose window region is to be set
3541 * HRGN hRgn handle to region
3542 * BOOL bRedraw window redraw flag
3543 * Variables :
3544 * Result : If the function succeeds, the return value is non-zero.
3545 * If the function fails, the return value is zero.
3546 * Remark :
3547 * Status : UNTESTED STUB
3548 *
3549 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3550 *****************************************************************************/
3551
3552int WIN32API SetWindowRgn(HWND hWnd,
3553 HRGN hRgn,
3554 BOOL bRedraw)
3555{
3556 dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
3557 hWnd,
3558 hRgn,
3559 bRedraw));
3560
3561 return (0);
3562}
3563
3564
3565/*****************************************************************************
3566 * Name : BOOL WIN32API SetWindowsHookW
3567 * Purpose : The SetWindowsHook function is not implemented in the Win32 API.
3568 * Win32-based applications should use the SetWindowsHookEx function.
3569 * Parameters:
3570 * Variables :
3571 * Result :
3572 * Remark : ARGH ! MICROSOFT !
3573 * Status : UNTESTED STUB
3574 *
3575 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3576 *****************************************************************************/
3577
3578HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
3579
3580{
3581 return (FALSE);
3582}
3583
3584
3585/*****************************************************************************
3586 * Name : BOOL WIN32API ShowWindowAsync
3587 * Purpose : The ShowWindowAsync function sets the show state of a window
3588 * created by a different thread.
3589 * Parameters: HWND hwnd handle of window
3590 * int nCmdShow show state of window
3591 * Variables :
3592 * Result : If the window was previously visible, the return value is TRUE.
3593 * If the window was previously hidden, the return value is FALSE.
3594 * Remark :
3595 * Status : UNTESTED STUB
3596 *
3597 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3598 *****************************************************************************/
3599
3600BOOL WIN32API ShowWindowAsync (HWND hWnd,
3601 int nCmdShow)
3602{
3603 dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
3604 hWnd,
3605 nCmdShow));
3606
3607 return (FALSE);
3608}
3609
3610
3611/*****************************************************************************
3612 * Name : BOOL WIN32API SwitchDesktop
3613 * Purpose : The SwitchDesktop function makes a desktop visible and activates
3614 * it. This enables the desktop to receive input from the user. The
3615 * calling process must have DESKTOP_SWITCHDESKTOP access to the
3616 * desktop for the SwitchDesktop function to succeed.
3617 * Parameters:
3618 * Variables :
3619 * Result : If the function succeeds, the return value is TRUE.
3620 * If the function fails, the return value is FALSE. To get extended
3621 * error information, call GetLastError.
3622 * Remark :
3623 * Status : UNTESTED STUB
3624 *
3625 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3626 *****************************************************************************/
3627
3628BOOL WIN32API SwitchDesktop(HDESK hDesktop)
3629{
3630 dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
3631 hDesktop));
3632
3633 return (FALSE);
3634}
3635
3636
3637/*****************************************************************************
3638 * Name : WORD WIN32API TileWindows
3639 * Purpose : The TileWindows function tiles the specified windows, or the child
3640 * windows of the specified parent window.
3641 * Parameters: HWND hwndParent handle of parent window
3642 * WORD wFlags types of windows not to arrange
3643 * LPCRECT lpRect rectangle to arrange windows in
3644 * WORD cChildrenb number of windows to arrange
3645 * const HWND *ahwndChildren array of window handles
3646 * Variables :
3647 * Result : If the function succeeds, the return value is the number of
3648 * windows arranged.
3649 * If the function fails, the return value is zero.
3650 * Remark :
3651 * Status : UNTESTED STUB
3652 *
3653 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3654 *****************************************************************************/
3655
3656WORD WIN32API TileWindows(HWND hwndParent,
3657 UINT wFlags,
3658 const LPRECT lpRect,
3659 UINT cChildrenb,
3660 const HWND *ahwndChildren)
3661{
3662 dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
3663 hwndParent,
3664 wFlags,
3665 lpRect,
3666 cChildrenb,
3667 ahwndChildren));
3668
3669 return (0);
3670}
3671
3672
3673/*****************************************************************************
3674 * Name : int WIN32API ToAscii
3675 * Purpose : The ToAscii function translates the specified virtual-key code
3676 * and keyboard state to the corresponding Windows character or characters.
3677 * Parameters: UINT uVirtKey virtual-key code
3678 * UINT uScanCode scan code
3679 * PBYTE lpbKeyState address of key-state array
3680 * LPWORD lpwTransKey buffer for translated key
3681 * UINT fuState active-menu flag
3682 * Variables :
3683 * Result : 0 The specified virtual key has no translation for the current
3684 * state of the keyboard.
3685 * 1 One Windows character was copied to the buffer.
3686 * 2 Two characters were copied to the buffer. This usually happens
3687 * when a dead-key character (accent or diacritic) stored in the
3688 * keyboard layout cannot be composed with the specified virtual
3689 * key to form a single character.
3690 * Remark :
3691 * Status : UNTESTED STUB
3692 *
3693 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3694 *****************************************************************************/
3695
3696int WIN32API ToAscii(UINT uVirtKey,
3697 UINT uScanCode,
3698 PBYTE lpbKeyState,
3699 LPWORD lpwTransKey,
3700 UINT fuState)
3701{
3702 dprintf(("USER32:ToAscii (%u,%u,%08xh,%08xh,%u) not implemented.\n",
3703 uVirtKey,
3704 uScanCode,
3705 lpbKeyState,
3706 lpwTransKey,
3707 fuState));
3708
3709 return (0);
3710}
3711
3712
3713/*****************************************************************************
3714 * Name : int WIN32API ToAsciiEx
3715 * Purpose : The ToAscii function translates the specified virtual-key code
3716 * and keyboard state to the corresponding Windows character or characters.
3717 * Parameters: UINT uVirtKey virtual-key code
3718 * UINT uScanCode scan code
3719 * PBYTE lpbKeyState address of key-state array
3720 * LPWORD lpwTransKey buffer for translated key
3721 * UINT fuState active-menu flag
3722 * HLK hlk keyboard layout handle
3723 * Variables :
3724 * Result : 0 The specified virtual key has no translation for the current
3725 * state of the keyboard.
3726 * 1 One Windows character was copied to the buffer.
3727 * 2 Two characters were copied to the buffer. This usually happens
3728 * when a dead-key character (accent or diacritic) stored in the
3729 * keyboard layout cannot be composed with the specified virtual
3730 * key to form a single character.
3731 * Remark :
3732 * Status : UNTESTED STUB
3733 *
3734 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3735 *****************************************************************************/
3736
3737int WIN32API ToAsciiEx(UINT uVirtKey,
3738 UINT uScanCode,
3739 PBYTE lpbKeyState,
3740 LPWORD lpwTransKey,
3741 UINT fuState,
3742 HKL hkl)
3743{
3744 dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
3745 uVirtKey,
3746 uScanCode,
3747 lpbKeyState,
3748 lpwTransKey,
3749 fuState,
3750 hkl));
3751
3752 return (0);
3753}
3754
3755
3756/*****************************************************************************
3757 * Name : int WIN32API ToUnicode
3758 * Purpose : The ToUnicode function translates the specified virtual-key code
3759 * and keyboard state to the corresponding Unicode character or characters.
3760 * Parameters: UINT wVirtKey virtual-key code
3761 * UINT wScanCode scan code
3762 * PBYTE lpKeyState address of key-state array
3763 * LPWSTR pwszBuff buffer for translated key
3764 * int cchBuff size of translated key buffer
3765 * UINT wFlags set of function-conditioning flags
3766 * Variables :
3767 * Result : - 1 The specified virtual key is a dead-key character (accent or
3768 * diacritic). This value is returned regardless of the keyboard
3769 * layout, even if several characters have been typed and are
3770 * stored in the keyboard state. If possible, even with Unicode
3771 * keyboard layouts, the function has written a spacing version of
3772 * the dead-key character to the buffer specified by pwszBuffer.
3773 * For example, the function writes the character SPACING ACUTE
3774 * (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
3775 * 0 The specified virtual key has no translation for the current
3776 * state of the keyboard. Nothing was written to the buffer
3777 * specified by pwszBuffer.
3778 * 1 One character was written to the buffer specified by pwszBuffer.
3779 * 2 or more Two or more characters were written to the buffer specified by
3780 * pwszBuff. The most common cause for this is that a dead-key
3781 * character (accent or diacritic) stored in the keyboard layout
3782 * could not be combined with the specified virtual key to form a
3783 * single character.
3784 * Remark :
3785 * Status : UNTESTED STUB
3786 *
3787 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3788 *****************************************************************************/
3789
3790int WIN32API ToUnicode(UINT uVirtKey,
3791 UINT uScanCode,
3792 PBYTE lpKeyState,
3793 LPWSTR pwszBuff,
3794 int cchBuff,
3795 UINT wFlags)
3796{
3797 dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
3798 uVirtKey,
3799 uScanCode,
3800 lpKeyState,
3801 pwszBuff,
3802 cchBuff,
3803 wFlags));
3804
3805 return (0);
3806}
3807
3808
3809/*****************************************************************************
3810 * Name : BOOL WIN32API UnloadKeyboardLayout
3811 * Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
3812 * Parameters: HKL hkl handle of keyboard layout
3813 * Variables :
3814 * Result : If the function succeeds, the return value is the handle of the
3815 * keyboard layout; otherwise, it is NULL. To get extended error
3816 * information, use the GetLastError function.
3817 * Remark :
3818 * Status : UNTESTED STUB
3819 *
3820 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3821 *****************************************************************************/
3822
3823BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
3824{
3825 dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
3826 hkl));
3827
3828 return (0);
3829}
3830
3831
3832/*****************************************************************************
3833 * Name : SHORT WIN32API VkKeyScanExW
3834 * Purpose : The VkKeyScanEx function translates a character to the
3835 * corresponding virtual-key code and shift state. The function
3836 * translates the character using the input language and physical
3837 * keyboard layout identified by the given keyboard layout handle.
3838 * Parameters: UINT uChar character to translate
3839 * HKL hkl keyboard layout handle
3840 * Variables :
3841 * Result : see docs
3842 * Remark :
3843 * Status : UNTESTED STUB
3844 *
3845 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3846 *****************************************************************************/
3847
3848WORD WIN32API VkKeyScanExW(WCHAR uChar,
3849 HKL hkl)
3850{
3851 dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
3852 uChar,
3853 hkl));
3854
3855 return (uChar);
3856}
3857
3858
3859/*****************************************************************************
3860 * Name : SHORT WIN32API VkKeyScanExA
3861 * Purpose : The VkKeyScanEx function translates a character to the
3862 * corresponding virtual-key code and shift state. The function
3863 * translates the character using the input language and physical
3864 * keyboard layout identified by the given keyboard layout handle.
3865 * Parameters: UINT uChar character to translate
3866 * HKL hkl keyboard layout handle
3867 * Variables :
3868 * Result : see docs
3869 * Remark :
3870 * Status : UNTESTED STUB
3871 *
3872 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3873 *****************************************************************************/
3874
3875WORD WIN32API VkKeyScanExA(CHAR uChar,
3876 HKL hkl)
3877{
3878 dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
3879 uChar,
3880 hkl));
3881
3882 return (uChar);
3883}
3884
3885
3886/*****************************************************************************
3887 * Name : VOID WIN32API keybd_event
3888 * Purpose : The keybd_event function synthesizes a keystroke. The system
3889 * can use such a synthesized keystroke to generate a WM_KEYUP or
3890 * WM_KEYDOWN message. The keyboard driver's interrupt handler calls
3891 * the keybd_event function.
3892 * Parameters: BYTE bVk virtual-key code
3893
3894 * BYTE bScan hardware scan code
3895 * DWORD dwFlags flags specifying various function options
3896 * DWORD dwExtraInfo additional data associated with keystroke
3897 * Variables :
3898 * Result :
3899 * Remark :
3900 * Status : UNTESTED STUB
3901 *
3902 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3903 *****************************************************************************/
3904
3905VOID WIN32API keybd_event (BYTE bVk,
3906 BYTE bScan,
3907 DWORD dwFlags,
3908 DWORD dwExtraInfo)
3909{
3910 dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
3911 bVk,
3912 bScan,
3913 dwFlags,
3914 dwExtraInfo));
3915}
3916
3917
3918/*****************************************************************************
3919 * Name : VOID WIN32API mouse_event
3920 * Purpose : The mouse_event function synthesizes mouse motion and button clicks.
3921 * Parameters: DWORD dwFlags flags specifying various motion/click variants
3922 * DWORD dx horizontal mouse position or position change
3923 * DWORD dy vertical mouse position or position change
3924 * DWORD cButtons unused, reserved for future use, set to zero
3925 * DWORD dwExtraInfo 32 bits of application-defined information
3926 * Variables :
3927 * Result :
3928 * Remark :
3929 * Status : UNTESTED STUB
3930 *
3931 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3932 *****************************************************************************/
3933
3934VOID WIN32API mouse_event(DWORD dwFlags,
3935 DWORD dx,
3936 DWORD dy,
3937 DWORD cButtons,
3938 DWORD dwExtraInfo)
3939{
3940 dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
3941 dwFlags,
3942 dx,
3943 dy,
3944 cButtons,
3945 dwExtraInfo));
3946}
3947
3948
3949/*****************************************************************************
3950 * Name : BOOL WIN32API SetShellWindow
3951 * Purpose : Unknown
3952 * Parameters: Unknown
3953 * Variables :
3954 * Result :
3955 * Remark :
3956 * Status : UNTESTED UNKNOWN STUB
3957 *
3958 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3959 *****************************************************************************/
3960
3961BOOL WIN32API SetShellWindow(DWORD x1)
3962{
3963 dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
3964 x1));
3965
3966 return (FALSE); /* default */
3967}
3968
3969
3970/*****************************************************************************
3971 * Name : BOOL WIN32API PlaySoundEvent
3972 * Purpose : Unknown
3973 * Parameters: Unknown
3974 * Variables :
3975 * Result :
3976 * Remark :
3977 * Status : UNTESTED UNKNOWN STUB
3978 *
3979 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3980 *****************************************************************************/
3981
3982BOOL WIN32API PlaySoundEvent(DWORD x1)
3983{
3984 dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
3985 x1));
3986
3987 return (FALSE); /* default */
3988}
3989
3990
3991/*****************************************************************************
3992 * Name : BOOL WIN32API TileChildWindows
3993 * Purpose : Unknown
3994 * Parameters: Unknown
3995 * Variables :
3996 * Result :
3997 * Remark :
3998 * Status : UNTESTED UNKNOWN STUB
3999 *
4000 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4001 *****************************************************************************/
4002
4003BOOL WIN32API TileChildWindows(DWORD x1,
4004 DWORD x2)
4005{
4006 dprintf(("USER32: TileChildWindows(%08xh,%08xh) not implemented.\n",
4007 x1,
4008 x2));
4009
4010 return (FALSE); /* default */
4011}
4012
4013
4014/*****************************************************************************
4015 * Name : BOOL WIN32API SetSysColorsTemp
4016 * Purpose : Unknown
4017 * Parameters: Unknown
4018 * Variables :
4019 * Result :
4020 * Remark :
4021 * Status : UNTESTED UNKNOWN STUB
4022 *
4023 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4024 *****************************************************************************/
4025
4026BOOL WIN32API SetSysColorsTemp(void)
4027{
4028 dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
4029
4030 return (FALSE); /* default */
4031}
4032
4033
4034/*****************************************************************************
4035 * Name : BOOL WIN32API RegisterNetworkCapabilities
4036 * Purpose : Unknown
4037 * Parameters: Unknown
4038 * Variables :
4039 * Result :
4040 * Remark :
4041 * Status : UNTESTED UNKNOWN STUB
4042 *
4043 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4044 *****************************************************************************/
4045
4046BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
4047 DWORD x2)
4048{
4049 dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
4050 x1,
4051 x2));
4052
4053 return (FALSE); /* default */
4054}
4055
4056
4057/*****************************************************************************
4058 * Name : BOOL WIN32API EndTask
4059 * Purpose : Unknown
4060 * Parameters: Unknown
4061 * Variables :
4062 * Result :
4063 * Remark :
4064 * Status : UNTESTED UNKNOWN STUB
4065 *
4066 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4067 *****************************************************************************/
4068
4069BOOL WIN32API EndTask(DWORD x1,
4070 DWORD x2,
4071 DWORD x3)
4072{
4073 dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
4074 x1,
4075 x2,
4076 x3));
4077
4078 return (FALSE); /* default */
4079}
4080
4081
4082
4083/*****************************************************************************
4084 * Name : BOOL WIN32API GetNextQueueWindow
4085 * Purpose : Unknown
4086 * Parameters: Unknown
4087 * Variables :
4088 * Result :
4089 * Remark :
4090 * Status : UNTESTED UNKNOWN STUB
4091 *
4092 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4093 *****************************************************************************/
4094
4095BOOL WIN32API GetNextQueueWindow(DWORD x1,
4096 DWORD x2)
4097{
4098 dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
4099 x1,
4100 x2));
4101
4102 return (FALSE); /* default */
4103}
4104
4105
4106/*****************************************************************************
4107 * Name : BOOL WIN32API YieldTask
4108 * Purpose : Unknown
4109 * Parameters: Unknown
4110 * Variables :
4111 * Result :
4112 * Remark :
4113 * Status : UNTESTED UNKNOWN STUB
4114 *
4115 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4116 *****************************************************************************/
4117
4118BOOL WIN32API YieldTask(void)
4119{
4120 dprintf(("USER32: YieldTask() not implemented.\n"));
4121
4122 return (FALSE); /* default */
4123}
4124
4125
4126/*****************************************************************************
4127 * Name : BOOL WIN32API WinOldAppHackoMatic
4128 * Purpose : Unknown
4129 * Parameters: Unknown
4130 * Variables :
4131 * Result :
4132 * Remark :
4133 * Status : UNTESTED UNKNOWN STUB
4134 *
4135 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4136 *****************************************************************************/
4137
4138BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
4139{
4140 dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
4141 x1));
4142
4143 return (FALSE); /* default */
4144}
4145
4146
4147/*****************************************************************************
4148 * Name : BOOL WIN32API DragObject
4149 * Purpose : Unknown
4150 * Parameters: Unknown
4151 * Variables :
4152 * Result :
4153 * Remark :
4154 * Status : UNTESTED UNKNOWN STUB
4155 *
4156 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4157 *****************************************************************************/
4158
4159DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
4160{
4161 dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4162 x1,
4163 x2,
4164 x3,
4165 x4,
4166 x5));
4167
4168 return (FALSE); /* default */
4169}
4170
4171
4172/*****************************************************************************
4173 * Name : BOOL WIN32API CascadeChildWindows
4174 * Purpose : Unknown
4175 * Parameters: Unknown
4176 * Variables :
4177 * Result :
4178 * Remark :
4179 * Status : UNTESTED UNKNOWN STUB
4180 *
4181 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4182 *****************************************************************************/
4183
4184BOOL WIN32API CascadeChildWindows(DWORD x1,
4185 DWORD x2)
4186{
4187 dprintf(("USER32: CascadeChildWindows(%08xh,%08xh) not implemented.\n",
4188 x1,
4189 x2));
4190
4191 return (FALSE); /* default */
4192}
4193
4194
4195/*****************************************************************************
4196 * Name : BOOL WIN32API RegisterSystemThread
4197 * Purpose : Unknown
4198 * Parameters: Unknown
4199 * Variables :
4200 * Result :
4201 * Remark :
4202 * Status : UNTESTED UNKNOWN STUB
4203 *
4204 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4205 *****************************************************************************/
4206
4207BOOL WIN32API RegisterSystemThread(DWORD x1,
4208 DWORD x2)
4209{
4210 dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
4211 x1,
4212 x2));
4213
4214 return (FALSE); /* default */
4215}
4216
4217
4218/*****************************************************************************
4219 * Name : BOOL WIN32API IsHungThread
4220 * Purpose : Unknown
4221 * Parameters: Unknown
4222 * Variables :
4223 * Result :
4224 * Remark :
4225 * Status : UNTESTED UNKNOWN STUB
4226 *
4227 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4228 *****************************************************************************/
4229
4230BOOL WIN32API IsHungThread(DWORD x1)
4231{
4232 dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
4233 x1));
4234
4235 return (FALSE); /* default */
4236}
4237
4238
4239
4240/*****************************************************************************
4241 * Name : BOOL WIN32API UserSignalProc
4242 * Purpose : Unknown
4243 * Parameters: Unknown
4244 * Variables :
4245 * Result :
4246 * Remark :
4247 * Status : UNTESTED UNKNOWN STUB
4248 *
4249 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4250 *****************************************************************************/
4251
4252BOOL WIN32API UserSignalProc(DWORD x1,
4253 DWORD x2,
4254 DWORD x3,
4255 DWORD x4)
4256{
4257 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4258 x1,
4259 x2,
4260 x3,
4261 x4));
4262
4263 return (FALSE); /* default */
4264}
4265
4266
4267/*****************************************************************************
4268 * Name : BOOL WIN32API GetShellWindow
4269 * Purpose : Unknown
4270 * Parameters: Unknown
4271 * Variables :
4272 * Result :
4273 * Remark :
4274 * Status : UNTESTED UNKNOWN STUB
4275 *
4276 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
4277 *****************************************************************************/
4278
4279HWND WIN32API GetShellWindow(void)
4280{
4281 dprintf(("USER32: GetShellWindow() not implemented.\n"));
4282
4283 return (0); /* default */
4284}
4285
4286
4287
4288/***********************************************************************
4289 * RegisterTasklist32 [USER32.436]
4290 */
4291DWORD WIN32API RegisterTasklist (DWORD x)
4292{
4293 dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
4294 x));
4295
4296 return TRUE;
4297}
4298
4299
Note: See TracBrowser for help on using the repository browser.