source: trunk/src/user32/user32.cpp@ 139

Last change on this file since 139 was 139, checked in by buerkle, 26 years ago

* empty log message *
File size: 243.1 KB
Line 
1/* $Id: user32.cpp,v 1.11 1999-06-21 00:42:48 buerkle 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 "wndproc.h"
26#include "wndsubproc.h"
27#include "wndclass.h"
28#include "icon.h"
29#include "usrcall.h"
30#include "syscolor.h"
31
32#include <wchar.h>
33#include <stdlib.h>
34#include <string.h>
35
36//undocumented stuff
37// WIN32API CalcChildScroll
38// WIN32API CascadeChildWindows
39// WIN32API ClientThreadConnect
40// WIN32API DragObject
41// WIN32API DrawFrame
42// WIN32API EditWndProc
43// WIN32API EndTask
44// WIN32API GetInputDesktop
45// WIN32API GetNextQueueWindow
46// WIN32API GetShellWindow
47// WIN32API InitSharedTable
48// WIN32API InitTask
49// WIN32API IsHungThread
50// WIN32API LockWindowStation
51// WIN32API ModifyAccess
52// WIN32API PlaySoundEvent
53// WIN32API RegisterLogonProcess
54// WIN32API RegisterNetworkCapabilities
55// WIN32API RegisterSystemThread
56// WIN32API SetDeskWallpaper
57// WIN32API SetDesktopBitmap
58// WIN32API SetInternalWindowPos
59// WIN32API SetLogonNotifyWindow
60// WIN32API SetShellWindow
61// WIN32API SetSysColorsTemp
62// WIN32API SetWindowFullScreenState
63// WIN32API SwitchToThisWindow
64// WIN32API SysErrorBox
65// WIN32API TileChildWindows
66// WIN32API UnlockWindowStation
67// WIN32API UserClientDllInitialize
68// WIN32API UserSignalProc
69// WIN32API WinOldAppHackoMatic
70// WIN32API WNDPROC_CALLBACK
71// WIN32API YieldTask
72
73
74
75
76//******************************************************************************
77//******************************************************************************
78HWND WIN32API GetActiveWindow()
79{
80 return(O32_GetActiveWindow());
81}
82//******************************************************************************
83//******************************************************************************
84int __cdecl wsprintfA(char *lpOut, LPCSTR lpFmt, ...)
85{
86 int rc;
87 va_list argptr;
88
89#ifdef DEBUG
90 WriteLog("USER32: wsprintfA\n");
91 WriteLog("USER32: %s\n", lpFmt);
92#endif
93 va_start(argptr, lpFmt);
94 rc = O32_wvsprintf(lpOut, (char *)lpFmt, argptr);
95 va_end(argptr);
96#ifdef DEBUG
97 WriteLog("USER32: %s\n", lpOut);
98#endif
99 return(rc);
100}
101//******************************************************************************
102//******************************************************************************
103int __cdecl wsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, ...)
104{
105 int rc;
106 char *lpFmtA;
107 char szOut[512];
108 va_list argptr;
109
110 dprintf(("USER32: wsprintfW(%08xh,%08xh).\n",
111 lpOut,
112 lpFmt));
113
114 lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
115
116 /* @@@PH 98/07/13 transform "%s" to "%ls" does the unicode magic */
117 {
118 PSZ pszTemp;
119 PSZ pszTemp1;
120 ULONG ulStrings;
121 ULONG ulIndex; /* temporary string counter */
122
123 for (ulStrings = 0, /* determine number of placeholders */
124 pszTemp = lpFmtA;
125
126 (pszTemp != NULL) &&
127 (*pszTemp != 0);
128
129 ulStrings++)
130 {
131 pszTemp = strstr(pszTemp,
132 "%s");
133 if (pszTemp != NULL) /* skip 2 characters */
134 {
135 pszTemp++;
136 pszTemp++;
137 }
138 else
139 break; /* leave loop immediately */
140 }
141
142 if (ulStrings != 0) /* transformation required ? */
143 {
144 /* now reallocate lpFmt */
145 ulStrings += strlen(lpFmtA); /* calculate total string length */
146 pszTemp = lpFmtA; /* save string pointer */
147 pszTemp1 = lpFmtA; /* save string pointer */
148
149 /* @@@PH allocation has to be compatible to FreeAsciiString !!! */
150 lpFmtA = (char *)malloc(ulStrings + 1);
151 if (lpFmtA == NULL) /* check proper allocation */
152 return (0); /* raise error condition */
153
154 for (ulIndex = 0;
155 ulIndex <= ulStrings;
156 ulIndex++,
157 pszTemp++)
158 {
159 if ((pszTemp[0] == '%') &&
160 (pszTemp[1] == 's') )
161 {
162 /* replace %s by %ls */
163 lpFmtA[ulIndex++] = '%';
164 lpFmtA[ulIndex ] = 'l';
165 lpFmtA[ulIndex+1] = 's';
166 }
167 else
168 lpFmtA[ulIndex] = *pszTemp; /* just copy over the character */
169 }
170
171 lpFmtA[ulStrings] = 0; /* string termination */
172
173 FreeAsciiString(pszTemp1); /* the original string is obsolete */
174 }
175 }
176
177 dprintf(("USER32: wsprintfW (%s).\n",
178 lpFmt));
179
180 va_start(argptr,
181 lpFmt);
182
183 rc = O32_wvsprintf(szOut,
184 lpFmtA,
185 argptr);
186
187 AsciiToUnicode(szOut,
188 lpOut);
189
190 FreeAsciiString(lpFmtA);
191 return(rc);
192}
193//******************************************************************************
194//******************************************************************************
195int WIN32API MessageBoxA(HWND hwndOwner, LPCTSTR lpszText, LPCTSTR lpszTitle, UINT fuStyle)
196{
197 dprintf(("USER32: MessageBoxA %s %s\n", lpszText, lpszTitle));
198 return(O32_MessageBox(hwndOwner, lpszText, lpszTitle, fuStyle));
199}
200//******************************************************************************
201//******************************************************************************
202BOOL WIN32API MessageBeep( UINT arg1)
203{
204#ifdef DEBUG
205 WriteLog("USER32: MessageBeep\n");
206#endif
207 return O32_MessageBeep(arg1);
208}
209//******************************************************************************
210//******************************************************************************
211LONG WIN32API SendDlgItemMessageA( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
212{
213#ifdef DEBUG
214 WriteLog("USER32: SendDlgItemMessageA\n");
215#endif
216 return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
217}
218//******************************************************************************
219//******************************************************************************
220VOID WIN32API PostQuitMessage( int arg1)
221{
222 dprintf(("USER32: PostQuitMessage\n"));
223 O32_PostQuitMessage(arg1);
224}
225//******************************************************************************
226// Not implemented by Open32 (31-5-99 Christoph Bratschi)
227//******************************************************************************
228BOOL WIN32API IsDlgButtonChecked( HWND arg1, UINT arg2)
229{
230#ifdef DEBUG
231 WriteLog("USER32: IsDlgButtonChecked\n");
232#endif
233// return O32_IsDlgButtonChecked(arg1, arg2);
234 return (BOOL)SendDlgItemMessageA(arg1,arg2,BM_GETCHECK,0,0);
235}
236//******************************************************************************
237//******************************************************************************
238int WIN32API GetWindowTextLengthA( HWND arg1)
239{
240 dprintf(("USER32: GetWindowTextLength\n"));
241 return O32_GetWindowTextLength(arg1);
242}
243//******************************************************************************
244//******************************************************************************
245int WIN32API GetWindowTextA( HWND arg1, LPSTR arg2, int arg3)
246{
247 dprintf(("USER32: GetWindowTextA\n"));
248 return O32_GetWindowText(arg1, arg2, arg3);
249}
250//******************************************************************************
251
252/*******************************************************************
253 * InternalGetWindowText (USER32.326)
254 */
255int WIN32API InternalGetWindowText(HWND hwnd,
256 LPWSTR lpString,
257 INT nMaxCount )
258{
259 dprintf(("USER32: InternalGetWindowText(%08xh,%08xh,%08xh) not properly implemented.\n",
260 hwnd,
261 lpString,
262 nMaxCount));
263
264 return GetWindowTextW(hwnd,lpString,nMaxCount);
265}
266
267
268//******************************************************************************
269BOOL WIN32API GetWindowRect( HWND arg1, PRECT arg2)
270{
271 BOOL rc;
272
273 rc = O32_GetWindowRect(arg1, arg2);
274 dprintf(("USER32: GetWindowRect %X returned %d\n", arg1, rc));
275 return(rc);
276}
277//******************************************************************************
278//******************************************************************************
279HWND WIN32API GetNextDlgTabItem( HWND arg1, HWND arg2, BOOL arg3)
280{
281 dprintf(("USER32: GetNextDlgTabItem\n"));
282 return O32_GetNextDlgTabItem(arg1, arg2, arg3);
283}
284//******************************************************************************
285//******************************************************************************
286BOOL WIN32API GetMessageA( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
287{
288//// dprintf(("USER32: GetMessage\n"));
289 return O32_GetMessage(arg1, arg2, arg3, arg4);
290}
291//******************************************************************************
292//******************************************************************************
293HWND WIN32API GetFocus(void)
294{
295 dprintf(("USER32: GetFocus\n"));
296 return O32_GetFocus();
297}
298//******************************************************************************
299//******************************************************************************
300HWND WIN32API GetDlgItem(HWND arg1, int arg2)
301{
302 HWND rc;
303
304 rc = O32_GetDlgItem(arg1, arg2);
305 dprintf(("USER32: GetDlgItem %d returned %d\n", arg2, rc));
306 return(rc);
307}
308//******************************************************************************
309//******************************************************************************
310int WIN32API GetDlgCtrlID( HWND arg1)
311{
312 dprintf(("USER32: GetDlgCtrlID\n"));
313 return O32_GetDlgCtrlID(arg1);
314}
315//******************************************************************************
316//******************************************************************************
317HWND WIN32API GetDesktopWindow(void)
318{
319 dprintf(("USER32: GetDesktopWindow\n"));
320 return O32_GetDesktopWindow();
321}
322//******************************************************************************
323//******************************************************************************
324BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
325{
326 BOOL rc;
327 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
328
329 dprintf(("USER32: EnumThreadWindows\n"));
330 rc = O32_EnumThreadWindows(dwThreadId, callback->GetOS2Callback(), (LPARAM)callback);
331 if(callback)
332 delete callback;
333 return(rc);
334}
335//******************************************************************************
336//******************************************************************************
337BOOL WIN32API EndDialog( HWND arg1, int arg2)
338{
339 BOOL rc;
340
341 dprintf(("USER32: EndDialog\n"));
342 rc = O32_EndDialog(arg1, arg2);
343 return(rc);
344}
345//******************************************************************************
346//******************************************************************************
347LONG WIN32API DispatchMessageA( const MSG * arg1)
348{
349//// dprintf(("USER32: DispatchMessage\n"));
350 return O32_DispatchMessage(arg1);
351}
352//******************************************************************************
353//******************************************************************************
354BOOL WIN32API OffsetRect( PRECT arg1, int arg2, int arg3)
355{
356#ifdef DEBUG
357//// WriteLog("USER32: OffsetRect\n");
358#endif
359 return O32_OffsetRect(arg1, arg2, arg3);
360}
361//******************************************************************************
362//******************************************************************************
363BOOL WIN32API CopyRect( PRECT arg1, const RECT * arg2)
364{
365// ddprintf(("USER32: CopyRect\n"));
366 return O32_CopyRect(arg1, arg2);
367}
368//******************************************************************************
369// Not implemented by Open32 (5-31-99 Christoph Bratschi)
370//******************************************************************************
371BOOL WIN32API CheckDlgButton( HWND arg1, int arg2, UINT arg3)
372{
373#ifdef DEBUG
374 WriteLog("USER32: CheckDlgButton\n");
375#endif
376// return O32_CheckDlgButton(arg1, arg2, arg3);
377 return (BOOL)SendDlgItemMessageA(arg1,arg2,BM_SETCHECK,arg3,0);
378}
379//******************************************************************************
380//******************************************************************************
381HWND WIN32API SetFocus( HWND arg1)
382{
383 dprintf(("USER32: SetFocus\n"));
384 return O32_SetFocus(arg1);
385}
386//******************************************************************************
387//******************************************************************************
388BOOL WIN32API TranslateMessage( const MSG * arg1)
389{
390#ifdef DEBUG
391//// WriteLog("USER32: TranslateMessage\n");
392#endif
393 return O32_TranslateMessage(arg1);
394}
395//******************************************************************************
396//******************************************************************************
397BOOL WIN32API SetWindowPos( HWND arg1, HWND arg2, int arg3, int arg4, int arg5, int arg6, UINT arg7)
398{
399#ifdef DEBUG
400 WriteLog("USER32: SetWindowPos\n");
401#endif
402 return O32_SetWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
403}
404//******************************************************************************
405//******************************************************************************
406BOOL WIN32API ShowWindow(HWND arg1, int arg2)
407{
408#ifdef DEBUG
409 WriteLog("USER32: ShowWindow %X %d\n", arg1, arg2);
410#endif
411 return O32_ShowWindow(arg1, arg2);
412}
413//******************************************************************************
414//******************************************************************************
415BOOL WIN32API SetWindowTextA(HWND arg1, LPCSTR arg2)
416{
417#ifdef DEBUG
418 WriteLog("USER32: SetWindowText %s\n", arg2);
419#endif
420 return O32_SetWindowText(arg1, arg2);
421}
422//******************************************************************************
423//******************************************************************************
424BOOL WIN32API SetForegroundWindow(HWND arg1)
425{
426#ifdef DEBUG
427 WriteLog("USER32: SetForegroundWindow\n");
428#endif
429 return O32_SetForegroundWindow(arg1);
430}
431//******************************************************************************
432//******************************************************************************
433int WIN32API ReleaseDC( HWND arg1, HDC arg2)
434{
435#ifdef DEBUG
436 WriteLog("USER32: ReleaseDC\n");
437#endif
438 return O32_ReleaseDC(arg1, arg2);
439}
440//******************************************************************************
441//******************************************************************************
442BOOL WIN32API InvalidateRect(HWND arg1, const RECT *arg2, BOOL arg3)
443{
444#ifdef DEBUG
445 if(arg2)
446 WriteLog("USER32: InvalidateRect for window %X (%d,%d)(%d,%d) %d\n", arg1, arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
447 else WriteLog("USER32: InvalidateRect for window %X NULL, %d\n", arg1, arg3);
448#endif
449 return O32_InvalidateRect(arg1, arg2, arg3);
450}
451//******************************************************************************
452//******************************************************************************
453BOOL WIN32API GetUpdateRect( HWND arg1, PRECT arg2, BOOL arg3)
454{
455#ifdef DEBUG
456 WriteLog("USER32: GetUpdateRect\n");
457#endif
458 return O32_GetUpdateRect(arg1, arg2, arg3);
459}
460//******************************************************************************
461//******************************************************************************
462HDC WIN32API GetDC( HWND arg1)
463{
464 HDC hdc;
465
466 hdc = O32_GetDC(arg1);
467#ifdef DEBUG
468 WriteLog("USER32: GetDC of %X returns %X\n", arg1, hdc);
469#endif
470 return(hdc);
471}
472//******************************************************************************
473//******************************************************************************
474HDC WIN32API GetDCEx(HWND arg1, HRGN arg2, DWORD arg3)
475{
476#ifdef DEBUG
477 WriteLog("USER32: GetDCEx\n");
478#endif
479 return O32_GetDCEx(arg1, arg2, arg3);
480}
481//******************************************************************************
482//******************************************************************************
483BOOL WIN32API GetClientRect( HWND arg1, PRECT arg2)
484{
485#ifdef DEBUG
486 WriteLog("USER32: GetClientRect of %X\n", arg1);
487#endif
488
489 return O32_GetClientRect(arg1, arg2);
490}
491//******************************************************************************
492//******************************************************************************
493HWND WIN32API FindWindowA(LPCSTR arg1, LPCSTR arg2)
494{
495#ifdef DEBUG
496 WriteLog("USER32: FindWindow\n");
497#endif
498 return O32_FindWindow(arg1, arg2);
499}
500//******************************************************************************
501//******************************************************************************
502HWND WIN32API FindWindowExA(HWND arg1, HWND arg2, LPCSTR arg3, LPCSTR arg4)
503{
504#ifdef DEBUG
505 WriteLog("USER32: FindWindowExA, not completely implemented\n");
506#endif
507 return O32_FindWindow(arg3, arg4);
508}
509//******************************************************************************
510//******************************************************************************
511BOOL WIN32API FlashWindow( HWND arg1, BOOL arg2)
512{
513#ifdef DEBUG
514 WriteLog("USER32: FlashWindow\n");
515#endif
516 return O32_FlashWindow(arg1, arg2);
517}
518//******************************************************************************
519//******************************************************************************
520BOOL WIN32API EndPaint( HWND arg1, const PAINTSTRUCT * arg2)
521{
522#ifdef DEBUG
523 WriteLog("USER32: EndPaint\n");
524#endif
525 return O32_EndPaint(arg1, arg2);
526}
527//******************************************************************************
528//******************************************************************************
529BOOL WIN32API MoveWindow(HWND arg1, int arg2, int arg3, int arg4, int arg5, BOOL arg6)
530{
531 BOOL rc;
532
533 rc = O32_MoveWindow(arg1, arg2, arg3, arg4, arg5, arg6);
534 dprintf(("USER32: MoveWindow %X to (%d,%d) size (%d,%d), repaint = %d returned %d\n", arg1, arg2, arg3, arg4, arg5, arg6, rc));
535 return(rc);
536}
537//******************************************************************************
538//******************************************************************************
539HWND WIN32API CreateWindowExA(DWORD dwExStyle,
540 LPCSTR arg2,
541 LPCSTR arg3,
542 DWORD dwStyle,
543 int x,
544 int y,
545 int nWidth,
546 int nHeight,
547 HWND parent,
548 HMENU arg10,
549 HINSTANCE arg11,
550 PVOID arg12)
551{
552 HWND hwnd;
553 Win32WindowProc *window = NULL;
554
555 /* @@@PH 98/06/12 CreateWindow crashes somewhere in Open32 */
556 if(arg3 == NULL)
557 arg3 = (LPCSTR)"CRASH, CRASH";
558
559 // 6-12-99 CB: WS_CLIPCHILDREN not set -> controls not redrawn
560 // Problems with group boxes
561 dwStyle |= WS_CLIPCHILDREN;
562
563 //SvL: Correct window style (like Wine does)
564 if(dwStyle & WS_CHILD) {
565 dwStyle |= WS_CLIPSIBLINGS;
566 if(!(dwStyle & WS_POPUP)) {
567 dwStyle |= WS_CAPTION;
568 }
569 }
570 if(dwExStyle & WS_EX_DLGMODALFRAME)
571 {
572 dwStyle &= ~WS_THICKFRAME;
573 }
574
575#ifdef DEBUG
576 WriteLog("USER32: CreateWindow: dwExStyle = %X\n", dwExStyle);
577 if((int)arg2 >> 16 != 0)
578 WriteLog("USER32: CreateWindow: classname = %s\n", arg2);
579 else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
580 WriteLog("USER32: CreateWindow: windowname= %s\n", arg3);
581 WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
582 WriteLog("USER32: CreateWindow: x = %d\n", x);
583 WriteLog("USER32: CreateWindow: y = %d\n", y);
584 WriteLog("USER32: CreateWindow: nWidth = %d\n", nWidth);
585 WriteLog("USER32: CreateWindow: nHeight = %d\n", nHeight);
586 WriteLog("USER32: CreateWindow: parent = %X\n", parent);
587 WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
588 WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
589 WriteLog("USER32: CreateWindow: param = %X\n", arg12);
590 #endif
591
592 if((int) arg2 >> 16 != 0 && strcmp(arg2, "COMBOBOX") == 0)
593 {
594 dprintf(("COMBOBOX creation"));
595 //TODO: #%@#%$ Open32 doesn't support this
596 dwStyle &= ~(CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE);
597
598 /* @@@PH 98/06/12 drop down combos are problematic too */
599 /* so we translate the styles to OS/2 style */
600 dwStyle |= CBS_DROPDOWN | CBS_DROPDOWNLIST;
601 }
602
603 //Classname might be name of system class, in which case we don't
604 //need to use our own callback
605// if(Win32WindowClass::FindClass((LPSTR)arg2) != NULL) {
606 window = new Win32WindowProc(arg11, arg2);
607// }
608
609 hwnd = O32_CreateWindowEx(dwExStyle,
610 arg2,
611 arg3,
612 dwStyle,
613 x,
614 y,
615 nWidth,
616 nHeight,
617 parent,
618 arg10,
619 arg11,
620 arg12);
621
622 //SvL: 16-11-'97: window can be already destroyed if hwnd == 0
623 if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
624 delete(window);
625 window = 0;
626 }
627 if(window) {
628 window->SetWindowHandle(hwnd);
629 }
630
631 dprintf(("USER32: ************CreateWindowExA %s (%d,%d,%d,%d), hwnd = %X\n", arg2, x, y, nWidth, nHeight, hwnd));
632 return(hwnd);
633}
634//******************************************************************************
635//******************************************************************************
636LRESULT WIN32API SendMessageA(HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
637{
638 LRESULT rc;
639
640#ifdef DEBUG
641 WriteLog("USER32: SendMessage....\n");
642#endif
643 rc = O32_SendMessage(arg1, arg2, arg3, arg4);
644#ifdef DEBUG
645 WriteLog("USER32: *****SendMessage %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
646#endif
647 return(rc);
648}
649//******************************************************************************
650//******************************************************************************
651HWND WIN32API SetActiveWindow( HWND arg1)
652{
653#ifdef DEBUG
654 WriteLog("USER32: SetActiveWindow\n");
655#endif
656 return O32_SetActiveWindow(arg1);
657}
658//******************************************************************************
659//******************************************************************************
660HDC WIN32API BeginPaint(HWND arg1, PPAINTSTRUCT arg2)
661{
662 dprintf(("USER32: BeginPaint %X\n", arg2));
663 return O32_BeginPaint(arg1, arg2);
664}
665//******************************************************************************
666//******************************************************************************
667BOOL WIN32API IsDialogMessageA( HWND arg1, LPMSG arg2)
668{
669#ifdef DEBUG
670//// WriteLog("USER32: IsDialogMessage\n");
671#endif
672 return O32_IsDialogMessage(arg1, arg2);
673}
674//******************************************************************************
675//******************************************************************************
676int WIN32API DrawTextA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5)
677{
678#ifdef DEBUG
679 WriteLog("USER32: DrawTextA %s", arg2);
680#endif
681 return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
682}
683//******************************************************************************
684//******************************************************************************
685int WIN32API DrawTextExA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
686{
687#ifdef DEBUG
688 WriteLog("USER32: DrawTextExA (not completely implemented) %s", arg2);
689#endif
690 return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
691}
692//******************************************************************************
693//******************************************************************************
694int WIN32API GetSystemMetrics(int arg1)
695{
696 int rc;
697
698 switch(arg1) {
699 case SM_CXICONSPACING: //TODO: size of grid cell for large icons
700 rc = O32_GetSystemMetrics(SM_CXICON);
701 break;
702 case SM_CYICONSPACING:
703 rc = O32_GetSystemMetrics(SM_CYICON);
704 break;
705 case SM_PENWINDOWS:
706 rc = FALSE;
707 break;
708 case SM_DBCSENABLED:
709 rc = FALSE;
710 break;
711 case SM_CXEDGE: //size of 3D window edge (not supported)
712 rc = 1;
713 break;
714 case SM_CYEDGE:
715 rc = 1;
716 break;
717 case SM_CXMINSPACING: //can be SM_CXMINIMIZED or larger
718 rc = O32_GetSystemMetrics(SM_CXMINIMIZED);
719 break;
720 case SM_CYMINSPACING:
721 rc = GetSystemMetrics(SM_CYMINIMIZED);
722 break;
723 case SM_CXSMICON: //recommended size of small icons (TODO: adjust to screen res.)
724 rc = 16;
725 break;
726 case SM_CYSMICON:
727 rc = 16;
728 break;
729 case SM_CYSMCAPTION: //size in pixels of a small caption (TODO: ????)
730 rc = 8;
731 break;
732 case SM_CXSMSIZE: //size of small caption buttons (pixels) (TODO: implement properly)
733 rc = 16;
734 break;
735 case SM_CYSMSIZE:
736 rc = 16;
737 break;
738 case SM_CXMENUSIZE: //TODO: size of menu bar buttons (such as MDI window close)
739 rc = 16;
740 break;
741 case SM_CYMENUSIZE:
742 rc = 16;
743 break;
744 case SM_ARRANGE:
745 rc = ARW_BOTTOMLEFT | ARW_LEFT;
746 break;
747 case SM_CXMINIMIZED:
748 break;
749 case SM_CYMINIMIZED:
750 break;
751 case SM_CXMAXTRACK: //max window size
752 case SM_CXMAXIMIZED: //max toplevel window size
753 rc = O32_GetSystemMetrics(SM_CXSCREEN);
754 break;
755 case SM_CYMAXTRACK:
756 case SM_CYMAXIMIZED:
757 rc = O32_GetSystemMetrics(SM_CYSCREEN);
758 break;
759 case SM_NETWORK:
760 rc = 0x01; //TODO: default = yes
761 break;
762 case SM_CLEANBOOT:
763 rc = 0; //normal boot
764 break;
765 case SM_CXDRAG: //nr of pixels before drag becomes a real one
766 rc = 2;
767 break;
768 case SM_CYDRAG:
769 rc = 2;
770 break;
771 case SM_SHOWSOUNDS: //show instead of play sound
772 rc = FALSE;
773 break;
774 case SM_CXMENUCHECK:
775 rc = 4; //TODO
776 break;
777 case SM_CYMENUCHECK:
778 rc = O32_GetSystemMetrics(SM_CYMENU);
779 break;
780 case SM_SLOWMACHINE:
781 rc = FALSE; //even a slow machine is fast with OS/2 :)
782 break;
783 case SM_MIDEASTENABLED:
784 rc = FALSE;
785 break;
786 case SM_CMETRICS:
787 rc = O32_GetSystemMetrics(44); //Open32 changed this one
788 break;
789 default:
790 rc = O32_GetSystemMetrics(arg1);
791 break;
792 }
793#ifdef DEBUG
794 WriteLog("USER32: GetSystemMetrics %d returned %d\n", arg1, rc);
795#endif
796 return(rc);
797}
798//******************************************************************************
799//******************************************************************************
800UINT WIN32API SetTimer( HWND arg1, UINT arg2, UINT arg3, TIMERPROC arg4)
801{
802#ifdef DEBUG
803 WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
804#endif
805 //SvL: Write callback handler class for this one
806 return O32_SetTimer(arg1, arg2, arg3, (TIMERPROC_O32)arg4);
807}
808//******************************************************************************
809//******************************************************************************
810BOOL WIN32API KillTimer(HWND arg1, UINT arg2)
811{
812#ifdef DEBUG
813 WriteLog("USER32: KillTimer\n");
814#endif
815 return O32_KillTimer(arg1, arg2);
816}
817//******************************************************************************
818//******************************************************************************
819BOOL WIN32API DestroyWindow(HWND arg1)
820{
821#ifdef DEBUG
822 WriteLog("USER32: DestroyWindow\n");
823#endif
824 return O32_DestroyWindow(arg1);
825}
826//******************************************************************************
827//******************************************************************************
828BOOL WIN32API PostMessageA( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
829{
830#ifdef DEBUG
831 WriteLog("USER32: PostMessageA %X %X %X %X\n", arg1, arg2, arg3, arg4);
832#endif
833 return O32_PostMessage(arg1, arg2, arg3, arg4);
834}
835//******************************************************************************
836//******************************************************************************
837BOOL WIN32API InflateRect( PRECT arg1, int arg2, int arg3)
838{
839#ifdef DEBUG
840 WriteLog("USER32: InflateRect\n");
841#endif
842 return O32_InflateRect(arg1, arg2, arg3);
843}
844//******************************************************************************
845//TODO:How can we emulate this one in OS/2???
846//******************************************************************************
847DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
848{
849#ifdef DEBUG
850 WriteLog("USER32: WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
851#endif
852
853 if(dwTimeOut == INFINITE) return(0);
854
855// DosSleep(dwTimeOut/16);
856 return(0);
857}
858//******************************************************************************
859//******************************************************************************
860UINT WIN32API GetDlgItemTextA(HWND arg1, int arg2, LPSTR arg3, UINT arg4)
861{
862 UINT rc;
863
864 rc = O32_GetDlgItemText(arg1, arg2, arg3, arg4);
865#ifdef DEBUG
866 if(rc)
867 WriteLog("USER32: GetDlgItemTextA returned %s\n", arg3);
868 else WriteLog("USER32: GetDlgItemTextA returned 0 (%d)\n", GetLastError());
869#endif
870 return(rc);
871}
872//******************************************************************************
873//******************************************************************************
874BOOL WIN32API PeekMessageA(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
875{
876#ifdef DEBUG
877// WriteLog("USER32: PeekMessage\n");
878#endif
879 return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
880}
881//******************************************************************************
882//******************************************************************************
883int WIN32API ShowCursor( BOOL arg1)
884{
885#ifdef DEBUG
886 WriteLog("USER32: ShowCursor\n");
887#endif
888 return O32_ShowCursor(arg1);
889}
890//******************************************************************************
891//BUGBUG: UpdateWindow sends a WM_ERASEBKGRND when it shouldn't!
892// So we just do it manually
893//******************************************************************************
894BOOL WIN32API UpdateWindow(HWND hwnd)
895{
896 RECT rect;
897
898#ifdef DEBUG
899 WriteLog("USER32: UpdateWindow\n");
900#endif
901
902#if 0 // EB: ->>> doesn't work. No correct update of Winhlp32 scrolling area.
903 if(O32_GetUpdateRect(hwnd, &rect, FALSE) != FALSE) {//update region empty?
904 WndCallback(hwnd, WM_PAINT, 0, 0);
905// O32_PostMessage(hwnd, WM_PAINT, 0, 0);
906 }
907#ifdef DEBUG
908 else WriteLog("USER32: Update region empty!\n");
909#endif
910 return(TRUE);
911#endif
912
913 return O32_UpdateWindow(hwnd);
914}
915//******************************************************************************
916//******************************************************************************
917BOOL WIN32API AdjustWindowRect( PRECT arg1, DWORD arg2, BOOL arg3)
918{
919#ifdef DEBUG
920 WriteLog("USER32: AdjustWindowRect\n");
921#endif
922 return O32_AdjustWindowRect(arg1, arg2, arg3);
923}
924//******************************************************************************
925//******************************************************************************
926BOOL WIN32API AdjustWindowRectEx( PRECT arg1, DWORD arg2, BOOL arg3, DWORD arg4)
927{
928#ifdef DEBUG
929 WriteLog("USER32: AdjustWindowRectEx\n");
930#endif
931 return O32_AdjustWindowRectEx(arg1, arg2, arg3, arg4);
932}
933//******************************************************************************
934//******************************************************************************
935BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
936{
937#ifdef DEBUG
938//// WriteLog("USER32: ClientToScreen\n");
939#endif
940 return O32_ClientToScreen(arg1, arg2);
941}
942//******************************************************************************
943//******************************************************************************
944BOOL WIN32API SetRect( PRECT arg1, int arg2, int arg3, int arg4, int arg5)
945{
946#ifdef DEBUG
947 WriteLog("USER32: SetRect\n");
948#endif
949 return O32_SetRect(arg1, arg2, arg3, arg4, arg5);
950}
951//******************************************************************************
952//******************************************************************************
953LONG WIN32API GetWindowLongA(HWND hwnd, int nIndex)
954{
955 LONG rc;
956
957 if(nIndex == GWL_WNDPROC || nIndex == DWL_DLGPROC) {
958#ifdef DEBUG
959 WriteLog("USER32: GetWindowLong %X %d\n", hwnd, nIndex);
960#endif
961 Win32WindowProc *window = Win32WindowProc::FindProc(hwnd);
962 if(window && !(nIndex == DWL_DLGPROC && window->IsWindow() == TRUE)) {
963 return (LONG)window->GetWin32Callback();
964 }
965 }
966 rc = O32_GetWindowLong(hwnd, nIndex);
967 return(rc);
968}
969//******************************************************************************
970//******************************************************************************
971BOOL WIN32API SetDlgItemInt( HWND arg1, int arg2, UINT arg3, BOOL arg4)
972{
973#ifdef DEBUG
974 WriteLog("USER32: SetDlgItemInt\n");
975#endif
976 return O32_SetDlgItemInt(arg1, arg2, arg3, arg4);
977}
978//******************************************************************************
979//******************************************************************************
980BOOL WIN32API SetDlgItemTextA( HWND arg1, int arg2, LPCSTR arg3)
981{
982#ifdef DEBUG
983 WriteLog("USER32: SetDlgItemText to %s\n", arg3);
984#endif
985 return O32_SetDlgItemText(arg1, arg2, arg3);
986}
987//******************************************************************************
988//******************************************************************************
989BOOL WIN32API WinHelpA( HWND arg1, LPCSTR arg2, UINT arg3, DWORD arg4)
990{
991#ifdef DEBUG
992 WriteLog("USER32: WinHelp not implemented %s\n", arg2);
993#endif
994// return O32_WinHelp(arg1, arg2, arg3, arg4);
995 return(TRUE);
996}
997//******************************************************************************
998//******************************************************************************
999BOOL WIN32API IsIconic( HWND arg1)
1000{
1001#ifdef DEBUG
1002 WriteLog("USER32: IsIconic\n");
1003#endif
1004 return O32_IsIconic(arg1);
1005}
1006//******************************************************************************
1007//******************************************************************************
1008int WIN32API TranslateAcceleratorA(HWND arg1, HACCEL arg2, LPMSG arg3)
1009{
1010#ifdef DEBUG
1011//// WriteLog("USER32: TranslateAccelerator\n");
1012#endif
1013 return O32_TranslateAccelerator(arg1, arg2, arg3);
1014}
1015//******************************************************************************
1016//******************************************************************************
1017HWND WIN32API GetWindow(HWND arg1, UINT arg2)
1018{
1019 HWND rc;
1020
1021 rc = O32_GetWindow(arg1, arg2);
1022#ifdef DEBUG
1023 WriteLog("USER32: GetWindow %X %d returned %d\n", arg1, arg2, rc);
1024#endif
1025 return(rc);
1026}
1027//******************************************************************************
1028//******************************************************************************
1029HDC WIN32API GetWindowDC(HWND arg1)
1030{
1031#ifdef DEBUG
1032 WriteLog("USER32: GetWindowDC\n");
1033#endif
1034 return O32_GetWindowDC(arg1);
1035}
1036//******************************************************************************
1037//******************************************************************************
1038BOOL WIN32API SubtractRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
1039{
1040#ifdef DEBUG
1041 WriteLog("USER32: SubtractRect");
1042#endif
1043 return O32_SubtractRect(arg1, arg2, arg3);
1044}
1045//******************************************************************************
1046//SvL: 24-6-'97 - Added
1047//******************************************************************************
1048BOOL WIN32API ClipCursor(const RECT * arg1)
1049{
1050#ifdef DEBUG
1051 WriteLog("USER32: ClipCursor\n");
1052#endif
1053 return O32_ClipCursor(arg1);
1054}
1055//******************************************************************************
1056//SvL: 24-6-'97 - Added
1057//TODO: Not implemented
1058//******************************************************************************
1059WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1060{
1061#ifdef DEBUG
1062//// WriteLog("USER32: GetAsyncKeyState Not implemented\n");
1063#endif
1064 return 0;
1065}
1066//******************************************************************************
1067//SvL: 24-6-'97 - Added
1068//******************************************************************************
1069HCURSOR WIN32API GetCursor(void)
1070{
1071#ifdef DEBUG
1072//// WriteLog("USER32: GetCursor\n");
1073#endif
1074 return O32_GetCursor();
1075}
1076//******************************************************************************
1077//SvL: 24-6-'97 - Added
1078//******************************************************************************
1079BOOL WIN32API GetCursorPos( PPOINT arg1)
1080{
1081#ifdef DEBUG
1082//// WriteLog("USER32: GetCursorPos\n");
1083#endif
1084 return O32_GetCursorPos(arg1);
1085}
1086//******************************************************************************
1087//SvL: 24-6-'97 - Added
1088//******************************************************************************
1089UINT WIN32API RegisterWindowMessageA(LPCSTR arg1)
1090{
1091 UINT rc;
1092
1093 rc = O32_RegisterWindowMessage(arg1);
1094#ifdef DEBUG
1095 WriteLog("USER32: RegisterWindowMessageA %s returned %X\n", arg1, rc);
1096#endif
1097 return(rc);
1098}
1099//******************************************************************************
1100//SvL: 24-6-'97 - Added
1101//******************************************************************************
1102WORD WIN32API VkKeyScanA( char arg1)
1103{
1104#ifdef DEBUG
1105 WriteLog("USER32: VkKeyScanA\n");
1106#endif
1107 return O32_VkKeyScan(arg1);
1108}
1109//******************************************************************************
1110//SvL: 24-6-'97 - Added
1111//******************************************************************************
1112SHORT WIN32API GetKeyState( int arg1)
1113{
1114#ifdef DEBUG
1115 WriteLog("USER32: GetKeyState %d\n", arg1);
1116#endif
1117 return O32_GetKeyState(arg1);
1118}
1119//******************************************************************************
1120//******************************************************************************
1121HCURSOR WIN32API SetCursor( HCURSOR arg1)
1122{
1123#ifdef DEBUG
1124 WriteLog("USER32: SetCursor\n");
1125#endif
1126 return O32_SetCursor(arg1);
1127}
1128//******************************************************************************
1129//******************************************************************************
1130BOOL WIN32API SetCursorPos( int arg1, int arg2)
1131{
1132#ifdef DEBUG
1133 WriteLog("USER32: SetCursorPos\n");
1134#endif
1135 return O32_SetCursorPos(arg1, arg2);
1136}
1137//******************************************************************************
1138//******************************************************************************
1139BOOL WIN32API EnableScrollBar( HWND arg1, INT arg2, UINT arg3)
1140{
1141#ifdef DEBUG
1142 WriteLog("USER32: EnableScrollBar\n");
1143#endif
1144 return O32_EnableScrollBar(arg1, arg2, arg3);
1145}
1146//******************************************************************************
1147//******************************************************************************
1148BOOL WIN32API EnableWindow( HWND arg1, BOOL arg2)
1149{
1150#ifdef DEBUG
1151 WriteLog("USER32: EnableWindow\n");
1152#endif
1153 return O32_EnableWindow(arg1, arg2);
1154}
1155//******************************************************************************
1156//******************************************************************************
1157HWND WIN32API SetCapture( HWND arg1)
1158{
1159#ifdef DEBUG
1160 WriteLog("USER32: SetCapture\n");
1161#endif
1162 return O32_SetCapture(arg1);
1163}
1164//******************************************************************************
1165//******************************************************************************
1166BOOL WIN32API ReleaseCapture(void)
1167{
1168#ifdef DEBUG
1169 WriteLog("USER32: ReleaseCapture\n");
1170#endif
1171 return O32_ReleaseCapture();
1172}
1173//******************************************************************************
1174//******************************************************************************
1175DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD arg5)
1176{
1177#ifdef DEBUG
1178 WriteLog("USER32: MsgWaitForMultipleObjects\n");
1179#endif
1180 return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
1181}
1182//******************************************************************************
1183//******************************************************************************
1184HDWP WIN32API BeginDeferWindowPos( int arg1)
1185{
1186#ifdef DEBUG
1187 WriteLog("USER32: BeginDeferWindowPos\n");
1188#endif
1189 return O32_BeginDeferWindowPos(arg1);
1190}
1191//******************************************************************************
1192//******************************************************************************
1193BOOL WIN32API BringWindowToTop( HWND arg1)
1194{
1195#ifdef DEBUG
1196 WriteLog("USER32: BringWindowToTop\n");
1197#endif
1198 return O32_BringWindowToTop(arg1);
1199}
1200//******************************************************************************
1201//******************************************************************************
1202BOOL WIN32API CallMsgFilterA( LPMSG arg1, int arg2)
1203{
1204#ifdef DEBUG
1205 WriteLog("USER32: CallMsgFilterA\n");
1206#endif
1207 return O32_CallMsgFilter(arg1, arg2);
1208}
1209//******************************************************************************
1210//******************************************************************************
1211BOOL WIN32API CallMsgFilterW( LPMSG arg1, int arg2)
1212{
1213#ifdef DEBUG
1214 WriteLog("USER32: CallMsgFilterW\n");
1215#endif
1216 // NOTE: This will not work as is (needs UNICODE support)
1217 return O32_CallMsgFilter(arg1, arg2);
1218}
1219//******************************************************************************
1220//******************************************************************************
1221LRESULT WIN32API CallWindowProcA(WNDPROC wndprcPrev,
1222 HWND arg2,
1223 UINT arg3,
1224 WPARAM arg4,
1225 LPARAM arg5)
1226{
1227#ifdef DEBUG
1228//// WriteLog("USER32: CallWindowProcA %X hwnd=%X, msg = %X\n", wndprcPrev, arg2, arg3);
1229#endif
1230
1231 if(Win32WindowSubProc::FindSubProc((WNDPROC_O32)wndprcPrev) != NULL) {
1232 WNDPROC_O32 orgprc = (WNDPROC_O32)wndprcPrev; //is original Open32 system class callback (_System)
1233 return orgprc(arg2, arg3, arg4, arg5);
1234 }
1235 else return wndprcPrev(arg2, arg3, arg4, arg5); //win32 callback (__stdcall)
1236}
1237//******************************************************************************
1238//******************************************************************************
1239LRESULT WIN32API CallWindowProcW(WNDPROC arg1,
1240 HWND arg2,
1241 UINT arg3,
1242 WPARAM arg4,
1243 LPARAM arg5)
1244{
1245 dprintf(("USER32: CallWindowProcW(%08xh,%08xh,%08xh,%08xh,%08xh) not properly implemented.\n",
1246 arg1,
1247 arg2,
1248 arg3,
1249 arg4,
1250 arg5));
1251
1252 return CallWindowProcA(arg1,
1253 arg2,
1254 arg3,
1255 arg4,
1256 arg5);
1257}
1258//******************************************************************************
1259//******************************************************************************
1260BOOL WIN32API ChangeClipboardChain( HWND arg1, HWND arg2)
1261{
1262#ifdef DEBUG
1263 WriteLog("USER32: ChangeClipboardChain\n");
1264#endif
1265 return O32_ChangeClipboardChain(arg1, arg2);
1266}
1267//******************************************************************************
1268//******************************************************************************
1269UINT WIN32API ArrangeIconicWindows( HWND arg1)
1270{
1271#ifdef DEBUG
1272 WriteLog("USER32: ArrangeIconicWindows\n");
1273#endif
1274 return O32_ArrangeIconicWindows(arg1);
1275}
1276//******************************************************************************
1277// Not implemented by Open32 (5-31-99 Christoph Bratschi)
1278//******************************************************************************
1279BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT arg4)
1280{
1281#ifdef DEBUG
1282 WriteLog("USER32: CheckRadioButton\n");
1283#endif
1284// return O32_CheckRadioButton(arg1, arg2, arg3, arg4);
1285 if (arg2 > arg3) return (FALSE);
1286 for (UINT x=arg2;x <= arg3;x++)
1287 {
1288 SendDlgItemMessageA(arg1,x,BM_SETCHECK,(x == arg4) ? BST_CHECKED : BST_UNCHECKED,0);
1289 }
1290 return (TRUE);
1291}
1292//******************************************************************************
1293//******************************************************************************
1294HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
1295{
1296#ifdef DEBUG
1297 WriteLog("USER32: ChildWindowFromPoint\n");
1298#endif
1299 return O32_ChildWindowFromPoint(arg1, arg2);
1300}
1301//******************************************************************************
1302//******************************************************************************
1303HWND WIN32API ChildWindowFromPointEx(HWND arg1, POINT arg2, UINT uFlags)
1304{
1305#ifdef DEBUG
1306 WriteLog("USER32: ChildWindowFromPointEx, not completely supported!\n");
1307#endif
1308 return O32_ChildWindowFromPoint(arg1, arg2);
1309}
1310//******************************************************************************
1311//******************************************************************************
1312BOOL WIN32API CloseClipboard(void)
1313{
1314#ifdef DEBUG
1315 WriteLog("USER32: CloseClipboard\n");
1316#endif
1317 return O32_CloseClipboard();
1318}
1319//******************************************************************************
1320//******************************************************************************
1321BOOL WIN32API CloseWindow( HWND arg1)
1322{
1323#ifdef DEBUG
1324 WriteLog("USER32: CloseWindow\n");
1325#endif
1326 return O32_CloseWindow(arg1);
1327}
1328//******************************************************************************
1329//******************************************************************************
1330HICON WIN32API CopyIcon( HICON arg1)
1331{
1332#ifdef DEBUG
1333 WriteLog("USER32: CopyIcon\n");
1334#endif
1335 return O32_CopyIcon(arg1);
1336}
1337//******************************************************************************
1338//******************************************************************************
1339int WIN32API CountClipboardFormats(void)
1340{
1341#ifdef DEBUG
1342 WriteLog("USER32: CountClipboardFormats\n");
1343#endif
1344 return O32_CountClipboardFormats();
1345}
1346//******************************************************************************
1347//******************************************************************************
1348HACCEL WIN32API CreateAcceleratorTableA( LPACCEL arg1, int arg2)
1349{
1350#ifdef DEBUG
1351 WriteLog("USER32: CreateAcceleratorTableA\n");
1352#endif
1353 return O32_CreateAcceleratorTable(arg1, arg2);
1354}
1355//******************************************************************************
1356//******************************************************************************
1357HACCEL WIN32API CreateAcceleratorTableW( LPACCEL arg1, int arg2)
1358{
1359#ifdef DEBUG
1360 WriteLog("USER32: CreateAcceleratorTableW\n");
1361#endif
1362 // NOTE: This will not work as is (needs UNICODE support)
1363 return O32_CreateAcceleratorTable(arg1, arg2);
1364}
1365//******************************************************************************
1366//******************************************************************************
1367BOOL WIN32API CreateCaret( HWND arg1, HBITMAP arg2, int arg3, int arg4)
1368{
1369#ifdef DEBUG
1370 WriteLog("USER32: CreateCaret\n");
1371#endif
1372 return O32_CreateCaret(arg1, arg2, arg3, arg4);
1373}
1374//******************************************************************************
1375//******************************************************************************
1376HCURSOR WIN32API CreateCursor( HINSTANCE arg1, int arg2, int arg3, int arg4, int arg5, const VOID * arg6, const VOID * arg7)
1377{
1378#ifdef DEBUG
1379 WriteLog("USER32: CreateCursor\n");
1380#endif
1381 return O32_CreateCursor(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1382}
1383//******************************************************************************
1384//******************************************************************************
1385HICON WIN32API CreateIcon( HINSTANCE arg1, INT arg2, INT arg3, BYTE arg4, BYTE arg5, LPCVOID arg6, LPCVOID arg7)
1386{
1387#ifdef DEBUG
1388 WriteLog("USER32: CreateIcon\n");
1389#endif
1390 return O32_CreateIcon(arg1, arg2, arg3, arg4, arg5, (const BYTE *)arg6, (const BYTE *)arg7);
1391}
1392//******************************************************************************
1393//ASSERT dwVer == win31 (ok according to SDK docs)
1394//******************************************************************************
1395HICON WIN32API CreateIconFromResource(PBYTE presbits, UINT dwResSize,
1396 BOOL fIcon, DWORD dwVer)
1397{
1398 HICON hicon;
1399 DWORD OS2ResSize = 0;
1400 PBYTE OS2Icon = ConvertWin32Icon(presbits, dwResSize, &OS2ResSize);
1401
1402 hicon = O32_CreateIconFromResource(OS2Icon, OS2ResSize, fIcon, dwVer);
1403#ifdef DEBUG
1404 WriteLog("USER32: CreateIconFromResource returned %X (%X)\n", hicon, GetLastError());
1405#endif
1406 if(OS2Icon)
1407 FreeIcon(OS2Icon);
1408
1409 return(hicon);
1410}
1411//******************************************************************************
1412//******************************************************************************
1413HICON WIN32API CreateIconFromResourceEx(PBYTE presbits, UINT dwResSize,
1414 BOOL fIcon, DWORD dwVer,
1415 int cxDesired, int cyDesired,
1416 UINT Flags)
1417{
1418#ifdef DEBUG
1419 WriteLog("USER32: CreateIconFromResourceEx %X %d %d %X %d %d %X, not completely supported!\n", presbits, dwResSize, fIcon, dwVer, cxDesired, cyDesired, Flags);
1420#endif
1421 return CreateIconFromResource(presbits, dwResSize, fIcon, dwVer);
1422}
1423//******************************************************************************
1424//******************************************************************************
1425HICON WIN32API CreateIconIndirect(LPICONINFO arg1)
1426{
1427#ifdef DEBUG
1428 WriteLog("USER32: CreateIconIndirect\n");
1429#endif
1430 return O32_CreateIconIndirect(arg1);
1431}
1432//******************************************************************************
1433//******************************************************************************
1434HWND WIN32API CreateMDIWindowA(LPCSTR arg1, LPCSTR arg2, DWORD arg3,
1435 int arg4, int arg5, int arg6, int arg7,
1436 HWND arg8, HINSTANCE arg9, LPARAM arg10)
1437{
1438 HWND hwnd;
1439
1440#ifdef DEBUG
1441 WriteLog("USER32: CreateMDIWindowA\n");
1442#endif
1443 Win32WindowProc *window = new Win32WindowProc(arg9, arg1);
1444 hwnd = O32_CreateMDIWindow((LPSTR)arg1, (LPSTR)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1445 //SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1446 if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1447 delete(window);
1448 window = 0;
1449 }
1450
1451#ifdef DEBUG
1452 WriteLog("USER32: CreateMDIWindowA returned %X\n", hwnd);
1453#endif
1454 return hwnd;
1455}
1456//******************************************************************************
1457//******************************************************************************
1458HWND WIN32API CreateMDIWindowW(LPCWSTR arg1, LPCWSTR arg2, DWORD arg3, int arg4,
1459 int arg5, int arg6, int arg7, HWND arg8, HINSTANCE arg9,
1460 LPARAM arg10)
1461{
1462 HWND hwnd;
1463 char *astring1 = NULL, *astring2 = NULL;
1464 Win32WindowProc *window = NULL;
1465
1466 if((int)arg1 >> 16 != 0) {
1467 astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1468 }
1469 else astring1 = (char *)arg2;
1470
1471 astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1472
1473 //Classname might be name of system class, in which case we don't
1474 //need to use our own callback
1475// if(Win32WindowClass::FindClass((LPSTR)astring1) != NULL) {
1476 window = new Win32WindowProc(arg9, astring1);
1477// }
1478 hwnd = O32_CreateMDIWindow(astring1, astring2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1479 //SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1480 if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1481 delete(window);
1482 window = 0;
1483 }
1484 if(window) {
1485 window->SetWindowHandle(hwnd);
1486 }
1487
1488 if(astring1) FreeAsciiString(astring1);
1489 FreeAsciiString(astring2);
1490#ifdef DEBUG
1491 WriteLog("USER32: CreateMDIWindowW hwnd = %X\n", hwnd);
1492#endif
1493 return(hwnd);
1494}
1495//******************************************************************************
1496//******************************************************************************
1497HWND WIN32API CreateWindowExW(DWORD arg1,
1498 LPCWSTR arg2,
1499 LPCWSTR arg3,
1500 DWORD dwStyle,
1501 int arg5,
1502 int arg6,
1503 int arg7,
1504 int arg8,
1505 HWND arg9,
1506 HMENU arg10,
1507 HINSTANCE arg11,
1508 PVOID arg12)
1509{
1510 HWND hwnd;
1511 char *astring1 = NULL,
1512 *astring2 = NULL;
1513 Win32WindowProc *window = NULL;
1514
1515 /* @@@PH 98/06/21 changed to call OS2CreateWindowExA */
1516 if((int)arg2 >> 16 != 0)
1517 astring1 = UnicodeToAsciiString((LPWSTR)arg2);
1518 else
1519 astring1 = (char *)arg2;
1520
1521 astring2 = UnicodeToAsciiString((LPWSTR)arg3);
1522
1523#ifdef DEBUG
1524 WriteLog("USER32: CreateWindowExW: dwExStyle = %X\n", arg1);
1525 if((int)arg2 >> 16 != 0)
1526 WriteLog("USER32: CreateWindow: classname = %s\n", astring1);
1527 else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
1528 WriteLog("USER32: CreateWindow: windowname= %s\n", astring2);
1529 WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
1530 WriteLog("USER32: CreateWindow: x = %d\n", arg5);
1531 WriteLog("USER32: CreateWindow: y = %d\n", arg6);
1532 WriteLog("USER32: CreateWindow: nWidth = %d\n", arg7);
1533 WriteLog("USER32: CreateWindow: nHeight = %d\n", arg8);
1534 WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
1535 WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
1536 WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
1537 WriteLog("USER32: CreateWindow: param = %X\n", arg12);
1538 #endif
1539
1540 hwnd = CreateWindowExA(arg1,
1541 astring1,
1542 astring2,
1543 dwStyle,
1544 arg5,
1545 arg6,
1546 arg7,
1547 arg8,
1548 arg9,
1549 arg10,
1550 arg11,
1551 arg12);
1552
1553 if(astring1)
1554 FreeAsciiString(astring1);
1555
1556 FreeAsciiString(astring2);
1557
1558#ifdef DEBUG
1559 WriteLog("USER32: ************CreateWindowExW hwnd = %X (%X)\n", hwnd, GetLastError());
1560#endif
1561 return(hwnd);
1562}
1563//******************************************************************************
1564//******************************************************************************
1565HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
1566{
1567#ifdef DEBUG
1568 WriteLog("USER32: DeferWindowPos\n");
1569#endif
1570 return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1571}
1572//******************************************************************************
1573//******************************************************************************
1574BOOL WIN32API DestroyAcceleratorTable( HACCEL arg1)
1575{
1576#ifdef DEBUG
1577 WriteLog("USER32: DestroyAcceleratorTable\n");
1578#endif
1579 return O32_DestroyAcceleratorTable(arg1);
1580}
1581//******************************************************************************
1582//******************************************************************************
1583BOOL WIN32API DestroyCaret(void)
1584{
1585#ifdef DEBUG
1586 WriteLog("USER32: DestroyCaret\n");
1587#endif
1588 return O32_DestroyCaret();
1589}
1590//******************************************************************************
1591//******************************************************************************
1592BOOL WIN32API DestroyCursor( HCURSOR arg1)
1593{
1594#ifdef DEBUG
1595 WriteLog("USER32: DestroyCursor\n");
1596#endif
1597 return O32_DestroyCursor(arg1);
1598}
1599//******************************************************************************
1600//******************************************************************************
1601BOOL WIN32API DestroyIcon( HICON arg1)
1602{
1603#ifdef DEBUG
1604 WriteLog("USER32: DestroyIcon\n");
1605#endif
1606 return O32_DestroyIcon(arg1);
1607}
1608//******************************************************************************
1609//******************************************************************************
1610LONG WIN32API DispatchMessageW( const MSG * arg1)
1611{
1612#ifdef DEBUG
1613 WriteLog("USER32: DispatchMessageW\n");
1614#endif
1615 // NOTE: This will not work as is (needs UNICODE support)
1616 return O32_DispatchMessage(arg1);
1617}
1618//******************************************************************************
1619//******************************************************************************
1620int WIN32API DlgDirListA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1621{
1622#ifdef DEBUG
1623 WriteLog("USER32: DlgDirListA\n");
1624#endif
1625 return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1626}
1627//******************************************************************************
1628//******************************************************************************
1629int WIN32API DlgDirListComboBoxA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1630{
1631#ifdef DEBUG
1632 WriteLog("USER32: DlgDirListComboBoxA\n");
1633#endif
1634 return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1635}
1636//******************************************************************************
1637//******************************************************************************
1638int WIN32API DlgDirListComboBoxW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1639{
1640#ifdef DEBUG
1641 WriteLog("USER32: DlgDirListComboBoxW NOT WORKING\n");
1642#endif
1643 // NOTE: This will not work as is (needs UNICODE support)
1644 return 0;
1645// return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1646}
1647//******************************************************************************
1648//******************************************************************************
1649int WIN32API DlgDirListW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1650{
1651#ifdef DEBUG
1652 WriteLog("USER32: DlgDirListW NOT WORKING\n");
1653#endif
1654 // NOTE: This will not work as is (needs UNICODE support)
1655 return 0;
1656// return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1657}
1658//******************************************************************************
1659//******************************************************************************
1660BOOL WIN32API DlgDirSelectComboBoxExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1661{
1662#ifdef DEBUG
1663 WriteLog("USER32: DlgDirSelectComboBoxExA\n");
1664#endif
1665 return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1666}
1667//******************************************************************************
1668//******************************************************************************
1669BOOL WIN32API DlgDirSelectComboBoxExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1670{
1671#ifdef DEBUG
1672 WriteLog("USER32: DlgDirSelectComboBoxExW NOT WORKING\n");
1673#endif
1674 // NOTE: This will not work as is (needs UNICODE support)
1675 return 0;
1676// return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1677}
1678//******************************************************************************
1679//******************************************************************************
1680BOOL WIN32API DlgDirSelectExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1681{
1682#ifdef DEBUG
1683 WriteLog("USER32: DlgDirSelectExA\n");
1684#endif
1685 return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1686}
1687//******************************************************************************
1688//******************************************************************************
1689BOOL WIN32API DlgDirSelectExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1690{
1691#ifdef DEBUG
1692 WriteLog("USER32: DlgDirSelectExW NOT WORKING\n");
1693#endif
1694 // NOTE: This will not work as is (needs UNICODE support)
1695 return 0;
1696// return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1697}
1698//******************************************************************************
1699//******************************************************************************
1700BOOL WIN32API DrawFocusRect( HDC arg1, const RECT * arg2)
1701{
1702#ifdef DEBUG
1703 WriteLog("USER32: DrawFocusRect\n");
1704#endif
1705 return O32_DrawFocusRect(arg1, arg2);
1706}
1707//******************************************************************************
1708//******************************************************************************
1709BOOL WIN32API DrawIcon( HDC arg1, int arg2, int arg3, HICON arg4)
1710{
1711#ifdef DEBUG
1712 WriteLog("USER32: DrawIcon\n");
1713#endif
1714 return O32_DrawIcon(arg1, arg2, arg3, arg4);
1715}
1716//******************************************************************************
1717//******************************************************************************
1718BOOL WIN32API DrawIconEx(HDC hdc, int xLeft, int xRight, HICON hIcon,
1719 int cxWidth, int cyWidth, UINT istepIfAniCur,
1720 HBRUSH hbrFlickerFreeDraw, UINT diFlags)
1721{
1722#ifdef DEBUG
1723 WriteLog("USER32: DrawIcon, partially implemented\n");
1724#endif
1725 return O32_DrawIcon(hdc, xLeft, xRight, hIcon);
1726}
1727//******************************************************************************
1728//******************************************************************************
1729BOOL WIN32API DrawMenuBar( HWND arg1)
1730{
1731#ifdef DEBUG
1732 WriteLog("USER32: DrawMenuBar\n");
1733#endif
1734 return O32_DrawMenuBar(arg1);
1735}
1736//******************************************************************************
1737//******************************************************************************
1738int WIN32API DrawTextW( HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5)
1739{
1740 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1741 int rc;
1742
1743#ifdef DEBUG
1744 WriteLog("USER32: DrawTextW %s\n", astring);
1745#endif
1746 rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1747 FreeAsciiString(astring);
1748 return(rc);
1749}
1750//******************************************************************************
1751//******************************************************************************
1752int WIN32API DrawTextExW(HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
1753{
1754 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1755 int rc;
1756
1757#ifdef DEBUG
1758 WriteLog("USER32: DrawTextExW (not completely supported) %s\n", astring);
1759#endif
1760 rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1761 FreeAsciiString(astring);
1762 return(rc);
1763}
1764//******************************************************************************
1765//******************************************************************************
1766BOOL WIN32API EmptyClipboard(void)
1767{
1768#ifdef DEBUG
1769 WriteLog("USER32: EmptyClipboard\n");
1770#endif
1771 return O32_EmptyClipboard();
1772}
1773//******************************************************************************
1774//******************************************************************************
1775BOOL WIN32API EndDeferWindowPos( HDWP arg1)
1776{
1777#ifdef DEBUG
1778 WriteLog("USER32: EndDeferWindowPos\n");
1779#endif
1780 return O32_EndDeferWindowPos(arg1);
1781}
1782//******************************************************************************
1783//******************************************************************************
1784BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1785{
1786 BOOL rc;
1787 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1788
1789#ifdef DEBUG
1790 WriteLog("USER32: EnumChildWindows\n");
1791#endif
1792 rc = O32_EnumChildWindows(hwnd, callback->GetOS2Callback(), (LPARAM)callback);
1793 if(callback)
1794 delete callback;
1795 return(rc);
1796}
1797//******************************************************************************
1798//******************************************************************************
1799UINT WIN32API EnumClipboardFormats(UINT arg1)
1800{
1801#ifdef DEBUG
1802 WriteLog("USER32: EnumClipboardFormats\n");
1803#endif
1804 return O32_EnumClipboardFormats(arg1);
1805}
1806//******************************************************************************
1807//******************************************************************************
1808int WIN32API EnumPropsA(HWND arg1, PROPENUMPROCA arg2)
1809{
1810#ifdef DEBUG
1811 WriteLog("USER32: EnumPropsA DOES NOT WORK\n");
1812#endif
1813 //calling convention problems
1814 return 0;
1815// return O32_EnumProps(arg1, (PROPENUMPROC_O32)arg2);
1816}
1817//******************************************************************************
1818//******************************************************************************
1819int WIN32API EnumPropsExA( HWND arg1, PROPENUMPROCEXA arg2, LPARAM arg3)
1820{
1821#ifdef DEBUG
1822 WriteLog("USER32: EnumPropsExA DOES NOT WORK\n");
1823#endif
1824 //calling convention problems
1825 return 0;
1826// return O32_EnumPropsEx(arg1, arg2, (PROPENUMPROCEX_O32)arg3);
1827}
1828//******************************************************************************
1829//******************************************************************************
1830int WIN32API EnumPropsExW( HWND arg1, PROPENUMPROCEXW arg2, LPARAM arg3)
1831{
1832#ifdef DEBUG
1833 WriteLog("USER32: EnumPropsExW\n");
1834#endif
1835 // NOTE: This will not work as is (needs UNICODE support)
1836 //calling convention problems
1837 return 0;
1838// return O32_EnumPropsEx(arg1, arg2, arg3);
1839}
1840//******************************************************************************
1841//******************************************************************************
1842int WIN32API EnumPropsW( HWND arg1, PROPENUMPROCW arg2)
1843{
1844#ifdef DEBUG
1845 WriteLog("USER32: EnumPropsW\n");
1846#endif
1847 // NOTE: This will not work as is (needs UNICODE support)
1848 //calling convention problems
1849 return 0;
1850// return O32_EnumProps(arg1, arg2);
1851}
1852//******************************************************************************
1853//******************************************************************************
1854BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1855{
1856 BOOL rc;
1857 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1858
1859#ifdef DEBUG
1860 WriteLog("USER32: EnumWindows\n");
1861#endif
1862 rc = O32_EnumWindows(callback->GetOS2Callback(), (LPARAM)callback);
1863 if(callback)
1864 delete callback;
1865 return(rc);
1866}
1867//******************************************************************************
1868//******************************************************************************
1869BOOL WIN32API EqualRect( const RECT * arg1, const RECT * arg2)
1870{
1871#ifdef DEBUG
1872 WriteLog("USER32: EqualRect\n");
1873#endif
1874 return O32_EqualRect(arg1, arg2);
1875}
1876//******************************************************************************
1877//******************************************************************************
1878BOOL WIN32API ExcludeUpdateRgn( HDC arg1, HWND arg2)
1879{
1880#ifdef DEBUG
1881 WriteLog("USER32: ExcludeUpdateRgn\n");
1882#endif
1883 return O32_ExcludeUpdateRgn(arg1, arg2);
1884}
1885//******************************************************************************
1886//******************************************************************************
1887BOOL WIN32API ExitWindowsEx( UINT arg1, DWORD arg2)
1888{
1889#ifdef DEBUG
1890 WriteLog("USER32: ExitWindowsEx\n");
1891#endif
1892 return O32_ExitWindowsEx(arg1, arg2);
1893}
1894//******************************************************************************
1895//******************************************************************************
1896int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
1897{
1898#ifdef DEBUG
1899 WriteLog("USER32: FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
1900#endif
1901 return O32_FillRect(arg1, arg2, arg3);
1902}
1903//******************************************************************************
1904//******************************************************************************
1905HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
1906{
1907 char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1908 char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1909 HWND rc;
1910
1911#ifdef DEBUG
1912 WriteLog("USER32: FindWindowW\n");
1913#endif
1914 rc = O32_FindWindow(astring1, astring2);
1915 FreeAsciiString(astring1);
1916 FreeAsciiString(astring2);
1917 return rc;
1918}
1919//******************************************************************************
1920//******************************************************************************
1921int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH arg3)
1922{
1923#ifdef DEBUG
1924 WriteLog("USER32: FrameRect\n");
1925#endif
1926 return O32_FrameRect(arg1, arg2, arg3);
1927}
1928//******************************************************************************
1929//******************************************************************************
1930HWND WIN32API GetCapture(void)
1931{
1932#ifdef DEBUG
1933 WriteLog("USER32: GetCapture\n");
1934#endif
1935 return O32_GetCapture();
1936}
1937//******************************************************************************
1938//******************************************************************************
1939UINT WIN32API GetCaretBlinkTime(void)
1940{
1941#ifdef DEBUG
1942 WriteLog("USER32: GetCaretBlinkTime\n");
1943#endif
1944 return O32_GetCaretBlinkTime();
1945}
1946//******************************************************************************
1947//******************************************************************************
1948BOOL WIN32API GetCaretPos( PPOINT arg1)
1949{
1950#ifdef DEBUG
1951 WriteLog("USER32: GetCaretPos\n");
1952#endif
1953 return O32_GetCaretPos(arg1);
1954}
1955//******************************************************************************
1956//******************************************************************************
1957BOOL WIN32API GetClipCursor( PRECT arg1)
1958{
1959#ifdef DEBUG
1960 WriteLog("USER32: GetClipCursor\n");
1961#endif
1962 return O32_GetClipCursor(arg1);
1963}
1964//******************************************************************************
1965//******************************************************************************
1966HANDLE WIN32API GetClipboardData( UINT arg1)
1967{
1968#ifdef DEBUG
1969 WriteLog("USER32: GetClipboardData\n");
1970#endif
1971 return O32_GetClipboardData(arg1);
1972}
1973//******************************************************************************
1974//******************************************************************************
1975int WIN32API GetClipboardFormatNameA( UINT arg1, LPSTR arg2, int arg3)
1976{
1977#ifdef DEBUG
1978 WriteLog("USER32: GetClipboardFormatNameA %s\n", arg2);
1979#endif
1980 return O32_GetClipboardFormatName(arg1, arg2, arg3);
1981}
1982//******************************************************************************
1983//******************************************************************************
1984int WIN32API GetClipboardFormatNameW(UINT arg1, LPWSTR arg2, int arg3)
1985{
1986 int rc;
1987 char *astring = UnicodeToAsciiString(arg2);
1988
1989#ifdef DEBUG
1990 WriteLog("USER32: GetClipboardFormatNameW %s\n", astring);
1991#endif
1992 rc = O32_GetClipboardFormatName(arg1, astring, arg3);
1993 FreeAsciiString(astring);
1994 return(rc);
1995}
1996//******************************************************************************
1997//******************************************************************************
1998HWND WIN32API GetClipboardOwner(void)
1999{
2000#ifdef DEBUG
2001 WriteLog("USER32: GetClipboardOwner\n");
2002#endif
2003 return O32_GetClipboardOwner();
2004}
2005//******************************************************************************
2006//******************************************************************************
2007HWND WIN32API GetClipboardViewer(void)
2008{
2009#ifdef DEBUG
2010 WriteLog("USER32: GetClipboardViewer\n");
2011#endif
2012 return O32_GetClipboardViewer();
2013}
2014//******************************************************************************
2015//******************************************************************************
2016DWORD WIN32API GetDialogBaseUnits(void)
2017{
2018#ifdef DEBUG
2019 WriteLog("USER32: GetDialogBaseUnits\n");
2020#endif
2021 return O32_GetDialogBaseUnits();
2022}
2023//******************************************************************************
2024//******************************************************************************
2025UINT WIN32API GetDlgItemInt( HWND arg1, int arg2, PBOOL arg3, BOOL arg4)
2026{
2027#ifdef DEBUG
2028 WriteLog("USER32: GetDlgItemInt\n");
2029#endif
2030 return O32_GetDlgItemInt(arg1, arg2, arg3, arg4);
2031}
2032
2033
2034/*****************************************************************************
2035 * Name : UINT WIN32API GetDlgItemTextW
2036 * Purpose : Determine the text of a window control
2037 * Parameters: HWND arg1
2038 * int arg2
2039 * LPWSTR arg3
2040 * UINT arg4
2041 * Variables :
2042 * Result :
2043 * Remark :
2044 * Status : UNTESTED UNKNOWN STUB
2045 *
2046 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2047 *****************************************************************************/
2048
2049UINT WIN32API GetDlgItemTextW(HWND arg1,
2050 int arg2,
2051 LPWSTR arg3,
2052 UINT arg4)
2053{
2054 LPSTR lpBuffer; /* temporary buffer for the ascii result */
2055 UINT uiResult; /* return value of the ascii variant */
2056
2057 dprintf(("USER32: GetDlgItemTextW(%08xh,%08xh,%08xh,%08xh)\n",
2058 arg1,
2059 arg2,
2060 arg3,
2061 arg4));
2062
2063
2064 lpBuffer = (LPSTR)malloc(arg4); /* allocate temporary buffer */
2065 uiResult = GetDlgItemTextA(arg1, /* call ascii variant */
2066 arg2,
2067 lpBuffer,
2068 arg4);
2069
2070 AsciiToUnicodeN(lpBuffer, /* now convert result to unicode */
2071 arg3,
2072 arg4);
2073
2074 free(lpBuffer); /* free the temporary buffer */
2075
2076 return (uiResult); /* OK, that's it */
2077}
2078
2079
2080//******************************************************************************
2081//******************************************************************************
2082UINT WIN32API GetDoubleClickTime(void)
2083{
2084#ifdef DEBUG
2085 WriteLog("USER32: GetDoubleClickTime\n");
2086#endif
2087 return O32_GetDoubleClickTime();
2088}
2089//******************************************************************************
2090//******************************************************************************
2091HWND WIN32API GetForegroundWindow(void)
2092{
2093#ifdef DEBUG
2094 WriteLog("USER32: GetForegroundWindow\n");
2095#endif
2096 return O32_GetForegroundWindow();
2097}
2098//******************************************************************************
2099//******************************************************************************
2100BOOL WIN32API GetIconInfo( HICON arg1, LPICONINFO arg2)
2101{
2102#ifdef DEBUG
2103 WriteLog("USER32: GetIconInfo\n");
2104#endif
2105 return O32_GetIconInfo(arg1, arg2);
2106}
2107//******************************************************************************
2108//******************************************************************************
2109int WIN32API GetKeyNameTextA( LPARAM arg1, LPSTR arg2, int arg3)
2110{
2111#ifdef DEBUG
2112 WriteLog("USER32: GetKeyNameTextA\n");
2113#endif
2114 return O32_GetKeyNameText(arg1, arg2, arg3);
2115}
2116//******************************************************************************
2117//******************************************************************************
2118int WIN32API GetKeyNameTextW( LPARAM arg1, LPWSTR arg2, int arg3)
2119{
2120#ifdef DEBUG
2121 WriteLog("USER32: GetKeyNameTextW DOES NOT WORK\n");
2122#endif
2123 // NOTE: This will not work as is (needs UNICODE support)
2124 return 0;
2125// return O32_GetKeyNameText(arg1, arg2, arg3);
2126}
2127//******************************************************************************
2128//******************************************************************************
2129int WIN32API GetKeyboardType( int arg1)
2130{
2131#ifdef DEBUG
2132 WriteLog("USER32: GetKeyboardType\n");
2133#endif
2134 return O32_GetKeyboardType(arg1);
2135}
2136//******************************************************************************
2137//******************************************************************************
2138HWND WIN32API GetLastActivePopup( HWND arg1)
2139{
2140#ifdef DEBUG
2141 WriteLog("USER32: GetLastActivePopup\n");
2142#endif
2143 return O32_GetLastActivePopup(arg1);
2144}
2145//******************************************************************************
2146//******************************************************************************
2147LONG WIN32API GetMessageExtraInfo(void)
2148{
2149 dprintf(("USER32: GetMessageExtraInfo\n"));
2150 return O32_GetMessageExtraInfo();
2151}
2152//******************************************************************************
2153//******************************************************************************
2154DWORD WIN32API GetMessagePos(void)
2155{
2156 dprintf(("USER32: GetMessagePos\n"));
2157 return O32_GetMessagePos();
2158}
2159//******************************************************************************
2160//******************************************************************************
2161LONG WIN32API GetMessageTime(void)
2162{
2163 dprintf(("USER32: GetMessageTime\n"));
2164 return O32_GetMessageTime();
2165}
2166//******************************************************************************
2167//******************************************************************************
2168BOOL WIN32API GetMessageW(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
2169{
2170 BOOL rc;
2171
2172 // NOTE: This will not work as is (needs UNICODE support)
2173 rc = O32_GetMessage(arg1, arg2, arg3, arg4);
2174 dprintf(("USER32: GetMessageW %X returned %d\n", arg2, rc));
2175 return(rc);
2176}
2177//******************************************************************************
2178//******************************************************************************
2179HWND WIN32API GetNextDlgGroupItem( HWND arg1, HWND arg2, BOOL arg3)
2180{
2181#ifdef DEBUG
2182 WriteLog("USER32: GetNextDlgGroupItem\n");
2183#endif
2184 return O32_GetNextDlgGroupItem(arg1, arg2, arg3);
2185}
2186//******************************************************************************
2187//******************************************************************************
2188HWND WIN32API GetOpenClipboardWindow(void)
2189{
2190#ifdef DEBUG
2191 WriteLog("USER32: GetOpenClipboardWindow\n");
2192#endif
2193 return O32_GetOpenClipboardWindow();
2194}
2195//******************************************************************************
2196//******************************************************************************
2197HWND WIN32API GetParent( HWND arg1)
2198{
2199#ifdef DEBUG
2200//// WriteLog("USER32: GetParent\n");
2201#endif
2202 return O32_GetParent(arg1);
2203}
2204//******************************************************************************
2205//******************************************************************************
2206int WIN32API GetPriorityClipboardFormat( PUINT arg1, int arg2)
2207{
2208#ifdef DEBUG
2209 WriteLog("USER32: GetPriorityClipboardFormat\n");
2210#endif
2211 return O32_GetPriorityClipboardFormat(arg1, arg2);
2212}
2213//******************************************************************************
2214//******************************************************************************
2215HANDLE WIN32API GetPropA( HWND arg1, LPCSTR arg2)
2216{
2217#ifdef DEBUG
2218 if((int)arg2 >> 16 != 0)
2219 WriteLog("USER32: GetPropA %s\n", arg2);
2220 else WriteLog("USER32: GetPropA %X\n", arg2);
2221#endif
2222 return O32_GetProp(arg1, arg2);
2223}
2224//******************************************************************************
2225//******************************************************************************
2226HANDLE WIN32API GetPropW(HWND arg1, LPCWSTR arg2)
2227{
2228 BOOL handle;
2229 char *astring;
2230
2231 if((int)arg2 >> 16 != 0)
2232 astring = UnicodeToAsciiString((LPWSTR)arg2);
2233 else astring = (char *)arg2;
2234#ifdef DEBUG
2235 if((int)arg2 >> 16 != 0)
2236 WriteLog("USER32: GetPropW %s\n", astring);
2237 else WriteLog("USER32: GetPropW %X\n", astring);
2238#endif
2239 handle = GetPropA(arg1, (LPCSTR)astring);
2240 if((int)arg2 >> 16 != 0)
2241 FreeAsciiString(astring);
2242
2243 return(handle);
2244}
2245//******************************************************************************
2246//******************************************************************************
2247DWORD WIN32API GetQueueStatus( UINT arg1)
2248{
2249#ifdef DEBUG
2250 WriteLog("USER32: GetQueueStatus\n");
2251#endif
2252 return O32_GetQueueStatus(arg1);
2253}
2254//******************************************************************************
2255//******************************************************************************
2256int WIN32API GetScrollPos(HWND hwnd, int fnBar)
2257{
2258 int pos;
2259
2260 pos = O32_GetScrollPos(hwnd, fnBar);
2261#ifdef DEBUG
2262 WriteLog("USER32: GetScrollPos of %X type %d returned %d\n", hwnd, fnBar, pos);
2263#endif
2264 return(pos);
2265}
2266//******************************************************************************
2267//******************************************************************************
2268BOOL WIN32API GetScrollRange( HWND arg1, int arg2, int * arg3, int * arg4)
2269{
2270#ifdef DEBUG
2271 WriteLog("USER32: GetScrollRange\n");
2272#endif
2273 return O32_GetScrollRange(arg1, arg2, arg3, arg4);
2274}
2275//******************************************************************************
2276//******************************************************************************
2277DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
2278{
2279#ifdef DEBUG
2280 WriteLog("USER32: GetTabbedTextExtentA\n");
2281#endif
2282 return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
2283}
2284//******************************************************************************
2285//******************************************************************************
2286DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
2287{
2288 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2289 DWORD rc;
2290
2291#ifdef DEBUG
2292 WriteLog("USER32: GetTabbedTextExtentW\n");
2293#endif
2294 rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
2295 FreeAsciiString(astring);
2296 return rc;
2297}
2298//******************************************************************************
2299//******************************************************************************
2300HWND WIN32API GetTopWindow( HWND arg1)
2301{
2302#ifdef DEBUG
2303//// WriteLog("USER32: GetTopWindow\n");
2304#endif
2305 return O32_GetTopWindow(arg1);
2306}
2307//******************************************************************************
2308//******************************************************************************
2309int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2310{
2311#ifdef DEBUG
2312 WriteLog("USER32: GetUpdateRgn\n");
2313#endif
2314 return O32_GetUpdateRgn(arg1, arg2, arg3);
2315}
2316//******************************************************************************
2317//******************************************************************************
2318LONG WIN32API GetWindowLongW( HWND arg1, int arg2)
2319{
2320#ifdef DEBUG
2321 WriteLog("USER32: GetWindowLongW\n");
2322#endif
2323 return GetWindowLongA(arg1, arg2); //class procedures..
2324}
2325//******************************************************************************
2326//******************************************************************************
2327BOOL WIN32API GetWindowPlacement( HWND arg1, LPWINDOWPLACEMENT arg2)
2328{
2329#ifdef DEBUG
2330 WriteLog("USER32: GetWindowPlacement\n");
2331#endif
2332 return O32_GetWindowPlacement(arg1, arg2);
2333}
2334//******************************************************************************
2335
2336/***********************************************************************
2337 * GetInternalWindowPos (USER32.245)
2338 */
2339UINT WIN32API GetInternalWindowPos(HWND hwnd,
2340 LPRECT rectWnd,
2341 LPPOINT ptIcon )
2342{
2343 WINDOWPLACEMENT wndpl;
2344
2345 dprintf(("USER32: GetInternalWindowPos(%08xh,%08xh,%08xh)\n",
2346 hwnd,
2347 rectWnd,
2348 ptIcon));
2349
2350 if (O32_GetWindowPlacement( hwnd, &wndpl ))
2351 {
2352 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
2353 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
2354 return wndpl.showCmd;
2355 }
2356 return 0;
2357}
2358
2359
2360//******************************************************************************
2361int WIN32API GetWindowTextLengthW( HWND arg1)
2362{
2363#ifdef DEBUG
2364 WriteLog("USER32: GetWindowTextLengthW\n");
2365#endif
2366 return O32_GetWindowTextLength(arg1);
2367}
2368//******************************************************************************
2369//******************************************************************************
2370int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
2371{
2372 char title[128];
2373 int rc;
2374
2375 rc = O32_GetWindowText(hwnd, title, sizeof(title));
2376#ifdef DEBUG
2377 WriteLog("USER32: GetWindowTextW returned %s\n", title);
2378#endif
2379 if(rc > cch) {
2380 title[cch-1] = 0;
2381 rc = cch;
2382 }
2383 AsciiToUnicode(title, lpsz);
2384 return(rc);
2385}
2386//******************************************************************************
2387//******************************************************************************
2388DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD arg2)
2389{
2390#ifdef DEBUG
2391 WriteLog("USER32: GetWindowThreadProcessId\n");
2392#endif
2393 return O32_GetWindowThreadProcessId(arg1, arg2);
2394}
2395//******************************************************************************
2396//******************************************************************************
2397WORD WIN32API GetWindowWord( HWND arg1, int arg2)
2398{
2399#ifdef DEBUG
2400 WriteLog("USER32: GetWindowWord\n");
2401#endif
2402 return O32_GetWindowWord(arg1, arg2);
2403}
2404//******************************************************************************
2405//******************************************************************************
2406BOOL WIN32API HideCaret( HWND arg1)
2407{
2408#ifdef DEBUG
2409 WriteLog("USER32: HideCaret\n");
2410#endif
2411 return O32_HideCaret(arg1);
2412}
2413//******************************************************************************
2414//******************************************************************************
2415BOOL WIN32API InSendMessage(void)
2416{
2417#ifdef DEBUG
2418 WriteLog("USER32: InSendMessage\n");
2419#endif
2420 return O32_InSendMessage();
2421}
2422//******************************************************************************
2423//******************************************************************************
2424BOOL WIN32API IntersectRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
2425{
2426#ifdef DEBUG
2427//// WriteLog("USER32: IntersectRect\n");
2428#endif
2429 return O32_IntersectRect(arg1, arg2, arg3);
2430}
2431//******************************************************************************
2432//******************************************************************************
2433BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2434{
2435#ifdef DEBUG
2436 WriteLog("USER32: InvalidateRgn\n");
2437#endif
2438 return O32_InvalidateRgn(arg1, arg2, arg3);
2439}
2440//******************************************************************************
2441//******************************************************************************
2442BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
2443{
2444#ifdef DEBUG
2445 WriteLog("USER32: InvertRect\n");
2446#endif
2447 return O32_InvertRect(arg1, arg2);
2448}
2449//******************************************************************************
2450//******************************************************************************
2451BOOL WIN32API IsChild( HWND arg1, HWND arg2)
2452{
2453#ifdef DEBUG
2454 WriteLog("USER32: IsChild\n");
2455#endif
2456 return O32_IsChild(arg1, arg2);
2457}
2458//******************************************************************************
2459//******************************************************************************
2460BOOL WIN32API IsClipboardFormatAvailable( UINT arg1)
2461{
2462#ifdef DEBUG
2463 WriteLog("USER32: IsClipboardFormatAvailable\n");
2464#endif
2465 return O32_IsClipboardFormatAvailable(arg1);
2466}
2467//******************************************************************************
2468//******************************************************************************
2469BOOL WIN32API IsDialogMessageW( HWND arg1, LPMSG arg2)
2470{
2471#ifdef DEBUG
2472 WriteLog("USER32: IsDialogMessageW\n");
2473#endif
2474 // NOTE: This will not work as is (needs UNICODE support)
2475 return O32_IsDialogMessage(arg1, arg2);
2476}
2477//******************************************************************************
2478//******************************************************************************
2479BOOL WIN32API IsRectEmpty( const RECT * arg1)
2480{
2481#ifdef DEBUG
2482 WriteLog("USER32: IsRectEmpty\n");
2483#endif
2484 return O32_IsRectEmpty(arg1);
2485}
2486//******************************************************************************
2487//******************************************************************************
2488BOOL WIN32API IsWindow( HWND arg1)
2489{
2490#ifdef DEBUG
2491 WriteLog("USER32: IsWindow\n");
2492#endif
2493 return O32_IsWindow(arg1);
2494}
2495//******************************************************************************
2496//******************************************************************************
2497BOOL WIN32API IsWindowEnabled( HWND arg1)
2498{
2499#ifdef DEBUG
2500 WriteLog("USER32: IsWindowEnabled\n");
2501#endif
2502 return O32_IsWindowEnabled(arg1);
2503}
2504//******************************************************************************
2505//******************************************************************************
2506BOOL WIN32API IsWindowVisible( HWND arg1)
2507{
2508#ifdef DEBUG
2509 WriteLog("USER32: IsWindowVisible\n");
2510#endif
2511 return O32_IsWindowVisible(arg1);
2512}
2513//******************************************************************************
2514//******************************************************************************
2515BOOL WIN32API IsZoomed( HWND arg1)
2516{
2517#ifdef DEBUG
2518 WriteLog("USER32: IsZoomed\n");
2519#endif
2520 return O32_IsZoomed(arg1);
2521}
2522//******************************************************************************
2523//******************************************************************************
2524BOOL WIN32API LockWindowUpdate( HWND arg1)
2525{
2526#ifdef DEBUG
2527 WriteLog("USER32: LockWindowUpdate\n");
2528#endif
2529 return O32_LockWindowUpdate(arg1);
2530}
2531//******************************************************************************
2532//******************************************************************************
2533BOOL WIN32API MapDialogRect( HWND arg1, PRECT arg2)
2534{
2535#ifdef DEBUG
2536 WriteLog("USER32: MapDialogRect\n");
2537#endif
2538 return O32_MapDialogRect(arg1, arg2);
2539}
2540//******************************************************************************
2541//******************************************************************************
2542UINT WIN32API MapVirtualKeyA( UINT arg1, UINT arg2)
2543{
2544#ifdef DEBUG
2545 WriteLog("USER32: MapVirtualKeyA\n");
2546#endif
2547 return O32_MapVirtualKey(arg1, arg2);
2548}
2549//******************************************************************************
2550//******************************************************************************
2551UINT WIN32API MapVirtualKeyW( UINT arg1, UINT arg2)
2552{
2553#ifdef DEBUG
2554 WriteLog("USER32: MapVirtualKeyW\n");
2555#endif
2556 // NOTE: This will not work as is (needs UNICODE support)
2557 return O32_MapVirtualKey(arg1, arg2);
2558}
2559//******************************************************************************
2560//******************************************************************************
2561int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
2562{
2563#ifdef DEBUG
2564 WriteLog("USER32: MapWindowPoints\n");
2565#endif
2566 return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
2567}
2568//******************************************************************************
2569//******************************************************************************
2570int WIN32API MessageBoxW(HWND arg1, LPCWSTR arg2, LPCWSTR arg3, UINT arg4)
2571{
2572 char *astring1, *astring2;
2573 int rc;
2574
2575 astring1 = UnicodeToAsciiString((LPWSTR)arg2);
2576 astring2 = UnicodeToAsciiString((LPWSTR)arg3);
2577#ifdef DEBUG
2578 WriteLog("USER32: MessageBoxW %s %s\n", astring1, astring2);
2579#endif
2580 rc = O32_MessageBox(arg1, astring1, astring2, arg4);
2581 FreeAsciiString(astring1);
2582 FreeAsciiString(astring2);
2583 return(rc);
2584}
2585//******************************************************************************
2586//******************************************************************************
2587BOOL WIN32API OpenClipboard( HWND arg1)
2588{
2589#ifdef DEBUG
2590 WriteLog("USER32: OpenClipboard\n");
2591#endif
2592 return O32_OpenClipboard(arg1);
2593}
2594//******************************************************************************
2595//******************************************************************************
2596BOOL WIN32API PeekMessageW( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
2597{
2598#ifdef DEBUG
2599 WriteLog("USER32: PeekMessageW\n");
2600#endif
2601 // NOTE: This will not work as is (needs UNICODE support)
2602 return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
2603}
2604//******************************************************************************
2605//******************************************************************************
2606// NOTE: Open32 function doesn't have the 'W'.
2607BOOL WIN32API PostMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2608{
2609#ifdef DEBUG
2610 WriteLog("USER32: PostMessageW\n");
2611#endif
2612 // NOTE: This will not work as is (needs UNICODE support)
2613 return O32_PostMessage(arg1, arg2, arg3, arg4);
2614}
2615//******************************************************************************
2616//******************************************************************************
2617BOOL WIN32API PostThreadMessageA( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2618{
2619#ifdef DEBUG
2620 WriteLog("USER32: PostThreadMessageA\n");
2621#endif
2622 return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2623}
2624//******************************************************************************
2625//******************************************************************************
2626BOOL WIN32API PostThreadMessageW( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2627{
2628#ifdef DEBUG
2629 WriteLog("USER32: PostThreadMessageW\n");
2630#endif
2631 // NOTE: This will not work as is (needs UNICODE support)
2632 return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2633}
2634//******************************************************************************
2635//******************************************************************************
2636BOOL WIN32API PtInRect( const RECT * arg1, POINT arg2)
2637{
2638#ifdef DEBUG1
2639 WriteLog("USER32: PtInRect\n");
2640#endif
2641 return O32_PtInRect(arg1, arg2);
2642}
2643//******************************************************************************
2644//******************************************************************************
2645BOOL WIN32API RedrawWindow( HWND arg1, const RECT * arg2, HRGN arg3, UINT arg4)
2646{
2647 BOOL rc;
2648
2649 rc = O32_RedrawWindow(arg1, arg2, arg3, arg4);
2650#ifdef DEBUG
2651 WriteLog("USER32: RedrawWindow %X , %X, %X, %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2652#endif
2653 InvalidateRect(arg1, arg2, TRUE);
2654 UpdateWindow(arg1);
2655 SendMessageA(arg1, WM_PAINT, 0, 0);
2656 return(rc);
2657}
2658//******************************************************************************
2659//******************************************************************************
2660UINT WIN32API RegisterClipboardFormatA( LPCSTR arg1)
2661{
2662#ifdef DEBUG
2663 WriteLog("USER32: RegisterClipboardFormatA\n");
2664#endif
2665 return O32_RegisterClipboardFormat(arg1);
2666}
2667//******************************************************************************
2668//******************************************************************************
2669UINT WIN32API RegisterClipboardFormatW(LPCWSTR arg1)
2670{
2671 UINT rc;
2672 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2673
2674#ifdef DEBUG
2675 WriteLog("USER32: RegisterClipboardFormatW %s\n", astring);
2676#endif
2677 rc = O32_RegisterClipboardFormat(astring);
2678 FreeAsciiString(astring);
2679#ifdef DEBUG
2680 WriteLog("USER32: RegisterClipboardFormatW returned %d\n", rc);
2681#endif
2682 return(rc);
2683}
2684//******************************************************************************
2685//******************************************************************************
2686UINT WIN32API RegisterWindowMessageW( LPCWSTR arg1)
2687{
2688 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2689 UINT rc;
2690
2691#ifdef DEBUG
2692 WriteLog("USER32: RegisterWindowMessageW\n");
2693#endif
2694 rc = O32_RegisterWindowMessage(astring);
2695 FreeAsciiString(astring);
2696 return rc;
2697}
2698//******************************************************************************
2699//******************************************************************************
2700HANDLE WIN32API RemovePropA( HWND arg1, LPCSTR arg2)
2701{
2702#ifdef DEBUG
2703 WriteLog("USER32: RemovePropA\n");
2704#endif
2705 return O32_RemoveProp(arg1, arg2);
2706}
2707//******************************************************************************
2708//******************************************************************************
2709HANDLE WIN32API RemovePropW( HWND arg1, LPCWSTR arg2)
2710{
2711 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2712 HANDLE rc;
2713
2714#ifdef DEBUG
2715 WriteLog("USER32: RemovePropW\n");
2716#endif
2717 rc = O32_RemoveProp(arg1, astring);
2718 FreeAsciiString(astring);
2719 return rc;
2720}
2721//******************************************************************************
2722//******************************************************************************
2723BOOL WIN32API ReplyMessage( LRESULT arg1)
2724{
2725#ifdef DEBUG
2726 WriteLog("USER32: ReplyMessage\n");
2727#endif
2728 return O32_ReplyMessage(arg1);
2729}
2730//******************************************************************************
2731//******************************************************************************
2732BOOL WIN32API ScreenToClient( HWND arg1, LPPOINT arg2)
2733{
2734#ifdef DEBUG
2735 WriteLog("USER32: ScreenToClient\n");
2736#endif
2737 return O32_ScreenToClient(arg1, arg2);
2738}
2739//******************************************************************************
2740//******************************************************************************
2741BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7)
2742{
2743#ifdef DEBUG
2744 WriteLog("USER32: ScrollDC\n");
2745#endif
2746 return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2747}
2748//******************************************************************************
2749//******************************************************************************
2750BOOL WIN32API ScrollWindow( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5)
2751{
2752#ifdef DEBUG
2753 WriteLog("USER32: ScrollWindow\n");
2754#endif
2755 return O32_ScrollWindow(arg1, arg2, arg3, arg4, arg5);
2756}
2757//******************************************************************************
2758//******************************************************************************
2759BOOL WIN32API ScrollWindowEx( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7, UINT arg8)
2760{
2761#ifdef DEBUG
2762 WriteLog("USER32: ScrollWindowEx\n");
2763#endif
2764 return O32_ScrollWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2765}
2766//******************************************************************************
2767//******************************************************************************
2768LONG WIN32API SendDlgItemMessageW( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
2769{
2770#ifdef DEBUG
2771 WriteLog("USER32: SendDlgItemMessageW\n");
2772#endif
2773 return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
2774}
2775//******************************************************************************
2776//******************************************************************************
2777LRESULT WIN32API SendMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2778{
2779LRESULT rc;
2780
2781#ifdef DEBUG
2782 WriteLog("USER32: SendMessageW....\n");
2783#endif
2784 rc = O32_SendMessage(arg1, arg2, arg3, arg4);
2785#ifdef DEBUG
2786 WriteLog("USER32: SendMessageW %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2787#endif
2788 return(rc);
2789}
2790//******************************************************************************
2791//******************************************************************************
2792BOOL WIN32API SetCaretBlinkTime( UINT arg1)
2793{
2794#ifdef DEBUG
2795 WriteLog("USER32: SetCaretBlinkTime\n");
2796#endif
2797 return O32_SetCaretBlinkTime(arg1);
2798}
2799//******************************************************************************
2800//******************************************************************************
2801BOOL WIN32API SetCaretPos( int arg1, int arg2)
2802{
2803 dprintf(("USER32: SetCaretPos\n"));
2804 return O32_SetCaretPos(arg1, arg2);
2805}
2806//******************************************************************************
2807//******************************************************************************
2808HANDLE WIN32API SetClipboardData( UINT arg1, HANDLE arg2)
2809{
2810 dprintf(("USER32: SetClipboardData\n"));
2811 return O32_SetClipboardData(arg1, arg2);
2812}
2813//******************************************************************************
2814//******************************************************************************
2815HWND WIN32API SetClipboardViewer( HWND arg1)
2816{
2817 dprintf(("USER32: SetClipboardViewer\n"));
2818 return O32_SetClipboardViewer(arg1);
2819}
2820//******************************************************************************
2821//******************************************************************************
2822BOOL WIN32API SetDlgItemTextW( HWND arg1, int arg2, LPCWSTR arg3)
2823{
2824char *astring = UnicodeToAsciiString((LPWSTR)arg3);
2825BOOL rc;
2826
2827#ifdef DEBUG
2828 WriteLog("USER32: SetDlgItemTextW\n");
2829#endif
2830 // NOTE: This will not work as is (needs UNICODE support)
2831 rc = O32_SetDlgItemText(arg1, arg2, astring);
2832 FreeAsciiString(astring);
2833 return rc;
2834}
2835//******************************************************************************
2836//******************************************************************************
2837BOOL WIN32API SetDoubleClickTime( UINT arg1)
2838{
2839#ifdef DEBUG
2840 WriteLog("USER32: SetDoubleClickTime\n");
2841#endif
2842 return O32_SetDoubleClickTime(arg1);
2843}
2844//******************************************************************************
2845//******************************************************************************
2846HWND WIN32API SetParent( HWND arg1, HWND arg2)
2847{
2848#ifdef DEBUG
2849 WriteLog("USER32: SetParent\n");
2850#endif
2851 return O32_SetParent(arg1, arg2);
2852}
2853//******************************************************************************
2854//******************************************************************************
2855BOOL WIN32API SetPropA( HWND arg1, LPCSTR arg2, HANDLE arg3)
2856{
2857#ifdef DEBUG
2858 if((int)arg2 >> 16 != 0)
2859 WriteLog("USER32: SetPropA %S\n", arg2);
2860 else WriteLog("USER32: SetPropA %X\n", arg2);
2861#endif
2862 return O32_SetProp(arg1, arg2, arg3);
2863}
2864//******************************************************************************
2865//******************************************************************************
2866BOOL WIN32API SetPropW(HWND arg1, LPCWSTR arg2, HANDLE arg3)
2867{
2868 BOOL rc;
2869 char *astring;
2870
2871 if((int)arg2 >> 16 != 0)
2872 astring = UnicodeToAsciiString((LPWSTR)arg2);
2873 else astring = (char *)arg2;
2874
2875#ifdef DEBUG
2876 if((int)arg2 >> 16 != 0)
2877 WriteLog("USER32: SetPropW %S\n", astring);
2878 else WriteLog("USER32: SetPropW %X\n", astring);
2879#endif
2880 rc = O32_SetProp(arg1, astring, arg3);
2881 if((int)astring >> 16 != 0)
2882 FreeAsciiString(astring);
2883 return(rc);
2884}
2885//******************************************************************************
2886//******************************************************************************
2887BOOL WIN32API SetRectEmpty( PRECT arg1)
2888{
2889#ifdef DEBUG
2890 WriteLog("USER32: SetRectEmpty\n");
2891#endif
2892 return O32_SetRectEmpty(arg1);
2893}
2894//******************************************************************************
2895//******************************************************************************
2896int WIN32API SetScrollPos( HWND arg1, int arg2, int arg3, BOOL arg4)
2897{
2898#ifdef DEBUG
2899 WriteLog("USER32: SetScrollPos\n");
2900#endif
2901 return O32_SetScrollPos(arg1, arg2, arg3, arg4);
2902}
2903//******************************************************************************
2904//******************************************************************************
2905BOOL WIN32API SetScrollRange( HWND arg1, int arg2, int arg3, int arg4, BOOL arg5)
2906{
2907#ifdef DEBUG
2908 WriteLog("USER32: SetScrollRange\n");
2909#endif
2910 return O32_SetScrollRange(arg1, arg2, arg3, arg4, arg5);
2911}
2912//******************************************************************************
2913//******************************************************************************
2914LONG WIN32API SetWindowLongA(HWND hwnd, int nIndex, LONG arg3)
2915{
2916 LONG rc;
2917
2918 dprintf(("USER32: SetWindowLongA %X %d %X\n", hwnd, nIndex, arg3));
2919 if(nIndex == GWL_WNDPROC || nIndex == DWL_DLGPROC) {
2920 Win32WindowProc *wndproc = Win32WindowProc::FindProc(hwnd);
2921 if(wndproc == NULL) {//created with system class and app wants to change the handler
2922 dprintf(("USER32: SetWindowLong new WindowProc for system class\n"));
2923 wndproc = new Win32WindowProc((WNDPROC)arg3);
2924 wndproc->SetWindowHandle(hwnd);
2925 rc = O32_GetWindowLong(hwnd, nIndex);
2926 Win32WindowSubProc *subwndproc = new Win32WindowSubProc(hwnd, (WNDPROC_O32)rc);
2927 O32_SetWindowLong(hwnd, nIndex, (LONG)wndproc->GetOS2Callback());
2928 return((LONG)subwndproc->GetWin32Callback());
2929 }
2930 else {
2931 if(!(nIndex == DWL_DLGPROC && wndproc->IsWindow() == TRUE)) {
2932 rc = (LONG)wndproc->GetWin32Callback();
2933 dprintf(("USER32: SetWindowLong change WindowProc %X to %X\n", rc, arg3));
2934 wndproc->SetWin32Callback((WNDPROC)arg3);
2935 return(rc);
2936 }
2937 //else window that accesses it's normal window data
2938 }
2939 }
2940 return O32_SetWindowLong(hwnd, nIndex, arg3);
2941}
2942//******************************************************************************
2943//TODO: Is this always correct? (GWL_ID: window identifier??)
2944//******************************************************************************
2945LONG WIN32API SetWindowLongW(HWND arg1, int arg2, LONG arg3)
2946{
2947 dprintf(("USER32: SetWindowLongW %X %d %X\n", arg1, arg2, arg3));
2948 return SetWindowLongA(arg1, arg2, arg3);
2949}
2950//******************************************************************************
2951//******************************************************************************
2952BOOL WIN32API SetWindowPlacement( HWND arg1, const WINDOWPLACEMENT * arg2)
2953{
2954 dprintf(("USER32: SetWindowPlacement\n"));
2955 return O32_SetWindowPlacement(arg1, arg2);
2956}
2957//******************************************************************************
2958//******************************************************************************
2959BOOL WIN32API SetWindowTextW( HWND arg1, LPCWSTR arg2)
2960{
2961 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2962 BOOL rc;
2963
2964 rc = SetWindowTextA(arg1, (LPCSTR)astring);
2965 dprintf(("USER32: SetWindowTextW %X %s returned %d\n", arg1, astring, rc));
2966 FreeAsciiString(astring);
2967 return(rc);
2968}
2969//******************************************************************************
2970//******************************************************************************
2971WORD WIN32API SetWindowWord( HWND arg1, int arg2, WORD arg3)
2972{
2973 dprintf(("USER32: SetWindowWord\n"));
2974 return O32_SetWindowWord(arg1, arg2, arg3);
2975}
2976//******************************************************************************
2977//******************************************************************************
2978BOOL WIN32API ShowCaret( HWND arg1)
2979{
2980 dprintf(("USER32: ShowCaret\n"));
2981 return O32_ShowCaret(arg1);
2982}
2983//******************************************************************************
2984//******************************************************************************
2985BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
2986{
2987 dprintf(("USER32: ShowOwnedPopups\n"));
2988 return O32_ShowOwnedPopups(arg1, arg2);
2989}
2990//******************************************************************************
2991//******************************************************************************
2992BOOL WIN32API ShowScrollBar( HWND arg1, int arg2, BOOL arg3)
2993{
2994#ifdef DEBUG
2995 WriteLog("USER32: ShowScrollBar\n");
2996#endif
2997 return O32_ShowScrollBar(arg1, arg2, arg3);
2998}
2999//******************************************************************************
3000//******************************************************************************
3001BOOL WIN32API SwapMouseButton( BOOL arg1)
3002{
3003#ifdef DEBUG
3004 WriteLog("USER32: SwapMouseButton\n");
3005#endif
3006 return O32_SwapMouseButton(arg1);
3007}
3008//******************************************************************************
3009//******************************************************************************
3010BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
3011{
3012 BOOL rc;
3013 NONCLIENTMETRICSA *cmetric = (NONCLIENTMETRICSA *)pvParam;
3014
3015 switch(uiAction) {
3016 case SPI_SCREENSAVERRUNNING:
3017 *(BOOL *)pvParam = FALSE;
3018 rc = TRUE;
3019 break;
3020 case SPI_GETDRAGFULLWINDOWS:
3021 *(BOOL *)pvParam = FALSE;
3022 rc = TRUE;
3023 break;
3024 case SPI_GETNONCLIENTMETRICS:
3025 memset(cmetric, 0, sizeof(NONCLIENTMETRICSA));
3026 cmetric->cbSize = sizeof(NONCLIENTMETRICSA);
3027 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfCaptionFont),0);
3028 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMenuFont),0);
3029 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfStatusFont),0);
3030 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMessageFont),0);
3031 cmetric->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
3032 cmetric->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
3033 cmetric->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
3034 cmetric->iCaptionWidth = 32; //TODO
3035 cmetric->iCaptionHeight = 16; //TODO
3036 cmetric->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
3037 cmetric->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
3038 cmetric->iMenuWidth = 32; //TODO
3039 cmetric->iMenuHeight = GetSystemMetrics(SM_CYMENU);
3040 rc = TRUE;
3041 break;
3042 case 104: //TODO: Undocumented
3043 rc = 16;
3044 break;
3045 default:
3046 rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
3047 break;
3048 }
3049#ifdef DEBUG
3050 WriteLog("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc);
3051#endif
3052 return(rc);
3053}
3054//******************************************************************************
3055//TODO: Check for more options that have different structs for Unicode!!!!
3056//******************************************************************************
3057BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
3058{
3059 BOOL rc;
3060 NONCLIENTMETRICSW *clientMetricsW = (NONCLIENTMETRICSW *)pvParam;
3061 NONCLIENTMETRICSA clientMetricsA = {0};
3062 PVOID pvParamA;
3063 UINT uiParamA;
3064
3065 switch(uiAction) {
3066 case SPI_SETNONCLIENTMETRICS:
3067 clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
3068 clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
3069 clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
3070 clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
3071 clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
3072 clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
3073 ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
3074 clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
3075 clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
3076 ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
3077 clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
3078 clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
3079 ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
3080 ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
3081 ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
3082 //no break
3083 case SPI_GETNONCLIENTMETRICS:
3084 uiParamA = sizeof(NONCLIENTMETRICSA);
3085 pvParamA = &clientMetricsA;
3086 break;
3087 default:
3088 pvParamA = pvParam;
3089 uiParamA = uiParam;
3090 break;
3091 }
3092 rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
3093
3094 switch(uiAction) {
3095 case SPI_GETNONCLIENTMETRICS:
3096 clientMetricsW->cbSize = sizeof(*clientMetricsW);
3097 clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
3098 clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
3099 clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
3100 clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
3101 clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
3102 ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
3103
3104 clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
3105 clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
3106 ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
3107
3108 clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
3109 clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
3110 ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
3111 ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
3112 ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
3113 break;
3114 }
3115#ifdef DEBUG
3116 WriteLog("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc);
3117#endif
3118 return(rc);
3119}
3120//******************************************************************************
3121//******************************************************************************
3122LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3123{
3124#ifdef DEBUG
3125 WriteLog("USER32: TabbedTextOutA\n");
3126#endif
3127 return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
3128}
3129//******************************************************************************
3130//******************************************************************************
3131LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3132{
3133 char *astring = UnicodeToAsciiString((LPWSTR)arg4);
3134 LONG rc;
3135
3136#ifdef DEBUG
3137 WriteLog("USER32: TabbedTextOutW\n");
3138#endif
3139 rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
3140 FreeAsciiString(astring);
3141 return rc;
3142}
3143//******************************************************************************
3144//******************************************************************************
3145int WIN32API TranslateAccelerator( HWND arg1, HACCEL arg2, LPMSG arg3)
3146{
3147#ifdef DEBUG
3148 WriteLog("USER32: TranslateAccelerator\n");
3149#endif
3150 return O32_TranslateAccelerator(arg1, arg2, arg3);
3151}
3152//******************************************************************************
3153//******************************************************************************
3154int WIN32API TranslateAcceleratorW( HWND arg1, HACCEL arg2, LPMSG arg3)
3155{
3156#ifdef DEBUG
3157 WriteLog("USER32: TranslateAcceleratorW\n");
3158#endif
3159 // NOTE: This will not work as is (needs UNICODE support)
3160 return O32_TranslateAccelerator(arg1, arg2, arg3);
3161}
3162//******************************************************************************
3163//******************************************************************************
3164BOOL WIN32API TranslateMDISysAccel( HWND arg1, LPMSG arg2)
3165{
3166#ifdef DEBUG
3167//// WriteLog("USER32: TranslateMDISysAccel\n");
3168#endif
3169 return O32_TranslateMDISysAccel(arg1, arg2);
3170}
3171//******************************************************************************
3172//******************************************************************************
3173BOOL WIN32API UnionRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
3174{
3175#ifdef DEBUG
3176 WriteLog("USER32: UnionRect\n");
3177#endif
3178 return O32_UnionRect(arg1, arg2, arg3);
3179}
3180//******************************************************************************
3181//******************************************************************************
3182BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
3183{
3184#ifdef DEBUG
3185 WriteLog("USER32: ValidateRect\n");
3186#endif
3187 return O32_ValidateRect(arg1, arg2);
3188}
3189//******************************************************************************
3190//******************************************************************************
3191BOOL WIN32API ValidateRgn( HWND arg1, HRGN arg2)
3192{
3193#ifdef DEBUG
3194 WriteLog("USER32: ValidateRgn\n");
3195#endif
3196 return O32_ValidateRgn(arg1, arg2);
3197}
3198//******************************************************************************
3199//******************************************************************************
3200WORD WIN32API VkKeyScanW( WCHAR arg1)
3201{
3202#ifdef DEBUG
3203 WriteLog("USER32: VkKeyScanW\n");
3204#endif
3205 // NOTE: This will not work as is (needs UNICODE support)
3206 return O32_VkKeyScan((char)arg1);
3207}
3208//******************************************************************************
3209//******************************************************************************
3210BOOL WIN32API WaitMessage(void)
3211{
3212#ifdef DEBUG
3213 WriteLog("USER32: WaitMessage\n");
3214#endif
3215 return O32_WaitMessage();
3216}
3217//******************************************************************************
3218//******************************************************************************
3219BOOL WIN32API WinHelpW( HWND arg1, LPCWSTR arg2, UINT arg3, DWORD arg4)
3220{
3221 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
3222 BOOL rc;
3223
3224#ifdef DEBUG
3225 WriteLog("USER32: WinHelpW\n");
3226#endif
3227 rc = WinHelpA(arg1, astring, arg3, arg4);
3228 FreeAsciiString(astring);
3229 return rc;
3230}
3231//******************************************************************************
3232//******************************************************************************
3233HWND WIN32API WindowFromDC( HDC arg1)
3234{
3235#ifdef DEBUG
3236 WriteLog("USER32: WindowFromDC\n");
3237#endif
3238 return O32_WindowFromDC(arg1);
3239}
3240//******************************************************************************
3241//******************************************************************************
3242HWND WIN32API WindowFromPoint( POINT arg1)
3243{
3244#ifdef DEBUG
3245 WriteLog("USER32: WindowFromPoint\n");
3246#endif
3247 return O32_WindowFromPoint(arg1);
3248}
3249//******************************************************************************
3250//******************************************************************************
3251int WIN32API wvsprintfA( LPSTR arg1, LPCSTR arg2, va_list arg3)
3252{
3253#ifdef DEBUG
3254 WriteLog("USER32: wvsprintfA\n");
3255#endif
3256 return O32_wvsprintf(arg1, arg2, (LPCVOID *)arg3);
3257}
3258//******************************************************************************
3259//******************************************************************************
3260int WIN32API wvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, va_list argptr)
3261{
3262 int rc;
3263 char szOut[256];
3264 char *lpFmtA;
3265
3266 lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
3267#ifdef DEBUG
3268 WriteLog("USER32: wvsprintfW, DOES NOT HANDLE UNICODE STRINGS!\n");
3269 WriteLog("USER32: %s\n", lpFmt);
3270#endif
3271 rc = O32_wvsprintf(szOut, lpFmtA, (LPCVOID)argptr);
3272
3273 AsciiToUnicode(szOut, lpOut);
3274#ifdef DEBUG
3275 WriteLog("USER32: %s\n", lpOut);
3276#endif
3277 FreeAsciiString(lpFmtA);
3278 return(rc);
3279}
3280//******************************************************************************
3281//No need to support this
3282//******************************************************************************
3283BOOL WIN32API SetMessageQueue(int cMessagesMax)
3284{
3285#ifdef DEBUG
3286 WriteLog("USER32: SetMessageQueue\n");
3287#endif
3288 return(TRUE);
3289}
3290//******************************************************************************
3291//TODO: Not complete
3292//******************************************************************************
3293BOOL WIN32API GetScrollInfo(HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
3294{
3295#ifdef DEBUG
3296 WriteLog("USER32: GetScrollInfo\n");
3297#endif
3298 if(lpsi == NULL)
3299 return(FALSE);
3300
3301 if(lpsi->fMask & SIF_POS)
3302 lpsi->nPos = GetScrollPos(hwnd, fnBar);
3303 if(lpsi->fMask & SIF_RANGE)
3304 GetScrollRange(hwnd, fnBar, &lpsi->nMin, &lpsi->nMax);
3305 if(lpsi->fMask & SIF_PAGE) {
3306#ifdef DEBUG
3307 WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3308#endif
3309 lpsi->nPage = 25;
3310 }
3311 return(TRUE);
3312}
3313//******************************************************************************
3314//TODO: Not complete
3315//******************************************************************************
3316INT WIN32API SetScrollInfo(HWND hwnd, INT fnBar, const SCROLLINFO *lpsi, BOOL fRedraw)
3317{
3318 int smin, smax;
3319
3320#ifdef DEBUG
3321 WriteLog("USER32: SetScrollInfo\n");
3322#endif
3323 if(lpsi == NULL)
3324 return(FALSE);
3325
3326 if(lpsi->fMask & SIF_POS)
3327 SetScrollPos(hwnd, fnBar, lpsi->nPos, fRedraw);
3328 if(lpsi->fMask & SIF_RANGE)
3329 SetScrollRange(hwnd, fnBar, lpsi->nMin, lpsi->nMax, fRedraw);
3330 if(lpsi->fMask & SIF_PAGE) {
3331#ifdef DEBUG
3332 WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3333#endif
3334 }
3335 if(lpsi->fMask & SIF_DISABLENOSCROLL) {
3336#ifdef DEBUG
3337 WriteLog("USER32: GetScrollInfo, disable scrollbar not yet implemented\n");
3338#endif
3339 }
3340 return(TRUE);
3341}
3342//******************************************************************************
3343//******************************************************************************
3344BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3345 LPARAM lpData, int nCount, int X, int Y, int nWidth,
3346 int nHeight)
3347{
3348 BOOL rc;
3349 COLORREF curclr;
3350
3351#ifdef DEBUG
3352 WriteLog("USER32: GrayStringA, not completely implemented\n");
3353#endif
3354 if(lpOutputFunc == NULL && lpData == NULL) {
3355#ifdef DEBUG
3356 WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3357#endif
3358 return(FALSE);
3359 }
3360 if(lpOutputFunc) {
3361 return(lpOutputFunc(hdc, lpData, nCount));
3362 }
3363 curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3364 rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
3365 SetTextColor(hdc, curclr);
3366
3367 return(rc);
3368}
3369//******************************************************************************
3370//******************************************************************************
3371BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3372 LPARAM lpData, int nCount, int X, int Y, int nWidth,
3373 int nHeight)
3374{
3375 BOOL rc;
3376 char *astring;
3377 COLORREF curclr;
3378
3379#ifdef DEBUG
3380 WriteLog("USER32: GrayStringW, not completely implemented\n");
3381#endif
3382
3383 if(lpOutputFunc == NULL && lpData == NULL) {
3384#ifdef DEBUG
3385 WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3386#endif
3387 return(FALSE);
3388 }
3389 if(nCount == 0)
3390 nCount = UniStrlen((UniChar*)lpData);
3391
3392 if(lpOutputFunc) {
3393 return(lpOutputFunc(hdc, lpData, nCount));
3394 }
3395 astring = UnicodeToAsciiString((LPWSTR)lpData);
3396
3397 curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3398 rc = TextOutA(hdc, X, Y, astring, nCount);
3399 SetTextColor(hdc, curclr);
3400
3401 FreeAsciiString(astring);
3402 return(rc);
3403}
3404//******************************************************************************
3405//TODO:
3406//******************************************************************************
3407int WIN32API CopyAcceleratorTableA(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3408 int cAccelEntries)
3409{
3410#ifdef DEBUG
3411 WriteLog("USER32: CopyAcceleratorTableA, not implemented\n");
3412#endif
3413 return(0);
3414}
3415//******************************************************************************
3416//TODO:
3417//******************************************************************************
3418int WIN32API CopyAcceleratorTableW(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3419 int cAccelEntries)
3420{
3421#ifdef DEBUG
3422 WriteLog("USER32: CopyAcceleratorTableW, not implemented\n");
3423#endif
3424 return(0);
3425}
3426//******************************************************************************
3427//Stolen from Wine (controls\uitools.c)
3428//******************************************************************************
3429BOOL DrawEdgeDiag(HDC hdc, RECT *rect, UINT edge, UINT flags)
3430{
3431 HPEN facePen, shadowPen, lightPen, blackPen, grayPen, nullPen;
3432 HPEN iPen, oPen, oldPen;
3433 HBRUSH oldBrush, faceBrush;
3434 int cl, cr, ct, cb;
3435 BOOL mainDiag;
3436 POINT tp;
3437 RECT r;
3438
3439 /* If both rasied and sunken is specified, they anihilate one another */
3440 if( !((flags & BF_MONO) || (flags & BF_FLAT)) ){
3441 if( (edge & BDR_RAISEDOUTER) && (edge & BDR_SUNKENOUTER) )
3442 return FALSE;
3443 if( (edge & BDR_RAISEDINNER) && (edge & BDR_SUNKENINNER) )
3444 return FALSE;
3445 }
3446
3447 /* Create/get the tools of the trade... */
3448 facePen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNFACE));
3449 shadowPen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNSHADOW));
3450 lightPen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNHILIGHT));
3451 grayPen = CreatePen(PS_SOLID, 0, RGB(168, 152, 144));
3452 blackPen = GetStockObject(BLACK_PEN);
3453 nullPen = GetStockObject(NULL_PEN);
3454 faceBrush = GetSysColorBrush(COLOR_BTNFACE);
3455 oldPen = SelectObject(hdc, nullPen);
3456 oldBrush = SelectObject(hdc, faceBrush);
3457
3458 /* this is my working rectangle */
3459 r = *rect;
3460
3461 if(flags & BF_MONO){
3462 oPen = blackPen;
3463 iPen = nullPen;
3464 }else if(flags & BF_FLAT){
3465 oPen = shadowPen;
3466 iPen = facePen;
3467 }else {
3468 if(flags & BF_SOFT){
3469 if(flags & BF_BOTTOM){
3470 oPen = (edge & BDR_RAISEDOUTER) ? blackPen : lightPen;
3471 iPen = (edge & BDR_RAISEDINNER) ? shadowPen : grayPen;
3472 }
3473 else{
3474 oPen = (edge & BDR_RAISEDOUTER) ? lightPen : blackPen;
3475 iPen = (edge & BDR_RAISEDINNER) ? grayPen : shadowPen;
3476 }
3477 }
3478 else{
3479 if(flags & BF_BOTTOM){
3480 oPen = (edge & BDR_RAISEDOUTER) ? blackPen : lightPen;
3481 iPen = (edge & BDR_RAISEDINNER) ? shadowPen : grayPen;
3482 }
3483 else{
3484 oPen = (edge & BDR_RAISEDOUTER) ? grayPen : shadowPen;
3485 iPen = (edge & BDR_RAISEDINNER) ? lightPen : blackPen;
3486 }
3487 }
3488 }
3489
3490 if(flags & BF_BOTTOM){
3491 if(flags & BF_LEFT){
3492 cr = -1; cl = 0;
3493 ct = 0; cb = -1;
3494 mainDiag = TRUE;
3495 tp.x = r.left; tp.y = r.top;
3496 }
3497 else{ /* RIGHT */
3498 cr = -1; cl = 0;
3499 ct = 1; cb = 0;
3500 tp.x = r.left; tp.y = r.bottom-1;
3501 mainDiag = FALSE;
3502 }
3503 }
3504 else{ /* TOP */
3505 if(flags & BF_LEFT){
3506 cr = 0; cl = 1;
3507 ct = 0; cb = -1;
3508 mainDiag = FALSE;
3509 tp.x = r.right; tp.y = r.top;
3510 }
3511 else{ /* RIGHT */
3512 cr = 0; cl = 1;
3513 ct = 1; cb = 0;
3514 tp.x = r.right; tp.y = r.bottom-1;
3515 mainDiag = TRUE;
3516 }
3517 }
3518
3519 /* if it has external edge, draw it */
3520 if(edge & BDR_OUTER){
3521 SelectObject(hdc, oPen);
3522 MoveToEx(hdc, r.left, mainDiag ? r.bottom-1 : r.top, 0);
3523 LineTo(hdc, r.right, mainDiag ? r.top-1 : r.bottom);
3524 r.left += cl; r.right += cr; r.top += ct; r.bottom += cb;
3525 }
3526
3527 /* if it has internal edge, draw it */
3528 if(edge & BDR_INNER){
3529 SelectObject(hdc, iPen);
3530 MoveToEx(hdc, r.left, mainDiag ? r.bottom-1 : r.top, 0);
3531 LineTo(hdc, r.right, mainDiag ? r.top-1 : r.bottom);
3532 r.left += cl; r.right += cr; r.top += ct; r.bottom += cb;
3533 }
3534
3535 if((flags & BF_MIDDLE) && !(flags & BF_MONO)){
3536 POINT p[3];
3537 p[0].x = mainDiag ? r.right: r.left;
3538 p[0].y = r.top;
3539 p[1].x = mainDiag ? r.left : r.right;
3540 p[1].y = r.bottom;
3541 p[2].x = tp.x;
3542 p[2].y = tp.y;
3543 SelectObject(hdc, nullPen);
3544 SelectObject(hdc, faceBrush);
3545 Polygon(hdc, p, 3);
3546 }
3547
3548 if(flags & BF_ADJUST)
3549 *rect = r;
3550
3551 /* Restore the DC */
3552 SelectObject(hdc, oldPen);
3553 SelectObject(hdc, oldBrush);
3554
3555 /* Clean-up */
3556 DeleteObject(facePen);
3557 DeleteObject(shadowPen);
3558 DeleteObject(lightPen);
3559 DeleteObject(grayPen);
3560
3561 return TRUE;
3562}
3563//******************************************************************************
3564//Stolen from Wine (controls\uitools.c)
3565//******************************************************************************
3566BOOL WIN32API DrawEdge(HDC hdc, LPRECT rect, UINT edge, UINT flags)
3567{
3568 HBRUSH faceBrush, shadowBrush, lightBrush, blackBrush, grayBrush, nullBrush;
3569 HBRUSH iNBrush, iSBrush, iEBrush, iWBrush;
3570 HBRUSH oNBrush, oSBrush, oEBrush, oWBrush;
3571 HBRUSH oldBrush;
3572 POINT point[2];
3573 RECT r;
3574
3575#ifdef DEBUG
3576 WriteLog("USER32: DrawEdge %X %X, partially implemented\n", edge, flags);
3577 WriteLog("USER32: DrawEdge (%d,%d) (%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom);
3578#endif
3579
3580 if(flags & BF_DIAGONAL) {
3581 return DrawEdgeDiag(hdc, rect, edge, flags);
3582 }
3583 /* If both rasied and sunken is specified, they anihilate one another */
3584 if( !((flags & BF_MONO) || (flags & BF_FLAT)) ){
3585 if( (edge & BDR_RAISEDOUTER) && (edge & BDR_SUNKENOUTER) )
3586 return FALSE;
3587 if( (edge & BDR_RAISEDINNER) && (edge & BDR_SUNKENINNER) )
3588 return FALSE;
3589 }
3590
3591 faceBrush = GetSysColorBrush(COLOR_BTNFACE);
3592 shadowBrush = GetSysColorBrush(COLOR_BTNSHADOW);
3593 lightBrush = GetSysColorBrush(COLOR_BTNHILIGHT);
3594 blackBrush = GetStockObject(BLACK_BRUSH);
3595 grayBrush = GetStockObject(LTGRAY_BRUSH);
3596 nullBrush = GetStockObject(NULL_BRUSH);
3597 oldBrush = SelectObject(hdc, nullBrush);
3598
3599 /* this is my working rectangle */
3600 r = *rect;
3601
3602 if(flags & BF_MONO){
3603 oNBrush = oSBrush = oEBrush = oWBrush = blackBrush;
3604 iNBrush = iSBrush = iEBrush = iWBrush = nullBrush;
3605 }else if(flags & BF_FLAT){
3606 oNBrush = oSBrush = oEBrush = oWBrush = shadowBrush;
3607 iNBrush = iSBrush = iEBrush = iWBrush = faceBrush;
3608 }else {
3609 if(flags & BF_SOFT){
3610 oNBrush = oWBrush = (edge & BDR_RAISEDOUTER) ? lightBrush : blackBrush;
3611 oSBrush = oEBrush = (edge & BDR_RAISEDOUTER) ? blackBrush : lightBrush;
3612 iNBrush = iWBrush = (edge & BDR_RAISEDINNER) ? grayBrush : shadowBrush;
3613 iSBrush = iEBrush = (edge & BDR_RAISEDINNER) ? shadowBrush : grayBrush;
3614 }
3615 else{
3616 oNBrush = oWBrush = (edge & BDR_RAISEDOUTER) ? grayBrush : shadowBrush;
3617 oSBrush = oEBrush = (edge & BDR_RAISEDOUTER) ? blackBrush : lightBrush;
3618 iNBrush = iWBrush = (edge & BDR_RAISEDINNER) ? lightBrush : blackBrush;
3619 iSBrush = iEBrush = (edge & BDR_RAISEDINNER) ? shadowBrush : grayBrush;
3620 }
3621 }
3622
3623 /* if it has external edge, draw it */
3624 if(edge & BDR_OUTER){
3625 if(flags & BF_RIGHT){
3626 SelectObject(hdc, oEBrush);
3627 PatBlt(hdc, r.right-1, r.top, 1, r.bottom - r.top, PATCOPY);
3628 r.right--;
3629 }
3630 if(flags & BF_BOTTOM){
3631 SelectObject(hdc, oSBrush);
3632 PatBlt(hdc, r.left, r.bottom-1, r.right-r.left, 1, PATCOPY);
3633 r.bottom--;
3634 }
3635 if(flags & BF_LEFT){
3636 SelectObject(hdc, oWBrush);
3637 PatBlt(hdc, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
3638 r.left++;
3639 }
3640 if(flags & BF_TOP){
3641 SelectObject(hdc, oNBrush);
3642 PatBlt(hdc, r.left, r.top, r.right-r.left, 1, PATCOPY);
3643 r.top++;
3644 }
3645 }
3646
3647 /* if it has internal edge, draw it */
3648 if(edge & BDR_INNER){
3649 if(flags & BF_RIGHT){
3650 SelectObject(hdc, iEBrush);
3651 PatBlt(hdc, r.right-1, r.top, 1, r.bottom - r.top, PATCOPY);
3652 r.right--;
3653 }
3654 if(flags & BF_BOTTOM){
3655 SelectObject(hdc, iSBrush);
3656 PatBlt(hdc, r.left, r.bottom-1, r.right-r.left, 1, PATCOPY);
3657 r.bottom--;
3658 }
3659 if(flags & BF_LEFT){
3660 SelectObject(hdc, iWBrush);
3661 PatBlt(hdc, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
3662 r.left++;
3663 }
3664 if(flags & BF_TOP){
3665 SelectObject(hdc, iNBrush);
3666 PatBlt(hdc, r.left, r.top, r.right-r.left, 1, PATCOPY);
3667 r.top++;
3668 }
3669 }
3670
3671 /* if we got to fill the middle, to it now */
3672 if((flags & BF_MIDDLE) && !(flags & BF_MONO))
3673 FillRect(hdc, &r, faceBrush);
3674
3675 /* adjust the rectangle if required */
3676 if(flags & BF_ADJUST)
3677 *rect = r;
3678
3679 /* Restore the DC */
3680 SelectObject(hdc, oldBrush);
3681
3682 return TRUE;
3683}
3684//******************************************************************************
3685//******************************************************************************
3686LRESULT WIN32API SendMessageTimeoutA(HWND hwnd, UINT Msg, WPARAM wParam,
3687 LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3688 LPDWORD lpdwResult)
3689{
3690#ifdef DEBUG
3691 WriteLog("USER32: SendMessageTimeoutA, partially implemented\n");
3692#endif
3693 //ignore fuFlags & wTimeOut
3694 *lpdwResult = SendMessageA(hwnd, Msg, wParam, lParam);
3695 return(TRUE);
3696}
3697//******************************************************************************
3698//******************************************************************************
3699LRESULT WIN32API SendMessageTimeoutW(HWND hwnd, UINT Msg, WPARAM wParam,
3700 LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3701 LPDWORD lpdwResult)
3702{
3703#ifdef DEBUG
3704 WriteLog("USER32: SendMessageTimeoutW, partially implemented\n");
3705#endif
3706 return(SendMessageTimeoutA(hwnd, Msg, wParam, lParam, fuFlags, uTimeOut, lpdwResult));
3707}
3708//******************************************************************************
3709//******************************************************************************
3710HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
3711{
3712#ifdef DEBUG
3713 WriteLog("USER32: CopyImage, not implemented\n");
3714#endif
3715 switch(uType) {
3716 case IMAGE_BITMAP:
3717 case IMAGE_CURSOR:
3718 case IMAGE_ICON:
3719 default:
3720#ifdef DEBUG
3721 WriteLog("USER32: CopyImage, unknown type\n");
3722#endif
3723 return(NULL);
3724 }
3725 return(NULL);
3726}
3727//******************************************************************************
3728//******************************************************************************
3729BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
3730{
3731#ifdef DEBUG
3732 WriteLog("USER32: GetKeyboardState, not properly implemented\n");
3733#endif
3734 memset(lpKeyState, 0, 256);
3735 return(TRUE);
3736}
3737//******************************************************************************
3738//******************************************************************************
3739BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
3740{
3741#ifdef DEBUG
3742 WriteLog("USER32: SetKeyboardState, not implemented\n");
3743#endif
3744 return(TRUE);
3745}
3746//******************************************************************************
3747//******************************************************************************
3748BOOL WIN32API DrawFrameControl(HDC hdc, LPRECT lprc, UINT uType, UINT uState)
3749{
3750#ifdef DEBUG
3751 WriteLog("USER32: DrawFrameControl, not implemented\n");
3752#endif
3753 return(TRUE);
3754}
3755//******************************************************************************
3756//******************************************************************************
3757BOOL WIN32API SendNotifyMessageA(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3758{
3759#ifdef DEBUG
3760 WriteLog("USER32: SendNotifyMessageA, not completely implemented\n");
3761#endif
3762 return(SendMessageA(hwnd, Msg, wParam, lParam));
3763}
3764//******************************************************************************
3765//******************************************************************************
3766BOOL WIN32API SendNotifyMessageW(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3767{
3768#ifdef DEBUG
3769 WriteLog("USER32: SendNotifyMessageW, not completely implemented\n");
3770#endif
3771 return(SendMessageA(hwnd, Msg, wParam, lParam));
3772}
3773//******************************************************************************
3774//2nd parameter not used according to SDK (yet?)
3775//******************************************************************************
3776VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
3777{
3778#ifdef DEBUG
3779 WriteLog("USER32: SetLastErrorEx\n");
3780#endif
3781 SetLastError(dwErrCode);
3782}
3783//******************************************************************************
3784//******************************************************************************
3785LPARAM WIN32API SetMessageExtraInfo(LPARAM lParam)
3786{
3787#ifdef DEBUG
3788 WriteLog("USER32: SetMessageExtraInfo, not implemented\n");
3789#endif
3790 return(0);
3791}
3792//******************************************************************************
3793//******************************************************************************
3794BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
3795{
3796#ifdef DEBUG
3797 WriteLog("USER32: ActivateKeyboardLayout, not implemented\n");
3798#endif
3799 return(TRUE);
3800}
3801//******************************************************************************
3802//******************************************************************************
3803int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
3804{
3805#ifdef DEBUG
3806 WriteLog("USER32: GetKeyboardLayoutList, not implemented\n");
3807#endif
3808 return(0);
3809}
3810//******************************************************************************
3811//******************************************************************************
3812HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
3813{
3814#ifdef DEBUG
3815 WriteLog("USER32: GetKeyboardLayout, not implemented\n");
3816#endif
3817 return(0);
3818}
3819//******************************************************************************
3820//******************************************************************************
3821int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
3822{
3823#ifdef DEBUG
3824 WriteLog("USER32: LookupIconIdFromDirectory, not implemented\n");
3825#endif
3826 return(0);
3827}
3828//******************************************************************************
3829//******************************************************************************
3830int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL fIcon,
3831 int cxDesired, int cyDesired,
3832 UINT Flags)
3833{
3834#ifdef DEBUG
3835 WriteLog("USER32: LookupIconIdFromDirectoryEx, not implemented\n");
3836#endif
3837 return(0);
3838}
3839//******************************************************************************
3840//DWORD idAttach; /* thread to attach */
3841//DWORD idAttachTo; /* thread to attach to */
3842//BOOL fAttach; /* attach or detach */
3843//******************************************************************************
3844BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
3845{
3846#ifdef DEBUG
3847 WriteLog("USER32: AttachThreadInput, not implemented\n");
3848#endif
3849 return(TRUE);
3850}
3851//******************************************************************************
3852//******************************************************************************
3853BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
3854{
3855#ifdef DEBUG
3856 WriteLog("USER32: RegisterHotKey, not implemented\n");
3857#endif
3858 return(TRUE);
3859}
3860//******************************************************************************
3861//******************************************************************************
3862BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
3863{
3864#ifdef DEBUG
3865 WriteLog("USER32: UnregisterHotKey, not implemented\n");
3866#endif
3867 return(TRUE);
3868}
3869//******************************************************************************
3870//******************************************************************************
3871BOOL WIN32API DrawStateA(HDC hdc, HBRUSH hbc, DRAWSTATEPROC lpOutputFunc,
3872 LPARAM lData, WPARAM wData, int x, int y, int cx,
3873 int cy, UINT fuFlags)
3874{
3875#ifdef DEBUG
3876 WriteLog("USER32: DrawStateA, not implemented\n");
3877#endif
3878 return(TRUE);
3879}
3880//******************************************************************************
3881//******************************************************************************
3882//******************************************************************************
3883//******************************************************************************
3884BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
3885{
3886#ifdef DEBUG
3887 WriteLog("USER32: SetWindowContextHelpId, not implemented\n");
3888#endif
3889 return(TRUE);
3890}
3891//******************************************************************************
3892//******************************************************************************
3893DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
3894{
3895#ifdef DEBUG
3896 WriteLog("USER32: GetWindowContextHelpId, not implemented\n");
3897#endif
3898 return(0);
3899}
3900//******************************************************************************
3901//restores iconized window to previous size/position
3902//******************************************************************************
3903BOOL WIN32API OpenIcon(HWND hwnd)
3904{
3905#ifdef DEBUG
3906 WriteLog("USER32: OpenIcon\n");
3907#endif
3908 if(!IsIconic(hwnd))
3909 return FALSE;
3910 ShowWindow(hwnd, SW_SHOWNORMAL);
3911 return TRUE;
3912}
3913//******************************************************************************
3914//******************************************************************************
3915BOOL WIN32API IsWindowUnicode(HWND hwnd)
3916{
3917#ifdef DEBUG
3918 WriteLog("USER32: IsWindowUnicode, not implemented\n");
3919#endif
3920 return(FALSE);
3921}
3922//******************************************************************************
3923//******************************************************************************
3924BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
3925{
3926#ifdef DEBUG
3927 WriteLog("USER32: GetMonitorInfoA not supported!!\n");
3928#endif
3929 return(FALSE);
3930}
3931//******************************************************************************
3932//******************************************************************************
3933BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
3934{
3935#ifdef DEBUG
3936 WriteLog("USER32: GetMonitorInfoW not supported!!\n");
3937#endif
3938 return(FALSE);
3939}
3940//******************************************************************************
3941//******************************************************************************
3942HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
3943{
3944#ifdef DEBUG
3945 WriteLog("USER32: MonitorFromWindow not correctly supported??\n");
3946#endif
3947 return(0);
3948}
3949//******************************************************************************
3950//******************************************************************************
3951HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
3952{
3953#ifdef DEBUG
3954 WriteLog("USER32: MonitorFromRect not correctly supported??\n");
3955#endif
3956 return(0);
3957}
3958//******************************************************************************
3959//******************************************************************************
3960HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
3961{
3962#ifdef DEBUG
3963 WriteLog("USER32: MonitorFromPoint not correctly supported??\n");
3964#endif
3965 return(0);
3966}
3967//******************************************************************************
3968//******************************************************************************
3969BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
3970{
3971#ifdef DEBUG
3972 WriteLog("USER32: EnumDisplayMonitors not supported??\n");
3973#endif
3974 return(FALSE);
3975}
3976//******************************************************************************
3977//******************************************************************************
3978BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
3979 LPDEVMODEA lpDevMode)
3980{
3981#ifdef DEBUG
3982 WriteLog("USER32: EnumDisplaySettingsA FAKED\n");
3983#endif
3984 switch(iModeNum) {
3985 case 0:
3986 lpDevMode->dmBitsPerPel = 16;
3987 lpDevMode->dmPelsWidth = 768;
3988 lpDevMode->dmPelsHeight = 1024;
3989 lpDevMode->dmDisplayFlags = 0;
3990 lpDevMode->dmDisplayFrequency = 70;
3991 break;
3992 case 1:
3993 lpDevMode->dmBitsPerPel = 16;
3994 lpDevMode->dmPelsWidth = 640;
3995 lpDevMode->dmPelsHeight = 480;
3996 lpDevMode->dmDisplayFlags = 0;
3997 lpDevMode->dmDisplayFrequency = 70;
3998 break;
3999 default:
4000 return(FALSE);
4001 }
4002 return(TRUE);
4003}
4004//******************************************************************************
4005//******************************************************************************
4006LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA lpDevMode, DWORD dwFlags)
4007{
4008#ifdef DEBUG
4009 if(lpDevMode) {
4010 WriteLog("USER32: ChangeDisplaySettingsA FAKED %X\n", dwFlags);
4011 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
4012 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsWidth %d\n", lpDevMode->dmPelsWidth);
4013 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
4014 }
4015#endif
4016 return(DISP_CHANGE_SUCCESSFUL);
4017}
4018//******************************************************************************
4019//******************************************************************************
4020
4021
4022/*****************************************************************************
4023 * Name : BOOL WIN32API AnyPopup
4024 * Purpose : The AnyPopup function indicates whether an owned, visible,
4025 * top-level pop-up, or overlapped window exists on the screen. The
4026 * function searches the entire Windows screen, not just the calling
4027 * application's client area.
4028 * Parameters: VOID
4029 * Variables :
4030 * Result : If a pop-up window exists, the return value is TRUE even if the
4031 * pop-up window is completely covered by other windows. Otherwise,
4032 * it is FALSE.
4033 * Remark : AnyPopup is a Windows version 1.x function and is retained for
4034 * compatibility purposes. It is generally not useful.
4035 * Status : UNTESTED STUB
4036 *
4037 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4038 *****************************************************************************/
4039
4040BOOL WIN32API AnyPopup(VOID)
4041{
4042 dprintf(("USER32:AnyPopup() not implemented.\n"));
4043
4044 return (FALSE);
4045}
4046
4047
4048/*****************************************************************************
4049 * Name : long WIN32API BroadcastSystemMessage
4050 * Purpose : The BroadcastSystemMessage function sends a message to the given
4051 * recipients. The recipients can be applications, installable
4052 * drivers, Windows-based network drivers, system-level device
4053 * drivers, or any combination of these system components.
4054 * Parameters: DWORD dwFlags,
4055 LPDWORD lpdwRecipients,
4056 UINT uiMessage,
4057 WPARAM wParam,
4058 LPARAM lParam
4059 * Variables :
4060 * Result : If the function succeeds, the return value is a positive value.
4061 * If the function is unable to broadcast the message, the return value is -1.
4062 * If the dwFlags parameter is BSF_QUERY and at least one recipient returned FALSE to the corresponding message, the return value is zero.
4063 * Remark :
4064 * Status : UNTESTED STUB
4065 *
4066 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4067 *****************************************************************************/
4068
4069long WIN32API BroadcastSystemMessage(DWORD dwFlags,
4070 LPDWORD lpdwRecipients,
4071 UINT uiMessage,
4072 WPARAM wParam,
4073 LPARAM lParam)
4074{
4075 dprintf(("USER32:BroadcastSystemMessage(%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4076 dwFlags,
4077 lpdwRecipients,
4078 uiMessage,
4079 wParam,
4080 lParam));
4081
4082 return (-1);
4083}
4084
4085
4086/*****************************************************************************
4087 * Name : WORD WIN32API CascadeWindows
4088 * Purpose : The CascadeWindows function cascades the specified windows or
4089 * the child windows of the specified parent window.
4090 * Parameters: HWND hwndParent handle of parent window
4091 * UINT wHow types of windows not to arrange
4092 * CONST RECT * lpRect rectangle to arrange windows in
4093 * UINT cKids number of windows to arrange
4094 * const HWND FAR * lpKids array of window handles
4095 * Variables :
4096 * Result : If the function succeeds, the return value is the number of windows arranged.
4097 * If the function fails, the return value is zero.
4098 * Remark :
4099 * Status : UNTESTED STUB
4100 *
4101 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4102 *****************************************************************************/
4103
4104WORD WIN32API CascadeWindows(HWND hwndParent,
4105 UINT wHow,
4106 CONST LPRECT lpRect,
4107 UINT cKids,
4108 const HWND *lpKids)
4109{
4110 dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
4111 hwndParent,
4112 wHow,
4113 lpRect,
4114 cKids,
4115 lpKids));
4116
4117 return (0);
4118}
4119
4120
4121/*****************************************************************************
4122 * Name : LONG WIN32API ChangeDisplaySettingsW
4123 * Purpose : The ChangeDisplaySettings function changes the display settings
4124 * to the specified graphics mode.
4125 * Parameters: LPDEVMODEW lpDevModeW
4126 * DWORD dwFlags
4127 * Variables :
4128 * Result : DISP_CHANGE_SUCCESSFUL The settings change was successful.
4129 * DISP_CHANGE_RESTART The computer must be restarted in order for the graphics mode to work.
4130 * DISP_CHANGE_BADFLAGS An invalid set of flags was passed in.
4131 * DISP_CHANGE_FAILED The display driver failed the specified graphics mode.
4132 * DISP_CHANGE_BADMODE The graphics mode is not supported.
4133 * DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
4134 * Remark :
4135 * Status : UNTESTED STUB
4136 *
4137 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4138 *****************************************************************************/
4139
4140LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
4141 DWORD dwFlags)
4142{
4143 dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
4144 lpDevMode,
4145 dwFlags));
4146
4147 return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
4148 dwFlags));
4149}
4150
4151/*****************************************************************************
4152 * Name : BOOL WIN32API CloseDesktop
4153 * Purpose : The CloseDesktop function closes an open handle of a desktop
4154 * object. A desktop is a secure object contained within a window
4155 * station object. A desktop has a logical display surface and
4156 * contains windows, menus and hooks.
4157 * Parameters: HDESK hDesktop
4158 * Variables :
4159 * Result : If the function succeeds, the return value is TRUE.
4160 * If the functions fails, the return value is FALSE. To get
4161 * extended error information, call GetLastError.
4162 * Remark :
4163 * Status : UNTESTED STUB
4164 *
4165 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4166 *****************************************************************************/
4167
4168BOOL WIN32API CloseDesktop(HDESK hDesktop)
4169{
4170 dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
4171 hDesktop));
4172
4173 return (FALSE);
4174}
4175
4176
4177/*****************************************************************************
4178 * Name : BOOL WIN32API CloseWindowStation
4179 * Purpose : The CloseWindowStation function closes an open window station handle.
4180 * Parameters: HWINSTA hWinSta
4181 * Variables :
4182 * Result :
4183 * Remark : If the function succeeds, the return value is TRUE.
4184 * If the functions fails, the return value is FALSE. To get
4185 * extended error information, call GetLastError.
4186 * Status : UNTESTED STUB
4187 *
4188 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4189 *****************************************************************************/
4190
4191BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
4192{
4193 dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
4194 hWinSta));
4195
4196 return (FALSE);
4197}
4198
4199
4200/*****************************************************************************
4201 * Name : HDESK WIN32API CreateDesktopA
4202 * Purpose : The CreateDesktop function creates a new desktop on the window
4203 * station associated with the calling process.
4204 * Parameters: LPCTSTR lpszDesktop name of the new desktop
4205 * LPCTSTR lpszDevice name of display device to assign to the desktop
4206 * LPDEVMODE pDevMode reserved; must be NULL
4207 * DWORD dwFlags flags to control interaction with other applications
4208 * DWORD dwDesiredAccess specifies access of returned handle
4209 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
4210 * Variables :
4211 * Result : If the function succeeds, the return value is a handle of the
4212 * newly created desktop.
4213 * If the function fails, the return value is NULL. To get extended
4214 * error information, call GetLastError.
4215 * Remark :
4216 * Status : UNTESTED STUB
4217 *
4218 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4219 *****************************************************************************/
4220
4221HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
4222 LPCTSTR lpszDevice,
4223 LPDEVMODEA pDevMode,
4224 DWORD dwFlags,
4225 DWORD dwDesiredAccess,
4226 LPSECURITY_ATTRIBUTES lpsa)
4227{
4228 dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4229 lpszDesktop,
4230 lpszDevice,
4231 pDevMode,
4232 dwFlags,
4233 dwDesiredAccess,
4234 lpsa));
4235
4236 return (NULL);
4237}
4238
4239
4240/*****************************************************************************
4241 * Name : HDESK WIN32API CreateDesktopW
4242 * Purpose : The CreateDesktop function creates a new desktop on the window
4243 * station associated with the calling process.
4244 * Parameters: LPCTSTR lpszDesktop name of the new desktop
4245 * LPCTSTR lpszDevice name of display device to assign to the desktop
4246 * LPDEVMODE pDevMode reserved; must be NULL
4247 * DWORD dwFlags flags to control interaction with other applications
4248 * DWORD dwDesiredAccess specifies access of returned handle
4249 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
4250 * Variables :
4251 * Result : If the function succeeds, the return value is a handle of the
4252 * newly created desktop.
4253 * If the function fails, the return value is NULL. To get extended
4254 * error information, call GetLastError.
4255 * Remark :
4256 * Status : UNTESTED STUB
4257 *
4258 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4259 *****************************************************************************/
4260
4261HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
4262 LPCTSTR lpszDevice,
4263 LPDEVMODEW pDevMode,
4264 DWORD dwFlags,
4265 DWORD dwDesiredAccess,
4266 LPSECURITY_ATTRIBUTES lpsa)
4267{
4268 dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4269 lpszDesktop,
4270 lpszDevice,
4271 pDevMode,
4272 dwFlags,
4273 dwDesiredAccess,
4274 lpsa));
4275
4276 return (NULL);
4277}
4278
4279
4280/*****************************************************************************
4281 * Name : HWINSTA WIN32API CreateWindowStationA
4282 * Purpose : The CreateWindowStation function creates a window station object.
4283 * It returns a handle that can be used to access the window station.
4284 * A window station is a secure object that contains a set of global
4285 * atoms, a clipboard, and a set of desktop objects.
4286 * Parameters: LPTSTR lpwinsta name of the new window station
4287 * DWORD dwReserved reserved; must be NULL
4288 * DWORD dwDesiredAccess specifies access of returned handle
4289 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4290 * Variables :
4291 * Result : If the function succeeds, the return value is the handle to the
4292 * newly created window station.
4293 * If the function fails, the return value is NULL. To get extended
4294 * error information, call GetLastError.
4295 * Remark :
4296 * Status : UNTESTED STUB
4297 *
4298 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4299 *****************************************************************************/
4300
4301HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
4302 DWORD dwReserved,
4303 DWORD dwDesiredAccess,
4304 LPSECURITY_ATTRIBUTES lpsa)
4305{
4306 dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
4307 lpWinSta,
4308 dwReserved,
4309 dwDesiredAccess,
4310 lpsa));
4311
4312 return (NULL);
4313}
4314
4315
4316/*****************************************************************************
4317 * Name : HWINSTA WIN32API CreateWindowStationW
4318 * Purpose : The CreateWindowStation function creates a window station object.
4319 * It returns a handle that can be used to access the window station.
4320 * A window station is a secure object that contains a set of global
4321 * atoms, a clipboard, and a set of desktop objects.
4322 * Parameters: LPTSTR lpwinsta name of the new window station
4323 * DWORD dwReserved reserved; must be NULL
4324 * DWORD dwDesiredAccess specifies access of returned handle
4325 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4326 * Variables :
4327 * Result : If the function succeeds, the return value is the handle to the
4328 * newly created window station.
4329 * If the function fails, the return value is NULL. To get extended
4330 * error information, call GetLastError.
4331 * Remark :
4332 * Status : UNTESTED STUB
4333 *
4334 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4335 *****************************************************************************/
4336
4337HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
4338 DWORD dwReserved,
4339 DWORD dwDesiredAccess,
4340 LPSECURITY_ATTRIBUTES lpsa)
4341{
4342 dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
4343 lpWinSta,
4344 dwReserved,
4345 dwDesiredAccess,
4346 lpsa));
4347
4348 return (NULL);
4349}
4350
4351/*****************************************************************************
4352 * Name : BOOL WIN32API DragDetect
4353 * Purpose : The DragDetect function captures the mouse and tracks its movement
4354 * Parameters: HWND hwnd
4355 * POINT pt
4356 * Variables :
4357 * Result : If the user moved the mouse outside of the drag rectangle while
4358 * holding the left button down, the return value is TRUE.
4359 * If the user did not move the mouse outside of the drag rectangle
4360 * while holding the left button down, the return value is FALSE.
4361 * Remark :
4362 * Status : UNTESTED STUB
4363 *
4364 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4365 *****************************************************************************/
4366
4367BOOL WIN32API DragDetect(HWND hwnd,
4368 POINT pt)
4369{
4370 dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
4371 hwnd));
4372
4373 return (FALSE);
4374}
4375
4376
4377/*****************************************************************************
4378 * Name : BOOL WIN32API DrawAnimatedRects
4379 * Purpose : The DrawAnimatedRects function draws a wire-frame rectangle
4380 * and animates it to indicate the opening of an icon or the
4381 * minimizing or maximizing of a window.
4382 * Parameters: HWND hwnd handle of clipping window
4383 * int idAni type of animation
4384 * CONST RECT * lprcFrom address of rectangle coordinates (minimized)
4385 * CONST RECT * lprcTo address of rectangle coordinates (restored)
4386 * Variables :
4387 * Result : If the function succeeds, the return value is TRUE.
4388 * If the function fails, the return value is FALSE.
4389 * Remark :
4390 * Status : UNTESTED STUB
4391 *
4392 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4393 *****************************************************************************/
4394
4395BOOL WIN32API DrawAnimatedRects(HWND hwnd,
4396 int idAni,
4397 CONST RECT *lprcFrom,
4398 CONST RECT *lprcTo)
4399{
4400 dprintf(("USER32:DrawAnimatedRects (%08xh,%u,%08xh,%08x) not implemented.\n",
4401 hwnd,
4402 idAni,
4403 lprcFrom,
4404 lprcTo));
4405
4406 return (TRUE);
4407}
4408
4409
4410/*****************************************************************************
4411 * Name : VOID WIN32API DrawCaption
4412 * Purpose : The DrawCaption function draws a window caption.
4413 * Parameters: HDC hdc handle of device context
4414 * LPRECT lprc address of bounding rectangle coordinates
4415 * HFONT hfont handle of font for caption
4416 * HICON hicon handle of icon in caption
4417 * LPSTR lpszText address of caption string
4418 * WORD wFlags drawing options
4419 * Variables :
4420 * Result :
4421 * Remark :
4422 * Status : UNTESTED STUB
4423 *
4424 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4425 *****************************************************************************/
4426
4427BOOL WIN32API DrawCaption (HWND hwnd,
4428 HDC hdc,
4429 const RECT *lprc,
4430 UINT wFlags)
4431{
4432 dprintf(("USER32:DrawCaption (%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4433 hwnd,
4434 hdc,
4435 lprc,
4436 wFlags));
4437
4438 return FALSE;
4439}
4440
4441
4442/*****************************************************************************
4443 * Name :
4444 * Purpose :
4445 * Parameters:
4446 * Variables :
4447 * Result :
4448 * Remark :
4449 * Status : UNTESTED STUB
4450 *
4451 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4452 *****************************************************************************/
4453
4454BOOL WIN32API DrawStateW(HDC hdc,
4455 HBRUSH hBrush,
4456 DRAWSTATEPROC lpOutputFunc,
4457 LPARAM lParam,
4458 WPARAM wParam,
4459 int x,
4460 int y,
4461 int cx,
4462 int cy,
4463 UINT fuFlags)
4464{
4465 dprintf(("USER32:DrawStateW (%08xh,%08xh,%08xh,%08xh,%08xh,%d,%d,%d,%d,%08x) not implemented.\n",
4466 hdc,
4467 hBrush,
4468 lpOutputFunc,
4469 lParam,
4470 wParam,
4471 x,
4472 y,
4473 cx,
4474 cy,
4475 fuFlags));
4476
4477 return(DrawStateA(hdc,
4478 hBrush,
4479 lpOutputFunc,
4480 lParam,
4481 wParam,
4482 x,
4483 y,
4484 cx,
4485 cy,
4486 fuFlags));
4487}
4488
4489
4490/*****************************************************************************
4491 * Name : BOOL WIN32API EnumDesktopWindows
4492 * Purpose : The EnumDesktopWindows function enumerates all windows in a
4493 * desktop by passing the handle of each window, in turn, to an
4494 * application-defined callback function.
4495 * Parameters: HDESK hDesktop handle of desktop to enumerate
4496 * WNDENUMPROC lpfn points to application's callback function
4497 * LPARAM lParam 32-bit value to pass to the callback function
4498 * Variables :
4499 * Result : If the function succeeds, the return value is TRUE.
4500 * If the function fails, the return value is FALSE. To get
4501 * extended error information, call GetLastError.
4502 * Remark :
4503 * Status : UNTESTED STUB
4504 *
4505 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4506 *****************************************************************************/
4507
4508BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
4509 WNDENUMPROC lpfn,
4510 LPARAM lParam)
4511{
4512 dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
4513 hDesktop,
4514 lpfn,
4515 lParam));
4516
4517 return (FALSE);
4518}
4519
4520
4521/*****************************************************************************
4522 * Name : BOOL WIN32API EnumDesktopsA
4523 * Purpose : The EnumDesktops function enumerates all desktops in the window
4524 * station assigned to the calling process. The function does so by
4525 * passing the name of each desktop, in turn, to an application-
4526 * defined callback function.
4527 * Parameters: HWINSTA hwinsta handle of window station to enumerate
4528 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
4529 * LPARAM lParam 32-bit value to pass to the callback function
4530 * Variables :
4531 * Result : If the function succeeds, the return value is TRUE.
4532 * If the function fails, the return value is FALSE. To get extended
4533 * error information, call GetLastError.
4534 * Remark :
4535 * Status : UNTESTED STUB
4536 *
4537 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4538 *****************************************************************************/
4539
4540BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
4541 DESKTOPENUMPROCA lpEnumFunc,
4542 LPARAM lParam)
4543{
4544 dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
4545 hWinSta,
4546 lpEnumFunc,
4547 lParam));
4548
4549 return (FALSE);
4550}
4551
4552
4553/*****************************************************************************
4554 * Name : BOOL WIN32API EnumDesktopsW
4555 * Purpose : The EnumDesktops function enumerates all desktops in the window
4556 * station assigned to the calling process. The function does so by
4557 * passing the name of each desktop, in turn, to an application-
4558 * defined callback function.
4559 * Parameters: HWINSTA hwinsta handle of window station to enumerate
4560 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
4561 * LPARAM lParam 32-bit value to pass to the callback function
4562 * Variables :
4563 * Result : If the function succeeds, the return value is TRUE.
4564 * If the function fails, the return value is FALSE. To get extended
4565 * error information, call GetLastError.
4566 * Remark :
4567 * Status : UNTESTED STUB
4568 *
4569 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4570 *****************************************************************************/
4571
4572BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
4573 DESKTOPENUMPROCW lpEnumFunc,
4574 LPARAM lParam)
4575{
4576 dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
4577 hWinSta,
4578 lpEnumFunc,
4579 lParam));
4580
4581 return (FALSE);
4582}
4583
4584
4585
4586/*****************************************************************************
4587 * Name : BOOL WIN32API EnumDisplaySettingsW
4588 * Purpose : The EnumDisplaySettings function obtains information about one
4589 * of a display device's graphics modes. You can obtain information
4590 * for all of a display device's graphics modes by making a series
4591 * of calls to this function.
4592 * Parameters: LPCTSTR lpszDeviceName specifies the display device
4593 * DWORD iModeNum specifies the graphics mode
4594 * LPDEVMODE lpDevMode points to structure to receive settings
4595 * Variables :
4596 * Result : If the function succeeds, the return value is TRUE.
4597 * If the function fails, the return value is FALSE.
4598 * Remark :
4599 * Status : UNTESTED STUB
4600 *
4601 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4602 *****************************************************************************/
4603
4604BOOL WIN32API EnumDisplaySettingsW(LPCSTR lpszDeviceName,
4605 DWORD iModeNum,
4606 LPDEVMODEW lpDevMode)
4607{
4608 dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
4609 lpszDeviceName,
4610 iModeNum,
4611 lpDevMode));
4612
4613 return (EnumDisplaySettingsA(lpszDeviceName,
4614 iModeNum,
4615 (LPDEVMODEA)lpDevMode));
4616}
4617
4618
4619/*****************************************************************************
4620 * Name : BOOL WIN32API EnumWindowStationsA
4621 * Purpose : The EnumWindowStations function enumerates all windowstations
4622 * in the system by passing the name of each window station, in
4623 * turn, to an application-defined callback function.
4624 * Parameters:
4625 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4626 * LPARAM lParam 32-bit value to pass to the callback function
4627 * Result : If the function succeeds, the return value is TRUE.
4628 * If the function fails the return value is FALSE. To get extended
4629 * error information, call GetLastError.
4630 * Remark :
4631 * Status : UNTESTED STUB
4632 *
4633 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4634 *****************************************************************************/
4635
4636BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
4637 LPARAM lParam)
4638{
4639 dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
4640 lpEnumFunc,
4641 lParam));
4642
4643 return (FALSE);
4644}
4645
4646
4647/*****************************************************************************
4648 * Name : BOOL WIN32API EnumWindowStationsW
4649 * Purpose : The EnumWindowStations function enumerates all windowstations
4650 * in the system by passing the name of each window station, in
4651 * turn, to an application-defined callback function.
4652 * Parameters:
4653 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4654 * LPARAM lParam 32-bit value to pass to the callback function
4655 * Result : If the function succeeds, the return value is TRUE.
4656 * If the function fails the return value is FALSE. To get extended
4657 * error information, call GetLastError.
4658 * Remark :
4659 * Status : UNTESTED STUB
4660 *
4661 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4662 *****************************************************************************/
4663
4664BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
4665 LPARAM lParam)
4666{
4667 dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
4668 lpEnumFunc,
4669 lParam));
4670
4671 return (FALSE);
4672}
4673
4674
4675/*****************************************************************************
4676 * Name : HWND WIN32API FindWindowExW
4677 * Purpose : The FindWindowEx function retrieves the handle of a window whose
4678 * class name and window name match the specified strings. The
4679 * function searches child windows, beginning with the one following
4680 * the given child window.
4681 * Parameters: HWND hwndParent handle of parent window
4682 * HWND hwndChildAfter handle of a child window
4683 * LPCTSTR lpszClass address of class name
4684 * LPCTSTR lpszWindow address of window name
4685 * Variables :
4686 * Result : If the function succeeds, the return value is the handle of the
4687 * window that has the specified class and window names.
4688 * If the function fails, the return value is NULL. To get extended
4689 * error information, call GetLastError.
4690 * Remark :
4691 * Status : UNTESTED STUB
4692 *
4693 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4694 *****************************************************************************/
4695
4696HWND WIN32API FindWindowExW(HWND hwndParent,
4697 HWND hwndChildAfter,
4698 LPCWSTR lpszClass,
4699 LPCWSTR lpszWindow)
4700{
4701 dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
4702 hwndParent,
4703 hwndChildAfter,
4704 lpszClass,
4705 lpszWindow));
4706
4707 return (NULL);
4708}
4709
4710/*****************************************************************************
4711 * Name : BOOL WIN32API GetInputState
4712 * Purpose : The GetInputState function determines whether there are
4713 * mouse-button or keyboard messages in the calling thread's message queue.
4714 * Parameters:
4715 * Variables :
4716 * Result : If the queue contains one or more new mouse-button or keyboard
4717 * messages, the return value is TRUE.
4718 * If the function fails, the return value is FALSE.
4719 * Remark :
4720 * Status : UNTESTED STUB
4721 *
4722 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4723 *****************************************************************************/
4724
4725BOOL WIN32API GetInputState(VOID)
4726{
4727 dprintf(("USER32:GetInputState () not implemented.\n"));
4728
4729 return (FALSE);
4730}
4731
4732
4733/*****************************************************************************
4734 * Name : UINT WIN32API GetKBCodePage
4735 * Purpose : The GetKBCodePage function is provided for compatibility with
4736 * earlier versions of Windows. In the Win32 application programming
4737 * interface (API) it just calls the GetOEMCP function.
4738 * Parameters:
4739 * Variables :
4740 * Result : If the function succeeds, the return value is an OEM code-page
4741 * identifier, or it is the default identifier if the registry
4742 * value is not readable. For a list of OEM code-page identifiers,
4743 * see GetOEMCP.
4744 * Remark :
4745 * Status : UNTESTED
4746 *
4747 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4748 *****************************************************************************/
4749
4750UINT WIN32API GetKBCodePage(VOID)
4751{
4752 return (GetOEMCP());
4753}
4754
4755
4756/*****************************************************************************
4757 * Name : BOOL WIN32API GetKeyboardLayoutNameA
4758 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
4759 * active keyboard layout.
4760 * Parameters: LPTSTR pwszKLID address of buffer for layout name
4761 * Variables :
4762 * Result : If the function succeeds, the return value is TRUE.
4763 * If the function fails, the return value is FALSE. To get extended
4764 * error information, call GetLastError.
4765 * Remark :
4766 * Status : UNTESTED STUB
4767 *
4768 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4769 *****************************************************************************/
4770
4771BOOL WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
4772{
4773 dprintf(("USER32:GetKeyboardLayoutNameA (%08x) not implemented.",
4774 pwszKLID));
4775
4776 return(FALSE);
4777}
4778
4779
4780/*****************************************************************************
4781 * Name : BOOL WIN32API GetKeyboardLayoutNameW
4782 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
4783 * active keyboard layout.
4784 * Parameters: LPTSTR pwszKLID address of buffer for layout name
4785 * Variables :
4786 * Result : If the function succeeds, the return value is TRUE.
4787 * If the function fails, the return value is FALSE. To get extended
4788 * error information, call GetLastError.
4789 * Remark :
4790 * Status : UNTESTED STUB
4791 *
4792 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4793 *****************************************************************************/
4794
4795BOOL WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
4796{
4797 dprintf(("USER32:GetKeyboardLayoutNameW (%08x) not implemented.",
4798 pwszKLID));
4799
4800 return(FALSE);
4801}
4802
4803
4804
4805
4806/*****************************************************************************
4807 * Name : HWINSTA WIN32API GetProcessWindowStation
4808 * Purpose : The GetProcessWindowStation function returns a handle of the
4809 * window station associated with the calling process.
4810 * Parameters:
4811 * Variables :
4812 * Result : If the function succeeds, the return value is a handle of the
4813 * window station associated with the calling process.
4814 * If the function fails, the return value is NULL. This can occur
4815 * if the calling process is not an application written for Windows
4816 * NT. To get extended error information, call GetLastError.
4817 * Remark :
4818 * Status : UNTESTED STUB
4819 *
4820 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4821 *****************************************************************************/
4822
4823HWINSTA WIN32API GetProcessWindowStation(VOID)
4824{
4825 dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
4826
4827 return (NULL);
4828}
4829
4830
4831
4832/*****************************************************************************
4833 * Name : HDESK WIN32API GetThreadDesktop
4834 * Purpose : The GetThreadDesktop function returns a handle to the desktop
4835 * associated with a specified thread.
4836 * Parameters: DWORD dwThreadId thread identifier
4837 * Variables :
4838 * Result : If the function succeeds, the return value is the handle of the
4839 * desktop associated with the specified thread.
4840 * Remark :
4841 * Status : UNTESTED STUB
4842 *
4843 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4844 *****************************************************************************/
4845
4846HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
4847{
4848 dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
4849 dwThreadId));
4850
4851 return (NULL);
4852}
4853
4854
4855/*****************************************************************************
4856 * Name : BOOL WIN32API GetUserObjectInformationA
4857 * Purpose : The GetUserObjectInformation function returns information about
4858 * a window station or desktop object.
4859 * Parameters: HANDLE hObj handle of object to get information for
4860 * int nIndex type of information to get
4861 * PVOID pvInfo points to buffer that receives the information
4862 * DWORD nLength size, in bytes, of pvInfo buffer
4863 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4864 * Variables :
4865 * Result : If the function succeeds, the return value is TRUE.
4866 * If the function fails, the return value is FALSE. To get extended
4867 * error information, call GetLastError.
4868 * Remark :
4869 * Status : UNTESTED STUB
4870 *
4871 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4872 *****************************************************************************/
4873
4874BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
4875 int nIndex,
4876 PVOID pvInfo,
4877 DWORD nLength,
4878 LPDWORD lpnLengthNeeded)
4879{
4880 dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4881 hObj,
4882 nIndex,
4883 pvInfo,
4884 nLength,
4885 lpnLengthNeeded));
4886
4887 return (FALSE);
4888}
4889
4890
4891/*****************************************************************************
4892 * Name : BOOL WIN32API GetUserObjectInformationW
4893 * Purpose : The GetUserObjectInformation function returns information about
4894 * a window station or desktop object.
4895 * Parameters: HANDLE hObj handle of object to get information for
4896 * int nIndex type of information to get
4897 * PVOID pvInfo points to buffer that receives the information
4898 * DWORD nLength size, in bytes, of pvInfo buffer
4899 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4900 * Variables :
4901 * Result : If the function succeeds, the return value is TRUE.
4902 * If the function fails, the return value is FALSE. To get extended
4903 * error information, call GetLastError.
4904 * Remark :
4905 * Status : UNTESTED STUB
4906 *
4907 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4908 *****************************************************************************/
4909
4910BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
4911 int nIndex,
4912 PVOID pvInfo,
4913 DWORD nLength,
4914 LPDWORD lpnLengthNeeded)
4915{
4916 dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4917 hObj,
4918 nIndex,
4919 pvInfo,
4920 nLength,
4921 lpnLengthNeeded));
4922
4923 return (FALSE);
4924}
4925
4926
4927/*****************************************************************************
4928 * Name : BOOL WIN32API GetUserObjectSecurity
4929 * Purpose : The GetUserObjectSecurity function retrieves security information
4930 * for the specified user object.
4931 * Parameters: HANDLE hObj handle of user object
4932 * SECURITY_INFORMATION * pSIRequested address of requested security information
4933 * LPSECURITY_DESCRIPTOR pSID address of security descriptor
4934 * DWORD nLength size of buffer for security descriptor
4935 * LPDWORD lpnLengthNeeded address of required size of buffer
4936 * Variables :
4937 * Result : If the function succeeds, the return value is TRUE.
4938 * If the function fails, the return value is FALSE. To get extended
4939 * error information, call GetLastError.
4940 * Remark :
4941 * Status : UNTESTED STUB
4942 *
4943 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4944 *****************************************************************************/
4945
4946BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
4947 SECURITY_INFORMATION * pSIRequested,
4948 LPSECURITY_DESCRIPTOR pSID,
4949 DWORD nLength,
4950 LPDWORD lpnLengthNeeded)
4951{
4952 dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4953 hObj,
4954 pSIRequested,
4955 pSID,
4956 nLength,
4957 lpnLengthNeeded));
4958
4959 return (FALSE);
4960}
4961
4962
4963
4964/*****************************************************************************
4965 * Name : int WIN32API GetWindowRgn
4966 * Purpose : The GetWindowRgn function obtains a copy of the window region of a window.
4967 * Parameters: HWND hWnd handle to window whose window region is to be obtained
4968 * HRGN hRgn handle to region that receives a copy of the window region
4969 * Variables :
4970 * Result : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
4971 * Remark :
4972 * Status : UNTESTED STUB
4973 *
4974 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4975 *****************************************************************************/
4976
4977int WIN32API GetWindowRgn (HWND hWnd,
4978 HRGN hRgn)
4979{
4980 dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
4981 hWnd,
4982 hRgn));
4983
4984 return (NULLREGION);
4985}
4986
4987
4988
4989/*****************************************************************************
4990 * Name : HCURSOR WIN32API LoadCursorFromFileA
4991 * Purpose : The LoadCursorFromFile function creates a cursor based on data
4992 * contained in a file. The file is specified by its name or by a
4993 * system cursor identifier. The function returns a handle to the
4994 * newly created cursor. Files containing cursor data may be in
4995 * either cursor (.CUR) or animated cursor (.ANI) format.
4996 * Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4997 * Variables :
4998 * Result : If the function is successful, the return value is a handle to
4999 * the new cursor.
5000 * If the function fails, the return value is NULL. To get extended
5001 * error information, call GetLastError. GetLastError may return
5002 * the following
5003 * Remark :
5004 * Status : UNTESTED STUB
5005 *
5006 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5007 *****************************************************************************/
5008
5009HCURSOR WIN32API LoadCursorFromFileA(LPCTSTR lpFileName)
5010{
5011 dprintf(("USER32:LoadCursorFromFileA (%s) not implemented.\n",
5012 lpFileName));
5013
5014 return (NULL);
5015}
5016
5017
5018/*****************************************************************************
5019 * Name : HCURSOR WIN32API LoadCursorFromFileW
5020 * Purpose : The LoadCursorFromFile function creates a cursor based on data
5021 * contained in a file. The file is specified by its name or by a
5022 * system cursor identifier. The function returns a handle to the
5023 * newly created cursor. Files containing cursor data may be in
5024 * either cursor (.CUR) or animated cursor (.ANI) format.
5025 * Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
5026 * Variables :
5027 * Result : If the function is successful, the return value is a handle to
5028 * the new cursor.
5029 * If the function fails, the return value is NULL. To get extended
5030 * error information, call GetLastError. GetLastError may return
5031 * the following
5032 * Remark :
5033 * Status : UNTESTED STUB
5034 *
5035 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5036 *****************************************************************************/
5037
5038HCURSOR WIN32API LoadCursorFromFileW(LPCWSTR lpFileName)
5039{
5040 dprintf(("USER32:LoadCursorFromFileW (%s) not implemented.\n",
5041 lpFileName));
5042
5043 return (NULL);
5044}
5045
5046
5047/*****************************************************************************
5048 * Name : HLK WIN32API LoadKeyboardLayoutA
5049 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
5050 * the system. Several keyboard layouts can be loaded at a time, but
5051 * only one per process is active at a time. Loading multiple keyboard
5052 * layouts makes it possible to rapidly switch between layouts.
5053 * Parameters:
5054 * Variables :
5055 * Result : If the function succeeds, the return value is the handle of the
5056 * keyboard layout.
5057 * If the function fails, the return value is NULL. To get extended
5058 * error information, call GetLastError.
5059 * Remark :
5060 * Status : UNTESTED STUB
5061 *
5062 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5063 *****************************************************************************/
5064
5065HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
5066 UINT Flags)
5067{
5068 dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
5069 pwszKLID,
5070 Flags));
5071
5072 return (NULL);
5073}
5074
5075
5076/*****************************************************************************
5077 * Name : HLK WIN32API LoadKeyboardLayoutW
5078 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
5079 * the system. Several keyboard layouts can be loaded at a time, but
5080 * only one per process is active at a time. Loading multiple keyboard
5081 * layouts makes it possible to rapidly switch between layouts.
5082 * Parameters:
5083 * Variables :
5084 * Result : If the function succeeds, the return value is the handle of the
5085 * keyboard layout.
5086 * If the function fails, the return value is NULL. To get extended
5087 * error information, call GetLastError.
5088 * Remark :
5089 * Status : UNTESTED STUB
5090 *
5091 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5092 *****************************************************************************/
5093
5094HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
5095 UINT Flags)
5096{
5097 dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
5098 pwszKLID,
5099 Flags));
5100
5101 return (NULL);
5102}
5103
5104
5105/*****************************************************************************
5106 * Name : UINT WIN32API MapVirtualKeyExA
5107 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
5108 * code into a scan code or character value, or translates a scan
5109 * code into a virtual-key code. The function translates the codes
5110 * using the input language and physical keyboard layout identified
5111 * by the given keyboard layout handle.
5112 * Parameters:
5113 * Variables :
5114 * Result : The return value is either a scan code, a virtual-key code, or
5115 * a character value, depending on the value of uCode and uMapType.
5116 * If there is no translation, the return value is zero.
5117 * Remark :
5118 * Status : UNTESTED STUB
5119 *
5120 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5121 *****************************************************************************/
5122
5123UINT WIN32API MapVirtualKeyExA(UINT uCode,
5124 UINT uMapType,
5125 HKL dwhkl)
5126{
5127 dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
5128 uCode,
5129 uMapType,
5130 dwhkl));
5131
5132 return (0);
5133}
5134
5135
5136/*****************************************************************************
5137 * Name : UINT WIN32API MapVirtualKeyExW
5138 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
5139 * code into a scan code or character value, or translates a scan
5140 * code into a virtual-key code. The function translates the codes
5141 * using the input language and physical keyboard layout identified
5142 * by the given keyboard layout handle.
5143 * Parameters:
5144 * Variables :
5145 * Result : The return value is either a scan code, a virtual-key code, or
5146 * a character value, depending on the value of uCode and uMapType.
5147 * If there is no translation, the return value is zero.
5148 * Remark :
5149 * Status : UNTESTED STUB
5150 *
5151 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5152 *****************************************************************************/
5153
5154UINT WIN32API MapVirtualKeyExW(UINT uCode,
5155 UINT uMapType,
5156 HKL dwhkl)
5157{
5158 dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
5159 uCode,
5160 uMapType,
5161 dwhkl));
5162
5163 return (0);
5164}
5165
5166
5167/*****************************************************************************
5168 * Name : int WIN32API MessageBoxExA
5169 * Purpose : The MessageBoxEx function creates, displays, and operates a message box.
5170 * Parameters: HWND hWnd handle of owner window
5171 * LPCTSTR lpText address of text in message box
5172 * LPCTSTR lpCaption address of title of message box
5173 * UINT uType style of message box
5174 * WORD wLanguageId language identifier
5175 * Variables :
5176 * Result : If the function succeeds, the return value is a nonzero menu-item
5177 * value returned by the dialog box.
5178 * Remark :
5179 * Status : UNTESTED STUB
5180 *
5181 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5182 *****************************************************************************/
5183
5184int WIN32API MessageBoxExA(HWND hWnd,
5185 LPCTSTR lpText,
5186 LPCTSTR lpCaption,
5187 UINT uType,
5188 WORD wLanguageId)
5189{
5190 dprintf(("USER32:MessageBoxExA (%08xh,%s,%s,%u,%08w) not implemented.\n",
5191 hWnd,
5192 lpText,
5193 lpCaption,
5194 uType,
5195 wLanguageId));
5196
5197 return (MessageBoxA(hWnd,
5198 lpText,
5199 lpCaption,
5200 uType));
5201}
5202
5203
5204/*****************************************************************************
5205 * Name : int WIN32API MessageBoxExW
5206 * Purpose : The MessageBoxEx function creates, displays, and operates a message box.
5207 * Parameters: HWND hWnd handle of owner window
5208 * LPCTSTR lpText address of text in message box
5209 * LPCTSTR lpCaption address of title of message box
5210 * UINT uType style of message box
5211 * WORD wLanguageId language identifier
5212 * Variables :
5213 * Result : If the function succeeds, the return value is a nonzero menu-item
5214 * value returned by the dialog box.
5215 * Remark :
5216 * Status : UNTESTED STUB
5217 *
5218 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5219 *****************************************************************************/
5220
5221int WIN32API MessageBoxExW(HWND hWnd,
5222 LPCWSTR lpText,
5223 LPCWSTR lpCaption,
5224 UINT uType,
5225 WORD wLanguageId)
5226{
5227
5228 dprintf(("USER32:MessageBoxExW (%08xh,%x,%x,%u,%08w) not implemented.\n",
5229 hWnd,
5230 lpText,
5231 lpCaption,
5232 uType,
5233 wLanguageId));
5234
5235 return MessageBoxW(hWnd, lpText, lpCaption, uType);
5236}
5237
5238
5239/*****************************************************************************
5240 * Name : BOOL WIN32API MessageBoxIndirectW
5241 * Purpose : The MessageBoxIndirect function creates, displays, and operates
5242 * a message box. The message box contains application-defined
5243 * message text and title, any icon, and any combination of
5244 * predefined push buttons.
5245 * Parameters:
5246 * Variables :
5247 * Result :
5248 * Remark :
5249 * Status : UNTESTED STUB
5250 *
5251 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5252 *****************************************************************************/
5253
5254BOOL WIN32API MessageBoxIndirectW(LPMSGBOXPARAMSW lpMsgBoxParams)
5255{
5256 dprintf(("USER32:MessageBoxIndirectW (%08x) not implemented.\n",
5257 lpMsgBoxParams));
5258
5259 return (FALSE);
5260}
5261
5262
5263/*****************************************************************************
5264 * Name : BOOL WIN32API MessageBoxIndirectA
5265 * Purpose : The MessageBoxIndirect function creates, displays, and operates
5266 * a message box. The message box contains application-defined
5267 * message text and title, any icon, and any combination of
5268 * predefined push buttons.
5269 * Parameters:
5270 * Variables :
5271 * Result :
5272 * Remark :
5273 * Status : UNTESTED STUB
5274 *
5275 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5276 *****************************************************************************/
5277
5278BOOL WIN32API MessageBoxIndirectA(LPMSGBOXPARAMSA lpMsgBoxParams)
5279{
5280 dprintf(("USER32:MessageBoxIndirectA (%08x) not implemented.\n",
5281 lpMsgBoxParams));
5282
5283 return (FALSE);
5284}
5285
5286
5287/*****************************************************************************
5288 * Name : DWORD WIN32API OemKeyScan
5289 * Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
5290 * into the OEM scan codes and shift states. The function provides
5291 * information that allows a program to send OEM text to another
5292 * program by simulating keyboard input.
5293 * Parameters:
5294 * Variables :
5295 * Result :
5296 * Remark :
5297 * Status : UNTESTED STUB
5298 *
5299 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5300 *****************************************************************************/
5301
5302DWORD WIN32API OemKeyScan(WORD wOemChar)
5303{
5304 dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
5305 wOemChar));
5306
5307 return (wOemChar);
5308}
5309
5310
5311/*****************************************************************************
5312 * Name : HDESK WIN32API OpenDesktopA
5313 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
5314 * A desktop is a secure object contained within a window station
5315 * object. A desktop has a logical display surface and contains
5316 * windows, menus and hooks.
5317 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5318 * DWORD dwFlags flags to control interaction with other applications
5319 * BOOL fInherit specifies whether returned handle is inheritable
5320 * DWORD dwDesiredAccess specifies access of returned handle
5321 * Variables :
5322 * Result : If the function succeeds, the return value is the handle to the
5323 * opened desktop.
5324 * If the function fails, the return value is NULL. To get extended
5325 * error information, call GetLastError.
5326 * Remark :
5327 * Status : UNTESTED STUB
5328 *
5329 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5330 *****************************************************************************/
5331
5332HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
5333 DWORD dwFlags,
5334 BOOL fInherit,
5335 DWORD dwDesiredAccess)
5336{
5337 dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
5338 lpszDesktopName,
5339 dwFlags,
5340 fInherit,
5341 dwDesiredAccess));
5342
5343 return (NULL);
5344}
5345
5346
5347/*****************************************************************************
5348 * Name : HDESK WIN32API OpenDesktopW
5349 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
5350 * A desktop is a secure object contained within a window station
5351 * object. A desktop has a logical display surface and contains
5352 * windows, menus and hooks.
5353 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5354 * DWORD dwFlags flags to control interaction with other applications
5355 * BOOL fInherit specifies whether returned handle is inheritable
5356 * DWORD dwDesiredAccess specifies access of returned handle
5357 * Variables :
5358 * Result : If the function succeeds, the return value is the handle to the
5359 * opened desktop.
5360 * If the function fails, the return value is NULL. To get extended
5361 * error information, call GetLastError.
5362 * Remark :
5363 * Status : UNTESTED STUB
5364 *
5365 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5366 *****************************************************************************/
5367
5368HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
5369 DWORD dwFlags,
5370 BOOL fInherit,
5371 DWORD dwDesiredAccess)
5372{
5373 dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
5374 lpszDesktopName,
5375 dwFlags,
5376 fInherit,
5377 dwDesiredAccess));
5378
5379 return (NULL);
5380}
5381
5382
5383/*****************************************************************************
5384 * Name : HDESK WIN32API OpenInputDesktop
5385 * Purpose : The OpenInputDesktop function returns a handle to the desktop
5386 * that receives user input. The input desktop is a desktop on the
5387 * window station associated with the logged-on user.
5388 * Parameters: DWORD dwFlags flags to control interaction with other applications
5389 * BOOL fInherit specifies whether returned handle is inheritable
5390 * DWORD dwDesiredAccess specifies access of returned handle
5391 * Variables :
5392 * Result : If the function succeeds, the return value is a handle of the
5393 * desktop that receives user input.
5394 * If the function fails, the return value is NULL. To get extended
5395 * error information, call GetLastError.
5396 * Remark :
5397 * Status : UNTESTED STUB
5398 *
5399 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5400 *****************************************************************************/
5401
5402HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
5403 BOOL fInherit,
5404 DWORD dwDesiredAccess)
5405{
5406 dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
5407 dwFlags,
5408 fInherit,
5409 dwDesiredAccess));
5410
5411 return (NULL);
5412}
5413
5414
5415/*****************************************************************************
5416 * Name : HWINSTA WIN32API OpenWindowStationA
5417 * Purpose : The OpenWindowStation function returns a handle to an existing
5418 * window station.
5419 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
5420 * BOOL fInherit specifies whether returned handle is inheritable
5421 * DWORD dwDesiredAccess specifies access of returned handle
5422 * Variables :
5423 * Result : If the function succeeds, the return value is the handle to the
5424 * specified window station.
5425 * If the function fails, the return value is NULL. To get extended
5426 * error information, call GetLastError.
5427 * Remark :
5428 * Status : UNTESTED STUB
5429 *
5430 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5431 *****************************************************************************/
5432
5433HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
5434 BOOL fInherit,
5435 DWORD dwDesiredAccess)
5436{
5437 dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
5438 lpszWinStaName,
5439 fInherit,
5440 dwDesiredAccess));
5441
5442 return (NULL);
5443}
5444
5445
5446/*****************************************************************************
5447 * Name : HWINSTA WIN32API OpenWindowStationW
5448 * Purpose : The OpenWindowStation function returns a handle to an existing
5449 * window station.
5450 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
5451 * BOOL fInherit specifies whether returned handle is inheritable
5452 * DWORD dwDesiredAccess specifies access of returned handle
5453 * Variables :
5454 * Result : If the function succeeds, the return value is the handle to the
5455 * specified window station.
5456 * If the function fails, the return value is NULL. To get extended
5457 * error information, call GetLastError.
5458
5459 * Remark :
5460 * Status : UNTESTED STUB
5461 *
5462 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5463 *****************************************************************************/
5464
5465HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
5466 BOOL fInherit,
5467 DWORD dwDesiredAccess)
5468{
5469 dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
5470 lpszWinStaName,
5471 fInherit,
5472 dwDesiredAccess));
5473
5474 return (NULL);
5475}
5476
5477
5478/*****************************************************************************
5479 * Name : BOOL WIN32API PaintDesktop
5480 * Purpose : The PaintDesktop function fills the clipping region in the
5481 * specified device context with the desktop pattern or wallpaper.
5482 * The function is provided primarily for shell desktops.
5483 * Parameters:
5484 * Variables :
5485 * Result : If the function succeeds, the return value is TRUE.
5486 * If the function fails, the return value is FALSE.
5487 * Remark :
5488 * Status : UNTESTED STUB
5489 *
5490 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5491 *****************************************************************************/
5492
5493BOOL WIN32API PaintDesktop(HDC hdc)
5494{
5495 dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
5496 hdc));
5497
5498 return (FALSE);
5499}
5500
5501
5502/*****************************************************************************
5503 * Name : BOOL WIN32API SendMessageCallbackA
5504 * Purpose : The SendMessageCallback function sends the specified message to
5505 * a window or windows. The function calls the window procedure for
5506 * the specified window and returns immediately. After the window
5507 * procedure processes the message, the system calls the specified
5508 * callback function, passing the result of the message processing
5509 * and an application-defined value to the callback function.
5510 * Parameters: HWND hwnd handle of destination window
5511 * UINT uMsg message to send
5512 * WPARAM wParam first message parameter
5513 * LPARAM lParam second message parameter
5514 * SENDASYNCPROC lpResultCallBack function to receive message value
5515 * DWORD dwData value to pass to callback function
5516 * Variables :
5517 * Result : If the function succeeds, the return value is TRUE.
5518 * If the function fails, the return value is FALSE. To get extended
5519 * error information, call GetLastError.
5520 * Remark :
5521 * Status : UNTESTED STUB
5522 *
5523 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5524 *****************************************************************************/
5525
5526BOOL WIN32API SendMessageCallbackA(HWND hWnd,
5527 UINT uMsg,
5528 WPARAM wParam,
5529 LPARAM lParam,
5530 SENDASYNCPROC lpResultCallBack,
5531 DWORD dwData)
5532{
5533 dprintf(("USER32:SendMessageCallBackA (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5534 hWnd,
5535 uMsg,
5536 wParam,
5537 lParam,
5538 lpResultCallBack,
5539 dwData));
5540
5541 return (FALSE);
5542}
5543
5544
5545/*****************************************************************************
5546 * Name : BOOL WIN32API SendMessageCallbackW
5547 * Purpose : The SendMessageCallback function sends the specified message to
5548 * a window or windows. The function calls the window procedure for
5549 * the specified window and returns immediately. After the window
5550 * procedure processes the message, the system calls the specified
5551 * callback function, passing the result of the message processing
5552 * and an application-defined value to the callback function.
5553 * Parameters: HWND hwnd handle of destination window
5554 * UINT uMsg message to send
5555 * WPARAM wParam first message parameter
5556 * LPARAM lParam second message parameter
5557 * SENDASYNCPROC lpResultCallBack function to receive message value
5558 * DWORD dwData value to pass to callback function
5559 * Variables :
5560 * Result : If the function succeeds, the return value is TRUE.
5561 * If the function fails, the return value is FALSE. To get extended
5562 * error information, call GetLastError.
5563 * Remark :
5564 * Status : UNTESTED STUB
5565 *
5566 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5567 *****************************************************************************/
5568
5569BOOL WIN32API SendMessageCallbackW(HWND hWnd,
5570 UINT uMsg,
5571 WPARAM wParam,
5572 LPARAM lParam,
5573 SENDASYNCPROC lpResultCallBack,
5574 DWORD dwData)
5575{
5576 dprintf(("USER32:SendMessageCallBackW (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5577 hWnd,
5578 uMsg,
5579 wParam,
5580 lParam,
5581 lpResultCallBack,
5582 dwData));
5583
5584 return (FALSE);
5585}
5586
5587
5588/*****************************************************************************
5589 * Name : VOID WIN32API SetDebugErrorLevel
5590 * Purpose : The SetDebugErrorLevel function sets the minimum error level at
5591 * which Windows will generate debugging events and pass them to a debugger.
5592 * Parameters: DWORD dwLevel debugging error level
5593 * Variables :
5594 * Result :
5595 * Remark :
5596 * Status : UNTESTED STUB
5597 *
5598 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5599 *****************************************************************************/
5600
5601VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
5602{
5603 dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
5604 dwLevel));
5605}
5606
5607
5608/*****************************************************************************
5609 * Name : BOOL WIN32API SetProcessWindowStation
5610 * Purpose : The SetProcessWindowStation function assigns a window station
5611 * to the calling process. This enables the process to access
5612 * objects in the window station such as desktops, the clipboard,
5613 * and global atoms. All subsequent operations on the window station
5614 * use the access rights granted to hWinSta.
5615 * Parameters:
5616 * Variables :
5617 * Result : If the function succeeds, the return value is TRUE.
5618 * If the function fails, the return value is FALSE. To get extended
5619 * error information, call GetLastError.
5620 * Remark :
5621 * Status : UNTESTED STUB
5622 *
5623 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5624 *****************************************************************************/
5625
5626BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
5627{
5628 dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
5629 hWinSta));
5630
5631 return (FALSE);
5632}
5633
5634
5635/*****************************************************************************
5636 * Name : BOOL WIN32API SetSystemCursor
5637 * Purpose : The SetSystemCursor function replaces the contents of the system
5638 * cursor specified by dwCursorId with the contents of the cursor
5639 * specified by hCursor, and then destroys hCursor. This function
5640 * lets an application customize the system cursors.
5641 * Parameters: HCURSOR hCursor set specified system cursor to this cursor's
5642 * contents, then destroy this
5643 * DWORD dwCursorID system cursor specified by its identifier
5644 * Variables :
5645 * Result : If the function succeeds, the return value is TRUE.
5646 * If the function fails, the return value is FALSE. To get extended
5647 * error information, call GetLastError.
5648 * Remark :
5649 * Status : UNTESTED STUB
5650 *
5651 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5652 *****************************************************************************/
5653
5654BOOL WIN32API SetSystemCursor(HCURSOR hCursor,
5655 DWORD dwCursorId)
5656{
5657 dprintf(("USER32:SetSystemCursor (%08xh,%08x) not implemented.\n",
5658 hCursor,
5659 dwCursorId));
5660
5661 return (FALSE);
5662}
5663
5664
5665/*****************************************************************************
5666 * Name : BOOL WIN32API SetThreadDesktop
5667 * Purpose : The SetThreadDesktop function assigns a desktop to the calling
5668 * thread. All subsequent operations on the desktop use the access
5669 * rights granted to hDesk.
5670 * Parameters: HDESK hDesk handle of the desktop to assign to this thread
5671 * Variables :
5672 * Result : If the function succeeds, the return value is TRUE.
5673 * If the function fails, the return value is FALSE. To get extended
5674 * error information, call GetLastError.
5675 * Remark :
5676 * Status : UNTESTED STUB
5677 *
5678 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5679 *****************************************************************************/
5680
5681BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
5682{
5683 dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
5684 hDesktop));
5685
5686 return (FALSE);
5687}
5688
5689
5690/*****************************************************************************
5691 * Name : BOOL WIN32API SetUserObjectInformationA
5692 * Purpose : The SetUserObjectInformation function sets information about a
5693 * window station or desktop object.
5694 * Parameters: HANDLE hObject handle of the object for which to set information
5695 * int nIndex type of information to set
5696 * PVOID lpvInfo points to a buffer that contains the information
5697 * DWORD cbInfo size, in bytes, of lpvInfo buffer
5698 * Variables :
5699 * Result : If the function succeeds, the return value is TRUE.
5700 * If the function fails the return value is FALSE. To get extended
5701 * error information, call GetLastError.
5702 * Remark :
5703 * Status : UNTESTED STUB
5704 *
5705 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5706 *****************************************************************************/
5707
5708BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
5709 int nIndex,
5710 PVOID lpvInfo,
5711 DWORD cbInfo)
5712{
5713 dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
5714 hObject,
5715 nIndex,
5716 lpvInfo,
5717 cbInfo));
5718
5719 return (FALSE);
5720}
5721
5722
5723/*****************************************************************************
5724 * Name : BOOL WIN32API SetUserObjectInformationW
5725 * Purpose : The SetUserObjectInformation function sets information about a
5726 * window station or desktop object.
5727 * Parameters: HANDLE hObject handle of the object for which to set information
5728 * int nIndex type of information to set
5729 * PVOID lpvInfo points to a buffer that contains the information
5730 * DWORD cbInfo size, in bytes, of lpvInfo buffer
5731 * Variables :
5732 * Result : If the function succeeds, the return value is TRUE.
5733 * If the function fails the return value is FALSE. To get extended
5734 * error information, call GetLastError.
5735 * Remark :
5736 * Status : UNTESTED STUB
5737 *
5738 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5739 *****************************************************************************/
5740
5741BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
5742 int nIndex,
5743 PVOID lpvInfo,
5744 DWORD cbInfo)
5745{
5746 dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
5747 hObject,
5748 nIndex,
5749 lpvInfo,
5750 cbInfo));
5751
5752 return (FALSE);
5753}
5754
5755
5756/*****************************************************************************
5757 * Name : BOOL WIN32API SetUserObjectSecurity
5758 * Purpose : The SetUserObjectSecurity function sets the security of a user
5759 * object. This can be, for example, a window or a DDE conversation
5760 * Parameters: HANDLE hObject handle of user object
5761 * SECURITY_INFORMATION * psi address of security information
5762 * LPSECURITY_DESCRIPTOR psd address of security descriptor
5763 * Variables :
5764 * Result : If the function succeeds, the return value is TRUE.
5765 * If the function fails, the return value is FALSE. To get extended
5766 * error information, call GetLastError.
5767 * Remark :
5768 * Status : UNTESTED STUB
5769 *
5770 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5771 *****************************************************************************/
5772
5773BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
5774 SECURITY_INFORMATION * psi,
5775 LPSECURITY_DESCRIPTOR psd)
5776{
5777 dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
5778 hObject,
5779 psi,
5780 psd));
5781
5782 return (FALSE);
5783}
5784
5785
5786/*****************************************************************************
5787 * Name : int WIN32API SetWindowRgn
5788 * Purpose : The SetWindowRgn function sets the window region of a window. The
5789 * window region determines the area within the window where the
5790 * operating system permits drawing. The operating system does not
5791 * display any portion of a window that lies outside of the window region
5792 * Parameters: HWND hWnd handle to window whose window region is to be set
5793 * HRGN hRgn handle to region
5794 * BOOL bRedraw window redraw flag
5795 * Variables :
5796 * Result : If the function succeeds, the return value is non-zero.
5797 * If the function fails, the return value is zero.
5798 * Remark :
5799 * Status : UNTESTED STUB
5800 *
5801 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5802 *****************************************************************************/
5803
5804int WIN32API SetWindowRgn(HWND hWnd,
5805 HRGN hRgn,
5806 BOOL bRedraw)
5807{
5808 dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
5809 hWnd,
5810 hRgn,
5811 bRedraw));
5812
5813 return (0);
5814}
5815
5816
5817/*****************************************************************************
5818 * Name : BOOL WIN32API SetWindowsHookW
5819 * Purpose : The SetWindowsHook function is not implemented in the Win32 API.
5820 * Win32-based applications should use the SetWindowsHookEx function.
5821 * Parameters:
5822 * Variables :
5823 * Result :
5824 * Remark : ARGH ! MICROSOFT !
5825 * Status : UNTESTED STUB
5826 *
5827 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5828 *****************************************************************************/
5829
5830HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
5831
5832{
5833 return (FALSE);
5834}
5835
5836
5837/*****************************************************************************
5838 * Name : BOOL WIN32API ShowWindowAsync
5839 * Purpose : The ShowWindowAsync function sets the show state of a window
5840 * created by a different thread.
5841 * Parameters: HWND hwnd handle of window
5842 * int nCmdShow show state of window
5843 * Variables :
5844 * Result : If the window was previously visible, the return value is TRUE.
5845 * If the window was previously hidden, the return value is FALSE.
5846 * Remark :
5847 * Status : UNTESTED STUB
5848 *
5849 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5850 *****************************************************************************/
5851
5852BOOL WIN32API ShowWindowAsync (HWND hWnd,
5853 int nCmdShow)
5854{
5855 dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
5856 hWnd,
5857 nCmdShow));
5858
5859 return (FALSE);
5860}
5861
5862
5863/*****************************************************************************
5864 * Name : BOOL WIN32API SwitchDesktop
5865 * Purpose : The SwitchDesktop function makes a desktop visible and activates
5866 * it. This enables the desktop to receive input from the user. The
5867 * calling process must have DESKTOP_SWITCHDESKTOP access to the
5868 * desktop for the SwitchDesktop function to succeed.
5869 * Parameters:
5870 * Variables :
5871 * Result : If the function succeeds, the return value is TRUE.
5872 * If the function fails, the return value is FALSE. To get extended
5873 * error information, call GetLastError.
5874 * Remark :
5875 * Status : UNTESTED STUB
5876 *
5877 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5878 *****************************************************************************/
5879
5880BOOL WIN32API SwitchDesktop(HDESK hDesktop)
5881{
5882 dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
5883 hDesktop));
5884
5885 return (FALSE);
5886}
5887
5888
5889/*****************************************************************************
5890 * Name : WORD WIN32API TileWindows
5891 * Purpose : The TileWindows function tiles the specified windows, or the child
5892 * windows of the specified parent window.
5893 * Parameters: HWND hwndParent handle of parent window
5894 * WORD wFlags types of windows not to arrange
5895 * LPCRECT lpRect rectangle to arrange windows in
5896 * WORD cChildrenb number of windows to arrange
5897 * const HWND *ahwndChildren array of window handles
5898 * Variables :
5899 * Result : If the function succeeds, the return value is the number of
5900 * windows arranged.
5901 * If the function fails, the return value is zero.
5902 * Remark :
5903 * Status : UNTESTED STUB
5904 *
5905 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5906 *****************************************************************************/
5907
5908WORD WIN32API TileWindows(HWND hwndParent,
5909 UINT wFlags,
5910 const LPRECT lpRect,
5911 UINT cChildrenb,
5912 const HWND *ahwndChildren)
5913{
5914 dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5915 hwndParent,
5916 wFlags,
5917 lpRect,
5918 cChildrenb,
5919 ahwndChildren));
5920
5921 return (0);
5922}
5923
5924
5925/*****************************************************************************
5926 * Name : int WIN32API ToAscii
5927 * Purpose : The ToAscii function translates the specified virtual-key code
5928 * and keyboard state to the corresponding Windows character or characters.
5929 * Parameters: UINT uVirtKey virtual-key code
5930 * UINT uScanCode scan code
5931 * PBYTE lpbKeyState address of key-state array
5932 * LPWORD lpwTransKey buffer for translated key
5933 * UINT fuState active-menu flag
5934 * Variables :
5935 * Result : 0 The specified virtual key has no translation for the current
5936 * state of the keyboard.
5937 * 1 One Windows character was copied to the buffer.
5938 * 2 Two characters were copied to the buffer. This usually happens
5939 * when a dead-key character (accent or diacritic) stored in the
5940 * keyboard layout cannot be composed with the specified virtual
5941 * key to form a single character.
5942 * Remark :
5943 * Status : UNTESTED STUB
5944 *
5945 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5946 *****************************************************************************/
5947
5948int WIN32API ToAscii(UINT uVirtKey,
5949 UINT uScanCode,
5950 PBYTE lpbKeyState,
5951 LPWORD lpwTransKey,
5952 UINT fuState)
5953{
5954 dprintf(("USER32:ToAscii (%u,%u,%08xh,%08xh,%u) not implemented.\n",
5955 uVirtKey,
5956 uScanCode,
5957 lpbKeyState,
5958 lpwTransKey,
5959 fuState));
5960
5961 return (0);
5962}
5963
5964
5965/*****************************************************************************
5966 * Name : int WIN32API ToAsciiEx
5967 * Purpose : The ToAscii function translates the specified virtual-key code
5968 * and keyboard state to the corresponding Windows character or characters.
5969 * Parameters: UINT uVirtKey virtual-key code
5970 * UINT uScanCode scan code
5971 * PBYTE lpbKeyState address of key-state array
5972 * LPWORD lpwTransKey buffer for translated key
5973 * UINT fuState active-menu flag
5974 * HLK hlk keyboard layout handle
5975 * Variables :
5976 * Result : 0 The specified virtual key has no translation for the current
5977 * state of the keyboard.
5978 * 1 One Windows character was copied to the buffer.
5979 * 2 Two characters were copied to the buffer. This usually happens
5980 * when a dead-key character (accent or diacritic) stored in the
5981 * keyboard layout cannot be composed with the specified virtual
5982 * key to form a single character.
5983 * Remark :
5984 * Status : UNTESTED STUB
5985 *
5986 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5987 *****************************************************************************/
5988
5989int WIN32API ToAsciiEx(UINT uVirtKey,
5990 UINT uScanCode,
5991 PBYTE lpbKeyState,
5992 LPWORD lpwTransKey,
5993 UINT fuState,
5994 HKL hkl)
5995{
5996 dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5997 uVirtKey,
5998 uScanCode,
5999 lpbKeyState,
6000 lpwTransKey,
6001 fuState,
6002 hkl));
6003
6004 return (0);
6005}
6006
6007
6008/*****************************************************************************
6009 * Name : int WIN32API ToUnicode
6010 * Purpose : The ToUnicode function translates the specified virtual-key code
6011 * and keyboard state to the corresponding Unicode character or characters.
6012 * Parameters: UINT wVirtKey virtual-key code
6013 * UINT wScanCode scan code
6014 * PBYTE lpKeyState address of key-state array
6015 * LPWSTR pwszBuff buffer for translated key
6016 * int cchBuff size of translated key buffer
6017 * UINT wFlags set of function-conditioning flags
6018 * Variables :
6019 * Result : - 1 The specified virtual key is a dead-key character (accent or
6020 * diacritic). This value is returned regardless of the keyboard
6021 * layout, even if several characters have been typed and are
6022 * stored in the keyboard state. If possible, even with Unicode
6023 * keyboard layouts, the function has written a spacing version of
6024 * the dead-key character to the buffer specified by pwszBuffer.
6025 * For example, the function writes the character SPACING ACUTE
6026 * (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
6027 * 0 The specified virtual key has no translation for the current
6028 * state of the keyboard. Nothing was written to the buffer
6029 * specified by pwszBuffer.
6030 * 1 One character was written to the buffer specified by pwszBuffer.
6031 * 2 or more Two or more characters were written to the buffer specified by
6032 * pwszBuff. The most common cause for this is that a dead-key
6033 * character (accent or diacritic) stored in the keyboard layout
6034 * could not be combined with the specified virtual key to form a
6035 * single character.
6036 * Remark :
6037 * Status : UNTESTED STUB
6038 *
6039 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
6040 *****************************************************************************/
6041
6042int WIN32API ToUnicode(UINT uVirtKey,
6043 UINT uScanCode,
6044 PBYTE lpKeyState,
6045 LPWSTR pwszBuff,
6046 int cchBuff,
6047 UINT wFlags)
6048{
6049 dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
6050 uVirtKey,
6051 uScanCode,
6052 lpKeyState,
6053 pwszBuff,
6054 cchBuff,
6055 wFlags));
6056
6057 return (0);
6058}
6059
6060
6061/*****************************************************************************
6062 * Name : BOOL WIN32API UnloadKeyboardLayout
6063 * Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
6064 * Parameters: HKL hkl handle of keyboard layout
6065 * Variables :
6066 * Result : If the function succeeds, the return value is the handle of the
6067 * keyboard layout; otherwise, it is NULL. To get extended error
6068 * information, use the GetLastError function.
6069 * Remark :
6070 * Status : UNTESTED STUB
6071 *
6072 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
6073 *****************************************************************************/
6074
6075BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
6076{
6077 dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
6078 hkl));
6079
6080 return (0);
6081}
6082
6083
6084/*****************************************************************************
6085 * Name : SHORT WIN32API VkKeyScanExW
6086 * Purpose : The VkKeyScanEx function translates a character to the
6087 * corresponding virtual-key code and shift state. The function
6088 * translates the character using the input language and physical
6089 * keyboard layout identified by the given keyboard layout handle.
6090 * Parameters: UINT uChar character to translate
6091 * HKL hkl keyboard layout handle
6092 * Variables :
6093 * Result : see docs
6094 * Remark :
6095 * Status : UNTESTED STUB
6096 *
6097 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
6098 *****************************************************************************/
6099
6100WORD WIN32API VkKeyScanExW(WCHAR uChar,
6101 HKL hkl)
6102{
6103 dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
6104 uChar,
6105 hkl));
6106
6107 return (uChar);
6108}
6109
6110
6111/*****************************************************************************
6112 * Name : SHORT WIN32API VkKeyScanExA
6113 * Purpose : The VkKeyScanEx function translates a character to the
6114 * corresponding virtual-key code and shift state. The function
6115 * translates the character using the input language and physical
6116 * keyboard layout identified by the given keyboard layout handle.
6117 * Parameters: UINT uChar character to translate
6118 * HKL hkl keyboard layout handle
6119 * Variables :
6120 * Result : see docs
6121 * Remark :
6122 * Status : UNTESTED STUB
6123 *
6124 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
6125 *****************************************************************************/
6126
6127WORD WIN32API VkKeyScanExA(CHAR uChar,
6128 HKL hkl)
6129{
6130 dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
6131 uChar,
6132 hkl));
6133
6134 return (uChar);
6135}
6136
6137
6138/*****************************************************************************
6139 * Name : VOID WIN32API keybd_event
6140 * Purpose : The keybd_event function synthesizes a keystroke. The system
6141 * can use such a synthesized keystroke to generate a WM_KEYUP or
6142 * WM_KEYDOWN message. The keyboard driver's interrupt handler calls
6143 * the keybd_event function.
6144 * Parameters: BYTE bVk virtual-key code
6145
6146 * BYTE bScan hardware scan code
6147 * DWORD dwFlags flags specifying various function options
6148 * DWORD dwExtraInfo additional data associated with keystroke
6149 * Variables :
6150 * Result :
6151 * Remark :
6152 * Status : UNTESTED STUB
6153 *
6154 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
6155 *****************************************************************************/
6156
6157VOID WIN32API keybd_event (BYTE bVk,
6158 BYTE bScan,
6159 DWORD dwFlags,
6160 DWORD dwExtraInfo)
6161{
6162 dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
6163 bVk,
6164 bScan,
6165 dwFlags,
6166 dwExtraInfo));
6167}
6168
6169
6170/*****************************************************************************
6171 * Name : VOID WIN32API mouse_event
6172 * Purpose : The mouse_event function synthesizes mouse motion and button clicks.
6173 * Parameters: DWORD dwFlags flags specifying various motion/click variants
6174 * DWORD dx horizontal mouse position or position change
6175 * DWORD dy vertical mouse position or position change
6176 * DWORD cButtons unused, reserved for future use, set to zero
6177 * DWORD dwExtraInfo 32 bits of application-defined information
6178 * Variables :
6179 * Result :
6180 * Remark :
6181 * Status : UNTESTED STUB
6182 *
6183 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
6184 *****************************************************************************/
6185
6186VOID WIN32API mouse_event(DWORD dwFlags,
6187 DWORD dx,
6188 DWORD dy,
6189 DWORD cButtons,
6190 DWORD dwExtraInfo)
6191{
6192 dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
6193 dwFlags,
6194 dx,
6195 dy,
6196 cButtons,
6197 dwExtraInfo));
6198}
6199
6200
6201/*****************************************************************************
6202 * Name : BOOL WIN32API SetShellWindow
6203 * Purpose : Unknown
6204 * Parameters: Unknown
6205 * Variables :
6206 * Result :
6207 * Remark :
6208 * Status : UNTESTED UNKNOWN STUB
6209 *
6210 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6211 *****************************************************************************/
6212
6213BOOL WIN32API SetShellWindow(DWORD x1)
6214{
6215 dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
6216 x1));
6217
6218 return (FALSE); /* default */
6219}
6220
6221
6222/*****************************************************************************
6223 * Name : BOOL WIN32API PlaySoundEvent
6224 * Purpose : Unknown
6225 * Parameters: Unknown
6226 * Variables :
6227 * Result :
6228 * Remark :
6229 * Status : UNTESTED UNKNOWN STUB
6230 *
6231 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6232 *****************************************************************************/
6233
6234BOOL WIN32API PlaySoundEvent(DWORD x1)
6235{
6236 dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
6237 x1));
6238
6239 return (FALSE); /* default */
6240}
6241
6242
6243/*****************************************************************************
6244 * Name : BOOL WIN32API TileChildWindows
6245 * Purpose : Unknown
6246 * Parameters: Unknown
6247 * Variables :
6248 * Result :
6249 * Remark :
6250 * Status : UNTESTED UNKNOWN STUB
6251 *
6252 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6253 *****************************************************************************/
6254
6255BOOL WIN32API TileChildWindows(DWORD x1,
6256 DWORD x2)
6257{
6258 dprintf(("USER32: TileChildWindows(%08xh,%08xh) not implemented.\n",
6259 x1,
6260 x2));
6261
6262 return (FALSE); /* default */
6263}
6264
6265
6266/*****************************************************************************
6267 * Name : BOOL WIN32API SetSysColorsTemp
6268 * Purpose : Unknown
6269 * Parameters: Unknown
6270 * Variables :
6271 * Result :
6272 * Remark :
6273 * Status : UNTESTED UNKNOWN STUB
6274 *
6275 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6276 *****************************************************************************/
6277
6278BOOL WIN32API SetSysColorsTemp(void)
6279{
6280 dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
6281
6282 return (FALSE); /* default */
6283}
6284
6285
6286/*****************************************************************************
6287 * Name : BOOL WIN32API RegisterNetworkCapabilities
6288 * Purpose : Unknown
6289 * Parameters: Unknown
6290 * Variables :
6291 * Result :
6292 * Remark :
6293 * Status : UNTESTED UNKNOWN STUB
6294 *
6295 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6296 *****************************************************************************/
6297
6298BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
6299 DWORD x2)
6300{
6301 dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
6302 x1,
6303 x2));
6304
6305 return (FALSE); /* default */
6306}
6307
6308
6309/*****************************************************************************
6310 * Name : BOOL WIN32API EndTask
6311 * Purpose : Unknown
6312 * Parameters: Unknown
6313 * Variables :
6314 * Result :
6315 * Remark :
6316 * Status : UNTESTED UNKNOWN STUB
6317 *
6318 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6319 *****************************************************************************/
6320
6321BOOL WIN32API EndTask(DWORD x1,
6322 DWORD x2,
6323 DWORD x3)
6324{
6325 dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
6326 x1,
6327 x2,
6328 x3));
6329
6330 return (FALSE); /* default */
6331}
6332
6333
6334/*****************************************************************************
6335 * Name : BOOL WIN32API SwitchToThisWindow
6336 * Purpose : Unknown
6337 * Parameters: Unknown
6338 * Variables :
6339 * Result :
6340 * Remark :
6341 * Status : UNTESTED UNKNOWN STUB
6342 *
6343 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6344 *****************************************************************************/
6345
6346BOOL WIN32API SwitchToThisWindow(HWND hwnd,
6347 BOOL x2)
6348{
6349 dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
6350 hwnd,
6351 x2));
6352
6353 return (FALSE); /* default */
6354}
6355
6356
6357/*****************************************************************************
6358 * Name : BOOL WIN32API GetNextQueueWindow
6359 * Purpose : Unknown
6360 * Parameters: Unknown
6361 * Variables :
6362 * Result :
6363 * Remark :
6364 * Status : UNTESTED UNKNOWN STUB
6365 *
6366 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6367 *****************************************************************************/
6368
6369BOOL WIN32API GetNextQueueWindow(DWORD x1,
6370 DWORD x2)
6371{
6372 dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
6373 x1,
6374 x2));
6375
6376 return (FALSE); /* default */
6377}
6378
6379
6380/*****************************************************************************
6381 * Name : BOOL WIN32API YieldTask
6382 * Purpose : Unknown
6383 * Parameters: Unknown
6384 * Variables :
6385 * Result :
6386 * Remark :
6387 * Status : UNTESTED UNKNOWN STUB
6388 *
6389 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6390 *****************************************************************************/
6391
6392BOOL WIN32API YieldTask(void)
6393{
6394 dprintf(("USER32: YieldTask() not implemented.\n"));
6395
6396 return (FALSE); /* default */
6397}
6398
6399
6400/*****************************************************************************
6401 * Name : BOOL WIN32API WinOldAppHackoMatic
6402 * Purpose : Unknown
6403 * Parameters: Unknown
6404 * Variables :
6405 * Result :
6406 * Remark :
6407 * Status : UNTESTED UNKNOWN STUB
6408 *
6409 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6410 *****************************************************************************/
6411
6412BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
6413{
6414 dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
6415 x1));
6416
6417 return (FALSE); /* default */
6418}
6419
6420
6421/*****************************************************************************
6422 * Name : BOOL WIN32API DragObject
6423 * Purpose : Unknown
6424 * Parameters: Unknown
6425 * Variables :
6426 * Result :
6427 * Remark :
6428 * Status : UNTESTED UNKNOWN STUB
6429 *
6430 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6431 *****************************************************************************/
6432
6433DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
6434{
6435 dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6436 x1,
6437 x2,
6438 x3,
6439 x4,
6440 x5));
6441
6442 return (FALSE); /* default */
6443}
6444
6445
6446/*****************************************************************************
6447 * Name : BOOL WIN32API CascadeChildWindows
6448 * Purpose : Unknown
6449 * Parameters: Unknown
6450 * Variables :
6451 * Result :
6452 * Remark :
6453 * Status : UNTESTED UNKNOWN STUB
6454 *
6455 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6456 *****************************************************************************/
6457
6458BOOL WIN32API CascadeChildWindows(DWORD x1,
6459 DWORD x2)
6460{
6461 dprintf(("USER32: CascadeChildWindows(%08xh,%08xh) not implemented.\n",
6462 x1,
6463 x2));
6464
6465 return (FALSE); /* default */
6466}
6467
6468
6469/*****************************************************************************
6470 * Name : BOOL WIN32API RegisterSystemThread
6471 * Purpose : Unknown
6472 * Parameters: Unknown
6473 * Variables :
6474 * Result :
6475 * Remark :
6476 * Status : UNTESTED UNKNOWN STUB
6477 *
6478 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6479 *****************************************************************************/
6480
6481BOOL WIN32API RegisterSystemThread(DWORD x1,
6482 DWORD x2)
6483{
6484 dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
6485 x1,
6486 x2));
6487
6488 return (FALSE); /* default */
6489}
6490
6491
6492/*****************************************************************************
6493 * Name : BOOL WIN32API IsHungThread
6494 * Purpose : Unknown
6495 * Parameters: Unknown
6496 * Variables :
6497 * Result :
6498 * Remark :
6499 * Status : UNTESTED UNKNOWN STUB
6500 *
6501 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6502 *****************************************************************************/
6503
6504BOOL WIN32API IsHungThread(DWORD x1)
6505{
6506 dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
6507 x1));
6508
6509 return (FALSE); /* default */
6510}
6511
6512
6513/*****************************************************************************
6514 * Name : BOOL WIN32API SysErrorBox
6515 * Purpose : Unknown
6516 * Parameters: Unknown
6517 * Variables :
6518 * Result :
6519 * Remark : HARDERR like ?
6520 * Status : UNTESTED UNKNOWN STUB
6521 *
6522 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6523 *****************************************************************************/
6524
6525BOOL WIN32API SysErrorBox(DWORD x1,
6526 DWORD x2,
6527 DWORD x3)
6528{
6529 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh) not implemented.\n",
6530 x1,
6531 x2,
6532 x3));
6533
6534 return (FALSE); /* default */
6535}
6536
6537
6538/*****************************************************************************
6539 * Name : BOOL WIN32API UserSignalProc
6540 * Purpose : Unknown
6541 * Parameters: Unknown
6542 * Variables :
6543 * Result :
6544 * Remark :
6545 * Status : UNTESTED UNKNOWN STUB
6546 *
6547 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6548 *****************************************************************************/
6549
6550BOOL WIN32API UserSignalProc(DWORD x1,
6551 DWORD x2,
6552 DWORD x3,
6553 DWORD x4)
6554{
6555 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6556 x1,
6557 x2,
6558 x3,
6559 x4));
6560
6561 return (FALSE); /* default */
6562}
6563
6564
6565/*****************************************************************************
6566 * Name : BOOL WIN32API GetShellWindow
6567 * Purpose : Unknown
6568 * Parameters: Unknown
6569 * Variables :
6570 * Result :
6571 * Remark :
6572 * Status : UNTESTED UNKNOWN STUB
6573 *
6574 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6575 *****************************************************************************/
6576
6577HWND WIN32API GetShellWindow(void)
6578{
6579 dprintf(("USER32: GetShellWindow() not implemented.\n"));
6580
6581 return (0); /* default */
6582}
6583
6584
6585/***********************************************************************
6586 * RegisterTasklist32 [USER32.436]
6587 */
6588DWORD WIN32API RegisterTasklist (DWORD x)
6589{
6590 dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
6591 x));
6592
6593 return TRUE;
6594}
6595
6596
6597/***********************************************************************
6598 * DrawCaptionTemp32A [USER32.599]
6599 *
6600 * PARAMS
6601 *
6602 * RETURNS
6603 * Success:
6604 * Failure:
6605 */
6606
6607BOOL WIN32API DrawCaptionTempA(HWND hwnd,
6608 HDC hdc,
6609 const RECT *rect,
6610 HFONT hFont,
6611 HICON hIcon,
6612 LPCSTR str,
6613 UINT uFlags)
6614{
6615 RECT rc = *rect;
6616
6617 dprintf(("USER32: DrawCaptionTempA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
6618 hwnd,
6619 hdc,
6620 rect,
6621 hFont,
6622 hIcon,
6623 str,
6624 uFlags));
6625
6626 /* drawing background */
6627 if (uFlags & DC_INBUTTON)
6628 {
6629 O32_FillRect (hdc,
6630 &rc,
6631 GetSysColorBrush (COLOR_3DFACE));
6632
6633 if (uFlags & DC_ACTIVE)
6634 {
6635 HBRUSH hbr = O32_SelectObject (hdc,
6636 GetSysColorBrush (COLOR_ACTIVECAPTION));
6637 O32_PatBlt (hdc,
6638 rc.left,
6639 rc.top,
6640 rc.right - rc.left,
6641 rc.bottom - rc.top,
6642 0xFA0089);
6643
6644 O32_SelectObject (hdc,
6645 hbr);
6646 }
6647 }
6648 else
6649 {
6650 O32_FillRect (hdc,
6651 &rc,
6652 GetSysColorBrush ((uFlags & DC_ACTIVE) ?
6653 COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
6654 }
6655
6656
6657 /* drawing icon */
6658 if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP))
6659 {
6660 POINT pt;
6661
6662 pt.x = rc.left + 2;
6663 pt.y = (rc.bottom + rc.top - O32_GetSystemMetrics(SM_CYSMICON)) / 2;
6664
6665 if (hIcon)
6666 {
6667 DrawIconEx (hdc,
6668 pt.x,
6669 pt.y,
6670 hIcon,
6671 O32_GetSystemMetrics(SM_CXSMICON),
6672 O32_GetSystemMetrics(SM_CYSMICON),
6673 0,
6674 0,
6675 DI_NORMAL);
6676 }
6677 else
6678 {
6679 /* @@@PH 1999/06/08 not ported yet, just don't draw any icon
6680 WND *wndPtr = WIN_FindWndPtr(hwnd);
6681 HICON hAppIcon = 0;
6682
6683 if (wndPtr->class->hIconSm)
6684 hAppIcon = wndPtr->class->hIconSm;
6685 else
6686 if (wndPtr->class->hIcon)
6687 hAppIcon = wndPtr->class->hIcon;
6688
6689 DrawIconEx (hdc,
6690 pt.x,
6691 pt.y,
6692 hAppIcon,
6693 GetSystemMetrics(SM_CXSMICON),
6694 GetSystemMetrics(SM_CYSMICON),
6695 0,
6696 0,
6697 DI_NORMAL);
6698
6699 WIN_ReleaseWndPtr(wndPtr);
6700 */
6701 }
6702
6703 rc.left += (rc.bottom - rc.top);
6704 }
6705
6706 /* drawing text */
6707 if (uFlags & DC_TEXT)
6708 {
6709 HFONT hOldFont;
6710
6711 if (uFlags & DC_INBUTTON)
6712 O32_SetTextColor (hdc,
6713 O32_GetSysColor (COLOR_BTNTEXT));
6714 else
6715 if (uFlags & DC_ACTIVE)
6716 O32_SetTextColor (hdc,
6717 O32_GetSysColor (COLOR_CAPTIONTEXT));
6718 else
6719 O32_SetTextColor (hdc,
6720 O32_GetSysColor (COLOR_INACTIVECAPTIONTEXT));
6721
6722 O32_SetBkMode (hdc,
6723 TRANSPARENT);
6724
6725 if (hFont)
6726 hOldFont = O32_SelectObject (hdc,
6727 hFont);
6728 else
6729 {
6730 NONCLIENTMETRICSA nclm;
6731 HFONT hNewFont;
6732
6733 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
6734 O32_SystemParametersInfo (SPI_GETNONCLIENTMETRICS,
6735 0,
6736 &nclm,
6737 0);
6738 hNewFont = O32_CreateFontIndirect ((uFlags & DC_SMALLCAP) ?
6739 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
6740 hOldFont = O32_SelectObject (hdc,
6741 hNewFont);
6742 }
6743
6744 if (str)
6745 O32_DrawText (hdc,
6746 str,
6747 -1,
6748 &rc,
6749 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
6750 else
6751 {
6752 CHAR szText[128];
6753 INT nLen;
6754
6755 nLen = O32_GetWindowText (hwnd,
6756 szText,
6757 128);
6758
6759 O32_DrawText (hdc,
6760 szText,
6761 nLen,
6762 &rc,
6763 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
6764 }
6765
6766 if (hFont)
6767 O32_SelectObject (hdc,
6768 hOldFont);
6769 else
6770 O32_DeleteObject (O32_SelectObject (hdc,
6771 hOldFont));
6772 }
6773
6774 /* drawing focus ??? */
6775 if (uFlags & 0x2000)
6776 {
6777 dprintf(("USER32: DrawCaptionTempA undocumented flag (0x2000)!\n"));
6778 }
6779
6780 return 0;
6781}
6782
6783
6784/***********************************************************************
6785 * DrawCaptionTemp32W [USER32.602]
6786 *
6787 * PARAMS
6788 *
6789 * RETURNS
6790 * Success:
6791 * Failure:
6792 */
6793
6794BOOL WIN32API DrawCaptionTempW (HWND hwnd,
6795 HDC hdc,
6796 const RECT *rect,
6797 HFONT hFont,
6798 HICON hIcon,
6799 LPCWSTR str,
6800 UINT uFlags)
6801{
6802 LPSTR strAscii = UnicodeToAsciiString((LPWSTR)str);
6803
6804 BOOL res = DrawCaptionTempA (hwnd,
6805 hdc,
6806 rect,
6807 hFont,
6808 hIcon,
6809 strAscii,
6810 uFlags);
6811
6812 FreeAsciiString(strAscii);
6813
6814 return res;
6815}
Note: See TracBrowser for help on using the repository browser.