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

Last change on this file since 323 was 322, checked in by cbratschi, 26 years ago

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