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

Last change on this file since 393 was 392, checked in by sandervl, 26 years ago

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