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

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

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