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

Last change on this file since 161 was 161, checked in by achimha, 26 years ago

Incorporated complete DrawFrameControl code from WINE - should be fully functionaluitools.cpp
File size: 235.1 KB
Line 
1/* $Id: user32.cpp,v 1.14 1999-06-23 16:36:56 achimha 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 //SvL: Not necessary anymore (EB's fixes)
562// dwStyle |= WS_CLIPCHILDREN;
563
564 //SvL: Correct window style (like Wine does)
565 if(dwStyle & WS_CHILD) {
566 dwStyle |= WS_CLIPSIBLINGS;
567 if(!(dwStyle & WS_POPUP)) {
568 dwStyle |= WS_CAPTION;
569 }
570 }
571 if(dwExStyle & WS_EX_DLGMODALFRAME)
572 {
573 dwStyle &= ~WS_THICKFRAME;
574 }
575
576#ifdef DEBUG
577 WriteLog("USER32: CreateWindow: dwExStyle = %X\n", dwExStyle);
578 if((int)arg2 >> 16 != 0)
579 WriteLog("USER32: CreateWindow: classname = %s\n", arg2);
580 else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
581 WriteLog("USER32: CreateWindow: windowname= %s\n", arg3);
582 WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
583 WriteLog("USER32: CreateWindow: x = %d\n", x);
584 WriteLog("USER32: CreateWindow: y = %d\n", y);
585 WriteLog("USER32: CreateWindow: nWidth = %d\n", nWidth);
586 WriteLog("USER32: CreateWindow: nHeight = %d\n", nHeight);
587 WriteLog("USER32: CreateWindow: parent = %X\n", parent);
588 WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
589 WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
590 WriteLog("USER32: CreateWindow: param = %X\n", arg12);
591 #endif
592
593 if((int) arg2 >> 16 != 0 && strcmp(arg2, "COMBOBOX") == 0)
594 {
595 dprintf(("COMBOBOX creation"));
596 //TODO: #%@#%$ Open32 doesn't support this
597 dwStyle &= ~(CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE);
598
599 /* @@@PH 98/06/12 drop down combos are problematic too */
600 /* so we translate the styles to OS/2 style */
601 dwStyle |= CBS_DROPDOWN | CBS_DROPDOWNLIST;
602 }
603
604 //Classname might be name of system class, in which case we don't
605 //need to use our own callback
606// if(Win32WindowClass::FindClass((LPSTR)arg2) != NULL) {
607 window = new Win32WindowProc(arg11, arg2);
608// }
609
610 hwnd = O32_CreateWindowEx(dwExStyle,
611 arg2,
612 arg3,
613 dwStyle,
614 x,
615 y,
616 nWidth,
617 nHeight,
618 parent,
619 arg10,
620 arg11,
621 arg12);
622
623 //SvL: 16-11-'97: window can be already destroyed if hwnd == 0
624 if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
625 delete(window);
626 window = 0;
627 }
628 if(window) {
629 window->SetWindowHandle(hwnd);
630 }
631
632 dprintf(("USER32: ************CreateWindowExA %s (%d,%d,%d,%d), hwnd = %X\n", arg2, x, y, nWidth, nHeight, hwnd));
633 return(hwnd);
634}
635//******************************************************************************
636//******************************************************************************
637LRESULT WIN32API SendMessageA(HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
638{
639 LRESULT rc;
640
641#ifdef DEBUG
642 WriteLog("USER32: SendMessage....\n");
643#endif
644 rc = O32_SendMessage(arg1, arg2, arg3, arg4);
645#ifdef DEBUG
646 WriteLog("USER32: *****SendMessage %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
647#endif
648 return(rc);
649}
650//******************************************************************************
651//******************************************************************************
652HWND WIN32API SetActiveWindow( HWND arg1)
653{
654#ifdef DEBUG
655 WriteLog("USER32: SetActiveWindow\n");
656#endif
657 return O32_SetActiveWindow(arg1);
658}
659//******************************************************************************
660//******************************************************************************
661HDC WIN32API BeginPaint(HWND arg1, PPAINTSTRUCT arg2)
662{
663 dprintf(("USER32: BeginPaint %X\n", arg2));
664 return O32_BeginPaint(arg1, arg2);
665}
666//******************************************************************************
667//******************************************************************************
668BOOL WIN32API IsDialogMessageA( HWND arg1, LPMSG arg2)
669{
670#ifdef DEBUG
671//// WriteLog("USER32: IsDialogMessage\n");
672#endif
673 return O32_IsDialogMessage(arg1, arg2);
674}
675//******************************************************************************
676//******************************************************************************
677int WIN32API DrawTextA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5)
678{
679#ifdef DEBUG
680 WriteLog("USER32: DrawTextA %s", arg2);
681#endif
682 return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
683}
684//******************************************************************************
685//******************************************************************************
686int WIN32API DrawTextExA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
687{
688#ifdef DEBUG
689 WriteLog("USER32: DrawTextExA (not completely implemented) %s", arg2);
690#endif
691 return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
692}
693//******************************************************************************
694//******************************************************************************
695int WIN32API GetSystemMetrics(int arg1)
696{
697 int rc;
698
699 switch(arg1) {
700 case SM_CXICONSPACING: //TODO: size of grid cell for large icons
701 rc = O32_GetSystemMetrics(SM_CXICON);
702 break;
703 case SM_CYICONSPACING:
704 rc = O32_GetSystemMetrics(SM_CYICON);
705 break;
706 case SM_PENWINDOWS:
707 rc = FALSE;
708 break;
709 case SM_DBCSENABLED:
710 rc = FALSE;
711 break;
712 case SM_CXEDGE: //size of 3D window edge (not supported)
713 rc = 1;
714 break;
715 case SM_CYEDGE:
716 rc = 1;
717 break;
718 case SM_CXMINSPACING: //can be SM_CXMINIMIZED or larger
719 rc = O32_GetSystemMetrics(SM_CXMINIMIZED);
720 break;
721 case SM_CYMINSPACING:
722 rc = GetSystemMetrics(SM_CYMINIMIZED);
723 break;
724 case SM_CXSMICON: //recommended size of small icons (TODO: adjust to screen res.)
725 rc = 16;
726 break;
727 case SM_CYSMICON:
728 rc = 16;
729 break;
730 case SM_CYSMCAPTION: //size in pixels of a small caption (TODO: ????)
731 rc = 8;
732 break;
733 case SM_CXSMSIZE: //size of small caption buttons (pixels) (TODO: implement properly)
734 rc = 16;
735 break;
736 case SM_CYSMSIZE:
737 rc = 16;
738 break;
739 case SM_CXMENUSIZE: //TODO: size of menu bar buttons (such as MDI window close)
740 rc = 16;
741 break;
742 case SM_CYMENUSIZE:
743 rc = 16;
744 break;
745 case SM_ARRANGE:
746 rc = ARW_BOTTOMLEFT | ARW_LEFT;
747 break;
748 case SM_CXMINIMIZED:
749 break;
750 case SM_CYMINIMIZED:
751 break;
752 case SM_CXMAXTRACK: //max window size
753 case SM_CXMAXIMIZED: //max toplevel window size
754 rc = O32_GetSystemMetrics(SM_CXSCREEN);
755 break;
756 case SM_CYMAXTRACK:
757 case SM_CYMAXIMIZED:
758 rc = O32_GetSystemMetrics(SM_CYSCREEN);
759 break;
760 case SM_NETWORK:
761 rc = 0x01; //TODO: default = yes
762 break;
763 case SM_CLEANBOOT:
764 rc = 0; //normal boot
765 break;
766 case SM_CXDRAG: //nr of pixels before drag becomes a real one
767 rc = 2;
768 break;
769 case SM_CYDRAG:
770 rc = 2;
771 break;
772 case SM_SHOWSOUNDS: //show instead of play sound
773 rc = FALSE;
774 break;
775 case SM_CXMENUCHECK:
776 rc = 4; //TODO
777 break;
778 case SM_CYMENUCHECK:
779 rc = O32_GetSystemMetrics(SM_CYMENU);
780 break;
781 case SM_SLOWMACHINE:
782 rc = FALSE; //even a slow machine is fast with OS/2 :)
783 break;
784 case SM_MIDEASTENABLED:
785 rc = FALSE;
786 break;
787 case SM_CMETRICS:
788 rc = O32_GetSystemMetrics(44); //Open32 changed this one
789 break;
790 default:
791 rc = O32_GetSystemMetrics(arg1);
792 break;
793 }
794#ifdef DEBUG
795 WriteLog("USER32: GetSystemMetrics %d returned %d\n", arg1, rc);
796#endif
797 return(rc);
798}
799//******************************************************************************
800//******************************************************************************
801UINT WIN32API SetTimer( HWND arg1, UINT arg2, UINT arg3, TIMERPROC arg4)
802{
803#ifdef DEBUG
804 WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
805#endif
806 //SvL: Write callback handler class for this one
807 return O32_SetTimer(arg1, arg2, arg3, (TIMERPROC_O32)arg4);
808}
809//******************************************************************************
810//******************************************************************************
811BOOL WIN32API KillTimer(HWND arg1, UINT arg2)
812{
813#ifdef DEBUG
814 WriteLog("USER32: KillTimer\n");
815#endif
816 return O32_KillTimer(arg1, arg2);
817}
818//******************************************************************************
819//******************************************************************************
820BOOL WIN32API DestroyWindow(HWND arg1)
821{
822#ifdef DEBUG
823 WriteLog("USER32: DestroyWindow\n");
824#endif
825 return O32_DestroyWindow(arg1);
826}
827//******************************************************************************
828//******************************************************************************
829BOOL WIN32API PostMessageA( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
830{
831#ifdef DEBUG
832 WriteLog("USER32: PostMessageA %X %X %X %X\n", arg1, arg2, arg3, arg4);
833#endif
834 return O32_PostMessage(arg1, arg2, arg3, arg4);
835}
836//******************************************************************************
837//******************************************************************************
838BOOL WIN32API InflateRect( PRECT arg1, int arg2, int arg3)
839{
840#ifdef DEBUG
841 WriteLog("USER32: InflateRect\n");
842#endif
843 return O32_InflateRect(arg1, arg2, arg3);
844}
845//******************************************************************************
846//TODO:How can we emulate this one in OS/2???
847//******************************************************************************
848DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
849{
850#ifdef DEBUG
851 WriteLog("USER32: WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
852#endif
853
854 if(dwTimeOut == INFINITE) return(0);
855
856// DosSleep(dwTimeOut/16);
857 return(0);
858}
859//******************************************************************************
860//******************************************************************************
861UINT WIN32API GetDlgItemTextA(HWND arg1, int arg2, LPSTR arg3, UINT arg4)
862{
863 UINT rc;
864
865 rc = O32_GetDlgItemText(arg1, arg2, arg3, arg4);
866#ifdef DEBUG
867 if(rc)
868 WriteLog("USER32: GetDlgItemTextA returned %s\n", arg3);
869 else WriteLog("USER32: GetDlgItemTextA returned 0 (%d)\n", GetLastError());
870#endif
871 return(rc);
872}
873//******************************************************************************
874//******************************************************************************
875BOOL WIN32API PeekMessageA(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
876{
877#ifdef DEBUG
878// WriteLog("USER32: PeekMessage\n");
879#endif
880 return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
881}
882//******************************************************************************
883//******************************************************************************
884int WIN32API ShowCursor( BOOL arg1)
885{
886#ifdef DEBUG
887 WriteLog("USER32: ShowCursor\n");
888#endif
889 return O32_ShowCursor(arg1);
890}
891//******************************************************************************
892//BUGBUG: UpdateWindow sends a WM_ERASEBKGRND when it shouldn't!
893// So we just do it manually
894//******************************************************************************
895BOOL WIN32API UpdateWindow(HWND hwnd)
896{
897 RECT rect;
898
899#ifdef DEBUG
900 WriteLog("USER32: UpdateWindow\n");
901#endif
902
903#if 0 // EB: ->>> doesn't work. No correct update of Winhlp32 scrolling area.
904 if(O32_GetUpdateRect(hwnd, &rect, FALSE) != FALSE) {//update region empty?
905 WndCallback(hwnd, WM_PAINT, 0, 0);
906// O32_PostMessage(hwnd, WM_PAINT, 0, 0);
907 }
908#ifdef DEBUG
909 else WriteLog("USER32: Update region empty!\n");
910#endif
911 return(TRUE);
912#endif
913
914 return O32_UpdateWindow(hwnd);
915}
916//******************************************************************************
917//******************************************************************************
918BOOL WIN32API AdjustWindowRect( PRECT arg1, DWORD arg2, BOOL arg3)
919{
920#ifdef DEBUG
921 WriteLog("USER32: AdjustWindowRect\n");
922#endif
923 return O32_AdjustWindowRect(arg1, arg2, arg3);
924}
925//******************************************************************************
926//******************************************************************************
927BOOL WIN32API AdjustWindowRectEx( PRECT arg1, DWORD arg2, BOOL arg3, DWORD arg4)
928{
929#ifdef DEBUG
930 WriteLog("USER32: AdjustWindowRectEx\n");
931#endif
932 return O32_AdjustWindowRectEx(arg1, arg2, arg3, arg4);
933}
934//******************************************************************************
935//******************************************************************************
936BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
937{
938#ifdef DEBUG
939//// WriteLog("USER32: ClientToScreen\n");
940#endif
941 return O32_ClientToScreen(arg1, arg2);
942}
943//******************************************************************************
944//******************************************************************************
945BOOL WIN32API SetRect( PRECT arg1, int arg2, int arg3, int arg4, int arg5)
946{
947#ifdef DEBUG
948 WriteLog("USER32: SetRect\n");
949#endif
950 return O32_SetRect(arg1, arg2, arg3, arg4, arg5);
951}
952//******************************************************************************
953//******************************************************************************
954LONG WIN32API GetWindowLongA(HWND hwnd, int nIndex)
955{
956 LONG rc;
957
958 if(nIndex == GWL_WNDPROC || nIndex == DWL_DLGPROC) {
959#ifdef DEBUG
960 WriteLog("USER32: GetWindowLong %X %d\n", hwnd, nIndex);
961#endif
962 Win32WindowProc *window = Win32WindowProc::FindProc(hwnd);
963 if(window && !(nIndex == DWL_DLGPROC && window->IsWindow() == TRUE)) {
964 return (LONG)window->GetWin32Callback();
965 }
966 }
967 rc = O32_GetWindowLong(hwnd, nIndex);
968 return(rc);
969}
970//******************************************************************************
971//******************************************************************************
972BOOL WIN32API SetDlgItemInt( HWND arg1, int arg2, UINT arg3, BOOL arg4)
973{
974#ifdef DEBUG
975 WriteLog("USER32: SetDlgItemInt\n");
976#endif
977 return O32_SetDlgItemInt(arg1, arg2, arg3, arg4);
978}
979//******************************************************************************
980//******************************************************************************
981BOOL WIN32API SetDlgItemTextA( HWND arg1, int arg2, LPCSTR arg3)
982{
983#ifdef DEBUG
984 WriteLog("USER32: SetDlgItemText to %s\n", arg3);
985#endif
986 return O32_SetDlgItemText(arg1, arg2, arg3);
987}
988//******************************************************************************
989//******************************************************************************
990BOOL WIN32API WinHelpA( HWND arg1, LPCSTR arg2, UINT arg3, DWORD arg4)
991{
992#ifdef DEBUG
993 WriteLog("USER32: WinHelp not implemented %s\n", arg2);
994#endif
995// return O32_WinHelp(arg1, arg2, arg3, arg4);
996 return(TRUE);
997}
998//******************************************************************************
999//******************************************************************************
1000BOOL WIN32API IsIconic( HWND arg1)
1001{
1002#ifdef DEBUG
1003 WriteLog("USER32: IsIconic\n");
1004#endif
1005 return O32_IsIconic(arg1);
1006}
1007//******************************************************************************
1008//******************************************************************************
1009int WIN32API TranslateAcceleratorA(HWND arg1, HACCEL arg2, LPMSG arg3)
1010{
1011#ifdef DEBUG
1012//// WriteLog("USER32: TranslateAccelerator\n");
1013#endif
1014 return O32_TranslateAccelerator(arg1, arg2, arg3);
1015}
1016//******************************************************************************
1017//******************************************************************************
1018HWND WIN32API GetWindow(HWND arg1, UINT arg2)
1019{
1020 HWND rc;
1021
1022 rc = O32_GetWindow(arg1, arg2);
1023#ifdef DEBUG
1024 WriteLog("USER32: GetWindow %X %d returned %d\n", arg1, arg2, rc);
1025#endif
1026 return(rc);
1027}
1028//******************************************************************************
1029//******************************************************************************
1030HDC WIN32API GetWindowDC(HWND arg1)
1031{
1032#ifdef DEBUG
1033 WriteLog("USER32: GetWindowDC\n");
1034#endif
1035 return O32_GetWindowDC(arg1);
1036}
1037//******************************************************************************
1038//******************************************************************************
1039BOOL WIN32API SubtractRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
1040{
1041#ifdef DEBUG
1042 WriteLog("USER32: SubtractRect");
1043#endif
1044 return O32_SubtractRect(arg1, arg2, arg3);
1045}
1046//******************************************************************************
1047//SvL: 24-6-'97 - Added
1048//******************************************************************************
1049BOOL WIN32API ClipCursor(const RECT * arg1)
1050{
1051#ifdef DEBUG
1052 WriteLog("USER32: ClipCursor\n");
1053#endif
1054 return O32_ClipCursor(arg1);
1055}
1056//******************************************************************************
1057//SvL: 24-6-'97 - Added
1058//TODO: Not implemented
1059//******************************************************************************
1060WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1061{
1062#ifdef DEBUG
1063//// WriteLog("USER32: GetAsyncKeyState Not implemented\n");
1064#endif
1065 return 0;
1066}
1067//******************************************************************************
1068//SvL: 24-6-'97 - Added
1069//******************************************************************************
1070HCURSOR WIN32API GetCursor(void)
1071{
1072#ifdef DEBUG
1073//// WriteLog("USER32: GetCursor\n");
1074#endif
1075 return O32_GetCursor();
1076}
1077//******************************************************************************
1078//SvL: 24-6-'97 - Added
1079//******************************************************************************
1080BOOL WIN32API GetCursorPos( PPOINT arg1)
1081{
1082#ifdef DEBUG
1083//// WriteLog("USER32: GetCursorPos\n");
1084#endif
1085 return O32_GetCursorPos(arg1);
1086}
1087//******************************************************************************
1088//SvL: 24-6-'97 - Added
1089//******************************************************************************
1090UINT WIN32API RegisterWindowMessageA(LPCSTR arg1)
1091{
1092 UINT rc;
1093
1094 rc = O32_RegisterWindowMessage(arg1);
1095#ifdef DEBUG
1096 WriteLog("USER32: RegisterWindowMessageA %s returned %X\n", arg1, rc);
1097#endif
1098 return(rc);
1099}
1100//******************************************************************************
1101//SvL: 24-6-'97 - Added
1102//******************************************************************************
1103WORD WIN32API VkKeyScanA( char arg1)
1104{
1105#ifdef DEBUG
1106 WriteLog("USER32: VkKeyScanA\n");
1107#endif
1108 return O32_VkKeyScan(arg1);
1109}
1110//******************************************************************************
1111//SvL: 24-6-'97 - Added
1112//******************************************************************************
1113SHORT WIN32API GetKeyState( int arg1)
1114{
1115#ifdef DEBUG
1116 WriteLog("USER32: GetKeyState %d\n", arg1);
1117#endif
1118 return O32_GetKeyState(arg1);
1119}
1120//******************************************************************************
1121//******************************************************************************
1122HCURSOR WIN32API SetCursor( HCURSOR arg1)
1123{
1124#ifdef DEBUG
1125 WriteLog("USER32: SetCursor\n");
1126#endif
1127 return O32_SetCursor(arg1);
1128}
1129//******************************************************************************
1130//******************************************************************************
1131BOOL WIN32API SetCursorPos( int arg1, int arg2)
1132{
1133#ifdef DEBUG
1134 WriteLog("USER32: SetCursorPos\n");
1135#endif
1136 return O32_SetCursorPos(arg1, arg2);
1137}
1138//******************************************************************************
1139//******************************************************************************
1140BOOL WIN32API EnableScrollBar( HWND arg1, INT arg2, UINT arg3)
1141{
1142#ifdef DEBUG
1143 WriteLog("USER32: EnableScrollBar\n");
1144#endif
1145 return O32_EnableScrollBar(arg1, arg2, arg3);
1146}
1147//******************************************************************************
1148//******************************************************************************
1149BOOL WIN32API EnableWindow( HWND arg1, BOOL arg2)
1150{
1151#ifdef DEBUG
1152 WriteLog("USER32: EnableWindow\n");
1153#endif
1154 return O32_EnableWindow(arg1, arg2);
1155}
1156//******************************************************************************
1157//******************************************************************************
1158HWND WIN32API SetCapture( HWND arg1)
1159{
1160#ifdef DEBUG
1161 WriteLog("USER32: SetCapture\n");
1162#endif
1163 return O32_SetCapture(arg1);
1164}
1165//******************************************************************************
1166//******************************************************************************
1167BOOL WIN32API ReleaseCapture(void)
1168{
1169#ifdef DEBUG
1170 WriteLog("USER32: ReleaseCapture\n");
1171#endif
1172 return O32_ReleaseCapture();
1173}
1174//******************************************************************************
1175//******************************************************************************
1176DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD arg5)
1177{
1178#ifdef DEBUG
1179 WriteLog("USER32: MsgWaitForMultipleObjects\n");
1180#endif
1181 return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
1182}
1183//******************************************************************************
1184//******************************************************************************
1185HDWP WIN32API BeginDeferWindowPos( int arg1)
1186{
1187#ifdef DEBUG
1188 WriteLog("USER32: BeginDeferWindowPos\n");
1189#endif
1190 return O32_BeginDeferWindowPos(arg1);
1191}
1192//******************************************************************************
1193//******************************************************************************
1194BOOL WIN32API BringWindowToTop( HWND arg1)
1195{
1196#ifdef DEBUG
1197 WriteLog("USER32: BringWindowToTop\n");
1198#endif
1199 return O32_BringWindowToTop(arg1);
1200}
1201//******************************************************************************
1202//******************************************************************************
1203BOOL WIN32API CallMsgFilterA( LPMSG arg1, int arg2)
1204{
1205#ifdef DEBUG
1206 WriteLog("USER32: CallMsgFilterA\n");
1207#endif
1208 return O32_CallMsgFilter(arg1, arg2);
1209}
1210//******************************************************************************
1211//******************************************************************************
1212BOOL WIN32API CallMsgFilterW( LPMSG arg1, int arg2)
1213{
1214#ifdef DEBUG
1215 WriteLog("USER32: CallMsgFilterW\n");
1216#endif
1217 // NOTE: This will not work as is (needs UNICODE support)
1218 return O32_CallMsgFilter(arg1, arg2);
1219}
1220//******************************************************************************
1221//******************************************************************************
1222LRESULT WIN32API CallWindowProcA(WNDPROC wndprcPrev,
1223 HWND arg2,
1224 UINT arg3,
1225 WPARAM arg4,
1226 LPARAM arg5)
1227{
1228#ifdef DEBUG
1229//// WriteLog("USER32: CallWindowProcA %X hwnd=%X, msg = %X\n", wndprcPrev, arg2, arg3);
1230#endif
1231
1232 if(Win32WindowSubProc::FindSubProc((WNDPROC_O32)wndprcPrev) != NULL) {
1233 WNDPROC_O32 orgprc = (WNDPROC_O32)wndprcPrev; //is original Open32 system class callback (_System)
1234 return orgprc(arg2, arg3, arg4, arg5);
1235 }
1236 else return wndprcPrev(arg2, arg3, arg4, arg5); //win32 callback (__stdcall)
1237}
1238//******************************************************************************
1239//******************************************************************************
1240LRESULT WIN32API CallWindowProcW(WNDPROC arg1,
1241 HWND arg2,
1242 UINT arg3,
1243 WPARAM arg4,
1244 LPARAM arg5)
1245{
1246 dprintf(("USER32: CallWindowProcW(%08xh,%08xh,%08xh,%08xh,%08xh) not properly implemented.\n",
1247 arg1,
1248 arg2,
1249 arg3,
1250 arg4,
1251 arg5));
1252
1253 return CallWindowProcA(arg1,
1254 arg2,
1255 arg3,
1256 arg4,
1257 arg5);
1258}
1259//******************************************************************************
1260//******************************************************************************
1261BOOL WIN32API ChangeClipboardChain( HWND arg1, HWND arg2)
1262{
1263#ifdef DEBUG
1264 WriteLog("USER32: ChangeClipboardChain\n");
1265#endif
1266 return O32_ChangeClipboardChain(arg1, arg2);
1267}
1268//******************************************************************************
1269//******************************************************************************
1270UINT WIN32API ArrangeIconicWindows( HWND arg1)
1271{
1272#ifdef DEBUG
1273 WriteLog("USER32: ArrangeIconicWindows\n");
1274#endif
1275 return O32_ArrangeIconicWindows(arg1);
1276}
1277//******************************************************************************
1278// Not implemented by Open32 (5-31-99 Christoph Bratschi)
1279//******************************************************************************
1280BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT arg4)
1281{
1282#ifdef DEBUG
1283 WriteLog("USER32: CheckRadioButton\n");
1284#endif
1285// return O32_CheckRadioButton(arg1, arg2, arg3, arg4);
1286 if (arg2 > arg3) return (FALSE);
1287 for (UINT x=arg2;x <= arg3;x++)
1288 {
1289 SendDlgItemMessageA(arg1,x,BM_SETCHECK,(x == arg4) ? BST_CHECKED : BST_UNCHECKED,0);
1290 }
1291 return (TRUE);
1292}
1293//******************************************************************************
1294//******************************************************************************
1295HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
1296{
1297#ifdef DEBUG
1298 WriteLog("USER32: ChildWindowFromPoint\n");
1299#endif
1300 return O32_ChildWindowFromPoint(arg1, arg2);
1301}
1302//******************************************************************************
1303//******************************************************************************
1304HWND WIN32API ChildWindowFromPointEx(HWND arg1, POINT arg2, UINT uFlags)
1305{
1306#ifdef DEBUG
1307 WriteLog("USER32: ChildWindowFromPointEx, not completely supported!\n");
1308#endif
1309 return O32_ChildWindowFromPoint(arg1, arg2);
1310}
1311//******************************************************************************
1312//******************************************************************************
1313BOOL WIN32API CloseClipboard(void)
1314{
1315#ifdef DEBUG
1316 WriteLog("USER32: CloseClipboard\n");
1317#endif
1318 return O32_CloseClipboard();
1319}
1320//******************************************************************************
1321//******************************************************************************
1322BOOL WIN32API CloseWindow( HWND arg1)
1323{
1324#ifdef DEBUG
1325 WriteLog("USER32: CloseWindow\n");
1326#endif
1327 return O32_CloseWindow(arg1);
1328}
1329//******************************************************************************
1330//******************************************************************************
1331HICON WIN32API CopyIcon( HICON arg1)
1332{
1333#ifdef DEBUG
1334 WriteLog("USER32: CopyIcon\n");
1335#endif
1336 return O32_CopyIcon(arg1);
1337}
1338//******************************************************************************
1339//******************************************************************************
1340int WIN32API CountClipboardFormats(void)
1341{
1342#ifdef DEBUG
1343 WriteLog("USER32: CountClipboardFormats\n");
1344#endif
1345 return O32_CountClipboardFormats();
1346}
1347//******************************************************************************
1348//******************************************************************************
1349HACCEL WIN32API CreateAcceleratorTableA( LPACCEL arg1, int arg2)
1350{
1351#ifdef DEBUG
1352 WriteLog("USER32: CreateAcceleratorTableA\n");
1353#endif
1354 return O32_CreateAcceleratorTable(arg1, arg2);
1355}
1356//******************************************************************************
1357//******************************************************************************
1358HACCEL WIN32API CreateAcceleratorTableW( LPACCEL arg1, int arg2)
1359{
1360#ifdef DEBUG
1361 WriteLog("USER32: CreateAcceleratorTableW\n");
1362#endif
1363 // NOTE: This will not work as is (needs UNICODE support)
1364 return O32_CreateAcceleratorTable(arg1, arg2);
1365}
1366//******************************************************************************
1367//******************************************************************************
1368BOOL WIN32API CreateCaret( HWND arg1, HBITMAP arg2, int arg3, int arg4)
1369{
1370#ifdef DEBUG
1371 WriteLog("USER32: CreateCaret\n");
1372#endif
1373 return O32_CreateCaret(arg1, arg2, arg3, arg4);
1374}
1375//******************************************************************************
1376//******************************************************************************
1377HCURSOR WIN32API CreateCursor( HINSTANCE arg1, int arg2, int arg3, int arg4, int arg5, const VOID * arg6, const VOID * arg7)
1378{
1379#ifdef DEBUG
1380 WriteLog("USER32: CreateCursor\n");
1381#endif
1382 return O32_CreateCursor(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1383}
1384//******************************************************************************
1385//******************************************************************************
1386HICON WIN32API CreateIcon( HINSTANCE arg1, INT arg2, INT arg3, BYTE arg4, BYTE arg5, LPCVOID arg6, LPCVOID arg7)
1387{
1388#ifdef DEBUG
1389 WriteLog("USER32: CreateIcon\n");
1390#endif
1391 return O32_CreateIcon(arg1, arg2, arg3, arg4, arg5, (const BYTE *)arg6, (const BYTE *)arg7);
1392}
1393//******************************************************************************
1394//ASSERT dwVer == win31 (ok according to SDK docs)
1395//******************************************************************************
1396HICON WIN32API CreateIconFromResource(PBYTE presbits, UINT dwResSize,
1397 BOOL fIcon, DWORD dwVer)
1398{
1399 HICON hicon;
1400 DWORD OS2ResSize = 0;
1401 PBYTE OS2Icon = ConvertWin32Icon(presbits, dwResSize, &OS2ResSize);
1402
1403 hicon = O32_CreateIconFromResource(OS2Icon, OS2ResSize, fIcon, dwVer);
1404#ifdef DEBUG
1405 WriteLog("USER32: CreateIconFromResource returned %X (%X)\n", hicon, GetLastError());
1406#endif
1407 if(OS2Icon)
1408 FreeIcon(OS2Icon);
1409
1410 return(hicon);
1411}
1412//******************************************************************************
1413//******************************************************************************
1414HICON WIN32API CreateIconFromResourceEx(PBYTE presbits, UINT dwResSize,
1415 BOOL fIcon, DWORD dwVer,
1416 int cxDesired, int cyDesired,
1417 UINT Flags)
1418{
1419#ifdef DEBUG
1420 WriteLog("USER32: CreateIconFromResourceEx %X %d %d %X %d %d %X, not completely supported!\n", presbits, dwResSize, fIcon, dwVer, cxDesired, cyDesired, Flags);
1421#endif
1422 return CreateIconFromResource(presbits, dwResSize, fIcon, dwVer);
1423}
1424//******************************************************************************
1425//******************************************************************************
1426HICON WIN32API CreateIconIndirect(LPICONINFO arg1)
1427{
1428#ifdef DEBUG
1429 WriteLog("USER32: CreateIconIndirect\n");
1430#endif
1431 return O32_CreateIconIndirect(arg1);
1432}
1433//******************************************************************************
1434//******************************************************************************
1435HWND WIN32API CreateMDIWindowA(LPCSTR arg1, LPCSTR arg2, DWORD arg3,
1436 int arg4, int arg5, int arg6, int arg7,
1437 HWND arg8, HINSTANCE arg9, LPARAM arg10)
1438{
1439 HWND hwnd;
1440
1441#ifdef DEBUG
1442 WriteLog("USER32: CreateMDIWindowA\n");
1443#endif
1444 Win32WindowProc *window = new Win32WindowProc(arg9, arg1);
1445 hwnd = O32_CreateMDIWindow((LPSTR)arg1, (LPSTR)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1446 //SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1447 if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1448 delete(window);
1449 window = 0;
1450 }
1451
1452#ifdef DEBUG
1453 WriteLog("USER32: CreateMDIWindowA returned %X\n", hwnd);
1454#endif
1455 return hwnd;
1456}
1457//******************************************************************************
1458//******************************************************************************
1459HWND WIN32API CreateMDIWindowW(LPCWSTR arg1, LPCWSTR arg2, DWORD arg3, int arg4,
1460 int arg5, int arg6, int arg7, HWND arg8, HINSTANCE arg9,
1461 LPARAM arg10)
1462{
1463 HWND hwnd;
1464 char *astring1 = NULL, *astring2 = NULL;
1465 Win32WindowProc *window = NULL;
1466
1467 if((int)arg1 >> 16 != 0) {
1468 astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1469 }
1470 else astring1 = (char *)arg2;
1471
1472 astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1473
1474 //Classname might be name of system class, in which case we don't
1475 //need to use our own callback
1476// if(Win32WindowClass::FindClass((LPSTR)astring1) != NULL) {
1477 window = new Win32WindowProc(arg9, astring1);
1478// }
1479 hwnd = O32_CreateMDIWindow(astring1, astring2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1480 //SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1481 if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1482 delete(window);
1483 window = 0;
1484 }
1485 if(window) {
1486 window->SetWindowHandle(hwnd);
1487 }
1488
1489 if(astring1) FreeAsciiString(astring1);
1490 FreeAsciiString(astring2);
1491#ifdef DEBUG
1492 WriteLog("USER32: CreateMDIWindowW hwnd = %X\n", hwnd);
1493#endif
1494 return(hwnd);
1495}
1496//******************************************************************************
1497//******************************************************************************
1498HWND WIN32API CreateWindowExW(DWORD arg1,
1499 LPCWSTR arg2,
1500 LPCWSTR arg3,
1501 DWORD dwStyle,
1502 int arg5,
1503 int arg6,
1504 int arg7,
1505 int arg8,
1506 HWND arg9,
1507 HMENU arg10,
1508 HINSTANCE arg11,
1509 PVOID arg12)
1510{
1511 HWND hwnd;
1512 char *astring1 = NULL,
1513 *astring2 = NULL;
1514 Win32WindowProc *window = NULL;
1515
1516 /* @@@PH 98/06/21 changed to call OS2CreateWindowExA */
1517 if((int)arg2 >> 16 != 0)
1518 astring1 = UnicodeToAsciiString((LPWSTR)arg2);
1519 else
1520 astring1 = (char *)arg2;
1521
1522 astring2 = UnicodeToAsciiString((LPWSTR)arg3);
1523
1524#ifdef DEBUG
1525 WriteLog("USER32: CreateWindowExW: dwExStyle = %X\n", arg1);
1526 if((int)arg2 >> 16 != 0)
1527 WriteLog("USER32: CreateWindow: classname = %s\n", astring1);
1528 else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
1529 WriteLog("USER32: CreateWindow: windowname= %s\n", astring2);
1530 WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
1531 WriteLog("USER32: CreateWindow: x = %d\n", arg5);
1532 WriteLog("USER32: CreateWindow: y = %d\n", arg6);
1533 WriteLog("USER32: CreateWindow: nWidth = %d\n", arg7);
1534 WriteLog("USER32: CreateWindow: nHeight = %d\n", arg8);
1535 WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
1536 WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
1537 WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
1538 WriteLog("USER32: CreateWindow: param = %X\n", arg12);
1539 #endif
1540
1541 hwnd = CreateWindowExA(arg1,
1542 astring1,
1543 astring2,
1544 dwStyle,
1545 arg5,
1546 arg6,
1547 arg7,
1548 arg8,
1549 arg9,
1550 arg10,
1551 arg11,
1552 arg12);
1553
1554 if(astring1)
1555 FreeAsciiString(astring1);
1556
1557 FreeAsciiString(astring2);
1558
1559#ifdef DEBUG
1560 WriteLog("USER32: ************CreateWindowExW hwnd = %X (%X)\n", hwnd, GetLastError());
1561#endif
1562 return(hwnd);
1563}
1564//******************************************************************************
1565//******************************************************************************
1566HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
1567{
1568#ifdef DEBUG
1569 WriteLog("USER32: DeferWindowPos\n");
1570#endif
1571 return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1572}
1573//******************************************************************************
1574//******************************************************************************
1575BOOL WIN32API DestroyAcceleratorTable( HACCEL arg1)
1576{
1577#ifdef DEBUG
1578 WriteLog("USER32: DestroyAcceleratorTable\n");
1579#endif
1580 return O32_DestroyAcceleratorTable(arg1);
1581}
1582//******************************************************************************
1583//******************************************************************************
1584BOOL WIN32API DestroyCaret(void)
1585{
1586#ifdef DEBUG
1587 WriteLog("USER32: DestroyCaret\n");
1588#endif
1589 return O32_DestroyCaret();
1590}
1591//******************************************************************************
1592//******************************************************************************
1593BOOL WIN32API DestroyCursor( HCURSOR arg1)
1594{
1595#ifdef DEBUG
1596 WriteLog("USER32: DestroyCursor\n");
1597#endif
1598 return O32_DestroyCursor(arg1);
1599}
1600//******************************************************************************
1601//******************************************************************************
1602BOOL WIN32API DestroyIcon( HICON arg1)
1603{
1604#ifdef DEBUG
1605 WriteLog("USER32: DestroyIcon\n");
1606#endif
1607 return O32_DestroyIcon(arg1);
1608}
1609//******************************************************************************
1610//******************************************************************************
1611LONG WIN32API DispatchMessageW( const MSG * arg1)
1612{
1613#ifdef DEBUG
1614 WriteLog("USER32: DispatchMessageW\n");
1615#endif
1616 // NOTE: This will not work as is (needs UNICODE support)
1617 return O32_DispatchMessage(arg1);
1618}
1619//******************************************************************************
1620//******************************************************************************
1621int WIN32API DlgDirListA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1622{
1623#ifdef DEBUG
1624 WriteLog("USER32: DlgDirListA\n");
1625#endif
1626 return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1627}
1628//******************************************************************************
1629//******************************************************************************
1630int WIN32API DlgDirListComboBoxA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1631{
1632#ifdef DEBUG
1633 WriteLog("USER32: DlgDirListComboBoxA\n");
1634#endif
1635 return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1636}
1637//******************************************************************************
1638//******************************************************************************
1639int WIN32API DlgDirListComboBoxW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1640{
1641#ifdef DEBUG
1642 WriteLog("USER32: DlgDirListComboBoxW NOT WORKING\n");
1643#endif
1644 // NOTE: This will not work as is (needs UNICODE support)
1645 return 0;
1646// return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1647}
1648//******************************************************************************
1649//******************************************************************************
1650int WIN32API DlgDirListW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1651{
1652#ifdef DEBUG
1653 WriteLog("USER32: DlgDirListW NOT WORKING\n");
1654#endif
1655 // NOTE: This will not work as is (needs UNICODE support)
1656 return 0;
1657// return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1658}
1659//******************************************************************************
1660//******************************************************************************
1661BOOL WIN32API DlgDirSelectComboBoxExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1662{
1663#ifdef DEBUG
1664 WriteLog("USER32: DlgDirSelectComboBoxExA\n");
1665#endif
1666 return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1667}
1668//******************************************************************************
1669//******************************************************************************
1670BOOL WIN32API DlgDirSelectComboBoxExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1671{
1672#ifdef DEBUG
1673 WriteLog("USER32: DlgDirSelectComboBoxExW NOT WORKING\n");
1674#endif
1675 // NOTE: This will not work as is (needs UNICODE support)
1676 return 0;
1677// return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1678}
1679//******************************************************************************
1680//******************************************************************************
1681BOOL WIN32API DlgDirSelectExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1682{
1683#ifdef DEBUG
1684 WriteLog("USER32: DlgDirSelectExA\n");
1685#endif
1686 return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1687}
1688//******************************************************************************
1689//******************************************************************************
1690BOOL WIN32API DlgDirSelectExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1691{
1692#ifdef DEBUG
1693 WriteLog("USER32: DlgDirSelectExW NOT WORKING\n");
1694#endif
1695 // NOTE: This will not work as is (needs UNICODE support)
1696 return 0;
1697// return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1698}
1699//******************************************************************************
1700//******************************************************************************
1701BOOL WIN32API DrawFocusRect( HDC arg1, const RECT * arg2)
1702{
1703#ifdef DEBUG
1704 WriteLog("USER32: DrawFocusRect\n");
1705#endif
1706 return O32_DrawFocusRect(arg1, arg2);
1707}
1708//******************************************************************************
1709//******************************************************************************
1710BOOL WIN32API DrawIcon( HDC arg1, int arg2, int arg3, HICON arg4)
1711{
1712#ifdef DEBUG
1713 WriteLog("USER32: DrawIcon\n");
1714#endif
1715 return O32_DrawIcon(arg1, arg2, arg3, arg4);
1716}
1717//******************************************************************************
1718//******************************************************************************
1719BOOL WIN32API DrawIconEx(HDC hdc, int xLeft, int xRight, HICON hIcon,
1720 int cxWidth, int cyWidth, UINT istepIfAniCur,
1721 HBRUSH hbrFlickerFreeDraw, UINT diFlags)
1722{
1723#ifdef DEBUG
1724 WriteLog("USER32: DrawIcon, partially implemented\n");
1725#endif
1726 return O32_DrawIcon(hdc, xLeft, xRight, hIcon);
1727}
1728//******************************************************************************
1729//******************************************************************************
1730BOOL WIN32API DrawMenuBar( HWND arg1)
1731{
1732#ifdef DEBUG
1733 WriteLog("USER32: DrawMenuBar\n");
1734#endif
1735 return O32_DrawMenuBar(arg1);
1736}
1737//******************************************************************************
1738//******************************************************************************
1739int WIN32API DrawTextW( HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5)
1740{
1741 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1742 int rc;
1743
1744#ifdef DEBUG
1745 WriteLog("USER32: DrawTextW %s\n", astring);
1746#endif
1747 rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1748 FreeAsciiString(astring);
1749 return(rc);
1750}
1751//******************************************************************************
1752//******************************************************************************
1753int WIN32API DrawTextExW(HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5, LPDRAWTEXTPARAMS lpDTParams)
1754{
1755 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1756 int rc;
1757
1758#ifdef DEBUG
1759 WriteLog("USER32: DrawTextExW (not completely supported) %s\n", astring);
1760#endif
1761 rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1762 FreeAsciiString(astring);
1763 return(rc);
1764}
1765//******************************************************************************
1766//******************************************************************************
1767BOOL WIN32API EmptyClipboard(void)
1768{
1769#ifdef DEBUG
1770 WriteLog("USER32: EmptyClipboard\n");
1771#endif
1772 return O32_EmptyClipboard();
1773}
1774//******************************************************************************
1775//******************************************************************************
1776BOOL WIN32API EndDeferWindowPos( HDWP arg1)
1777{
1778#ifdef DEBUG
1779 WriteLog("USER32: EndDeferWindowPos\n");
1780#endif
1781 return O32_EndDeferWindowPos(arg1);
1782}
1783//******************************************************************************
1784//******************************************************************************
1785BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1786{
1787 BOOL rc;
1788 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1789
1790#ifdef DEBUG
1791 WriteLog("USER32: EnumChildWindows\n");
1792#endif
1793 rc = O32_EnumChildWindows(hwnd, callback->GetOS2Callback(), (LPARAM)callback);
1794 if(callback)
1795 delete callback;
1796 return(rc);
1797}
1798//******************************************************************************
1799//******************************************************************************
1800UINT WIN32API EnumClipboardFormats(UINT arg1)
1801{
1802#ifdef DEBUG
1803 WriteLog("USER32: EnumClipboardFormats\n");
1804#endif
1805 return O32_EnumClipboardFormats(arg1);
1806}
1807//******************************************************************************
1808//******************************************************************************
1809int WIN32API EnumPropsA(HWND arg1, PROPENUMPROCA arg2)
1810{
1811#ifdef DEBUG
1812 WriteLog("USER32: EnumPropsA DOES NOT WORK\n");
1813#endif
1814 //calling convention problems
1815 return 0;
1816// return O32_EnumProps(arg1, (PROPENUMPROC_O32)arg2);
1817}
1818//******************************************************************************
1819//******************************************************************************
1820int WIN32API EnumPropsExA( HWND arg1, PROPENUMPROCEXA arg2, LPARAM arg3)
1821{
1822#ifdef DEBUG
1823 WriteLog("USER32: EnumPropsExA DOES NOT WORK\n");
1824#endif
1825 //calling convention problems
1826 return 0;
1827// return O32_EnumPropsEx(arg1, arg2, (PROPENUMPROCEX_O32)arg3);
1828}
1829//******************************************************************************
1830//******************************************************************************
1831int WIN32API EnumPropsExW( HWND arg1, PROPENUMPROCEXW arg2, LPARAM arg3)
1832{
1833#ifdef DEBUG
1834 WriteLog("USER32: EnumPropsExW\n");
1835#endif
1836 // NOTE: This will not work as is (needs UNICODE support)
1837 //calling convention problems
1838 return 0;
1839// return O32_EnumPropsEx(arg1, arg2, arg3);
1840}
1841//******************************************************************************
1842//******************************************************************************
1843int WIN32API EnumPropsW( HWND arg1, PROPENUMPROCW arg2)
1844{
1845#ifdef DEBUG
1846 WriteLog("USER32: EnumPropsW\n");
1847#endif
1848 // NOTE: This will not work as is (needs UNICODE support)
1849 //calling convention problems
1850 return 0;
1851// return O32_EnumProps(arg1, arg2);
1852}
1853//******************************************************************************
1854//******************************************************************************
1855BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1856{
1857 BOOL rc;
1858 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1859
1860#ifdef DEBUG
1861 WriteLog("USER32: EnumWindows\n");
1862#endif
1863 rc = O32_EnumWindows(callback->GetOS2Callback(), (LPARAM)callback);
1864 if(callback)
1865 delete callback;
1866 return(rc);
1867}
1868//******************************************************************************
1869//******************************************************************************
1870BOOL WIN32API EqualRect( const RECT * arg1, const RECT * arg2)
1871{
1872#ifdef DEBUG
1873 WriteLog("USER32: EqualRect\n");
1874#endif
1875 return O32_EqualRect(arg1, arg2);
1876}
1877//******************************************************************************
1878//******************************************************************************
1879BOOL WIN32API ExcludeUpdateRgn( HDC arg1, HWND arg2)
1880{
1881#ifdef DEBUG
1882 WriteLog("USER32: ExcludeUpdateRgn\n");
1883#endif
1884 return O32_ExcludeUpdateRgn(arg1, arg2);
1885}
1886//******************************************************************************
1887//******************************************************************************
1888BOOL WIN32API ExitWindowsEx( UINT arg1, DWORD arg2)
1889{
1890#ifdef DEBUG
1891 WriteLog("USER32: ExitWindowsEx\n");
1892#endif
1893 return O32_ExitWindowsEx(arg1, arg2);
1894}
1895//******************************************************************************
1896//******************************************************************************
1897int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
1898{
1899#ifdef DEBUG
1900 WriteLog("USER32: FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
1901#endif
1902 return O32_FillRect(arg1, arg2, arg3);
1903}
1904//******************************************************************************
1905//******************************************************************************
1906HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
1907{
1908 char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1909 char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1910 HWND rc;
1911
1912#ifdef DEBUG
1913 WriteLog("USER32: FindWindowW\n");
1914#endif
1915 rc = O32_FindWindow(astring1, astring2);
1916 FreeAsciiString(astring1);
1917 FreeAsciiString(astring2);
1918 return rc;
1919}
1920//******************************************************************************
1921//******************************************************************************
1922int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH arg3)
1923{
1924#ifdef DEBUG
1925 WriteLog("USER32: FrameRect\n");
1926#endif
1927 return O32_FrameRect(arg1, arg2, arg3);
1928}
1929//******************************************************************************
1930//******************************************************************************
1931HWND WIN32API GetCapture(void)
1932{
1933#ifdef DEBUG
1934 WriteLog("USER32: GetCapture\n");
1935#endif
1936 return O32_GetCapture();
1937}
1938//******************************************************************************
1939//******************************************************************************
1940UINT WIN32API GetCaretBlinkTime(void)
1941{
1942#ifdef DEBUG
1943 WriteLog("USER32: GetCaretBlinkTime\n");
1944#endif
1945 return O32_GetCaretBlinkTime();
1946}
1947//******************************************************************************
1948//******************************************************************************
1949BOOL WIN32API GetCaretPos( PPOINT arg1)
1950{
1951#ifdef DEBUG
1952 WriteLog("USER32: GetCaretPos\n");
1953#endif
1954 return O32_GetCaretPos(arg1);
1955}
1956//******************************************************************************
1957//******************************************************************************
1958BOOL WIN32API GetClipCursor( PRECT arg1)
1959{
1960#ifdef DEBUG
1961 WriteLog("USER32: GetClipCursor\n");
1962#endif
1963 return O32_GetClipCursor(arg1);
1964}
1965//******************************************************************************
1966//******************************************************************************
1967HANDLE WIN32API GetClipboardData( UINT arg1)
1968{
1969#ifdef DEBUG
1970 WriteLog("USER32: GetClipboardData\n");
1971#endif
1972 return O32_GetClipboardData(arg1);
1973}
1974//******************************************************************************
1975//******************************************************************************
1976int WIN32API GetClipboardFormatNameA( UINT arg1, LPSTR arg2, int arg3)
1977{
1978#ifdef DEBUG
1979 WriteLog("USER32: GetClipboardFormatNameA %s\n", arg2);
1980#endif
1981 return O32_GetClipboardFormatName(arg1, arg2, arg3);
1982}
1983//******************************************************************************
1984//******************************************************************************
1985int WIN32API GetClipboardFormatNameW(UINT arg1, LPWSTR arg2, int arg3)
1986{
1987 int rc;
1988 char *astring = UnicodeToAsciiString(arg2);
1989
1990#ifdef DEBUG
1991 WriteLog("USER32: GetClipboardFormatNameW %s\n", astring);
1992#endif
1993 rc = O32_GetClipboardFormatName(arg1, astring, arg3);
1994 FreeAsciiString(astring);
1995 return(rc);
1996}
1997//******************************************************************************
1998//******************************************************************************
1999HWND WIN32API GetClipboardOwner(void)
2000{
2001#ifdef DEBUG
2002 WriteLog("USER32: GetClipboardOwner\n");
2003#endif
2004 return O32_GetClipboardOwner();
2005}
2006//******************************************************************************
2007//******************************************************************************
2008HWND WIN32API GetClipboardViewer(void)
2009{
2010#ifdef DEBUG
2011 WriteLog("USER32: GetClipboardViewer\n");
2012#endif
2013 return O32_GetClipboardViewer();
2014}
2015//******************************************************************************
2016//******************************************************************************
2017DWORD WIN32API GetDialogBaseUnits(void)
2018{
2019#ifdef DEBUG
2020 WriteLog("USER32: GetDialogBaseUnits\n");
2021#endif
2022 return O32_GetDialogBaseUnits();
2023}
2024//******************************************************************************
2025//******************************************************************************
2026UINT WIN32API GetDlgItemInt( HWND arg1, int arg2, PBOOL arg3, BOOL arg4)
2027{
2028#ifdef DEBUG
2029 WriteLog("USER32: GetDlgItemInt\n");
2030#endif
2031 return O32_GetDlgItemInt(arg1, arg2, arg3, arg4);
2032}
2033
2034
2035/*****************************************************************************
2036 * Name : UINT WIN32API GetDlgItemTextW
2037 * Purpose : Determine the text of a window control
2038 * Parameters: HWND arg1
2039 * int arg2
2040 * LPWSTR arg3
2041 * UINT arg4
2042 * Variables :
2043 * Result :
2044 * Remark :
2045 * Status : UNTESTED UNKNOWN STUB
2046 *
2047 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2048 *****************************************************************************/
2049
2050UINT WIN32API GetDlgItemTextW(HWND arg1,
2051 int arg2,
2052 LPWSTR arg3,
2053 UINT arg4)
2054{
2055 LPSTR lpBuffer; /* temporary buffer for the ascii result */
2056 UINT uiResult; /* return value of the ascii variant */
2057
2058 dprintf(("USER32: GetDlgItemTextW(%08xh,%08xh,%08xh,%08xh)\n",
2059 arg1,
2060 arg2,
2061 arg3,
2062 arg4));
2063
2064
2065 lpBuffer = (LPSTR)malloc(arg4); /* allocate temporary buffer */
2066 uiResult = GetDlgItemTextA(arg1, /* call ascii variant */
2067 arg2,
2068 lpBuffer,
2069 arg4);
2070
2071 AsciiToUnicodeN(lpBuffer, /* now convert result to unicode */
2072 arg3,
2073 arg4);
2074
2075 free(lpBuffer); /* free the temporary buffer */
2076
2077 return (uiResult); /* OK, that's it */
2078}
2079
2080
2081//******************************************************************************
2082//******************************************************************************
2083UINT WIN32API GetDoubleClickTime(void)
2084{
2085#ifdef DEBUG
2086 WriteLog("USER32: GetDoubleClickTime\n");
2087#endif
2088 return O32_GetDoubleClickTime();
2089}
2090//******************************************************************************
2091//******************************************************************************
2092HWND WIN32API GetForegroundWindow(void)
2093{
2094#ifdef DEBUG
2095 WriteLog("USER32: GetForegroundWindow\n");
2096#endif
2097 return O32_GetForegroundWindow();
2098}
2099//******************************************************************************
2100//******************************************************************************
2101BOOL WIN32API GetIconInfo( HICON arg1, LPICONINFO arg2)
2102{
2103#ifdef DEBUG
2104 WriteLog("USER32: GetIconInfo\n");
2105#endif
2106 return O32_GetIconInfo(arg1, arg2);
2107}
2108//******************************************************************************
2109//******************************************************************************
2110int WIN32API GetKeyNameTextA( LPARAM arg1, LPSTR arg2, int arg3)
2111{
2112#ifdef DEBUG
2113 WriteLog("USER32: GetKeyNameTextA\n");
2114#endif
2115 return O32_GetKeyNameText(arg1, arg2, arg3);
2116}
2117//******************************************************************************
2118//******************************************************************************
2119int WIN32API GetKeyNameTextW( LPARAM arg1, LPWSTR arg2, int arg3)
2120{
2121#ifdef DEBUG
2122 WriteLog("USER32: GetKeyNameTextW DOES NOT WORK\n");
2123#endif
2124 // NOTE: This will not work as is (needs UNICODE support)
2125 return 0;
2126// return O32_GetKeyNameText(arg1, arg2, arg3);
2127}
2128//******************************************************************************
2129//******************************************************************************
2130int WIN32API GetKeyboardType( int arg1)
2131{
2132#ifdef DEBUG
2133 WriteLog("USER32: GetKeyboardType\n");
2134#endif
2135 return O32_GetKeyboardType(arg1);
2136}
2137//******************************************************************************
2138//******************************************************************************
2139HWND WIN32API GetLastActivePopup( HWND arg1)
2140{
2141#ifdef DEBUG
2142 WriteLog("USER32: GetLastActivePopup\n");
2143#endif
2144 return O32_GetLastActivePopup(arg1);
2145}
2146//******************************************************************************
2147//******************************************************************************
2148LONG WIN32API GetMessageExtraInfo(void)
2149{
2150 dprintf(("USER32: GetMessageExtraInfo\n"));
2151 return O32_GetMessageExtraInfo();
2152}
2153//******************************************************************************
2154//******************************************************************************
2155DWORD WIN32API GetMessagePos(void)
2156{
2157 dprintf(("USER32: GetMessagePos\n"));
2158 return O32_GetMessagePos();
2159}
2160//******************************************************************************
2161//******************************************************************************
2162LONG WIN32API GetMessageTime(void)
2163{
2164 dprintf(("USER32: GetMessageTime\n"));
2165 return O32_GetMessageTime();
2166}
2167//******************************************************************************
2168//******************************************************************************
2169BOOL WIN32API GetMessageW(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
2170{
2171 BOOL rc;
2172
2173 // NOTE: This will not work as is (needs UNICODE support)
2174 rc = O32_GetMessage(arg1, arg2, arg3, arg4);
2175 dprintf(("USER32: GetMessageW %X returned %d\n", arg2, rc));
2176 return(rc);
2177}
2178//******************************************************************************
2179//******************************************************************************
2180HWND WIN32API GetNextDlgGroupItem( HWND arg1, HWND arg2, BOOL arg3)
2181{
2182#ifdef DEBUG
2183 WriteLog("USER32: GetNextDlgGroupItem\n");
2184#endif
2185 return O32_GetNextDlgGroupItem(arg1, arg2, arg3);
2186}
2187//******************************************************************************
2188//******************************************************************************
2189HWND WIN32API GetOpenClipboardWindow(void)
2190{
2191#ifdef DEBUG
2192 WriteLog("USER32: GetOpenClipboardWindow\n");
2193#endif
2194 return O32_GetOpenClipboardWindow();
2195}
2196//******************************************************************************
2197//******************************************************************************
2198HWND WIN32API GetParent( HWND arg1)
2199{
2200#ifdef DEBUG
2201//// WriteLog("USER32: GetParent\n");
2202#endif
2203 return O32_GetParent(arg1);
2204}
2205//******************************************************************************
2206//******************************************************************************
2207int WIN32API GetPriorityClipboardFormat( PUINT arg1, int arg2)
2208{
2209#ifdef DEBUG
2210 WriteLog("USER32: GetPriorityClipboardFormat\n");
2211#endif
2212 return O32_GetPriorityClipboardFormat(arg1, arg2);
2213}
2214//******************************************************************************
2215//******************************************************************************
2216HANDLE WIN32API GetPropA( HWND arg1, LPCSTR arg2)
2217{
2218#ifdef DEBUG
2219 if((int)arg2 >> 16 != 0)
2220 WriteLog("USER32: GetPropA %s\n", arg2);
2221 else WriteLog("USER32: GetPropA %X\n", arg2);
2222#endif
2223 return O32_GetProp(arg1, arg2);
2224}
2225//******************************************************************************
2226//******************************************************************************
2227HANDLE WIN32API GetPropW(HWND arg1, LPCWSTR arg2)
2228{
2229 BOOL handle;
2230 char *astring;
2231
2232 if((int)arg2 >> 16 != 0)
2233 astring = UnicodeToAsciiString((LPWSTR)arg2);
2234 else astring = (char *)arg2;
2235#ifdef DEBUG
2236 if((int)arg2 >> 16 != 0)
2237 WriteLog("USER32: GetPropW %s\n", astring);
2238 else WriteLog("USER32: GetPropW %X\n", astring);
2239#endif
2240 handle = GetPropA(arg1, (LPCSTR)astring);
2241 if((int)arg2 >> 16 != 0)
2242 FreeAsciiString(astring);
2243
2244 return(handle);
2245}
2246//******************************************************************************
2247//******************************************************************************
2248DWORD WIN32API GetQueueStatus( UINT arg1)
2249{
2250#ifdef DEBUG
2251 WriteLog("USER32: GetQueueStatus\n");
2252#endif
2253 return O32_GetQueueStatus(arg1);
2254}
2255//******************************************************************************
2256//******************************************************************************
2257int WIN32API GetScrollPos(HWND hwnd, int fnBar)
2258{
2259 int pos;
2260
2261 pos = O32_GetScrollPos(hwnd, fnBar);
2262#ifdef DEBUG
2263 WriteLog("USER32: GetScrollPos of %X type %d returned %d\n", hwnd, fnBar, pos);
2264#endif
2265 return(pos);
2266}
2267//******************************************************************************
2268//******************************************************************************
2269BOOL WIN32API GetScrollRange( HWND arg1, int arg2, int * arg3, int * arg4)
2270{
2271#ifdef DEBUG
2272 WriteLog("USER32: GetScrollRange\n");
2273#endif
2274 return O32_GetScrollRange(arg1, arg2, arg3, arg4);
2275}
2276//******************************************************************************
2277//******************************************************************************
2278DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
2279{
2280#ifdef DEBUG
2281 WriteLog("USER32: GetTabbedTextExtentA\n");
2282#endif
2283 return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
2284}
2285//******************************************************************************
2286//******************************************************************************
2287DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
2288{
2289 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2290 DWORD rc;
2291
2292#ifdef DEBUG
2293 WriteLog("USER32: GetTabbedTextExtentW\n");
2294#endif
2295 rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
2296 FreeAsciiString(astring);
2297 return rc;
2298}
2299//******************************************************************************
2300//******************************************************************************
2301HWND WIN32API GetTopWindow( HWND arg1)
2302{
2303#ifdef DEBUG
2304//// WriteLog("USER32: GetTopWindow\n");
2305#endif
2306 return O32_GetTopWindow(arg1);
2307}
2308//******************************************************************************
2309//******************************************************************************
2310int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2311{
2312#ifdef DEBUG
2313 WriteLog("USER32: GetUpdateRgn\n");
2314#endif
2315 return O32_GetUpdateRgn(arg1, arg2, arg3);
2316}
2317//******************************************************************************
2318//******************************************************************************
2319LONG WIN32API GetWindowLongW( HWND arg1, int arg2)
2320{
2321#ifdef DEBUG
2322 WriteLog("USER32: GetWindowLongW\n");
2323#endif
2324 return GetWindowLongA(arg1, arg2); //class procedures..
2325}
2326//******************************************************************************
2327//******************************************************************************
2328BOOL WIN32API GetWindowPlacement( HWND arg1, LPWINDOWPLACEMENT arg2)
2329{
2330#ifdef DEBUG
2331 WriteLog("USER32: GetWindowPlacement\n");
2332#endif
2333 return O32_GetWindowPlacement(arg1, arg2);
2334}
2335//******************************************************************************
2336
2337/***********************************************************************
2338 * GetInternalWindowPos (USER32.245)
2339 */
2340UINT WIN32API GetInternalWindowPos(HWND hwnd,
2341 LPRECT rectWnd,
2342 LPPOINT ptIcon )
2343{
2344 WINDOWPLACEMENT wndpl;
2345
2346 dprintf(("USER32: GetInternalWindowPos(%08xh,%08xh,%08xh)\n",
2347 hwnd,
2348 rectWnd,
2349 ptIcon));
2350
2351 if (O32_GetWindowPlacement( hwnd, &wndpl ))
2352 {
2353 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
2354 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
2355 return wndpl.showCmd;
2356 }
2357 return 0;
2358}
2359
2360
2361//******************************************************************************
2362int WIN32API GetWindowTextLengthW( HWND arg1)
2363{
2364#ifdef DEBUG
2365 WriteLog("USER32: GetWindowTextLengthW\n");
2366#endif
2367 return O32_GetWindowTextLength(arg1);
2368}
2369//******************************************************************************
2370//******************************************************************************
2371int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
2372{
2373 char title[128];
2374 int rc;
2375
2376 rc = O32_GetWindowText(hwnd, title, sizeof(title));
2377#ifdef DEBUG
2378 WriteLog("USER32: GetWindowTextW returned %s\n", title);
2379#endif
2380 if(rc > cch) {
2381 title[cch-1] = 0;
2382 rc = cch;
2383 }
2384 AsciiToUnicode(title, lpsz);
2385 return(rc);
2386}
2387//******************************************************************************
2388//******************************************************************************
2389DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD arg2)
2390{
2391#ifdef DEBUG
2392 WriteLog("USER32: GetWindowThreadProcessId\n");
2393#endif
2394 return O32_GetWindowThreadProcessId(arg1, arg2);
2395}
2396//******************************************************************************
2397//******************************************************************************
2398WORD WIN32API GetWindowWord( HWND arg1, int arg2)
2399{
2400#ifdef DEBUG
2401 WriteLog("USER32: GetWindowWord\n");
2402#endif
2403 return O32_GetWindowWord(arg1, arg2);
2404}
2405//******************************************************************************
2406//******************************************************************************
2407BOOL WIN32API HideCaret( HWND arg1)
2408{
2409#ifdef DEBUG
2410 WriteLog("USER32: HideCaret\n");
2411#endif
2412 return O32_HideCaret(arg1);
2413}
2414//******************************************************************************
2415//******************************************************************************
2416BOOL WIN32API InSendMessage(void)
2417{
2418#ifdef DEBUG
2419 WriteLog("USER32: InSendMessage\n");
2420#endif
2421 return O32_InSendMessage();
2422}
2423//******************************************************************************
2424//******************************************************************************
2425BOOL WIN32API IntersectRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
2426{
2427#ifdef DEBUG
2428//// WriteLog("USER32: IntersectRect\n");
2429#endif
2430 return O32_IntersectRect(arg1, arg2, arg3);
2431}
2432//******************************************************************************
2433//******************************************************************************
2434BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2435{
2436#ifdef DEBUG
2437 WriteLog("USER32: InvalidateRgn\n");
2438#endif
2439 return O32_InvalidateRgn(arg1, arg2, arg3);
2440}
2441//******************************************************************************
2442//******************************************************************************
2443BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
2444{
2445#ifdef DEBUG
2446 WriteLog("USER32: InvertRect\n");
2447#endif
2448 return O32_InvertRect(arg1, arg2);
2449}
2450//******************************************************************************
2451//******************************************************************************
2452BOOL WIN32API IsChild( HWND arg1, HWND arg2)
2453{
2454#ifdef DEBUG
2455 WriteLog("USER32: IsChild\n");
2456#endif
2457 return O32_IsChild(arg1, arg2);
2458}
2459//******************************************************************************
2460//******************************************************************************
2461BOOL WIN32API IsClipboardFormatAvailable( UINT arg1)
2462{
2463#ifdef DEBUG
2464 WriteLog("USER32: IsClipboardFormatAvailable\n");
2465#endif
2466 return O32_IsClipboardFormatAvailable(arg1);
2467}
2468//******************************************************************************
2469//******************************************************************************
2470BOOL WIN32API IsDialogMessageW( HWND arg1, LPMSG arg2)
2471{
2472#ifdef DEBUG
2473 WriteLog("USER32: IsDialogMessageW\n");
2474#endif
2475 // NOTE: This will not work as is (needs UNICODE support)
2476 return O32_IsDialogMessage(arg1, arg2);
2477}
2478//******************************************************************************
2479//******************************************************************************
2480BOOL WIN32API IsRectEmpty( const RECT * arg1)
2481{
2482#ifdef DEBUG
2483 WriteLog("USER32: IsRectEmpty\n");
2484#endif
2485 return O32_IsRectEmpty(arg1);
2486}
2487//******************************************************************************
2488//******************************************************************************
2489BOOL WIN32API IsWindow( HWND arg1)
2490{
2491#ifdef DEBUG
2492 WriteLog("USER32: IsWindow\n");
2493#endif
2494 return O32_IsWindow(arg1);
2495}
2496//******************************************************************************
2497//******************************************************************************
2498BOOL WIN32API IsWindowEnabled( HWND arg1)
2499{
2500#ifdef DEBUG
2501 WriteLog("USER32: IsWindowEnabled\n");
2502#endif
2503 return O32_IsWindowEnabled(arg1);
2504}
2505//******************************************************************************
2506//******************************************************************************
2507BOOL WIN32API IsWindowVisible( HWND arg1)
2508{
2509#ifdef DEBUG
2510 WriteLog("USER32: IsWindowVisible\n");
2511#endif
2512 return O32_IsWindowVisible(arg1);
2513}
2514//******************************************************************************
2515//******************************************************************************
2516BOOL WIN32API IsZoomed( HWND arg1)
2517{
2518#ifdef DEBUG
2519 WriteLog("USER32: IsZoomed\n");
2520#endif
2521 return O32_IsZoomed(arg1);
2522}
2523//******************************************************************************
2524//******************************************************************************
2525BOOL WIN32API LockWindowUpdate( HWND arg1)
2526{
2527#ifdef DEBUG
2528 WriteLog("USER32: LockWindowUpdate\n");
2529#endif
2530 return O32_LockWindowUpdate(arg1);
2531}
2532//******************************************************************************
2533//******************************************************************************
2534BOOL WIN32API MapDialogRect( HWND arg1, PRECT arg2)
2535{
2536#ifdef DEBUG
2537 WriteLog("USER32: MapDialogRect\n");
2538#endif
2539 return O32_MapDialogRect(arg1, arg2);
2540}
2541//******************************************************************************
2542//******************************************************************************
2543UINT WIN32API MapVirtualKeyA( UINT arg1, UINT arg2)
2544{
2545#ifdef DEBUG
2546 WriteLog("USER32: MapVirtualKeyA\n");
2547#endif
2548 return O32_MapVirtualKey(arg1, arg2);
2549}
2550//******************************************************************************
2551//******************************************************************************
2552UINT WIN32API MapVirtualKeyW( UINT arg1, UINT arg2)
2553{
2554#ifdef DEBUG
2555 WriteLog("USER32: MapVirtualKeyW\n");
2556#endif
2557 // NOTE: This will not work as is (needs UNICODE support)
2558 return O32_MapVirtualKey(arg1, arg2);
2559}
2560//******************************************************************************
2561//******************************************************************************
2562int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
2563{
2564#ifdef DEBUG
2565 WriteLog("USER32: MapWindowPoints\n");
2566#endif
2567 return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
2568}
2569//******************************************************************************
2570//******************************************************************************
2571int WIN32API MessageBoxW(HWND arg1, LPCWSTR arg2, LPCWSTR arg3, UINT arg4)
2572{
2573 char *astring1, *astring2;
2574 int rc;
2575
2576 astring1 = UnicodeToAsciiString((LPWSTR)arg2);
2577 astring2 = UnicodeToAsciiString((LPWSTR)arg3);
2578#ifdef DEBUG
2579 WriteLog("USER32: MessageBoxW %s %s\n", astring1, astring2);
2580#endif
2581 rc = O32_MessageBox(arg1, astring1, astring2, arg4);
2582 FreeAsciiString(astring1);
2583 FreeAsciiString(astring2);
2584 return(rc);
2585}
2586//******************************************************************************
2587//******************************************************************************
2588BOOL WIN32API OpenClipboard( HWND arg1)
2589{
2590#ifdef DEBUG
2591 WriteLog("USER32: OpenClipboard\n");
2592#endif
2593 return O32_OpenClipboard(arg1);
2594}
2595//******************************************************************************
2596//******************************************************************************
2597BOOL WIN32API PeekMessageW( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
2598{
2599#ifdef DEBUG
2600 WriteLog("USER32: PeekMessageW\n");
2601#endif
2602 // NOTE: This will not work as is (needs UNICODE support)
2603 return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
2604}
2605//******************************************************************************
2606//******************************************************************************
2607// NOTE: Open32 function doesn't have the 'W'.
2608BOOL WIN32API PostMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2609{
2610#ifdef DEBUG
2611 WriteLog("USER32: PostMessageW\n");
2612#endif
2613 // NOTE: This will not work as is (needs UNICODE support)
2614 return O32_PostMessage(arg1, arg2, arg3, arg4);
2615}
2616//******************************************************************************
2617//******************************************************************************
2618BOOL WIN32API PostThreadMessageA( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2619{
2620#ifdef DEBUG
2621 WriteLog("USER32: PostThreadMessageA\n");
2622#endif
2623 return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2624}
2625//******************************************************************************
2626//******************************************************************************
2627BOOL WIN32API PostThreadMessageW( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2628{
2629#ifdef DEBUG
2630 WriteLog("USER32: PostThreadMessageW\n");
2631#endif
2632 // NOTE: This will not work as is (needs UNICODE support)
2633 return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2634}
2635//******************************************************************************
2636//******************************************************************************
2637BOOL WIN32API PtInRect( const RECT * arg1, POINT arg2)
2638{
2639#ifdef DEBUG1
2640 WriteLog("USER32: PtInRect\n");
2641#endif
2642 return O32_PtInRect(arg1, arg2);
2643}
2644//******************************************************************************
2645//******************************************************************************
2646BOOL WIN32API RedrawWindow( HWND arg1, const RECT * arg2, HRGN arg3, UINT arg4)
2647{
2648 BOOL rc;
2649
2650 rc = O32_RedrawWindow(arg1, arg2, arg3, arg4);
2651#ifdef DEBUG
2652 WriteLog("USER32: RedrawWindow %X , %X, %X, %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2653#endif
2654 InvalidateRect(arg1, arg2, TRUE);
2655 UpdateWindow(arg1);
2656 SendMessageA(arg1, WM_PAINT, 0, 0);
2657 return(rc);
2658}
2659//******************************************************************************
2660//******************************************************************************
2661UINT WIN32API RegisterClipboardFormatA( LPCSTR arg1)
2662{
2663#ifdef DEBUG
2664 WriteLog("USER32: RegisterClipboardFormatA\n");
2665#endif
2666 return O32_RegisterClipboardFormat(arg1);
2667}
2668//******************************************************************************
2669//******************************************************************************
2670UINT WIN32API RegisterClipboardFormatW(LPCWSTR arg1)
2671{
2672 UINT rc;
2673 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2674
2675#ifdef DEBUG
2676 WriteLog("USER32: RegisterClipboardFormatW %s\n", astring);
2677#endif
2678 rc = O32_RegisterClipboardFormat(astring);
2679 FreeAsciiString(astring);
2680#ifdef DEBUG
2681 WriteLog("USER32: RegisterClipboardFormatW returned %d\n", rc);
2682#endif
2683 return(rc);
2684}
2685//******************************************************************************
2686//******************************************************************************
2687UINT WIN32API RegisterWindowMessageW( LPCWSTR arg1)
2688{
2689 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2690 UINT rc;
2691
2692#ifdef DEBUG
2693 WriteLog("USER32: RegisterWindowMessageW\n");
2694#endif
2695 rc = O32_RegisterWindowMessage(astring);
2696 FreeAsciiString(astring);
2697 return rc;
2698}
2699//******************************************************************************
2700//******************************************************************************
2701HANDLE WIN32API RemovePropA( HWND arg1, LPCSTR arg2)
2702{
2703#ifdef DEBUG
2704 WriteLog("USER32: RemovePropA\n");
2705#endif
2706 return O32_RemoveProp(arg1, arg2);
2707}
2708//******************************************************************************
2709//******************************************************************************
2710HANDLE WIN32API RemovePropW( HWND arg1, LPCWSTR arg2)
2711{
2712 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2713 HANDLE rc;
2714
2715#ifdef DEBUG
2716 WriteLog("USER32: RemovePropW\n");
2717#endif
2718 rc = O32_RemoveProp(arg1, astring);
2719 FreeAsciiString(astring);
2720 return rc;
2721}
2722//******************************************************************************
2723//******************************************************************************
2724BOOL WIN32API ReplyMessage( LRESULT arg1)
2725{
2726#ifdef DEBUG
2727 WriteLog("USER32: ReplyMessage\n");
2728#endif
2729 return O32_ReplyMessage(arg1);
2730}
2731//******************************************************************************
2732//******************************************************************************
2733BOOL WIN32API ScreenToClient( HWND arg1, LPPOINT arg2)
2734{
2735#ifdef DEBUG
2736 WriteLog("USER32: ScreenToClient\n");
2737#endif
2738 return O32_ScreenToClient(arg1, arg2);
2739}
2740//******************************************************************************
2741//******************************************************************************
2742BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7)
2743{
2744#ifdef DEBUG
2745 WriteLog("USER32: ScrollDC\n");
2746#endif
2747 return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2748}
2749//******************************************************************************
2750//******************************************************************************
2751BOOL WIN32API ScrollWindow( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5)
2752{
2753#ifdef DEBUG
2754 WriteLog("USER32: ScrollWindow\n");
2755#endif
2756 return O32_ScrollWindow(arg1, arg2, arg3, arg4, arg5);
2757}
2758//******************************************************************************
2759//******************************************************************************
2760BOOL WIN32API ScrollWindowEx( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7, UINT arg8)
2761{
2762#ifdef DEBUG
2763 WriteLog("USER32: ScrollWindowEx\n");
2764#endif
2765 return O32_ScrollWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2766}
2767//******************************************************************************
2768//******************************************************************************
2769LONG WIN32API SendDlgItemMessageW( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
2770{
2771#ifdef DEBUG
2772 WriteLog("USER32: SendDlgItemMessageW\n");
2773#endif
2774 return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
2775}
2776//******************************************************************************
2777//******************************************************************************
2778LRESULT WIN32API SendMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2779{
2780LRESULT rc;
2781
2782#ifdef DEBUG
2783 WriteLog("USER32: SendMessageW....\n");
2784#endif
2785 rc = O32_SendMessage(arg1, arg2, arg3, arg4);
2786#ifdef DEBUG
2787 WriteLog("USER32: SendMessageW %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2788#endif
2789 return(rc);
2790}
2791//******************************************************************************
2792//******************************************************************************
2793BOOL WIN32API SetCaretBlinkTime( UINT arg1)
2794{
2795#ifdef DEBUG
2796 WriteLog("USER32: SetCaretBlinkTime\n");
2797#endif
2798 return O32_SetCaretBlinkTime(arg1);
2799}
2800//******************************************************************************
2801//******************************************************************************
2802BOOL WIN32API SetCaretPos( int arg1, int arg2)
2803{
2804 dprintf(("USER32: SetCaretPos\n"));
2805 return O32_SetCaretPos(arg1, arg2);
2806}
2807//******************************************************************************
2808//******************************************************************************
2809HANDLE WIN32API SetClipboardData( UINT arg1, HANDLE arg2)
2810{
2811 dprintf(("USER32: SetClipboardData\n"));
2812 return O32_SetClipboardData(arg1, arg2);
2813}
2814//******************************************************************************
2815//******************************************************************************
2816HWND WIN32API SetClipboardViewer( HWND arg1)
2817{
2818 dprintf(("USER32: SetClipboardViewer\n"));
2819 return O32_SetClipboardViewer(arg1);
2820}
2821//******************************************************************************
2822//******************************************************************************
2823BOOL WIN32API SetDlgItemTextW( HWND arg1, int arg2, LPCWSTR arg3)
2824{
2825char *astring = UnicodeToAsciiString((LPWSTR)arg3);
2826BOOL rc;
2827
2828#ifdef DEBUG
2829 WriteLog("USER32: SetDlgItemTextW\n");
2830#endif
2831 // NOTE: This will not work as is (needs UNICODE support)
2832 rc = O32_SetDlgItemText(arg1, arg2, astring);
2833 FreeAsciiString(astring);
2834 return rc;
2835}
2836//******************************************************************************
2837//******************************************************************************
2838BOOL WIN32API SetDoubleClickTime( UINT arg1)
2839{
2840#ifdef DEBUG
2841 WriteLog("USER32: SetDoubleClickTime\n");
2842#endif
2843 return O32_SetDoubleClickTime(arg1);
2844}
2845//******************************************************************************
2846//******************************************************************************
2847HWND WIN32API SetParent( HWND arg1, HWND arg2)
2848{
2849#ifdef DEBUG
2850 WriteLog("USER32: SetParent\n");
2851#endif
2852 return O32_SetParent(arg1, arg2);
2853}
2854//******************************************************************************
2855//******************************************************************************
2856BOOL WIN32API SetPropA( HWND arg1, LPCSTR arg2, HANDLE arg3)
2857{
2858#ifdef DEBUG
2859 if((int)arg2 >> 16 != 0)
2860 WriteLog("USER32: SetPropA %S\n", arg2);
2861 else WriteLog("USER32: SetPropA %X\n", arg2);
2862#endif
2863 return O32_SetProp(arg1, arg2, arg3);
2864}
2865//******************************************************************************
2866//******************************************************************************
2867BOOL WIN32API SetPropW(HWND arg1, LPCWSTR arg2, HANDLE arg3)
2868{
2869 BOOL rc;
2870 char *astring;
2871
2872 if((int)arg2 >> 16 != 0)
2873 astring = UnicodeToAsciiString((LPWSTR)arg2);
2874 else astring = (char *)arg2;
2875
2876#ifdef DEBUG
2877 if((int)arg2 >> 16 != 0)
2878 WriteLog("USER32: SetPropW %S\n", astring);
2879 else WriteLog("USER32: SetPropW %X\n", astring);
2880#endif
2881 rc = O32_SetProp(arg1, astring, arg3);
2882 if((int)astring >> 16 != 0)
2883 FreeAsciiString(astring);
2884 return(rc);
2885}
2886//******************************************************************************
2887//******************************************************************************
2888BOOL WIN32API SetRectEmpty( PRECT arg1)
2889{
2890#ifdef DEBUG
2891 WriteLog("USER32: SetRectEmpty\n");
2892#endif
2893 return O32_SetRectEmpty(arg1);
2894}
2895//******************************************************************************
2896//******************************************************************************
2897int WIN32API SetScrollPos( HWND arg1, int arg2, int arg3, BOOL arg4)
2898{
2899#ifdef DEBUG
2900 WriteLog("USER32: SetScrollPos\n");
2901#endif
2902 return O32_SetScrollPos(arg1, arg2, arg3, arg4);
2903}
2904//******************************************************************************
2905//******************************************************************************
2906BOOL WIN32API SetScrollRange( HWND arg1, int arg2, int arg3, int arg4, BOOL arg5)
2907{
2908#ifdef DEBUG
2909 WriteLog("USER32: SetScrollRange\n");
2910#endif
2911 return O32_SetScrollRange(arg1, arg2, arg3, arg4, arg5);
2912}
2913//******************************************************************************
2914//******************************************************************************
2915LONG WIN32API SetWindowLongA(HWND hwnd, int nIndex, LONG arg3)
2916{
2917 LONG rc;
2918
2919 dprintf(("USER32: SetWindowLongA %X %d %X\n", hwnd, nIndex, arg3));
2920 if(nIndex == GWL_WNDPROC || nIndex == DWL_DLGPROC) {
2921 Win32WindowProc *wndproc = Win32WindowProc::FindProc(hwnd);
2922 if(wndproc == NULL) {//created with system class and app wants to change the handler
2923 dprintf(("USER32: SetWindowLong new WindowProc for system class\n"));
2924 wndproc = new Win32WindowProc((WNDPROC)arg3);
2925 wndproc->SetWindowHandle(hwnd);
2926 rc = O32_GetWindowLong(hwnd, nIndex);
2927 Win32WindowSubProc *subwndproc = new Win32WindowSubProc(hwnd, (WNDPROC_O32)rc);
2928 O32_SetWindowLong(hwnd, nIndex, (LONG)wndproc->GetOS2Callback());
2929 return((LONG)subwndproc->GetWin32Callback());
2930 }
2931 else {
2932 if(!(nIndex == DWL_DLGPROC && wndproc->IsWindow() == TRUE)) {
2933 rc = (LONG)wndproc->GetWin32Callback();
2934 dprintf(("USER32: SetWindowLong change WindowProc %X to %X\n", rc, arg3));
2935 wndproc->SetWin32Callback((WNDPROC)arg3);
2936 return(rc);
2937 }
2938 //else window that accesses it's normal window data
2939 }
2940 }
2941 return O32_SetWindowLong(hwnd, nIndex, arg3);
2942}
2943//******************************************************************************
2944//TODO: Is this always correct? (GWL_ID: window identifier??)
2945//******************************************************************************
2946LONG WIN32API SetWindowLongW(HWND arg1, int arg2, LONG arg3)
2947{
2948 dprintf(("USER32: SetWindowLongW %X %d %X\n", arg1, arg2, arg3));
2949 return SetWindowLongA(arg1, arg2, arg3);
2950}
2951//******************************************************************************
2952//******************************************************************************
2953BOOL WIN32API SetWindowPlacement( HWND arg1, const WINDOWPLACEMENT * arg2)
2954{
2955 dprintf(("USER32: SetWindowPlacement\n"));
2956 return O32_SetWindowPlacement(arg1, arg2);
2957}
2958//******************************************************************************
2959//******************************************************************************
2960BOOL WIN32API SetWindowTextW( HWND arg1, LPCWSTR arg2)
2961{
2962 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2963 BOOL rc;
2964
2965 rc = SetWindowTextA(arg1, (LPCSTR)astring);
2966 dprintf(("USER32: SetWindowTextW %X %s returned %d\n", arg1, astring, rc));
2967 FreeAsciiString(astring);
2968 return(rc);
2969}
2970//******************************************************************************
2971//******************************************************************************
2972WORD WIN32API SetWindowWord( HWND arg1, int arg2, WORD arg3)
2973{
2974 dprintf(("USER32: SetWindowWord\n"));
2975 return O32_SetWindowWord(arg1, arg2, arg3);
2976}
2977//******************************************************************************
2978//******************************************************************************
2979BOOL WIN32API ShowCaret( HWND arg1)
2980{
2981 dprintf(("USER32: ShowCaret\n"));
2982 return O32_ShowCaret(arg1);
2983}
2984//******************************************************************************
2985//******************************************************************************
2986BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
2987{
2988 dprintf(("USER32: ShowOwnedPopups\n"));
2989 return O32_ShowOwnedPopups(arg1, arg2);
2990}
2991//******************************************************************************
2992//******************************************************************************
2993BOOL WIN32API ShowScrollBar( HWND arg1, int arg2, BOOL arg3)
2994{
2995#ifdef DEBUG
2996 WriteLog("USER32: ShowScrollBar\n");
2997#endif
2998 return O32_ShowScrollBar(arg1, arg2, arg3);
2999}
3000//******************************************************************************
3001//******************************************************************************
3002BOOL WIN32API SwapMouseButton( BOOL arg1)
3003{
3004#ifdef DEBUG
3005 WriteLog("USER32: SwapMouseButton\n");
3006#endif
3007 return O32_SwapMouseButton(arg1);
3008}
3009//******************************************************************************
3010//******************************************************************************
3011BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
3012{
3013 BOOL rc;
3014 NONCLIENTMETRICSA *cmetric = (NONCLIENTMETRICSA *)pvParam;
3015
3016 switch(uiAction) {
3017 case SPI_SCREENSAVERRUNNING:
3018 *(BOOL *)pvParam = FALSE;
3019 rc = TRUE;
3020 break;
3021 case SPI_GETDRAGFULLWINDOWS:
3022 *(BOOL *)pvParam = FALSE;
3023 rc = TRUE;
3024 break;
3025 case SPI_GETNONCLIENTMETRICS:
3026 memset(cmetric, 0, sizeof(NONCLIENTMETRICSA));
3027 cmetric->cbSize = sizeof(NONCLIENTMETRICSA);
3028 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfCaptionFont),0);
3029 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMenuFont),0);
3030 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfStatusFont),0);
3031 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMessageFont),0);
3032 cmetric->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
3033 cmetric->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
3034 cmetric->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
3035 cmetric->iCaptionWidth = 32; //TODO
3036 cmetric->iCaptionHeight = 16; //TODO
3037 cmetric->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
3038 cmetric->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
3039 cmetric->iMenuWidth = 32; //TODO
3040 cmetric->iMenuHeight = GetSystemMetrics(SM_CYMENU);
3041 rc = TRUE;
3042 break;
3043 case 104: //TODO: Undocumented
3044 rc = 16;
3045 break;
3046 default:
3047 rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
3048 break;
3049 }
3050#ifdef DEBUG
3051 WriteLog("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc);
3052#endif
3053 return(rc);
3054}
3055//******************************************************************************
3056//TODO: Check for more options that have different structs for Unicode!!!!
3057//******************************************************************************
3058BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
3059{
3060 BOOL rc;
3061 NONCLIENTMETRICSW *clientMetricsW = (NONCLIENTMETRICSW *)pvParam;
3062 NONCLIENTMETRICSA clientMetricsA = {0};
3063 PVOID pvParamA;
3064 UINT uiParamA;
3065
3066 switch(uiAction) {
3067 case SPI_SETNONCLIENTMETRICS:
3068 clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
3069 clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
3070 clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
3071 clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
3072 clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
3073 clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
3074 ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
3075 clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
3076 clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
3077 ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
3078 clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
3079 clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
3080 ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
3081 ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
3082 ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
3083 //no break
3084 case SPI_GETNONCLIENTMETRICS:
3085 uiParamA = sizeof(NONCLIENTMETRICSA);
3086 pvParamA = &clientMetricsA;
3087 break;
3088 default:
3089 pvParamA = pvParam;
3090 uiParamA = uiParam;
3091 break;
3092 }
3093 rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
3094
3095 switch(uiAction) {
3096 case SPI_GETNONCLIENTMETRICS:
3097 clientMetricsW->cbSize = sizeof(*clientMetricsW);
3098 clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
3099 clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
3100 clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
3101 clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
3102 clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
3103 ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
3104
3105 clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
3106 clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
3107 ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
3108
3109 clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
3110 clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
3111 ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
3112 ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
3113 ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
3114 break;
3115 }
3116#ifdef DEBUG
3117 WriteLog("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc);
3118#endif
3119 return(rc);
3120}
3121//******************************************************************************
3122//******************************************************************************
3123LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3124{
3125#ifdef DEBUG
3126 WriteLog("USER32: TabbedTextOutA\n");
3127#endif
3128 return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
3129}
3130//******************************************************************************
3131//******************************************************************************
3132LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3133{
3134 char *astring = UnicodeToAsciiString((LPWSTR)arg4);
3135 LONG rc;
3136
3137#ifdef DEBUG
3138 WriteLog("USER32: TabbedTextOutW\n");
3139#endif
3140 rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
3141 FreeAsciiString(astring);
3142 return rc;
3143}
3144//******************************************************************************
3145//******************************************************************************
3146int WIN32API TranslateAccelerator( HWND arg1, HACCEL arg2, LPMSG arg3)
3147{
3148#ifdef DEBUG
3149 WriteLog("USER32: TranslateAccelerator\n");
3150#endif
3151 return O32_TranslateAccelerator(arg1, arg2, arg3);
3152}
3153//******************************************************************************
3154//******************************************************************************
3155int WIN32API TranslateAcceleratorW( HWND arg1, HACCEL arg2, LPMSG arg3)
3156{
3157#ifdef DEBUG
3158 WriteLog("USER32: TranslateAcceleratorW\n");
3159#endif
3160 // NOTE: This will not work as is (needs UNICODE support)
3161 return O32_TranslateAccelerator(arg1, arg2, arg3);
3162}
3163//******************************************************************************
3164//******************************************************************************
3165BOOL WIN32API TranslateMDISysAccel( HWND arg1, LPMSG arg2)
3166{
3167#ifdef DEBUG
3168//// WriteLog("USER32: TranslateMDISysAccel\n");
3169#endif
3170 return O32_TranslateMDISysAccel(arg1, arg2);
3171}
3172//******************************************************************************
3173//******************************************************************************
3174BOOL WIN32API UnionRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
3175{
3176#ifdef DEBUG
3177 WriteLog("USER32: UnionRect\n");
3178#endif
3179 return O32_UnionRect(arg1, arg2, arg3);
3180}
3181//******************************************************************************
3182//******************************************************************************
3183BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
3184{
3185#ifdef DEBUG
3186 WriteLog("USER32: ValidateRect\n");
3187#endif
3188 return O32_ValidateRect(arg1, arg2);
3189}
3190//******************************************************************************
3191//******************************************************************************
3192BOOL WIN32API ValidateRgn( HWND arg1, HRGN arg2)
3193{
3194#ifdef DEBUG
3195 WriteLog("USER32: ValidateRgn\n");
3196#endif
3197 return O32_ValidateRgn(arg1, arg2);
3198}
3199//******************************************************************************
3200//******************************************************************************
3201WORD WIN32API VkKeyScanW( WCHAR arg1)
3202{
3203#ifdef DEBUG
3204 WriteLog("USER32: VkKeyScanW\n");
3205#endif
3206 // NOTE: This will not work as is (needs UNICODE support)
3207 return O32_VkKeyScan((char)arg1);
3208}
3209//******************************************************************************
3210//******************************************************************************
3211BOOL WIN32API WaitMessage(void)
3212{
3213#ifdef DEBUG
3214 WriteLog("USER32: WaitMessage\n");
3215#endif
3216 return O32_WaitMessage();
3217}
3218//******************************************************************************
3219//******************************************************************************
3220BOOL WIN32API WinHelpW( HWND arg1, LPCWSTR arg2, UINT arg3, DWORD arg4)
3221{
3222 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
3223 BOOL rc;
3224
3225#ifdef DEBUG
3226 WriteLog("USER32: WinHelpW\n");
3227#endif
3228 rc = WinHelpA(arg1, astring, arg3, arg4);
3229 FreeAsciiString(astring);
3230 return rc;
3231}
3232//******************************************************************************
3233//******************************************************************************
3234HWND WIN32API WindowFromDC( HDC arg1)
3235{
3236#ifdef DEBUG
3237 WriteLog("USER32: WindowFromDC\n");
3238#endif
3239 return O32_WindowFromDC(arg1);
3240}
3241//******************************************************************************
3242//******************************************************************************
3243HWND WIN32API WindowFromPoint( POINT arg1)
3244{
3245#ifdef DEBUG
3246 WriteLog("USER32: WindowFromPoint\n");
3247#endif
3248 return O32_WindowFromPoint(arg1);
3249}
3250//******************************************************************************
3251//******************************************************************************
3252int WIN32API wvsprintfA( LPSTR arg1, LPCSTR arg2, va_list arg3)
3253{
3254#ifdef DEBUG
3255 WriteLog("USER32: wvsprintfA\n");
3256#endif
3257 return O32_wvsprintf(arg1, arg2, (LPCVOID *)arg3);
3258}
3259//******************************************************************************
3260//******************************************************************************
3261int WIN32API wvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, va_list argptr)
3262{
3263 int rc;
3264 char szOut[256];
3265 char *lpFmtA;
3266
3267 lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
3268#ifdef DEBUG
3269 WriteLog("USER32: wvsprintfW, DOES NOT HANDLE UNICODE STRINGS!\n");
3270 WriteLog("USER32: %s\n", lpFmt);
3271#endif
3272 rc = O32_wvsprintf(szOut, lpFmtA, (LPCVOID)argptr);
3273
3274 AsciiToUnicode(szOut, lpOut);
3275#ifdef DEBUG
3276 WriteLog("USER32: %s\n", lpOut);
3277#endif
3278 FreeAsciiString(lpFmtA);
3279 return(rc);
3280}
3281//******************************************************************************
3282//No need to support this
3283//******************************************************************************
3284BOOL WIN32API SetMessageQueue(int cMessagesMax)
3285{
3286#ifdef DEBUG
3287 WriteLog("USER32: SetMessageQueue\n");
3288#endif
3289 return(TRUE);
3290}
3291//******************************************************************************
3292//TODO: Not complete
3293//******************************************************************************
3294BOOL WIN32API GetScrollInfo(HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
3295{
3296#ifdef DEBUG
3297 WriteLog("USER32: GetScrollInfo\n");
3298#endif
3299 if(lpsi == NULL)
3300 return(FALSE);
3301
3302 if(lpsi->fMask & SIF_POS)
3303 lpsi->nPos = GetScrollPos(hwnd, fnBar);
3304 if(lpsi->fMask & SIF_RANGE)
3305 GetScrollRange(hwnd, fnBar, &lpsi->nMin, &lpsi->nMax);
3306 if(lpsi->fMask & SIF_PAGE) {
3307#ifdef DEBUG
3308 WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3309#endif
3310 lpsi->nPage = 25;
3311 }
3312 return(TRUE);
3313}
3314//******************************************************************************
3315//TODO: Not complete
3316//******************************************************************************
3317INT WIN32API SetScrollInfo(HWND hwnd, INT fnBar, const SCROLLINFO *lpsi, BOOL fRedraw)
3318{
3319 int smin, smax;
3320
3321#ifdef DEBUG
3322 WriteLog("USER32: SetScrollInfo\n");
3323#endif
3324 if(lpsi == NULL)
3325 return(FALSE);
3326
3327 if(lpsi->fMask & SIF_POS)
3328 SetScrollPos(hwnd, fnBar, lpsi->nPos, fRedraw);
3329 if(lpsi->fMask & SIF_RANGE)
3330 SetScrollRange(hwnd, fnBar, lpsi->nMin, lpsi->nMax, fRedraw);
3331 if(lpsi->fMask & SIF_PAGE) {
3332#ifdef DEBUG
3333 WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3334#endif
3335 }
3336 if(lpsi->fMask & SIF_DISABLENOSCROLL) {
3337#ifdef DEBUG
3338 WriteLog("USER32: GetScrollInfo, disable scrollbar not yet implemented\n");
3339#endif
3340 }
3341 return(TRUE);
3342}
3343//******************************************************************************
3344//******************************************************************************
3345BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3346 LPARAM lpData, int nCount, int X, int Y, int nWidth,
3347 int nHeight)
3348{
3349 BOOL rc;
3350 COLORREF curclr;
3351
3352#ifdef DEBUG
3353 WriteLog("USER32: GrayStringA, not completely implemented\n");
3354#endif
3355 if(lpOutputFunc == NULL && lpData == NULL) {
3356#ifdef DEBUG
3357 WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3358#endif
3359 return(FALSE);
3360 }
3361 if(lpOutputFunc) {
3362 return(lpOutputFunc(hdc, lpData, nCount));
3363 }
3364 curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3365 rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
3366 SetTextColor(hdc, curclr);
3367
3368 return(rc);
3369}
3370//******************************************************************************
3371//******************************************************************************
3372BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3373 LPARAM lpData, int nCount, int X, int Y, int nWidth,
3374 int nHeight)
3375{
3376 BOOL rc;
3377 char *astring;
3378 COLORREF curclr;
3379
3380#ifdef DEBUG
3381 WriteLog("USER32: GrayStringW, not completely implemented\n");
3382#endif
3383
3384 if(lpOutputFunc == NULL && lpData == NULL) {
3385#ifdef DEBUG
3386 WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3387#endif
3388 return(FALSE);
3389 }
3390 if(nCount == 0)
3391 nCount = UniStrlen((UniChar*)lpData);
3392
3393 if(lpOutputFunc) {
3394 return(lpOutputFunc(hdc, lpData, nCount));
3395 }
3396 astring = UnicodeToAsciiString((LPWSTR)lpData);
3397
3398 curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3399 rc = TextOutA(hdc, X, Y, astring, nCount);
3400 SetTextColor(hdc, curclr);
3401
3402 FreeAsciiString(astring);
3403 return(rc);
3404}
3405//******************************************************************************
3406//TODO:
3407//******************************************************************************
3408int WIN32API CopyAcceleratorTableA(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3409 int cAccelEntries)
3410{
3411#ifdef DEBUG
3412 WriteLog("USER32: CopyAcceleratorTableA, not implemented\n");
3413#endif
3414 return(0);
3415}
3416//******************************************************************************
3417//TODO:
3418//******************************************************************************
3419int WIN32API CopyAcceleratorTableW(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3420 int cAccelEntries)
3421{
3422#ifdef DEBUG
3423 WriteLog("USER32: CopyAcceleratorTableW, not implemented\n");
3424#endif
3425 return(0);
3426}
3427//******************************************************************************
3428//******************************************************************************
3429LRESULT WIN32API SendMessageTimeoutA(HWND hwnd, UINT Msg, WPARAM wParam,
3430 LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3431 LPDWORD lpdwResult)
3432{
3433#ifdef DEBUG
3434 WriteLog("USER32: SendMessageTimeoutA, partially implemented\n");
3435#endif
3436 //ignore fuFlags & wTimeOut
3437 *lpdwResult = SendMessageA(hwnd, Msg, wParam, lParam);
3438 return(TRUE);
3439}
3440//******************************************************************************
3441//******************************************************************************
3442LRESULT WIN32API SendMessageTimeoutW(HWND hwnd, UINT Msg, WPARAM wParam,
3443 LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3444 LPDWORD lpdwResult)
3445{
3446#ifdef DEBUG
3447 WriteLog("USER32: SendMessageTimeoutW, partially implemented\n");
3448#endif
3449 return(SendMessageTimeoutA(hwnd, Msg, wParam, lParam, fuFlags, uTimeOut, lpdwResult));
3450}
3451//******************************************************************************
3452//******************************************************************************
3453HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
3454{
3455#ifdef DEBUG
3456 WriteLog("USER32: CopyImage, not implemented\n");
3457#endif
3458 switch(uType) {
3459 case IMAGE_BITMAP:
3460 case IMAGE_CURSOR:
3461 case IMAGE_ICON:
3462 default:
3463#ifdef DEBUG
3464 WriteLog("USER32: CopyImage, unknown type\n");
3465#endif
3466 return(NULL);
3467 }
3468 return(NULL);
3469}
3470//******************************************************************************
3471//******************************************************************************
3472BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
3473{
3474#ifdef DEBUG
3475 WriteLog("USER32: GetKeyboardState, not properly implemented\n");
3476#endif
3477 memset(lpKeyState, 0, 256);
3478 return(TRUE);
3479}
3480//******************************************************************************
3481//******************************************************************************
3482BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
3483{
3484#ifdef DEBUG
3485 WriteLog("USER32: SetKeyboardState, not implemented\n");
3486#endif
3487 return(TRUE);
3488}
3489//******************************************************************************
3490//******************************************************************************
3491BOOL WIN32API SendNotifyMessageA(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3492{
3493#ifdef DEBUG
3494 WriteLog("USER32: SendNotifyMessageA, not completely implemented\n");
3495#endif
3496 return(SendMessageA(hwnd, Msg, wParam, lParam));
3497}
3498//******************************************************************************
3499//******************************************************************************
3500BOOL WIN32API SendNotifyMessageW(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3501{
3502#ifdef DEBUG
3503 WriteLog("USER32: SendNotifyMessageW, not completely implemented\n");
3504#endif
3505 return(SendMessageA(hwnd, Msg, wParam, lParam));
3506}
3507//******************************************************************************
3508//2nd parameter not used according to SDK (yet?)
3509//******************************************************************************
3510VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
3511{
3512#ifdef DEBUG
3513 WriteLog("USER32: SetLastErrorEx\n");
3514#endif
3515 SetLastError(dwErrCode);
3516}
3517//******************************************************************************
3518//******************************************************************************
3519LPARAM WIN32API SetMessageExtraInfo(LPARAM lParam)
3520{
3521#ifdef DEBUG
3522 WriteLog("USER32: SetMessageExtraInfo, not implemented\n");
3523#endif
3524 return(0);
3525}
3526//******************************************************************************
3527//******************************************************************************
3528BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
3529{
3530#ifdef DEBUG
3531 WriteLog("USER32: ActivateKeyboardLayout, not implemented\n");
3532#endif
3533 return(TRUE);
3534}
3535//******************************************************************************
3536//******************************************************************************
3537int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
3538{
3539#ifdef DEBUG
3540 WriteLog("USER32: GetKeyboardLayoutList, not implemented\n");
3541#endif
3542 return(0);
3543}
3544//******************************************************************************
3545//******************************************************************************
3546HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
3547{
3548#ifdef DEBUG
3549 WriteLog("USER32: GetKeyboardLayout, not implemented\n");
3550#endif
3551 return(0);
3552}
3553//******************************************************************************
3554//******************************************************************************
3555int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
3556{
3557#ifdef DEBUG
3558 WriteLog("USER32: LookupIconIdFromDirectory, not implemented\n");
3559#endif
3560 return(0);
3561}
3562//******************************************************************************
3563//******************************************************************************
3564int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL fIcon,
3565 int cxDesired, int cyDesired,
3566 UINT Flags)
3567{
3568#ifdef DEBUG
3569 WriteLog("USER32: LookupIconIdFromDirectoryEx, not implemented\n");
3570#endif
3571 return(0);
3572}
3573//******************************************************************************
3574//DWORD idAttach; /* thread to attach */
3575//DWORD idAttachTo; /* thread to attach to */
3576//BOOL fAttach; /* attach or detach */
3577//******************************************************************************
3578BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
3579{
3580#ifdef DEBUG
3581 WriteLog("USER32: AttachThreadInput, not implemented\n");
3582#endif
3583 return(TRUE);
3584}
3585//******************************************************************************
3586//******************************************************************************
3587BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
3588{
3589#ifdef DEBUG
3590 WriteLog("USER32: RegisterHotKey, not implemented\n");
3591#endif
3592 return(TRUE);
3593}
3594//******************************************************************************
3595//******************************************************************************
3596BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
3597{
3598#ifdef DEBUG
3599 WriteLog("USER32: UnregisterHotKey, not implemented\n");
3600#endif
3601 return(TRUE);
3602}
3603//******************************************************************************
3604//******************************************************************************
3605BOOL WIN32API DrawStateA(HDC hdc, HBRUSH hbc, DRAWSTATEPROC lpOutputFunc,
3606 LPARAM lData, WPARAM wData, int x, int y, int cx,
3607 int cy, UINT fuFlags)
3608{
3609#ifdef DEBUG
3610 WriteLog("USER32: DrawStateA, not implemented\n");
3611#endif
3612 return(TRUE);
3613}
3614//******************************************************************************
3615//******************************************************************************
3616//******************************************************************************
3617//******************************************************************************
3618BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
3619{
3620#ifdef DEBUG
3621 WriteLog("USER32: SetWindowContextHelpId, not implemented\n");
3622#endif
3623 return(TRUE);
3624}
3625//******************************************************************************
3626//******************************************************************************
3627DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
3628{
3629#ifdef DEBUG
3630 WriteLog("USER32: GetWindowContextHelpId, not implemented\n");
3631#endif
3632 return(0);
3633}
3634//******************************************************************************
3635//restores iconized window to previous size/position
3636//******************************************************************************
3637BOOL WIN32API OpenIcon(HWND hwnd)
3638{
3639#ifdef DEBUG
3640 WriteLog("USER32: OpenIcon\n");
3641#endif
3642 if(!IsIconic(hwnd))
3643 return FALSE;
3644 ShowWindow(hwnd, SW_SHOWNORMAL);
3645 return TRUE;
3646}
3647//******************************************************************************
3648//******************************************************************************
3649BOOL WIN32API IsWindowUnicode(HWND hwnd)
3650{
3651#ifdef DEBUG
3652 WriteLog("USER32: IsWindowUnicode, not implemented\n");
3653#endif
3654 return(FALSE);
3655}
3656//******************************************************************************
3657//******************************************************************************
3658BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
3659{
3660#ifdef DEBUG
3661 WriteLog("USER32: GetMonitorInfoA not supported!!\n");
3662#endif
3663 return(FALSE);
3664}
3665//******************************************************************************
3666//******************************************************************************
3667BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
3668{
3669#ifdef DEBUG
3670 WriteLog("USER32: GetMonitorInfoW not supported!!\n");
3671#endif
3672 return(FALSE);
3673}
3674//******************************************************************************
3675//******************************************************************************
3676HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
3677{
3678#ifdef DEBUG
3679 WriteLog("USER32: MonitorFromWindow not correctly supported??\n");
3680#endif
3681 return(0);
3682}
3683//******************************************************************************
3684//******************************************************************************
3685HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
3686{
3687#ifdef DEBUG
3688 WriteLog("USER32: MonitorFromRect not correctly supported??\n");
3689#endif
3690 return(0);
3691}
3692//******************************************************************************
3693//******************************************************************************
3694HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
3695{
3696#ifdef DEBUG
3697 WriteLog("USER32: MonitorFromPoint not correctly supported??\n");
3698#endif
3699 return(0);
3700}
3701//******************************************************************************
3702//******************************************************************************
3703BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
3704{
3705#ifdef DEBUG
3706 WriteLog("USER32: EnumDisplayMonitors not supported??\n");
3707#endif
3708 return(FALSE);
3709}
3710//******************************************************************************
3711//******************************************************************************
3712BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
3713 LPDEVMODEA lpDevMode)
3714{
3715#ifdef DEBUG
3716 WriteLog("USER32: EnumDisplaySettingsA FAKED\n");
3717#endif
3718 switch(iModeNum) {
3719 case 0:
3720 lpDevMode->dmBitsPerPel = 16;
3721 lpDevMode->dmPelsWidth = 768;
3722 lpDevMode->dmPelsHeight = 1024;
3723 lpDevMode->dmDisplayFlags = 0;
3724 lpDevMode->dmDisplayFrequency = 70;
3725 break;
3726 case 1:
3727 lpDevMode->dmBitsPerPel = 16;
3728 lpDevMode->dmPelsWidth = 640;
3729 lpDevMode->dmPelsHeight = 480;
3730 lpDevMode->dmDisplayFlags = 0;
3731 lpDevMode->dmDisplayFrequency = 70;
3732 break;
3733 default:
3734 return(FALSE);
3735 }
3736 return(TRUE);
3737}
3738//******************************************************************************
3739//******************************************************************************
3740LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA lpDevMode, DWORD dwFlags)
3741{
3742#ifdef DEBUG
3743 if(lpDevMode) {
3744 WriteLog("USER32: ChangeDisplaySettingsA FAKED %X\n", dwFlags);
3745 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
3746 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsWidth %d\n", lpDevMode->dmPelsWidth);
3747 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
3748 }
3749#endif
3750 return(DISP_CHANGE_SUCCESSFUL);
3751}
3752//******************************************************************************
3753//******************************************************************************
3754
3755
3756/*****************************************************************************
3757 * Name : BOOL WIN32API AnyPopup
3758 * Purpose : The AnyPopup function indicates whether an owned, visible,
3759 * top-level pop-up, or overlapped window exists on the screen. The
3760 * function searches the entire Windows screen, not just the calling
3761 * application's client area.
3762 * Parameters: VOID
3763 * Variables :
3764 * Result : If a pop-up window exists, the return value is TRUE even if the
3765 * pop-up window is completely covered by other windows. Otherwise,
3766 * it is FALSE.
3767 * Remark : AnyPopup is a Windows version 1.x function and is retained for
3768 * compatibility purposes. It is generally not useful.
3769 * Status : UNTESTED STUB
3770 *
3771 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3772 *****************************************************************************/
3773
3774BOOL WIN32API AnyPopup(VOID)
3775{
3776 dprintf(("USER32:AnyPopup() not implemented.\n"));
3777
3778 return (FALSE);
3779}
3780
3781
3782/*****************************************************************************
3783 * Name : long WIN32API BroadcastSystemMessage
3784 * Purpose : The BroadcastSystemMessage function sends a message to the given
3785 * recipients. The recipients can be applications, installable
3786 * drivers, Windows-based network drivers, system-level device
3787 * drivers, or any combination of these system components.
3788 * Parameters: DWORD dwFlags,
3789 LPDWORD lpdwRecipients,
3790 UINT uiMessage,
3791 WPARAM wParam,
3792 LPARAM lParam
3793 * Variables :
3794 * Result : If the function succeeds, the return value is a positive value.
3795 * If the function is unable to broadcast the message, the return value is -1.
3796 * If the dwFlags parameter is BSF_QUERY and at least one recipient returned FALSE to the corresponding message, the return value is zero.
3797 * Remark :
3798 * Status : UNTESTED STUB
3799 *
3800 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3801 *****************************************************************************/
3802
3803long WIN32API BroadcastSystemMessage(DWORD dwFlags,
3804 LPDWORD lpdwRecipients,
3805 UINT uiMessage,
3806 WPARAM wParam,
3807 LPARAM lParam)
3808{
3809 dprintf(("USER32:BroadcastSystemMessage(%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
3810 dwFlags,
3811 lpdwRecipients,
3812 uiMessage,
3813 wParam,
3814 lParam));
3815
3816 return (-1);
3817}
3818
3819
3820/*****************************************************************************
3821 * Name : WORD WIN32API CascadeWindows
3822 * Purpose : The CascadeWindows function cascades the specified windows or
3823 * the child windows of the specified parent window.
3824 * Parameters: HWND hwndParent handle of parent window
3825 * UINT wHow types of windows not to arrange
3826 * CONST RECT * lpRect rectangle to arrange windows in
3827 * UINT cKids number of windows to arrange
3828 * const HWND FAR * lpKids array of window handles
3829 * Variables :
3830 * Result : If the function succeeds, the return value is the number of windows arranged.
3831 * If the function fails, the return value is zero.
3832 * Remark :
3833 * Status : UNTESTED STUB
3834 *
3835 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3836 *****************************************************************************/
3837
3838WORD WIN32API CascadeWindows(HWND hwndParent,
3839 UINT wHow,
3840 CONST LPRECT lpRect,
3841 UINT cKids,
3842 const HWND *lpKids)
3843{
3844 dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
3845 hwndParent,
3846 wHow,
3847 lpRect,
3848 cKids,
3849 lpKids));
3850
3851 return (0);
3852}
3853
3854
3855/*****************************************************************************
3856 * Name : LONG WIN32API ChangeDisplaySettingsW
3857 * Purpose : The ChangeDisplaySettings function changes the display settings
3858 * to the specified graphics mode.
3859 * Parameters: LPDEVMODEW lpDevModeW
3860 * DWORD dwFlags
3861 * Variables :
3862 * Result : DISP_CHANGE_SUCCESSFUL The settings change was successful.
3863 * DISP_CHANGE_RESTART The computer must be restarted in order for the graphics mode to work.
3864 * DISP_CHANGE_BADFLAGS An invalid set of flags was passed in.
3865 * DISP_CHANGE_FAILED The display driver failed the specified graphics mode.
3866 * DISP_CHANGE_BADMODE The graphics mode is not supported.
3867 * DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
3868 * Remark :
3869 * Status : UNTESTED STUB
3870 *
3871 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3872 *****************************************************************************/
3873
3874LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
3875 DWORD dwFlags)
3876{
3877 dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
3878 lpDevMode,
3879 dwFlags));
3880
3881 return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
3882 dwFlags));
3883}
3884
3885/*****************************************************************************
3886 * Name : BOOL WIN32API CloseDesktop
3887 * Purpose : The CloseDesktop function closes an open handle of a desktop
3888 * object. A desktop is a secure object contained within a window
3889 * station object. A desktop has a logical display surface and
3890 * contains windows, menus and hooks.
3891 * Parameters: HDESK hDesktop
3892 * Variables :
3893 * Result : If the function succeeds, the return value is TRUE.
3894 * If the functions fails, the return value is FALSE. To get
3895 * extended error information, call GetLastError.
3896 * Remark :
3897 * Status : UNTESTED STUB
3898 *
3899 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3900 *****************************************************************************/
3901
3902BOOL WIN32API CloseDesktop(HDESK hDesktop)
3903{
3904 dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
3905 hDesktop));
3906
3907 return (FALSE);
3908}
3909
3910
3911/*****************************************************************************
3912 * Name : BOOL WIN32API CloseWindowStation
3913 * Purpose : The CloseWindowStation function closes an open window station handle.
3914 * Parameters: HWINSTA hWinSta
3915 * Variables :
3916 * Result :
3917 * Remark : If the function succeeds, the return value is TRUE.
3918 * If the functions fails, the return value is FALSE. To get
3919 * extended error information, call GetLastError.
3920 * Status : UNTESTED STUB
3921 *
3922 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3923 *****************************************************************************/
3924
3925BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
3926{
3927 dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
3928 hWinSta));
3929
3930 return (FALSE);
3931}
3932
3933
3934/*****************************************************************************
3935 * Name : HDESK WIN32API CreateDesktopA
3936 * Purpose : The CreateDesktop function creates a new desktop on the window
3937 * station associated with the calling process.
3938 * Parameters: LPCTSTR lpszDesktop name of the new desktop
3939 * LPCTSTR lpszDevice name of display device to assign to the desktop
3940 * LPDEVMODE pDevMode reserved; must be NULL
3941 * DWORD dwFlags flags to control interaction with other applications
3942 * DWORD dwDesiredAccess specifies access of returned handle
3943 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
3944 * Variables :
3945 * Result : If the function succeeds, the return value is a handle of the
3946 * newly created desktop.
3947 * If the function fails, the return value is NULL. To get extended
3948 * error information, call GetLastError.
3949 * Remark :
3950 * Status : UNTESTED STUB
3951 *
3952 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3953 *****************************************************************************/
3954
3955HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
3956 LPCTSTR lpszDevice,
3957 LPDEVMODEA pDevMode,
3958 DWORD dwFlags,
3959 DWORD dwDesiredAccess,
3960 LPSECURITY_ATTRIBUTES lpsa)
3961{
3962 dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
3963 lpszDesktop,
3964 lpszDevice,
3965 pDevMode,
3966 dwFlags,
3967 dwDesiredAccess,
3968 lpsa));
3969
3970 return (NULL);
3971}
3972
3973
3974/*****************************************************************************
3975 * Name : HDESK WIN32API CreateDesktopW
3976 * Purpose : The CreateDesktop function creates a new desktop on the window
3977 * station associated with the calling process.
3978 * Parameters: LPCTSTR lpszDesktop name of the new desktop
3979 * LPCTSTR lpszDevice name of display device to assign to the desktop
3980 * LPDEVMODE pDevMode reserved; must be NULL
3981 * DWORD dwFlags flags to control interaction with other applications
3982 * DWORD dwDesiredAccess specifies access of returned handle
3983 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
3984 * Variables :
3985 * Result : If the function succeeds, the return value is a handle of the
3986 * newly created desktop.
3987 * If the function fails, the return value is NULL. To get extended
3988 * error information, call GetLastError.
3989 * Remark :
3990 * Status : UNTESTED STUB
3991 *
3992 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3993 *****************************************************************************/
3994
3995HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
3996 LPCTSTR lpszDevice,
3997 LPDEVMODEW pDevMode,
3998 DWORD dwFlags,
3999 DWORD dwDesiredAccess,
4000 LPSECURITY_ATTRIBUTES lpsa)
4001{
4002 dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4003 lpszDesktop,
4004 lpszDevice,
4005 pDevMode,
4006 dwFlags,
4007 dwDesiredAccess,
4008 lpsa));
4009
4010 return (NULL);
4011}
4012
4013
4014/*****************************************************************************
4015 * Name : HWINSTA WIN32API CreateWindowStationA
4016 * Purpose : The CreateWindowStation function creates a window station object.
4017 * It returns a handle that can be used to access the window station.
4018 * A window station is a secure object that contains a set of global
4019 * atoms, a clipboard, and a set of desktop objects.
4020 * Parameters: LPTSTR lpwinsta name of the new window station
4021 * DWORD dwReserved reserved; must be NULL
4022 * DWORD dwDesiredAccess specifies access of returned handle
4023 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4024 * Variables :
4025 * Result : If the function succeeds, the return value is the handle to the
4026 * newly created window station.
4027 * If the function fails, the return value is NULL. To get extended
4028 * error information, call GetLastError.
4029 * Remark :
4030 * Status : UNTESTED STUB
4031 *
4032 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4033 *****************************************************************************/
4034
4035HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
4036 DWORD dwReserved,
4037 DWORD dwDesiredAccess,
4038 LPSECURITY_ATTRIBUTES lpsa)
4039{
4040 dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
4041 lpWinSta,
4042 dwReserved,
4043 dwDesiredAccess,
4044 lpsa));
4045
4046 return (NULL);
4047}
4048
4049
4050/*****************************************************************************
4051 * Name : HWINSTA WIN32API CreateWindowStationW
4052 * Purpose : The CreateWindowStation function creates a window station object.
4053 * It returns a handle that can be used to access the window station.
4054 * A window station is a secure object that contains a set of global
4055 * atoms, a clipboard, and a set of desktop objects.
4056 * Parameters: LPTSTR lpwinsta name of the new window station
4057 * DWORD dwReserved reserved; must be NULL
4058 * DWORD dwDesiredAccess specifies access of returned handle
4059 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4060 * Variables :
4061 * Result : If the function succeeds, the return value is the handle to the
4062 * newly created window station.
4063 * If the function fails, the return value is NULL. To get extended
4064 * error information, call GetLastError.
4065 * Remark :
4066 * Status : UNTESTED STUB
4067 *
4068 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4069 *****************************************************************************/
4070
4071HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
4072 DWORD dwReserved,
4073 DWORD dwDesiredAccess,
4074 LPSECURITY_ATTRIBUTES lpsa)
4075{
4076 dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
4077 lpWinSta,
4078 dwReserved,
4079 dwDesiredAccess,
4080 lpsa));
4081
4082 return (NULL);
4083}
4084
4085/*****************************************************************************
4086 * Name : BOOL WIN32API DragDetect
4087 * Purpose : The DragDetect function captures the mouse and tracks its movement
4088 * Parameters: HWND hwnd
4089 * POINT pt
4090 * Variables :
4091 * Result : If the user moved the mouse outside of the drag rectangle while
4092 * holding the left button down, the return value is TRUE.
4093 * If the user did not move the mouse outside of the drag rectangle
4094 * while holding the left button down, the return value is FALSE.
4095 * Remark :
4096 * Status : UNTESTED STUB
4097 *
4098 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4099 *****************************************************************************/
4100
4101BOOL WIN32API DragDetect(HWND hwnd,
4102 POINT pt)
4103{
4104 dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
4105 hwnd));
4106
4107 return (FALSE);
4108}
4109
4110
4111/*****************************************************************************
4112 * Name : BOOL WIN32API DrawAnimatedRects
4113 * Purpose : The DrawAnimatedRects function draws a wire-frame rectangle
4114 * and animates it to indicate the opening of an icon or the
4115 * minimizing or maximizing of a window.
4116 * Parameters: HWND hwnd handle of clipping window
4117 * int idAni type of animation
4118 * CONST RECT * lprcFrom address of rectangle coordinates (minimized)
4119 * CONST RECT * lprcTo address of rectangle coordinates (restored)
4120 * Variables :
4121 * Result : If the function succeeds, the return value is TRUE.
4122 * If the function fails, the return value is FALSE.
4123 * Remark :
4124 * Status : UNTESTED STUB
4125 *
4126 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4127 *****************************************************************************/
4128
4129BOOL WIN32API DrawAnimatedRects(HWND hwnd,
4130 int idAni,
4131 CONST RECT *lprcFrom,
4132 CONST RECT *lprcTo)
4133{
4134 dprintf(("USER32:DrawAnimatedRects (%08xh,%u,%08xh,%08x) not implemented.\n",
4135 hwnd,
4136 idAni,
4137 lprcFrom,
4138 lprcTo));
4139
4140 return (TRUE);
4141}
4142
4143
4144/*****************************************************************************
4145 * Name : VOID WIN32API DrawCaption
4146 * Purpose : The DrawCaption function draws a window caption.
4147 * Parameters: HDC hdc handle of device context
4148 * LPRECT lprc address of bounding rectangle coordinates
4149 * HFONT hfont handle of font for caption
4150 * HICON hicon handle of icon in caption
4151 * LPSTR lpszText address of caption string
4152 * WORD wFlags drawing options
4153 * Variables :
4154 * Result :
4155 * Remark :
4156 * Status : UNTESTED STUB
4157 *
4158 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4159 *****************************************************************************/
4160
4161BOOL WIN32API DrawCaption (HWND hwnd,
4162 HDC hdc,
4163 const RECT *lprc,
4164 UINT wFlags)
4165{
4166 dprintf(("USER32:DrawCaption (%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4167 hwnd,
4168 hdc,
4169 lprc,
4170 wFlags));
4171
4172 return FALSE;
4173}
4174
4175
4176/*****************************************************************************
4177 * Name :
4178 * Purpose :
4179 * Parameters:
4180 * Variables :
4181 * Result :
4182 * Remark :
4183 * Status : UNTESTED STUB
4184 *
4185 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4186 *****************************************************************************/
4187
4188BOOL WIN32API DrawStateW(HDC hdc,
4189 HBRUSH hBrush,
4190 DRAWSTATEPROC lpOutputFunc,
4191 LPARAM lParam,
4192 WPARAM wParam,
4193 int x,
4194 int y,
4195 int cx,
4196 int cy,
4197 UINT fuFlags)
4198{
4199 dprintf(("USER32:DrawStateW (%08xh,%08xh,%08xh,%08xh,%08xh,%d,%d,%d,%d,%08x) not implemented.\n",
4200 hdc,
4201 hBrush,
4202 lpOutputFunc,
4203 lParam,
4204 wParam,
4205 x,
4206 y,
4207 cx,
4208 cy,
4209 fuFlags));
4210
4211 return(DrawStateA(hdc,
4212 hBrush,
4213 lpOutputFunc,
4214 lParam,
4215 wParam,
4216 x,
4217 y,
4218 cx,
4219 cy,
4220 fuFlags));
4221}
4222
4223
4224/*****************************************************************************
4225 * Name : BOOL WIN32API EnumDesktopWindows
4226 * Purpose : The EnumDesktopWindows function enumerates all windows in a
4227 * desktop by passing the handle of each window, in turn, to an
4228 * application-defined callback function.
4229 * Parameters: HDESK hDesktop handle of desktop to enumerate
4230 * WNDENUMPROC lpfn points to application's callback function
4231 * LPARAM lParam 32-bit value to pass to the callback function
4232 * Variables :
4233 * Result : If the function succeeds, the return value is TRUE.
4234 * If the function fails, the return value is FALSE. To get
4235 * extended error information, call GetLastError.
4236 * Remark :
4237 * Status : UNTESTED STUB
4238 *
4239 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4240 *****************************************************************************/
4241
4242BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
4243 WNDENUMPROC lpfn,
4244 LPARAM lParam)
4245{
4246 dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
4247 hDesktop,
4248 lpfn,
4249 lParam));
4250
4251 return (FALSE);
4252}
4253
4254
4255/*****************************************************************************
4256 * Name : BOOL WIN32API EnumDesktopsA
4257 * Purpose : The EnumDesktops function enumerates all desktops in the window
4258 * station assigned to the calling process. The function does so by
4259 * passing the name of each desktop, in turn, to an application-
4260 * defined callback function.
4261 * Parameters: HWINSTA hwinsta handle of window station to enumerate
4262 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
4263 * LPARAM lParam 32-bit value to pass to the callback function
4264 * Variables :
4265 * Result : If the function succeeds, the return value is TRUE.
4266 * If the function fails, the return value is FALSE. To get extended
4267 * error information, call GetLastError.
4268 * Remark :
4269 * Status : UNTESTED STUB
4270 *
4271 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4272 *****************************************************************************/
4273
4274BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
4275 DESKTOPENUMPROCA lpEnumFunc,
4276 LPARAM lParam)
4277{
4278 dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
4279 hWinSta,
4280 lpEnumFunc,
4281 lParam));
4282
4283 return (FALSE);
4284}
4285
4286
4287/*****************************************************************************
4288 * Name : BOOL WIN32API EnumDesktopsW
4289 * Purpose : The EnumDesktops function enumerates all desktops in the window
4290 * station assigned to the calling process. The function does so by
4291 * passing the name of each desktop, in turn, to an application-
4292 * defined callback function.
4293 * Parameters: HWINSTA hwinsta handle of window station to enumerate
4294 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
4295 * LPARAM lParam 32-bit value to pass to the callback function
4296 * Variables :
4297 * Result : If the function succeeds, the return value is TRUE.
4298 * If the function fails, the return value is FALSE. To get extended
4299 * error information, call GetLastError.
4300 * Remark :
4301 * Status : UNTESTED STUB
4302 *
4303 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4304 *****************************************************************************/
4305
4306BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
4307 DESKTOPENUMPROCW lpEnumFunc,
4308 LPARAM lParam)
4309{
4310 dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
4311 hWinSta,
4312 lpEnumFunc,
4313 lParam));
4314
4315 return (FALSE);
4316}
4317
4318
4319
4320/*****************************************************************************
4321 * Name : BOOL WIN32API EnumDisplaySettingsW
4322 * Purpose : The EnumDisplaySettings function obtains information about one
4323 * of a display device's graphics modes. You can obtain information
4324 * for all of a display device's graphics modes by making a series
4325 * of calls to this function.
4326 * Parameters: LPCTSTR lpszDeviceName specifies the display device
4327 * DWORD iModeNum specifies the graphics mode
4328 * LPDEVMODE lpDevMode points to structure to receive settings
4329 * Variables :
4330 * Result : If the function succeeds, the return value is TRUE.
4331 * If the function fails, the return value is FALSE.
4332 * Remark :
4333 * Status : UNTESTED STUB
4334 *
4335 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4336 *****************************************************************************/
4337
4338BOOL WIN32API EnumDisplaySettingsW(LPCSTR lpszDeviceName,
4339 DWORD iModeNum,
4340 LPDEVMODEW lpDevMode)
4341{
4342 dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
4343 lpszDeviceName,
4344 iModeNum,
4345 lpDevMode));
4346
4347 return (EnumDisplaySettingsA(lpszDeviceName,
4348 iModeNum,
4349 (LPDEVMODEA)lpDevMode));
4350}
4351
4352
4353/*****************************************************************************
4354 * Name : BOOL WIN32API EnumWindowStationsA
4355 * Purpose : The EnumWindowStations function enumerates all windowstations
4356 * in the system by passing the name of each window station, in
4357 * turn, to an application-defined callback function.
4358 * Parameters:
4359 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4360 * LPARAM lParam 32-bit value to pass to the callback function
4361 * Result : If the function succeeds, the return value is TRUE.
4362 * If the function fails the return value is FALSE. To get extended
4363 * error information, call GetLastError.
4364 * Remark :
4365 * Status : UNTESTED STUB
4366 *
4367 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4368 *****************************************************************************/
4369
4370BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
4371 LPARAM lParam)
4372{
4373 dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
4374 lpEnumFunc,
4375 lParam));
4376
4377 return (FALSE);
4378}
4379
4380
4381/*****************************************************************************
4382 * Name : BOOL WIN32API EnumWindowStationsW
4383 * Purpose : The EnumWindowStations function enumerates all windowstations
4384 * in the system by passing the name of each window station, in
4385 * turn, to an application-defined callback function.
4386 * Parameters:
4387 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4388 * LPARAM lParam 32-bit value to pass to the callback function
4389 * Result : If the function succeeds, the return value is TRUE.
4390 * If the function fails the return value is FALSE. To get extended
4391 * error information, call GetLastError.
4392 * Remark :
4393 * Status : UNTESTED STUB
4394 *
4395 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4396 *****************************************************************************/
4397
4398BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
4399 LPARAM lParam)
4400{
4401 dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
4402 lpEnumFunc,
4403 lParam));
4404
4405 return (FALSE);
4406}
4407
4408
4409/*****************************************************************************
4410 * Name : HWND WIN32API FindWindowExW
4411 * Purpose : The FindWindowEx function retrieves the handle of a window whose
4412 * class name and window name match the specified strings. The
4413 * function searches child windows, beginning with the one following
4414 * the given child window.
4415 * Parameters: HWND hwndParent handle of parent window
4416 * HWND hwndChildAfter handle of a child window
4417 * LPCTSTR lpszClass address of class name
4418 * LPCTSTR lpszWindow address of window name
4419 * Variables :
4420 * Result : If the function succeeds, the return value is the handle of the
4421 * window that has the specified class and window names.
4422 * If the function fails, the return value is NULL. To get extended
4423 * error information, call GetLastError.
4424 * Remark :
4425 * Status : UNTESTED STUB
4426 *
4427 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4428 *****************************************************************************/
4429
4430HWND WIN32API FindWindowExW(HWND hwndParent,
4431 HWND hwndChildAfter,
4432 LPCWSTR lpszClass,
4433 LPCWSTR lpszWindow)
4434{
4435 dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
4436 hwndParent,
4437 hwndChildAfter,
4438 lpszClass,
4439 lpszWindow));
4440
4441 return (NULL);
4442}
4443
4444/*****************************************************************************
4445 * Name : BOOL WIN32API GetInputState
4446 * Purpose : The GetInputState function determines whether there are
4447 * mouse-button or keyboard messages in the calling thread's message queue.
4448 * Parameters:
4449 * Variables :
4450 * Result : If the queue contains one or more new mouse-button or keyboard
4451 * messages, the return value is TRUE.
4452 * If the function fails, the return value is FALSE.
4453 * Remark :
4454 * Status : UNTESTED STUB
4455 *
4456 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4457 *****************************************************************************/
4458
4459BOOL WIN32API GetInputState(VOID)
4460{
4461 dprintf(("USER32:GetInputState () not implemented.\n"));
4462
4463 return (FALSE);
4464}
4465
4466
4467/*****************************************************************************
4468 * Name : UINT WIN32API GetKBCodePage
4469 * Purpose : The GetKBCodePage function is provided for compatibility with
4470 * earlier versions of Windows. In the Win32 application programming
4471 * interface (API) it just calls the GetOEMCP function.
4472 * Parameters:
4473 * Variables :
4474 * Result : If the function succeeds, the return value is an OEM code-page
4475 * identifier, or it is the default identifier if the registry
4476 * value is not readable. For a list of OEM code-page identifiers,
4477 * see GetOEMCP.
4478 * Remark :
4479 * Status : UNTESTED
4480 *
4481 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4482 *****************************************************************************/
4483
4484UINT WIN32API GetKBCodePage(VOID)
4485{
4486 return (GetOEMCP());
4487}
4488
4489
4490/*****************************************************************************
4491 * Name : BOOL WIN32API GetKeyboardLayoutNameA
4492 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
4493 * active keyboard layout.
4494 * Parameters: LPTSTR pwszKLID address of buffer for layout name
4495 * Variables :
4496 * Result : If the function succeeds, the return value is TRUE.
4497 * If the function fails, the return value is FALSE. To get extended
4498 * error information, call GetLastError.
4499 * Remark :
4500 * Status : UNTESTED STUB
4501 *
4502 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4503 *****************************************************************************/
4504
4505BOOL WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
4506{
4507 dprintf(("USER32:GetKeyboardLayoutNameA (%08x) not implemented.",
4508 pwszKLID));
4509
4510 return(FALSE);
4511}
4512
4513
4514/*****************************************************************************
4515 * Name : BOOL WIN32API GetKeyboardLayoutNameW
4516 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
4517 * active keyboard layout.
4518 * Parameters: LPTSTR pwszKLID address of buffer for layout name
4519 * Variables :
4520 * Result : If the function succeeds, the return value is TRUE.
4521 * If the function fails, the return value is FALSE. To get extended
4522 * error information, call GetLastError.
4523 * Remark :
4524 * Status : UNTESTED STUB
4525 *
4526 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4527 *****************************************************************************/
4528
4529BOOL WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
4530{
4531 dprintf(("USER32:GetKeyboardLayoutNameW (%08x) not implemented.",
4532 pwszKLID));
4533
4534 return(FALSE);
4535}
4536
4537
4538
4539
4540/*****************************************************************************
4541 * Name : HWINSTA WIN32API GetProcessWindowStation
4542 * Purpose : The GetProcessWindowStation function returns a handle of the
4543 * window station associated with the calling process.
4544 * Parameters:
4545 * Variables :
4546 * Result : If the function succeeds, the return value is a handle of the
4547 * window station associated with the calling process.
4548 * If the function fails, the return value is NULL. This can occur
4549 * if the calling process is not an application written for Windows
4550 * NT. To get extended error information, call GetLastError.
4551 * Remark :
4552 * Status : UNTESTED STUB
4553 *
4554 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4555 *****************************************************************************/
4556
4557HWINSTA WIN32API GetProcessWindowStation(VOID)
4558{
4559 dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
4560
4561 return (NULL);
4562}
4563
4564
4565
4566/*****************************************************************************
4567 * Name : HDESK WIN32API GetThreadDesktop
4568 * Purpose : The GetThreadDesktop function returns a handle to the desktop
4569 * associated with a specified thread.
4570 * Parameters: DWORD dwThreadId thread identifier
4571 * Variables :
4572 * Result : If the function succeeds, the return value is the handle of the
4573 * desktop associated with the specified thread.
4574 * Remark :
4575 * Status : UNTESTED STUB
4576 *
4577 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4578 *****************************************************************************/
4579
4580HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
4581{
4582 dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
4583 dwThreadId));
4584
4585 return (NULL);
4586}
4587
4588
4589/*****************************************************************************
4590 * Name : BOOL WIN32API GetUserObjectInformationA
4591 * Purpose : The GetUserObjectInformation function returns information about
4592 * a window station or desktop object.
4593 * Parameters: HANDLE hObj handle of object to get information for
4594 * int nIndex type of information to get
4595 * PVOID pvInfo points to buffer that receives the information
4596 * DWORD nLength size, in bytes, of pvInfo buffer
4597 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4598 * Variables :
4599 * Result : If the function succeeds, the return value is TRUE.
4600 * If the function fails, the return value is FALSE. To get extended
4601 * error information, call GetLastError.
4602 * Remark :
4603 * Status : UNTESTED STUB
4604 *
4605 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4606 *****************************************************************************/
4607
4608BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
4609 int nIndex,
4610 PVOID pvInfo,
4611 DWORD nLength,
4612 LPDWORD lpnLengthNeeded)
4613{
4614 dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4615 hObj,
4616 nIndex,
4617 pvInfo,
4618 nLength,
4619 lpnLengthNeeded));
4620
4621 return (FALSE);
4622}
4623
4624
4625/*****************************************************************************
4626 * Name : BOOL WIN32API GetUserObjectInformationW
4627 * Purpose : The GetUserObjectInformation function returns information about
4628 * a window station or desktop object.
4629 * Parameters: HANDLE hObj handle of object to get information for
4630 * int nIndex type of information to get
4631 * PVOID pvInfo points to buffer that receives the information
4632 * DWORD nLength size, in bytes, of pvInfo buffer
4633 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4634 * Variables :
4635 * Result : If the function succeeds, the return value is TRUE.
4636 * If the function fails, the return value is FALSE. To get extended
4637 * error information, call GetLastError.
4638 * Remark :
4639 * Status : UNTESTED STUB
4640 *
4641 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4642 *****************************************************************************/
4643
4644BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
4645 int nIndex,
4646 PVOID pvInfo,
4647 DWORD nLength,
4648 LPDWORD lpnLengthNeeded)
4649{
4650 dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4651 hObj,
4652 nIndex,
4653 pvInfo,
4654 nLength,
4655 lpnLengthNeeded));
4656
4657 return (FALSE);
4658}
4659
4660
4661/*****************************************************************************
4662 * Name : BOOL WIN32API GetUserObjectSecurity
4663 * Purpose : The GetUserObjectSecurity function retrieves security information
4664 * for the specified user object.
4665 * Parameters: HANDLE hObj handle of user object
4666 * SECURITY_INFORMATION * pSIRequested address of requested security information
4667 * LPSECURITY_DESCRIPTOR pSID address of security descriptor
4668 * DWORD nLength size of buffer for security descriptor
4669 * LPDWORD lpnLengthNeeded address of required size of buffer
4670 * Variables :
4671 * Result : If the function succeeds, the return value is TRUE.
4672 * If the function fails, the return value is FALSE. To get extended
4673 * error information, call GetLastError.
4674 * Remark :
4675 * Status : UNTESTED STUB
4676 *
4677 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4678 *****************************************************************************/
4679
4680BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
4681 SECURITY_INFORMATION * pSIRequested,
4682 LPSECURITY_DESCRIPTOR pSID,
4683 DWORD nLength,
4684 LPDWORD lpnLengthNeeded)
4685{
4686 dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4687 hObj,
4688 pSIRequested,
4689 pSID,
4690 nLength,
4691 lpnLengthNeeded));
4692
4693 return (FALSE);
4694}
4695
4696
4697
4698/*****************************************************************************
4699 * Name : int WIN32API GetWindowRgn
4700 * Purpose : The GetWindowRgn function obtains a copy of the window region of a window.
4701 * Parameters: HWND hWnd handle to window whose window region is to be obtained
4702 * HRGN hRgn handle to region that receives a copy of the window region
4703 * Variables :
4704 * Result : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
4705 * Remark :
4706 * Status : UNTESTED STUB
4707 *
4708 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4709 *****************************************************************************/
4710
4711int WIN32API GetWindowRgn (HWND hWnd,
4712 HRGN hRgn)
4713{
4714 dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
4715 hWnd,
4716 hRgn));
4717
4718 return (NULLREGION);
4719}
4720
4721
4722
4723/*****************************************************************************
4724 * Name : HCURSOR WIN32API LoadCursorFromFileA
4725 * Purpose : The LoadCursorFromFile function creates a cursor based on data
4726 * contained in a file. The file is specified by its name or by a
4727 * system cursor identifier. The function returns a handle to the
4728 * newly created cursor. Files containing cursor data may be in
4729 * either cursor (.CUR) or animated cursor (.ANI) format.
4730 * Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4731 * Variables :
4732 * Result : If the function is successful, the return value is a handle to
4733 * the new cursor.
4734 * If the function fails, the return value is NULL. To get extended
4735 * error information, call GetLastError. GetLastError may return
4736 * the following
4737 * Remark :
4738 * Status : UNTESTED STUB
4739 *
4740 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4741 *****************************************************************************/
4742
4743HCURSOR WIN32API LoadCursorFromFileA(LPCTSTR lpFileName)
4744{
4745 dprintf(("USER32:LoadCursorFromFileA (%s) not implemented.\n",
4746 lpFileName));
4747
4748 return (NULL);
4749}
4750
4751
4752/*****************************************************************************
4753 * Name : HCURSOR WIN32API LoadCursorFromFileW
4754 * Purpose : The LoadCursorFromFile function creates a cursor based on data
4755 * contained in a file. The file is specified by its name or by a
4756 * system cursor identifier. The function returns a handle to the
4757 * newly created cursor. Files containing cursor data may be in
4758 * either cursor (.CUR) or animated cursor (.ANI) format.
4759 * Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4760 * Variables :
4761 * Result : If the function is successful, the return value is a handle to
4762 * the new cursor.
4763 * If the function fails, the return value is NULL. To get extended
4764 * error information, call GetLastError. GetLastError may return
4765 * the following
4766 * Remark :
4767 * Status : UNTESTED STUB
4768 *
4769 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4770 *****************************************************************************/
4771
4772HCURSOR WIN32API LoadCursorFromFileW(LPCWSTR lpFileName)
4773{
4774 dprintf(("USER32:LoadCursorFromFileW (%s) not implemented.\n",
4775 lpFileName));
4776
4777 return (NULL);
4778}
4779
4780
4781/*****************************************************************************
4782 * Name : HLK WIN32API LoadKeyboardLayoutA
4783 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
4784 * the system. Several keyboard layouts can be loaded at a time, but
4785 * only one per process is active at a time. Loading multiple keyboard
4786 * layouts makes it possible to rapidly switch between layouts.
4787 * Parameters:
4788 * Variables :
4789 * Result : If the function succeeds, the return value is the handle of the
4790 * keyboard layout.
4791 * If the function fails, the return value is NULL. To get extended
4792 * error information, call GetLastError.
4793 * Remark :
4794 * Status : UNTESTED STUB
4795 *
4796 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4797 *****************************************************************************/
4798
4799HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
4800 UINT Flags)
4801{
4802 dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
4803 pwszKLID,
4804 Flags));
4805
4806 return (NULL);
4807}
4808
4809
4810/*****************************************************************************
4811 * Name : HLK WIN32API LoadKeyboardLayoutW
4812 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
4813 * the system. Several keyboard layouts can be loaded at a time, but
4814 * only one per process is active at a time. Loading multiple keyboard
4815 * layouts makes it possible to rapidly switch between layouts.
4816 * Parameters:
4817 * Variables :
4818 * Result : If the function succeeds, the return value is the handle of the
4819 * keyboard layout.
4820 * If the function fails, the return value is NULL. To get extended
4821 * error information, call GetLastError.
4822 * Remark :
4823 * Status : UNTESTED STUB
4824 *
4825 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4826 *****************************************************************************/
4827
4828HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
4829 UINT Flags)
4830{
4831 dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
4832 pwszKLID,
4833 Flags));
4834
4835 return (NULL);
4836}
4837
4838
4839/*****************************************************************************
4840 * Name : UINT WIN32API MapVirtualKeyExA
4841 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
4842 * code into a scan code or character value, or translates a scan
4843 * code into a virtual-key code. The function translates the codes
4844 * using the input language and physical keyboard layout identified
4845 * by the given keyboard layout handle.
4846 * Parameters:
4847 * Variables :
4848 * Result : The return value is either a scan code, a virtual-key code, or
4849 * a character value, depending on the value of uCode and uMapType.
4850 * If there is no translation, the return value is zero.
4851 * Remark :
4852 * Status : UNTESTED STUB
4853 *
4854 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4855 *****************************************************************************/
4856
4857UINT WIN32API MapVirtualKeyExA(UINT uCode,
4858 UINT uMapType,
4859 HKL dwhkl)
4860{
4861 dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
4862 uCode,
4863 uMapType,
4864 dwhkl));
4865
4866 return (0);
4867}
4868
4869
4870/*****************************************************************************
4871 * Name : UINT WIN32API MapVirtualKeyExW
4872 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
4873 * code into a scan code or character value, or translates a scan
4874 * code into a virtual-key code. The function translates the codes
4875 * using the input language and physical keyboard layout identified
4876 * by the given keyboard layout handle.
4877 * Parameters:
4878 * Variables :
4879 * Result : The return value is either a scan code, a virtual-key code, or
4880 * a character value, depending on the value of uCode and uMapType.
4881 * If there is no translation, the return value is zero.
4882 * Remark :
4883 * Status : UNTESTED STUB
4884 *
4885 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4886 *****************************************************************************/
4887
4888UINT WIN32API MapVirtualKeyExW(UINT uCode,
4889 UINT uMapType,
4890 HKL dwhkl)
4891{
4892 dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
4893 uCode,
4894 uMapType,
4895 dwhkl));
4896
4897 return (0);
4898}
4899
4900
4901/*****************************************************************************
4902 * Name : int WIN32API MessageBoxExA
4903 * Purpose : The MessageBoxEx function creates, displays, and operates a message box.
4904 * Parameters: HWND hWnd handle of owner window
4905 * LPCTSTR lpText address of text in message box
4906 * LPCTSTR lpCaption address of title of message box
4907 * UINT uType style of message box
4908 * WORD wLanguageId language identifier
4909 * Variables :
4910 * Result : If the function succeeds, the return value is a nonzero menu-item
4911 * value returned by the dialog box.
4912 * Remark :
4913 * Status : UNTESTED STUB
4914 *
4915 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4916 *****************************************************************************/
4917
4918int WIN32API MessageBoxExA(HWND hWnd,
4919 LPCTSTR lpText,
4920 LPCTSTR lpCaption,
4921 UINT uType,
4922 WORD wLanguageId)
4923{
4924 dprintf(("USER32:MessageBoxExA (%08xh,%s,%s,%u,%08w) not implemented.\n",
4925 hWnd,
4926 lpText,
4927 lpCaption,
4928 uType,
4929 wLanguageId));
4930
4931 return (MessageBoxA(hWnd,
4932 lpText,
4933 lpCaption,
4934 uType));
4935}
4936
4937
4938/*****************************************************************************
4939 * Name : int WIN32API MessageBoxExW
4940 * Purpose : The MessageBoxEx function creates, displays, and operates a message box.
4941 * Parameters: HWND hWnd handle of owner window
4942 * LPCTSTR lpText address of text in message box
4943 * LPCTSTR lpCaption address of title of message box
4944 * UINT uType style of message box
4945 * WORD wLanguageId language identifier
4946 * Variables :
4947 * Result : If the function succeeds, the return value is a nonzero menu-item
4948 * value returned by the dialog box.
4949 * Remark :
4950 * Status : UNTESTED STUB
4951 *
4952 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4953 *****************************************************************************/
4954
4955int WIN32API MessageBoxExW(HWND hWnd,
4956 LPCWSTR lpText,
4957 LPCWSTR lpCaption,
4958 UINT uType,
4959 WORD wLanguageId)
4960{
4961
4962 dprintf(("USER32:MessageBoxExW (%08xh,%x,%x,%u,%08w) not implemented.\n",
4963 hWnd,
4964 lpText,
4965 lpCaption,
4966 uType,
4967 wLanguageId));
4968
4969 return MessageBoxW(hWnd, lpText, lpCaption, uType);
4970}
4971
4972
4973/*****************************************************************************
4974 * Name : BOOL WIN32API MessageBoxIndirectW
4975 * Purpose : The MessageBoxIndirect function creates, displays, and operates
4976 * a message box. The message box contains application-defined
4977 * message text and title, any icon, and any combination of
4978 * predefined push buttons.
4979 * Parameters:
4980 * Variables :
4981 * Result :
4982 * Remark :
4983 * Status : UNTESTED STUB
4984 *
4985 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4986 *****************************************************************************/
4987
4988BOOL WIN32API MessageBoxIndirectW(LPMSGBOXPARAMSW lpMsgBoxParams)
4989{
4990 dprintf(("USER32:MessageBoxIndirectW (%08x) not implemented.\n",
4991 lpMsgBoxParams));
4992
4993 return (FALSE);
4994}
4995
4996
4997/*****************************************************************************
4998 * Name : BOOL WIN32API MessageBoxIndirectA
4999 * Purpose : The MessageBoxIndirect function creates, displays, and operates
5000 * a message box. The message box contains application-defined
5001 * message text and title, any icon, and any combination of
5002 * predefined push buttons.
5003 * Parameters:
5004 * Variables :
5005 * Result :
5006 * Remark :
5007 * Status : UNTESTED STUB
5008 *
5009 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5010 *****************************************************************************/
5011
5012BOOL WIN32API MessageBoxIndirectA(LPMSGBOXPARAMSA lpMsgBoxParams)
5013{
5014 dprintf(("USER32:MessageBoxIndirectA (%08x) not implemented.\n",
5015 lpMsgBoxParams));
5016
5017 return (FALSE);
5018}
5019
5020
5021/*****************************************************************************
5022 * Name : DWORD WIN32API OemKeyScan
5023 * Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
5024 * into the OEM scan codes and shift states. The function provides
5025 * information that allows a program to send OEM text to another
5026 * program by simulating keyboard input.
5027 * Parameters:
5028 * Variables :
5029 * Result :
5030 * Remark :
5031 * Status : UNTESTED STUB
5032 *
5033 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5034 *****************************************************************************/
5035
5036DWORD WIN32API OemKeyScan(WORD wOemChar)
5037{
5038 dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
5039 wOemChar));
5040
5041 return (wOemChar);
5042}
5043
5044
5045/*****************************************************************************
5046 * Name : HDESK WIN32API OpenDesktopA
5047 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
5048 * A desktop is a secure object contained within a window station
5049 * object. A desktop has a logical display surface and contains
5050 * windows, menus and hooks.
5051 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5052 * DWORD dwFlags flags to control interaction with other applications
5053 * BOOL fInherit specifies whether returned handle is inheritable
5054 * DWORD dwDesiredAccess specifies access of returned handle
5055 * Variables :
5056 * Result : If the function succeeds, the return value is the handle to the
5057 * opened desktop.
5058 * If the function fails, the return value is NULL. To get extended
5059 * error information, call GetLastError.
5060 * Remark :
5061 * Status : UNTESTED STUB
5062 *
5063 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5064 *****************************************************************************/
5065
5066HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
5067 DWORD dwFlags,
5068 BOOL fInherit,
5069 DWORD dwDesiredAccess)
5070{
5071 dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
5072 lpszDesktopName,
5073 dwFlags,
5074 fInherit,
5075 dwDesiredAccess));
5076
5077 return (NULL);
5078}
5079
5080
5081/*****************************************************************************
5082 * Name : HDESK WIN32API OpenDesktopW
5083 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
5084 * A desktop is a secure object contained within a window station
5085 * object. A desktop has a logical display surface and contains
5086 * windows, menus and hooks.
5087 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5088 * DWORD dwFlags flags to control interaction with other applications
5089 * BOOL fInherit specifies whether returned handle is inheritable
5090 * DWORD dwDesiredAccess specifies access of returned handle
5091 * Variables :
5092 * Result : If the function succeeds, the return value is the handle to the
5093 * opened desktop.
5094 * If the function fails, the return value is NULL. To get extended
5095 * error information, call GetLastError.
5096 * Remark :
5097 * Status : UNTESTED STUB
5098 *
5099 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5100 *****************************************************************************/
5101
5102HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
5103 DWORD dwFlags,
5104 BOOL fInherit,
5105 DWORD dwDesiredAccess)
5106{
5107 dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
5108 lpszDesktopName,
5109 dwFlags,
5110 fInherit,
5111 dwDesiredAccess));
5112
5113 return (NULL);
5114}
5115
5116
5117/*****************************************************************************
5118 * Name : HDESK WIN32API OpenInputDesktop
5119 * Purpose : The OpenInputDesktop function returns a handle to the desktop
5120 * that receives user input. The input desktop is a desktop on the
5121 * window station associated with the logged-on user.
5122 * Parameters: DWORD dwFlags flags to control interaction with other applications
5123 * BOOL fInherit specifies whether returned handle is inheritable
5124 * DWORD dwDesiredAccess specifies access of returned handle
5125 * Variables :
5126 * Result : If the function succeeds, the return value is a handle of the
5127 * desktop that receives user input.
5128 * If the function fails, the return value is NULL. To get extended
5129 * error information, call GetLastError.
5130 * Remark :
5131 * Status : UNTESTED STUB
5132 *
5133 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5134 *****************************************************************************/
5135
5136HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
5137 BOOL fInherit,
5138 DWORD dwDesiredAccess)
5139{
5140 dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
5141 dwFlags,
5142 fInherit,
5143 dwDesiredAccess));
5144
5145 return (NULL);
5146}
5147
5148
5149/*****************************************************************************
5150 * Name : HWINSTA WIN32API OpenWindowStationA
5151 * Purpose : The OpenWindowStation function returns a handle to an existing
5152 * window station.
5153 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
5154 * BOOL fInherit specifies whether returned handle is inheritable
5155 * DWORD dwDesiredAccess specifies access of returned handle
5156 * Variables :
5157 * Result : If the function succeeds, the return value is the handle to the
5158 * specified window station.
5159 * If the function fails, the return value is NULL. To get extended
5160 * error information, call GetLastError.
5161 * Remark :
5162 * Status : UNTESTED STUB
5163 *
5164 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5165 *****************************************************************************/
5166
5167HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
5168 BOOL fInherit,
5169 DWORD dwDesiredAccess)
5170{
5171 dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
5172 lpszWinStaName,
5173 fInherit,
5174 dwDesiredAccess));
5175
5176 return (NULL);
5177}
5178
5179
5180/*****************************************************************************
5181 * Name : HWINSTA WIN32API OpenWindowStationW
5182 * Purpose : The OpenWindowStation function returns a handle to an existing
5183 * window station.
5184 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
5185 * BOOL fInherit specifies whether returned handle is inheritable
5186 * DWORD dwDesiredAccess specifies access of returned handle
5187 * Variables :
5188 * Result : If the function succeeds, the return value is the handle to the
5189 * specified window station.
5190 * If the function fails, the return value is NULL. To get extended
5191 * error information, call GetLastError.
5192
5193 * Remark :
5194 * Status : UNTESTED STUB
5195 *
5196 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5197 *****************************************************************************/
5198
5199HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
5200 BOOL fInherit,
5201 DWORD dwDesiredAccess)
5202{
5203 dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
5204 lpszWinStaName,
5205 fInherit,
5206 dwDesiredAccess));
5207
5208 return (NULL);
5209}
5210
5211
5212/*****************************************************************************
5213 * Name : BOOL WIN32API PaintDesktop
5214 * Purpose : The PaintDesktop function fills the clipping region in the
5215 * specified device context with the desktop pattern or wallpaper.
5216 * The function is provided primarily for shell desktops.
5217 * Parameters:
5218 * Variables :
5219 * Result : If the function succeeds, the return value is TRUE.
5220 * If the function fails, the return value is FALSE.
5221 * Remark :
5222 * Status : UNTESTED STUB
5223 *
5224 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5225 *****************************************************************************/
5226
5227BOOL WIN32API PaintDesktop(HDC hdc)
5228{
5229 dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
5230 hdc));
5231
5232 return (FALSE);
5233}
5234
5235
5236/*****************************************************************************
5237 * Name : BOOL WIN32API SendMessageCallbackA
5238 * Purpose : The SendMessageCallback function sends the specified message to
5239 * a window or windows. The function calls the window procedure for
5240 * the specified window and returns immediately. After the window
5241 * procedure processes the message, the system calls the specified
5242 * callback function, passing the result of the message processing
5243 * and an application-defined value to the callback function.
5244 * Parameters: HWND hwnd handle of destination window
5245 * UINT uMsg message to send
5246 * WPARAM wParam first message parameter
5247 * LPARAM lParam second message parameter
5248 * SENDASYNCPROC lpResultCallBack function to receive message value
5249 * DWORD dwData value to pass to callback function
5250 * Variables :
5251 * Result : If the function succeeds, the return value is TRUE.
5252 * If the function fails, the return value is FALSE. To get extended
5253 * error information, call GetLastError.
5254 * Remark :
5255 * Status : UNTESTED STUB
5256 *
5257 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5258 *****************************************************************************/
5259
5260BOOL WIN32API SendMessageCallbackA(HWND hWnd,
5261 UINT uMsg,
5262 WPARAM wParam,
5263 LPARAM lParam,
5264 SENDASYNCPROC lpResultCallBack,
5265 DWORD dwData)
5266{
5267 dprintf(("USER32:SendMessageCallBackA (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5268 hWnd,
5269 uMsg,
5270 wParam,
5271 lParam,
5272 lpResultCallBack,
5273 dwData));
5274
5275 return (FALSE);
5276}
5277
5278
5279/*****************************************************************************
5280 * Name : BOOL WIN32API SendMessageCallbackW
5281 * Purpose : The SendMessageCallback function sends the specified message to
5282 * a window or windows. The function calls the window procedure for
5283 * the specified window and returns immediately. After the window
5284 * procedure processes the message, the system calls the specified
5285 * callback function, passing the result of the message processing
5286 * and an application-defined value to the callback function.
5287 * Parameters: HWND hwnd handle of destination window
5288 * UINT uMsg message to send
5289 * WPARAM wParam first message parameter
5290 * LPARAM lParam second message parameter
5291 * SENDASYNCPROC lpResultCallBack function to receive message value
5292 * DWORD dwData value to pass to callback function
5293 * Variables :
5294 * Result : If the function succeeds, the return value is TRUE.
5295 * If the function fails, the return value is FALSE. To get extended
5296 * error information, call GetLastError.
5297 * Remark :
5298 * Status : UNTESTED STUB
5299 *
5300 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5301 *****************************************************************************/
5302
5303BOOL WIN32API SendMessageCallbackW(HWND hWnd,
5304 UINT uMsg,
5305 WPARAM wParam,
5306 LPARAM lParam,
5307 SENDASYNCPROC lpResultCallBack,
5308 DWORD dwData)
5309{
5310 dprintf(("USER32:SendMessageCallBackW (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5311 hWnd,
5312 uMsg,
5313 wParam,
5314 lParam,
5315 lpResultCallBack,
5316 dwData));
5317
5318 return (FALSE);
5319}
5320
5321
5322/*****************************************************************************
5323 * Name : VOID WIN32API SetDebugErrorLevel
5324 * Purpose : The SetDebugErrorLevel function sets the minimum error level at
5325 * which Windows will generate debugging events and pass them to a debugger.
5326 * Parameters: DWORD dwLevel debugging error level
5327 * Variables :
5328 * Result :
5329 * Remark :
5330 * Status : UNTESTED STUB
5331 *
5332 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5333 *****************************************************************************/
5334
5335VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
5336{
5337 dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
5338 dwLevel));
5339}
5340
5341
5342/*****************************************************************************
5343 * Name : BOOL WIN32API SetProcessWindowStation
5344 * Purpose : The SetProcessWindowStation function assigns a window station
5345 * to the calling process. This enables the process to access
5346 * objects in the window station such as desktops, the clipboard,
5347 * and global atoms. All subsequent operations on the window station
5348 * use the access rights granted to hWinSta.
5349 * Parameters:
5350 * Variables :
5351 * Result : If the function succeeds, the return value is TRUE.
5352 * If the function fails, the return value is FALSE. To get extended
5353 * error information, call GetLastError.
5354 * Remark :
5355 * Status : UNTESTED STUB
5356 *
5357 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5358 *****************************************************************************/
5359
5360BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
5361{
5362 dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
5363 hWinSta));
5364
5365 return (FALSE);
5366}
5367
5368
5369/*****************************************************************************
5370 * Name : BOOL WIN32API SetSystemCursor
5371 * Purpose : The SetSystemCursor function replaces the contents of the system
5372 * cursor specified by dwCursorId with the contents of the cursor
5373 * specified by hCursor, and then destroys hCursor. This function
5374 * lets an application customize the system cursors.
5375 * Parameters: HCURSOR hCursor set specified system cursor to this cursor's
5376 * contents, then destroy this
5377 * DWORD dwCursorID system cursor specified by its identifier
5378 * Variables :
5379 * Result : If the function succeeds, the return value is TRUE.
5380 * If the function fails, the return value is FALSE. To get extended
5381 * error information, call GetLastError.
5382 * Remark :
5383 * Status : UNTESTED STUB
5384 *
5385 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5386 *****************************************************************************/
5387
5388BOOL WIN32API SetSystemCursor(HCURSOR hCursor,
5389 DWORD dwCursorId)
5390{
5391 dprintf(("USER32:SetSystemCursor (%08xh,%08x) not implemented.\n",
5392 hCursor,
5393 dwCursorId));
5394
5395 return (FALSE);
5396}
5397
5398
5399/*****************************************************************************
5400 * Name : BOOL WIN32API SetThreadDesktop
5401 * Purpose : The SetThreadDesktop function assigns a desktop to the calling
5402 * thread. All subsequent operations on the desktop use the access
5403 * rights granted to hDesk.
5404 * Parameters: HDESK hDesk handle of the desktop to assign to this thread
5405 * Variables :
5406 * Result : If the function succeeds, the return value is TRUE.
5407 * If the function fails, the return value is FALSE. To get extended
5408 * error information, call GetLastError.
5409 * Remark :
5410 * Status : UNTESTED STUB
5411 *
5412 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5413 *****************************************************************************/
5414
5415BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
5416{
5417 dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
5418 hDesktop));
5419
5420 return (FALSE);
5421}
5422
5423
5424/*****************************************************************************
5425 * Name : BOOL WIN32API SetUserObjectInformationA
5426 * Purpose : The SetUserObjectInformation function sets information about a
5427 * window station or desktop object.
5428 * Parameters: HANDLE hObject handle of the object for which to set information
5429 * int nIndex type of information to set
5430 * PVOID lpvInfo points to a buffer that contains the information
5431 * DWORD cbInfo size, in bytes, of lpvInfo buffer
5432 * Variables :
5433 * Result : If the function succeeds, the return value is TRUE.
5434 * If the function fails the return value is FALSE. To get extended
5435 * error information, call GetLastError.
5436 * Remark :
5437 * Status : UNTESTED STUB
5438 *
5439 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5440 *****************************************************************************/
5441
5442BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
5443 int nIndex,
5444 PVOID lpvInfo,
5445 DWORD cbInfo)
5446{
5447 dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
5448 hObject,
5449 nIndex,
5450 lpvInfo,
5451 cbInfo));
5452
5453 return (FALSE);
5454}
5455
5456
5457/*****************************************************************************
5458 * Name : BOOL WIN32API SetUserObjectInformationW
5459 * Purpose : The SetUserObjectInformation function sets information about a
5460 * window station or desktop object.
5461 * Parameters: HANDLE hObject handle of the object for which to set information
5462 * int nIndex type of information to set
5463 * PVOID lpvInfo points to a buffer that contains the information
5464 * DWORD cbInfo size, in bytes, of lpvInfo buffer
5465 * Variables :
5466 * Result : If the function succeeds, the return value is TRUE.
5467 * If the function fails the return value is FALSE. To get extended
5468 * error information, call GetLastError.
5469 * Remark :
5470 * Status : UNTESTED STUB
5471 *
5472 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5473 *****************************************************************************/
5474
5475BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
5476 int nIndex,
5477 PVOID lpvInfo,
5478 DWORD cbInfo)
5479{
5480 dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
5481 hObject,
5482 nIndex,
5483 lpvInfo,
5484 cbInfo));
5485
5486 return (FALSE);
5487}
5488
5489
5490/*****************************************************************************
5491 * Name : BOOL WIN32API SetUserObjectSecurity
5492 * Purpose : The SetUserObjectSecurity function sets the security of a user
5493 * object. This can be, for example, a window or a DDE conversation
5494 * Parameters: HANDLE hObject handle of user object
5495 * SECURITY_INFORMATION * psi address of security information
5496 * LPSECURITY_DESCRIPTOR psd address of security descriptor
5497 * Variables :
5498 * Result : If the function succeeds, the return value is TRUE.
5499 * If the function fails, the return value is FALSE. To get extended
5500 * error information, call GetLastError.
5501 * Remark :
5502 * Status : UNTESTED STUB
5503 *
5504 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5505 *****************************************************************************/
5506
5507BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
5508 SECURITY_INFORMATION * psi,
5509 LPSECURITY_DESCRIPTOR psd)
5510{
5511 dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
5512 hObject,
5513 psi,
5514 psd));
5515
5516 return (FALSE);
5517}
5518
5519
5520/*****************************************************************************
5521 * Name : int WIN32API SetWindowRgn
5522 * Purpose : The SetWindowRgn function sets the window region of a window. The
5523 * window region determines the area within the window where the
5524 * operating system permits drawing. The operating system does not
5525 * display any portion of a window that lies outside of the window region
5526 * Parameters: HWND hWnd handle to window whose window region is to be set
5527 * HRGN hRgn handle to region
5528 * BOOL bRedraw window redraw flag
5529 * Variables :
5530 * Result : If the function succeeds, the return value is non-zero.
5531 * If the function fails, the return value is zero.
5532 * Remark :
5533 * Status : UNTESTED STUB
5534 *
5535 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5536 *****************************************************************************/
5537
5538int WIN32API SetWindowRgn(HWND hWnd,
5539 HRGN hRgn,
5540 BOOL bRedraw)
5541{
5542 dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
5543 hWnd,
5544 hRgn,
5545 bRedraw));
5546
5547 return (0);
5548}
5549
5550
5551/*****************************************************************************
5552 * Name : BOOL WIN32API SetWindowsHookW
5553 * Purpose : The SetWindowsHook function is not implemented in the Win32 API.
5554 * Win32-based applications should use the SetWindowsHookEx function.
5555 * Parameters:
5556 * Variables :
5557 * Result :
5558 * Remark : ARGH ! MICROSOFT !
5559 * Status : UNTESTED STUB
5560 *
5561 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5562 *****************************************************************************/
5563
5564HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
5565
5566{
5567 return (FALSE);
5568}
5569
5570
5571/*****************************************************************************
5572 * Name : BOOL WIN32API ShowWindowAsync
5573 * Purpose : The ShowWindowAsync function sets the show state of a window
5574 * created by a different thread.
5575 * Parameters: HWND hwnd handle of window
5576 * int nCmdShow show state of window
5577 * Variables :
5578 * Result : If the window was previously visible, the return value is TRUE.
5579 * If the window was previously hidden, the return value is FALSE.
5580 * Remark :
5581 * Status : UNTESTED STUB
5582 *
5583 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5584 *****************************************************************************/
5585
5586BOOL WIN32API ShowWindowAsync (HWND hWnd,
5587 int nCmdShow)
5588{
5589 dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
5590 hWnd,
5591 nCmdShow));
5592
5593 return (FALSE);
5594}
5595
5596
5597/*****************************************************************************
5598 * Name : BOOL WIN32API SwitchDesktop
5599 * Purpose : The SwitchDesktop function makes a desktop visible and activates
5600 * it. This enables the desktop to receive input from the user. The
5601 * calling process must have DESKTOP_SWITCHDESKTOP access to the
5602 * desktop for the SwitchDesktop function to succeed.
5603 * Parameters:
5604 * Variables :
5605 * Result : If the function succeeds, the return value is TRUE.
5606 * If the function fails, the return value is FALSE. To get extended
5607 * error information, call GetLastError.
5608 * Remark :
5609 * Status : UNTESTED STUB
5610 *
5611 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5612 *****************************************************************************/
5613
5614BOOL WIN32API SwitchDesktop(HDESK hDesktop)
5615{
5616 dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
5617 hDesktop));
5618
5619 return (FALSE);
5620}
5621
5622
5623/*****************************************************************************
5624 * Name : WORD WIN32API TileWindows
5625 * Purpose : The TileWindows function tiles the specified windows, or the child
5626 * windows of the specified parent window.
5627 * Parameters: HWND hwndParent handle of parent window
5628 * WORD wFlags types of windows not to arrange
5629 * LPCRECT lpRect rectangle to arrange windows in
5630 * WORD cChildrenb number of windows to arrange
5631 * const HWND *ahwndChildren array of window handles
5632 * Variables :
5633 * Result : If the function succeeds, the return value is the number of
5634 * windows arranged.
5635 * If the function fails, the return value is zero.
5636 * Remark :
5637 * Status : UNTESTED STUB
5638 *
5639 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5640 *****************************************************************************/
5641
5642WORD WIN32API TileWindows(HWND hwndParent,
5643 UINT wFlags,
5644 const LPRECT lpRect,
5645 UINT cChildrenb,
5646 const HWND *ahwndChildren)
5647{
5648 dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5649 hwndParent,
5650 wFlags,
5651 lpRect,
5652 cChildrenb,
5653 ahwndChildren));
5654
5655 return (0);
5656}
5657
5658
5659/*****************************************************************************
5660 * Name : int WIN32API ToAscii
5661 * Purpose : The ToAscii function translates the specified virtual-key code
5662 * and keyboard state to the corresponding Windows character or characters.
5663 * Parameters: UINT uVirtKey virtual-key code
5664 * UINT uScanCode scan code
5665 * PBYTE lpbKeyState address of key-state array
5666 * LPWORD lpwTransKey buffer for translated key
5667 * UINT fuState active-menu flag
5668 * Variables :
5669 * Result : 0 The specified virtual key has no translation for the current
5670 * state of the keyboard.
5671 * 1 One Windows character was copied to the buffer.
5672 * 2 Two characters were copied to the buffer. This usually happens
5673 * when a dead-key character (accent or diacritic) stored in the
5674 * keyboard layout cannot be composed with the specified virtual
5675 * key to form a single character.
5676 * Remark :
5677 * Status : UNTESTED STUB
5678 *
5679 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5680 *****************************************************************************/
5681
5682int WIN32API ToAscii(UINT uVirtKey,
5683 UINT uScanCode,
5684 PBYTE lpbKeyState,
5685 LPWORD lpwTransKey,
5686 UINT fuState)
5687{
5688 dprintf(("USER32:ToAscii (%u,%u,%08xh,%08xh,%u) not implemented.\n",
5689 uVirtKey,
5690 uScanCode,
5691 lpbKeyState,
5692 lpwTransKey,
5693 fuState));
5694
5695 return (0);
5696}
5697
5698
5699/*****************************************************************************
5700 * Name : int WIN32API ToAsciiEx
5701 * Purpose : The ToAscii function translates the specified virtual-key code
5702 * and keyboard state to the corresponding Windows character or characters.
5703 * Parameters: UINT uVirtKey virtual-key code
5704 * UINT uScanCode scan code
5705 * PBYTE lpbKeyState address of key-state array
5706 * LPWORD lpwTransKey buffer for translated key
5707 * UINT fuState active-menu flag
5708 * HLK hlk keyboard layout handle
5709 * Variables :
5710 * Result : 0 The specified virtual key has no translation for the current
5711 * state of the keyboard.
5712 * 1 One Windows character was copied to the buffer.
5713 * 2 Two characters were copied to the buffer. This usually happens
5714 * when a dead-key character (accent or diacritic) stored in the
5715 * keyboard layout cannot be composed with the specified virtual
5716 * key to form a single character.
5717 * Remark :
5718 * Status : UNTESTED STUB
5719 *
5720 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5721 *****************************************************************************/
5722
5723int WIN32API ToAsciiEx(UINT uVirtKey,
5724 UINT uScanCode,
5725 PBYTE lpbKeyState,
5726 LPWORD lpwTransKey,
5727 UINT fuState,
5728 HKL hkl)
5729{
5730 dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5731 uVirtKey,
5732 uScanCode,
5733 lpbKeyState,
5734 lpwTransKey,
5735 fuState,
5736 hkl));
5737
5738 return (0);
5739}
5740
5741
5742/*****************************************************************************
5743 * Name : int WIN32API ToUnicode
5744 * Purpose : The ToUnicode function translates the specified virtual-key code
5745 * and keyboard state to the corresponding Unicode character or characters.
5746 * Parameters: UINT wVirtKey virtual-key code
5747 * UINT wScanCode scan code
5748 * PBYTE lpKeyState address of key-state array
5749 * LPWSTR pwszBuff buffer for translated key
5750 * int cchBuff size of translated key buffer
5751 * UINT wFlags set of function-conditioning flags
5752 * Variables :
5753 * Result : - 1 The specified virtual key is a dead-key character (accent or
5754 * diacritic). This value is returned regardless of the keyboard
5755 * layout, even if several characters have been typed and are
5756 * stored in the keyboard state. If possible, even with Unicode
5757 * keyboard layouts, the function has written a spacing version of
5758 * the dead-key character to the buffer specified by pwszBuffer.
5759 * For example, the function writes the character SPACING ACUTE
5760 * (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
5761 * 0 The specified virtual key has no translation for the current
5762 * state of the keyboard. Nothing was written to the buffer
5763 * specified by pwszBuffer.
5764 * 1 One character was written to the buffer specified by pwszBuffer.
5765 * 2 or more Two or more characters were written to the buffer specified by
5766 * pwszBuff. The most common cause for this is that a dead-key
5767 * character (accent or diacritic) stored in the keyboard layout
5768 * could not be combined with the specified virtual key to form a
5769 * single character.
5770 * Remark :
5771 * Status : UNTESTED STUB
5772 *
5773 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5774 *****************************************************************************/
5775
5776int WIN32API ToUnicode(UINT uVirtKey,
5777 UINT uScanCode,
5778 PBYTE lpKeyState,
5779 LPWSTR pwszBuff,
5780 int cchBuff,
5781 UINT wFlags)
5782{
5783 dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5784 uVirtKey,
5785 uScanCode,
5786 lpKeyState,
5787 pwszBuff,
5788 cchBuff,
5789 wFlags));
5790
5791 return (0);
5792}
5793
5794
5795/*****************************************************************************
5796 * Name : BOOL WIN32API UnloadKeyboardLayout
5797 * Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
5798 * Parameters: HKL hkl handle of keyboard layout
5799 * Variables :
5800 * Result : If the function succeeds, the return value is the handle of the
5801 * keyboard layout; otherwise, it is NULL. To get extended error
5802 * information, use the GetLastError function.
5803 * Remark :
5804 * Status : UNTESTED STUB
5805 *
5806 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5807 *****************************************************************************/
5808
5809BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
5810{
5811 dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
5812 hkl));
5813
5814 return (0);
5815}
5816
5817
5818/*****************************************************************************
5819 * Name : SHORT WIN32API VkKeyScanExW
5820 * Purpose : The VkKeyScanEx function translates a character to the
5821 * corresponding virtual-key code and shift state. The function
5822 * translates the character using the input language and physical
5823 * keyboard layout identified by the given keyboard layout handle.
5824 * Parameters: UINT uChar character to translate
5825 * HKL hkl keyboard layout handle
5826 * Variables :
5827 * Result : see docs
5828 * Remark :
5829 * Status : UNTESTED STUB
5830 *
5831 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5832 *****************************************************************************/
5833
5834WORD WIN32API VkKeyScanExW(WCHAR uChar,
5835 HKL hkl)
5836{
5837 dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
5838 uChar,
5839 hkl));
5840
5841 return (uChar);
5842}
5843
5844
5845/*****************************************************************************
5846 * Name : SHORT WIN32API VkKeyScanExA
5847 * Purpose : The VkKeyScanEx function translates a character to the
5848 * corresponding virtual-key code and shift state. The function
5849 * translates the character using the input language and physical
5850 * keyboard layout identified by the given keyboard layout handle.
5851 * Parameters: UINT uChar character to translate
5852 * HKL hkl keyboard layout handle
5853 * Variables :
5854 * Result : see docs
5855 * Remark :
5856 * Status : UNTESTED STUB
5857 *
5858 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5859 *****************************************************************************/
5860
5861WORD WIN32API VkKeyScanExA(CHAR uChar,
5862 HKL hkl)
5863{
5864 dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
5865 uChar,
5866 hkl));
5867
5868 return (uChar);
5869}
5870
5871
5872/*****************************************************************************
5873 * Name : VOID WIN32API keybd_event
5874 * Purpose : The keybd_event function synthesizes a keystroke. The system
5875 * can use such a synthesized keystroke to generate a WM_KEYUP or
5876 * WM_KEYDOWN message. The keyboard driver's interrupt handler calls
5877 * the keybd_event function.
5878 * Parameters: BYTE bVk virtual-key code
5879
5880 * BYTE bScan hardware scan code
5881 * DWORD dwFlags flags specifying various function options
5882 * DWORD dwExtraInfo additional data associated with keystroke
5883 * Variables :
5884 * Result :
5885 * Remark :
5886 * Status : UNTESTED STUB
5887 *
5888 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5889 *****************************************************************************/
5890
5891VOID WIN32API keybd_event (BYTE bVk,
5892 BYTE bScan,
5893 DWORD dwFlags,
5894 DWORD dwExtraInfo)
5895{
5896 dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
5897 bVk,
5898 bScan,
5899 dwFlags,
5900 dwExtraInfo));
5901}
5902
5903
5904/*****************************************************************************
5905 * Name : VOID WIN32API mouse_event
5906 * Purpose : The mouse_event function synthesizes mouse motion and button clicks.
5907 * Parameters: DWORD dwFlags flags specifying various motion/click variants
5908 * DWORD dx horizontal mouse position or position change
5909 * DWORD dy vertical mouse position or position change
5910 * DWORD cButtons unused, reserved for future use, set to zero
5911 * DWORD dwExtraInfo 32 bits of application-defined information
5912 * Variables :
5913 * Result :
5914 * Remark :
5915 * Status : UNTESTED STUB
5916 *
5917 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5918 *****************************************************************************/
5919
5920VOID WIN32API mouse_event(DWORD dwFlags,
5921 DWORD dx,
5922 DWORD dy,
5923 DWORD cButtons,
5924 DWORD dwExtraInfo)
5925{
5926 dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
5927 dwFlags,
5928 dx,
5929 dy,
5930 cButtons,
5931 dwExtraInfo));
5932}
5933
5934
5935/*****************************************************************************
5936 * Name : BOOL WIN32API SetShellWindow
5937 * Purpose : Unknown
5938 * Parameters: Unknown
5939 * Variables :
5940 * Result :
5941 * Remark :
5942 * Status : UNTESTED UNKNOWN STUB
5943 *
5944 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
5945 *****************************************************************************/
5946
5947BOOL WIN32API SetShellWindow(DWORD x1)
5948{
5949 dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
5950 x1));
5951
5952 return (FALSE); /* default */
5953}
5954
5955
5956/*****************************************************************************
5957 * Name : BOOL WIN32API PlaySoundEvent
5958 * Purpose : Unknown
5959 * Parameters: Unknown
5960 * Variables :
5961 * Result :
5962 * Remark :
5963 * Status : UNTESTED UNKNOWN STUB
5964 *
5965 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
5966 *****************************************************************************/
5967
5968BOOL WIN32API PlaySoundEvent(DWORD x1)
5969{
5970 dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
5971 x1));
5972
5973 return (FALSE); /* default */
5974}
5975
5976
5977/*****************************************************************************
5978 * Name : BOOL WIN32API TileChildWindows
5979 * Purpose : Unknown
5980 * Parameters: Unknown
5981 * Variables :
5982 * Result :
5983 * Remark :
5984 * Status : UNTESTED UNKNOWN STUB
5985 *
5986 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
5987 *****************************************************************************/
5988
5989BOOL WIN32API TileChildWindows(DWORD x1,
5990 DWORD x2)
5991{
5992 dprintf(("USER32: TileChildWindows(%08xh,%08xh) not implemented.\n",
5993 x1,
5994 x2));
5995
5996 return (FALSE); /* default */
5997}
5998
5999
6000/*****************************************************************************
6001 * Name : BOOL WIN32API SetSysColorsTemp
6002 * Purpose : Unknown
6003 * Parameters: Unknown
6004 * Variables :
6005 * Result :
6006 * Remark :
6007 * Status : UNTESTED UNKNOWN STUB
6008 *
6009 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6010 *****************************************************************************/
6011
6012BOOL WIN32API SetSysColorsTemp(void)
6013{
6014 dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
6015
6016 return (FALSE); /* default */
6017}
6018
6019
6020/*****************************************************************************
6021 * Name : BOOL WIN32API RegisterNetworkCapabilities
6022 * Purpose : Unknown
6023 * Parameters: Unknown
6024 * Variables :
6025 * Result :
6026 * Remark :
6027 * Status : UNTESTED UNKNOWN STUB
6028 *
6029 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6030 *****************************************************************************/
6031
6032BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
6033 DWORD x2)
6034{
6035 dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
6036 x1,
6037 x2));
6038
6039 return (FALSE); /* default */
6040}
6041
6042
6043/*****************************************************************************
6044 * Name : BOOL WIN32API EndTask
6045 * Purpose : Unknown
6046 * Parameters: Unknown
6047 * Variables :
6048 * Result :
6049 * Remark :
6050 * Status : UNTESTED UNKNOWN STUB
6051 *
6052 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6053 *****************************************************************************/
6054
6055BOOL WIN32API EndTask(DWORD x1,
6056 DWORD x2,
6057 DWORD x3)
6058{
6059 dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
6060 x1,
6061 x2,
6062 x3));
6063
6064 return (FALSE); /* default */
6065}
6066
6067
6068/*****************************************************************************
6069 * Name : BOOL WIN32API SwitchToThisWindow
6070 * Purpose : Unknown
6071 * Parameters: Unknown
6072 * Variables :
6073 * Result :
6074 * Remark :
6075 * Status : UNTESTED UNKNOWN STUB
6076 *
6077 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6078 *****************************************************************************/
6079
6080BOOL WIN32API SwitchToThisWindow(HWND hwnd,
6081 BOOL x2)
6082{
6083 dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
6084 hwnd,
6085 x2));
6086
6087 return (FALSE); /* default */
6088}
6089
6090
6091/*****************************************************************************
6092 * Name : BOOL WIN32API GetNextQueueWindow
6093 * Purpose : Unknown
6094 * Parameters: Unknown
6095 * Variables :
6096 * Result :
6097 * Remark :
6098 * Status : UNTESTED UNKNOWN STUB
6099 *
6100 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6101 *****************************************************************************/
6102
6103BOOL WIN32API GetNextQueueWindow(DWORD x1,
6104 DWORD x2)
6105{
6106 dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
6107 x1,
6108 x2));
6109
6110 return (FALSE); /* default */
6111}
6112
6113
6114/*****************************************************************************
6115 * Name : BOOL WIN32API YieldTask
6116 * Purpose : Unknown
6117 * Parameters: Unknown
6118 * Variables :
6119 * Result :
6120 * Remark :
6121 * Status : UNTESTED UNKNOWN STUB
6122 *
6123 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6124 *****************************************************************************/
6125
6126BOOL WIN32API YieldTask(void)
6127{
6128 dprintf(("USER32: YieldTask() not implemented.\n"));
6129
6130 return (FALSE); /* default */
6131}
6132
6133
6134/*****************************************************************************
6135 * Name : BOOL WIN32API WinOldAppHackoMatic
6136 * Purpose : Unknown
6137 * Parameters: Unknown
6138 * Variables :
6139 * Result :
6140 * Remark :
6141 * Status : UNTESTED UNKNOWN STUB
6142 *
6143 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6144 *****************************************************************************/
6145
6146BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
6147{
6148 dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
6149 x1));
6150
6151 return (FALSE); /* default */
6152}
6153
6154
6155/*****************************************************************************
6156 * Name : BOOL WIN32API DragObject
6157 * Purpose : Unknown
6158 * Parameters: Unknown
6159 * Variables :
6160 * Result :
6161 * Remark :
6162 * Status : UNTESTED UNKNOWN STUB
6163 *
6164 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6165 *****************************************************************************/
6166
6167DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
6168{
6169 dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6170 x1,
6171 x2,
6172 x3,
6173 x4,
6174 x5));
6175
6176 return (FALSE); /* default */
6177}
6178
6179
6180/*****************************************************************************
6181 * Name : BOOL WIN32API CascadeChildWindows
6182 * Purpose : Unknown
6183 * Parameters: Unknown
6184 * Variables :
6185 * Result :
6186 * Remark :
6187 * Status : UNTESTED UNKNOWN STUB
6188 *
6189 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6190 *****************************************************************************/
6191
6192BOOL WIN32API CascadeChildWindows(DWORD x1,
6193 DWORD x2)
6194{
6195 dprintf(("USER32: CascadeChildWindows(%08xh,%08xh) not implemented.\n",
6196 x1,
6197 x2));
6198
6199 return (FALSE); /* default */
6200}
6201
6202
6203/*****************************************************************************
6204 * Name : BOOL WIN32API RegisterSystemThread
6205 * Purpose : Unknown
6206 * Parameters: Unknown
6207 * Variables :
6208 * Result :
6209 * Remark :
6210 * Status : UNTESTED UNKNOWN STUB
6211 *
6212 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6213 *****************************************************************************/
6214
6215BOOL WIN32API RegisterSystemThread(DWORD x1,
6216 DWORD x2)
6217{
6218 dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
6219 x1,
6220 x2));
6221
6222 return (FALSE); /* default */
6223}
6224
6225
6226/*****************************************************************************
6227 * Name : BOOL WIN32API IsHungThread
6228 * Purpose : Unknown
6229 * Parameters: Unknown
6230 * Variables :
6231 * Result :
6232 * Remark :
6233 * Status : UNTESTED UNKNOWN STUB
6234 *
6235 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6236 *****************************************************************************/
6237
6238BOOL WIN32API IsHungThread(DWORD x1)
6239{
6240 dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
6241 x1));
6242
6243 return (FALSE); /* default */
6244}
6245
6246
6247/*****************************************************************************
6248 * Name : BOOL WIN32API SysErrorBox
6249 * Purpose : Unknown
6250 * Parameters: Unknown
6251 * Variables :
6252 * Result :
6253 * Remark : HARDERR like ?
6254 * Status : UNTESTED UNKNOWN STUB
6255 *
6256 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6257 *****************************************************************************/
6258
6259BOOL WIN32API SysErrorBox(DWORD x1,
6260 DWORD x2,
6261 DWORD x3)
6262{
6263 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh) not implemented.\n",
6264 x1,
6265 x2,
6266 x3));
6267
6268 return (FALSE); /* default */
6269}
6270
6271
6272/*****************************************************************************
6273 * Name : BOOL WIN32API UserSignalProc
6274 * Purpose : Unknown
6275 * Parameters: Unknown
6276 * Variables :
6277 * Result :
6278 * Remark :
6279 * Status : UNTESTED UNKNOWN STUB
6280 *
6281 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6282 *****************************************************************************/
6283
6284BOOL WIN32API UserSignalProc(DWORD x1,
6285 DWORD x2,
6286 DWORD x3,
6287 DWORD x4)
6288{
6289 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6290 x1,
6291 x2,
6292 x3,
6293 x4));
6294
6295 return (FALSE); /* default */
6296}
6297
6298
6299/*****************************************************************************
6300 * Name : BOOL WIN32API GetShellWindow
6301 * Purpose : Unknown
6302 * Parameters: Unknown
6303 * Variables :
6304 * Result :
6305 * Remark :
6306 * Status : UNTESTED UNKNOWN STUB
6307 *
6308 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6309 *****************************************************************************/
6310
6311HWND WIN32API GetShellWindow(void)
6312{
6313 dprintf(("USER32: GetShellWindow() not implemented.\n"));
6314
6315 return (0); /* default */
6316}
6317
6318
6319/***********************************************************************
6320 * RegisterTasklist32 [USER32.436]
6321 */
6322DWORD WIN32API RegisterTasklist (DWORD x)
6323{
6324 dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
6325 x));
6326
6327 return TRUE;
6328}
6329
6330
6331/***********************************************************************
6332 * DrawCaptionTemp32A [USER32.599]
6333 *
6334 * PARAMS
6335 *
6336 * RETURNS
6337 * Success:
6338 * Failure:
6339 */
6340
6341BOOL WIN32API DrawCaptionTempA(HWND hwnd,
6342 HDC hdc,
6343 const RECT *rect,
6344 HFONT hFont,
6345 HICON hIcon,
6346 LPCSTR str,
6347 UINT uFlags)
6348{
6349 RECT rc = *rect;
6350
6351 dprintf(("USER32: DrawCaptionTempA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
6352 hwnd,
6353 hdc,
6354 rect,
6355 hFont,
6356 hIcon,
6357 str,
6358 uFlags));
6359
6360 /* drawing background */
6361 if (uFlags & DC_INBUTTON)
6362 {
6363 O32_FillRect (hdc,
6364 &rc,
6365 GetSysColorBrush (COLOR_3DFACE));
6366
6367 if (uFlags & DC_ACTIVE)
6368 {
6369 HBRUSH hbr = O32_SelectObject (hdc,
6370 GetSysColorBrush (COLOR_ACTIVECAPTION));
6371 O32_PatBlt (hdc,
6372 rc.left,
6373 rc.top,
6374 rc.right - rc.left,
6375 rc.bottom - rc.top,
6376 0xFA0089);
6377
6378 O32_SelectObject (hdc,
6379 hbr);
6380 }
6381 }
6382 else
6383 {
6384 O32_FillRect (hdc,
6385 &rc,
6386 GetSysColorBrush ((uFlags & DC_ACTIVE) ?
6387 COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
6388 }
6389
6390
6391 /* drawing icon */
6392 if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP))
6393 {
6394 POINT pt;
6395
6396 pt.x = rc.left + 2;
6397 pt.y = (rc.bottom + rc.top - O32_GetSystemMetrics(SM_CYSMICON)) / 2;
6398
6399 if (hIcon)
6400 {
6401 DrawIconEx (hdc,
6402 pt.x,
6403 pt.y,
6404 hIcon,
6405 O32_GetSystemMetrics(SM_CXSMICON),
6406 O32_GetSystemMetrics(SM_CYSMICON),
6407 0,
6408 0,
6409 DI_NORMAL);
6410 }
6411 else
6412 {
6413 /* @@@PH 1999/06/08 not ported yet, just don't draw any icon
6414 WND *wndPtr = WIN_FindWndPtr(hwnd);
6415 HICON hAppIcon = 0;
6416
6417 if (wndPtr->class->hIconSm)
6418 hAppIcon = wndPtr->class->hIconSm;
6419 else
6420 if (wndPtr->class->hIcon)
6421 hAppIcon = wndPtr->class->hIcon;
6422
6423 DrawIconEx (hdc,
6424 pt.x,
6425 pt.y,
6426 hAppIcon,
6427 GetSystemMetrics(SM_CXSMICON),
6428 GetSystemMetrics(SM_CYSMICON),
6429 0,
6430 0,
6431 DI_NORMAL);
6432
6433 WIN_ReleaseWndPtr(wndPtr);
6434 */
6435 }
6436
6437 rc.left += (rc.bottom - rc.top);
6438 }
6439
6440 /* drawing text */
6441 if (uFlags & DC_TEXT)
6442 {
6443 HFONT hOldFont;
6444
6445 if (uFlags & DC_INBUTTON)
6446 O32_SetTextColor (hdc,
6447 O32_GetSysColor (COLOR_BTNTEXT));
6448 else
6449 if (uFlags & DC_ACTIVE)
6450 O32_SetTextColor (hdc,
6451 O32_GetSysColor (COLOR_CAPTIONTEXT));
6452 else
6453 O32_SetTextColor (hdc,
6454 O32_GetSysColor (COLOR_INACTIVECAPTIONTEXT));
6455
6456 O32_SetBkMode (hdc,
6457 TRANSPARENT);
6458
6459 if (hFont)
6460 hOldFont = O32_SelectObject (hdc,
6461 hFont);
6462 else
6463 {
6464 NONCLIENTMETRICSA nclm;
6465 HFONT hNewFont;
6466
6467 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
6468 O32_SystemParametersInfo (SPI_GETNONCLIENTMETRICS,
6469 0,
6470 &nclm,
6471 0);
6472 hNewFont = O32_CreateFontIndirect ((uFlags & DC_SMALLCAP) ?
6473 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
6474 hOldFont = O32_SelectObject (hdc,
6475 hNewFont);
6476 }
6477
6478 if (str)
6479 O32_DrawText (hdc,
6480 str,
6481 -1,
6482 &rc,
6483 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
6484 else
6485 {
6486 CHAR szText[128];
6487 INT nLen;
6488
6489 nLen = O32_GetWindowText (hwnd,
6490 szText,
6491 128);
6492
6493 O32_DrawText (hdc,
6494 szText,
6495 nLen,
6496 &rc,
6497 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
6498 }
6499
6500 if (hFont)
6501 O32_SelectObject (hdc,
6502 hOldFont);
6503 else
6504 O32_DeleteObject (O32_SelectObject (hdc,
6505 hOldFont));
6506 }
6507
6508 /* drawing focus ??? */
6509 if (uFlags & 0x2000)
6510 {
6511 dprintf(("USER32: DrawCaptionTempA undocumented flag (0x2000)!\n"));
6512 }
6513
6514 return 0;
6515}
6516
6517
6518/***********************************************************************
6519 * DrawCaptionTemp32W [USER32.602]
6520 *
6521 * PARAMS
6522 *
6523 * RETURNS
6524 * Success:
6525 * Failure:
6526 */
6527
6528BOOL WIN32API DrawCaptionTempW (HWND hwnd,
6529 HDC hdc,
6530 const RECT *rect,
6531 HFONT hFont,
6532 HICON hIcon,
6533 LPCWSTR str,
6534 UINT uFlags)
6535{
6536 LPSTR strAscii = UnicodeToAsciiString((LPWSTR)str);
6537
6538 BOOL res = DrawCaptionTempA (hwnd,
6539 hdc,
6540 rect,
6541 hFont,
6542 hIcon,
6543 strAscii,
6544 uFlags);
6545
6546 FreeAsciiString(strAscii);
6547
6548 return res;
6549}
Note: See TracBrowser for help on using the repository browser.