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

Last change on this file since 334 was 330, checked in by sandervl, 26 years ago

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