source: trunk/src/user32/old/user32.cpp@ 3831

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

Compilation fixes
File size: 235.1 KB
Line 
1/* $Id: user32.cpp,v 1.4 1999-09-25 19:07:33 sandervl Exp $ */
2
3/*
4 * Win32 misc user32 API functions for OS/2
5 *
6 * Copyright 1998 Sander van Leeuwen
7 * Copyright 1998 Patrick Haller
8 * Copyright 1998 Peter Fitzsimmons
9 * Copyright 1999 Christoph Bratschi
10 *
11 *
12 * Project Odin Software License can be found in LICENSE.TXT
13 *
14 */
15/*****************************************************************************
16 * Name : USER32.CPP
17 * Purpose : This module maps all Win32 functions contained in USER32.DLL
18 * to their OS/2-specific counterparts as far as possible.
19 *****************************************************************************/
20
21#include <os2win.h>
22#include "misc.h"
23
24#include "user32.h"
25#include "wndproc.h"
26#include "wndclass.h"
27#include "usrcall.h"
28#include "syscolor.h"
29
30#include <wchar.h>
31#include <stdlib.h>
32#include <string.h>
33#include <winicon.h>
34
35//undocumented stuff
36// WIN32API CalcChildScroll
37// WIN32API CascadeChildWindows
38// WIN32API ClientThreadConnect
39// WIN32API DragObject
40// WIN32API DrawFrame
41// WIN32API EditWndProc
42// WIN32API EndTask
43// WIN32API GetInputDesktop
44// WIN32API GetNextQueueWindow
45// WIN32API GetShellWindow
46// WIN32API InitSharedTable
47// WIN32API InitTask
48// WIN32API IsHungThread
49// WIN32API LockWindowStation
50// WIN32API ModifyAccess
51// WIN32API PlaySoundEvent
52// WIN32API RegisterLogonProcess
53// WIN32API RegisterNetworkCapabilities
54// WIN32API RegisterSystemThread
55// WIN32API SetDeskWallpaper
56// WIN32API SetDesktopBitmap
57// WIN32API SetInternalWindowPos
58// WIN32API SetLogonNotifyWindow
59// WIN32API SetShellWindow
60// WIN32API SetSysColorsTemp
61// WIN32API SetWindowFullScreenState
62// WIN32API SwitchToThisWindow
63// WIN32API SysErrorBox
64// WIN32API TileChildWindows
65// WIN32API UnlockWindowStation
66// WIN32API UserClientDllInitialize
67// WIN32API UserSignalProc
68// WIN32API WinOldAppHackoMatic
69// WIN32API WNDPROC_CALLBACK
70// WIN32API YieldTask
71
72
73
74//******************************************************************************
75//******************************************************************************
76#ifdef DEBUG
77void PrintWindowStyle(DWORD dwStyle, DWORD dwExStyle)
78{
79 char style[256] = "";
80 char exstyle[256] = "";
81
82 /* Window styles */
83 if(dwStyle & WS_CHILD)
84 strcat(style, "WS_CHILD ");
85 if(dwStyle & WS_POPUP)
86 strcat(style, "WS_POPUP ");
87 if(dwStyle & WS_VISIBLE)
88 strcat(style, "WS_VISIBLE ");
89 if(dwStyle & WS_DISABLED)
90 strcat(style, "WS_DISABLED ");
91 if(dwStyle & WS_CLIPSIBLINGS)
92 strcat(style, "WS_CLIPSIBLINGS ");
93 if(dwStyle & WS_CLIPCHILDREN)
94 strcat(style, "WS_CLIPCHILDREN ");
95 if(dwStyle & WS_MAXIMIZE)
96 strcat(style, "WS_MAXIMIZE ");
97 if(dwStyle & WS_MINIMIZE)
98 strcat(style, "WS_MINIMIZE ");
99 if(dwStyle & WS_GROUP)
100 strcat(style, "WS_GROUP ");
101 if(dwStyle & WS_TABSTOP)
102 strcat(style, "WS_TABSTOP ");
103
104 if(dwStyle & WS_CAPTION)
105 strcat(style, "WS_CAPTION ");
106 if(dwStyle & WS_DLGFRAME)
107 strcat(style, "WS_DLGFRAME ");
108 if(dwStyle & WS_BORDER)
109 strcat(style, "WS_BORDER ");
110
111 if(dwStyle & WS_VSCROLL)
112 strcat(style, "WS_VSCROLL ");
113 if(dwStyle & WS_HSCROLL)
114 strcat(style, "WS_HSCROLL ");
115 if(dwStyle & WS_SYSMENU)
116 strcat(style, "WS_SYSMENU ");
117 if(dwStyle & WS_THICKFRAME)
118 strcat(style, "WS_THICKFRAME ");
119 if(dwStyle & WS_MINIMIZEBOX)
120 strcat(style, "WS_MINIMIZEBOX ");
121 if(dwStyle & WS_MAXIMIZEBOX)
122 strcat(style, "WS_MAXIMIZEBOX ");
123
124 if(dwExStyle & WS_EX_DLGMODALFRAME)
125 strcat(exstyle, "WS_EX_DLGMODALFRAME ");
126 if(dwExStyle & WS_EX_ACCEPTFILES)
127 strcat(exstyle, "WS_EX_ACCEPTFILES ");
128 if(dwExStyle & WS_EX_NOPARENTNOTIFY)
129 strcat(exstyle, "WS_EX_NOPARENTNOTIFY ");
130 if(dwExStyle & WS_EX_TOPMOST)
131 strcat(exstyle, "WS_EX_TOPMOST ");
132 if(dwExStyle & WS_EX_TRANSPARENT)
133 strcat(exstyle, "WS_EX_TRANSPARENT ");
134
135 if(dwExStyle & WS_EX_MDICHILD)
136 strcat(exstyle, "WS_EX_MDICHILD ");
137 if(dwExStyle & WS_EX_TOOLWINDOW)
138 strcat(exstyle, "WS_EX_TOOLWINDOW ");
139 if(dwExStyle & WS_EX_WINDOWEDGE)
140 strcat(exstyle, "WS_EX_WINDOWEDGE ");
141 if(dwExStyle & WS_EX_CLIENTEDGE)
142 strcat(exstyle, "WS_EX_CLIENTEDGE ");
143 if(dwExStyle & WS_EX_CONTEXTHELP)
144 strcat(exstyle, "WS_EX_CONTEXTHELP ");
145 if(dwExStyle & WS_EX_RIGHT)
146 strcat(exstyle, "WS_EX_RIGHT ");
147 if(dwExStyle & WS_EX_LEFT)
148 strcat(exstyle, "WS_EX_LEFT ");
149 if(dwExStyle & WS_EX_RTLREADING)
150 strcat(exstyle, "WS_EX_RTLREADING ");
151 if(dwExStyle & WS_EX_LTRREADING)
152 strcat(exstyle, "WS_EX_LTRREADING ");
153 if(dwExStyle & WS_EX_LEFTSCROLLBAR)
154 strcat(exstyle, "WS_EX_LEFTSCROLLBAR ");
155 if(dwExStyle & WS_EX_RIGHTSCROLLBAR)
156 strcat(exstyle, "WS_EX_RIGHTSCROLLBAR ");
157 if(dwExStyle & WS_EX_CONTROLPARENT)
158 strcat(exstyle, "WS_EX_CONTROLPARENT ");
159 if(dwExStyle & WS_EX_STATICEDGE)
160 strcat(exstyle, "WS_EX_STATICEDGE ");
161 if(dwExStyle & WS_EX_APPWINDOW)
162 strcat(exstyle, "WS_EX_APPWINDOW ");
163
164 dprintf(("Window style: %x %s", dwStyle, style));
165 dprintf(("Window exStyle: %x %s", dwExStyle, exstyle));
166}
167#endif
168
169
170//******************************************************************************
171//******************************************************************************
172HWND WIN32API GetActiveWindow()
173{
174 return(O32_GetActiveWindow());
175}
176//******************************************************************************
177//******************************************************************************
178int __cdecl wsprintfA(char *lpOut, LPCSTR lpFmt, ...)
179{
180 int rc;
181 va_list argptr;
182
183#ifdef DEBUG
184 WriteLog("USER32: wsprintfA\n");
185 WriteLog("USER32: %s\n", lpFmt);
186#endif
187 va_start(argptr, lpFmt);
188 rc = O32_wvsprintf(lpOut, (char *)lpFmt, argptr);
189 va_end(argptr);
190#ifdef DEBUG
191 WriteLog("USER32: %s\n", lpOut);
192#endif
193 return(rc);
194}
195//******************************************************************************
196//******************************************************************************
197int __cdecl wsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, ...)
198{
199 int rc;
200 char *lpFmtA;
201 char szOut[512];
202 va_list argptr;
203
204 dprintf(("USER32: wsprintfW(%08xh,%08xh).\n",
205 lpOut,
206 lpFmt));
207
208 lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
209
210 /* @@@PH 98/07/13 transform "%s" to "%ls" does the unicode magic */
211 {
212 PSZ pszTemp;
213 PSZ pszTemp1;
214 ULONG ulStrings;
215 ULONG ulIndex; /* temporary string counter */
216
217 for (ulStrings = 0, /* determine number of placeholders */
218 pszTemp = lpFmtA;
219
220 (pszTemp != NULL) &&
221 (*pszTemp != 0);
222
223 ulStrings++)
224 {
225 pszTemp = strstr(pszTemp,
226 "%s");
227 if (pszTemp != NULL) /* skip 2 characters */
228 {
229 pszTemp++;
230 pszTemp++;
231 }
232 else
233 break; /* leave loop immediately */
234 }
235
236 if (ulStrings != 0) /* transformation required ? */
237 {
238 /* now reallocate lpFmt */
239 ulStrings += strlen(lpFmtA); /* calculate total string length */
240 pszTemp = lpFmtA; /* save string pointer */
241 pszTemp1 = lpFmtA; /* save string pointer */
242
243 /* @@@PH allocation has to be compatible to FreeAsciiString !!! */
244 lpFmtA = (char *)malloc(ulStrings + 1);
245 if (lpFmtA == NULL) /* check proper allocation */
246 return (0); /* raise error condition */
247
248 for (ulIndex = 0;
249 ulIndex <= ulStrings;
250 ulIndex++,
251 pszTemp++)
252 {
253 if ((pszTemp[0] == '%') &&
254 (pszTemp[1] == 's') )
255 {
256 /* replace %s by %ls */
257 lpFmtA[ulIndex++] = '%';
258 lpFmtA[ulIndex ] = 'l';
259 lpFmtA[ulIndex+1] = 's';
260 }
261 else
262 lpFmtA[ulIndex] = *pszTemp; /* just copy over the character */
263 }
264
265 lpFmtA[ulStrings] = 0; /* string termination */
266
267 FreeAsciiString(pszTemp1); /* the original string is obsolete */
268 }
269 }
270
271 dprintf(("USER32: wsprintfW (%s).\n",
272 lpFmt));
273
274 va_start(argptr,
275 lpFmt);
276
277 rc = O32_wvsprintf(szOut,
278 lpFmtA,
279 argptr);
280
281 AsciiToUnicode(szOut,
282 lpOut);
283
284 FreeAsciiString(lpFmtA);
285 return(rc);
286}
287//******************************************************************************
288//******************************************************************************
289int WIN32API MessageBoxA(HWND hwndOwner, LPCTSTR lpszText, LPCTSTR lpszTitle, UINT fuStyle)
290{
291 dprintf(("USER32: MessageBoxA %s %s\n", lpszText, lpszTitle));
292 return(O32_MessageBox(hwndOwner, lpszText, lpszTitle, fuStyle));
293}
294//******************************************************************************
295//******************************************************************************
296BOOL WIN32API MessageBeep( UINT arg1)
297{
298#ifdef DEBUG
299 WriteLog("USER32: MessageBeep\n");
300#endif
301 return O32_MessageBeep(arg1);
302}
303//******************************************************************************
304//******************************************************************************
305LONG WIN32API SendDlgItemMessageA( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
306{
307#ifdef DEBUG
308 WriteLog("USER32: SendDlgItemMessageA\n");
309#endif
310 return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
311}
312//******************************************************************************
313//******************************************************************************
314VOID WIN32API PostQuitMessage( int arg1)
315{
316 dprintf(("USER32: PostQuitMessage\n"));
317 O32_PostQuitMessage(arg1);
318}
319//******************************************************************************
320// Not implemented by Open32 (31-5-99 Christoph Bratschi)
321//******************************************************************************
322BOOL WIN32API IsDlgButtonChecked( HWND arg1, UINT arg2)
323{
324#ifdef DEBUG
325 WriteLog("USER32: IsDlgButtonChecked\n");
326#endif
327// return O32_IsDlgButtonChecked(arg1, arg2);
328 return (BOOL)SendDlgItemMessageA(arg1,arg2,BM_GETCHECK,0,0);
329}
330//******************************************************************************
331//******************************************************************************
332int WIN32API GetWindowTextLengthA( HWND arg1)
333{
334 dprintf(("USER32: GetWindowTextLength\n"));
335 return O32_GetWindowTextLength(arg1);
336}
337//******************************************************************************
338//******************************************************************************
339int WIN32API GetWindowTextA( HWND arg1, LPSTR arg2, int arg3)
340{
341 dprintf(("USER32: GetWindowTextA\n"));
342 return O32_GetWindowText(arg1, arg2, arg3);
343}
344//******************************************************************************
345
346/*******************************************************************
347 * InternalGetWindowText (USER32.326)
348 */
349int WIN32API InternalGetWindowText(HWND hwnd,
350 LPWSTR lpString,
351 INT nMaxCount )
352{
353 dprintf(("USER32: InternalGetWindowText(%08xh,%08xh,%08xh) not properly implemented.\n",
354 hwnd,
355 lpString,
356 nMaxCount));
357
358 return GetWindowTextW(hwnd,lpString,nMaxCount);
359}
360
361
362//******************************************************************************
363BOOL WIN32API GetWindowRect( HWND arg1, PRECT arg2)
364{
365 BOOL rc;
366
367 rc = O32_GetWindowRect(arg1, arg2);
368 dprintf(("USER32: GetWindowRect %X returned %d\n", arg1, rc));
369 return(rc);
370}
371//******************************************************************************
372//******************************************************************************
373HWND WIN32API GetNextDlgTabItem( HWND arg1, HWND arg2, BOOL arg3)
374{
375 dprintf(("USER32: GetNextDlgTabItem\n"));
376 return O32_GetNextDlgTabItem(arg1, arg2, arg3);
377}
378//******************************************************************************
379//******************************************************************************
380BOOL WIN32API GetMessageA( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
381{
382//// dprintf(("USER32: GetMessage\n"));
383 return O32_GetMessage(arg1, arg2, arg3, arg4);
384}
385//******************************************************************************
386//******************************************************************************
387HWND WIN32API GetFocus(void)
388{
389// dprintf(("USER32: GetFocus\n"));
390 return O32_GetFocus();
391}
392//******************************************************************************
393//******************************************************************************
394HWND WIN32API GetDlgItem(HWND arg1, int arg2)
395{
396 HWND rc;
397
398 rc = O32_GetDlgItem(arg1, arg2);
399 dprintf(("USER32: GetDlgItem %d returned %d\n", arg2, rc));
400 return(rc);
401}
402//******************************************************************************
403//******************************************************************************
404int WIN32API GetDlgCtrlID( HWND arg1)
405{
406 dprintf(("USER32: GetDlgCtrlID\n"));
407 return O32_GetDlgCtrlID(arg1);
408}
409//******************************************************************************
410//******************************************************************************
411HWND WIN32API GetDesktopWindow(void)
412{
413 dprintf(("USER32: GetDesktopWindow\n"));
414 return O32_GetDesktopWindow();
415}
416//******************************************************************************
417//******************************************************************************
418BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
419{
420 BOOL rc;
421 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
422
423 dprintf(("USER32: EnumThreadWindows\n"));
424 rc = O32_EnumThreadWindows(dwThreadId, callback->GetOS2Callback(), (LPARAM)callback);
425 if(callback)
426 delete callback;
427 return(rc);
428}
429//******************************************************************************
430//******************************************************************************
431BOOL WIN32API EndDialog( HWND arg1, int arg2)
432{
433 BOOL rc;
434
435 dprintf(("USER32: EndDialog\n"));
436 rc = O32_EndDialog(arg1, arg2);
437 return(rc);
438}
439//******************************************************************************
440//******************************************************************************
441LONG WIN32API DispatchMessageA( const MSG * arg1)
442{
443//// dprintf(("USER32: DispatchMessage\n"));
444 return O32_DispatchMessage(arg1);
445}
446//******************************************************************************
447//******************************************************************************
448BOOL WIN32API OffsetRect( PRECT arg1, int arg2, int arg3)
449{
450#ifdef DEBUG
451//// WriteLog("USER32: OffsetRect\n");
452#endif
453 return O32_OffsetRect(arg1, arg2, arg3);
454}
455//******************************************************************************
456//******************************************************************************
457BOOL WIN32API CopyRect( PRECT arg1, const RECT * arg2)
458{
459// ddprintf(("USER32: CopyRect\n"));
460 return O32_CopyRect(arg1, arg2);
461}
462//******************************************************************************
463// Not implemented by Open32 (5-31-99 Christoph Bratschi)
464//******************************************************************************
465BOOL WIN32API CheckDlgButton( HWND arg1, int arg2, UINT arg3)
466{
467#ifdef DEBUG
468 WriteLog("USER32: CheckDlgButton\n");
469#endif
470// return O32_CheckDlgButton(arg1, arg2, arg3);
471 return (BOOL)SendDlgItemMessageA(arg1,arg2,BM_SETCHECK,arg3,0);
472}
473//******************************************************************************
474//******************************************************************************
475HWND WIN32API SetFocus( HWND arg1)
476{
477 dprintf(("USER32: SetFocus\n"));
478 return O32_SetFocus(arg1);
479}
480//******************************************************************************
481//******************************************************************************
482BOOL WIN32API TranslateMessage( const MSG * arg1)
483{
484#ifdef DEBUG
485//// WriteLog("USER32: TranslateMessage\n");
486#endif
487 return O32_TranslateMessage(arg1);
488}
489//******************************************************************************
490//******************************************************************************
491BOOL WIN32API SetWindowPos( HWND arg1, HWND arg2, int arg3, int arg4, int arg5, int arg6, UINT arg7)
492{
493#ifdef DEBUG
494 WriteLog("USER32: SetWindowPos\n");
495#endif
496 return O32_SetWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
497}
498//******************************************************************************
499//******************************************************************************
500BOOL WIN32API ShowWindow(HWND arg1, int arg2)
501{
502#ifdef DEBUG
503 WriteLog("USER32: ShowWindow %X %d\n", arg1, arg2);
504#endif
505 return O32_ShowWindow(arg1, arg2);
506}
507//******************************************************************************
508//******************************************************************************
509BOOL WIN32API SetWindowTextA(HWND arg1, LPCSTR arg2)
510{
511#ifdef DEBUG
512 WriteLog("USER32: SetWindowText %s\n", arg2);
513#endif
514 return O32_SetWindowText(arg1, arg2);
515}
516//******************************************************************************
517//******************************************************************************
518BOOL WIN32API SetForegroundWindow(HWND arg1)
519{
520#ifdef DEBUG
521 WriteLog("USER32: SetForegroundWindow\n");
522#endif
523 return O32_SetForegroundWindow(arg1);
524}
525//******************************************************************************
526//******************************************************************************
527int WIN32API ReleaseDC( HWND arg1, HDC arg2)
528{
529#ifdef DEBUG
530 WriteLog("USER32: ReleaseDC\n");
531#endif
532 return O32_ReleaseDC(arg1, arg2);
533}
534//******************************************************************************
535//******************************************************************************
536BOOL WIN32API InvalidateRect(HWND arg1, const RECT *arg2, BOOL arg3)
537{
538#ifdef DEBUG
539 if(arg2)
540 WriteLog("USER32: InvalidateRect for window %X (%d,%d)(%d,%d) %d\n", arg1, arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
541 else WriteLog("USER32: InvalidateRect for window %X NULL, %d\n", arg1, arg3);
542#endif
543 return O32_InvalidateRect(arg1, arg2, arg3);
544}
545//******************************************************************************
546//******************************************************************************
547BOOL WIN32API GetUpdateRect( HWND arg1, PRECT arg2, BOOL arg3)
548{
549#ifdef DEBUG
550 WriteLog("USER32: GetUpdateRect\n");
551#endif
552 return O32_GetUpdateRect(arg1, arg2, arg3);
553}
554//******************************************************************************
555//******************************************************************************
556HDC WIN32API GetDC( HWND arg1)
557{
558 HDC hdc;
559
560 hdc = O32_GetDC(arg1);
561#ifdef DEBUG
562 WriteLog("USER32: GetDC of %X returns %X\n", arg1, hdc);
563#endif
564 return(hdc);
565}
566//******************************************************************************
567//******************************************************************************
568HDC WIN32API GetDCEx(HWND arg1, HRGN arg2, DWORD arg3)
569{
570#ifdef DEBUG
571 WriteLog("USER32: GetDCEx\n");
572#endif
573 return O32_GetDCEx(arg1, arg2, arg3);
574}
575//******************************************************************************
576//******************************************************************************
577BOOL WIN32API GetClientRect( HWND hwnd, PRECT pRect)
578{
579 BOOL rc;
580
581 rc = O32_GetClientRect(hwnd, pRect);
582 dprintf(("USER32: GetClientRect of %X returned (%d,%d) (%d,%d)\n", hwnd, pRect->left, pRect->top, pRect->right, pRect->bottom));
583 return rc;
584}
585//******************************************************************************
586//******************************************************************************
587HWND WIN32API FindWindowA(LPCSTR arg1, LPCSTR arg2)
588{
589#ifdef DEBUG
590 WriteLog("USER32: FindWindow\n");
591#endif
592 return O32_FindWindow(arg1, arg2);
593}
594//******************************************************************************
595//******************************************************************************
596HWND WIN32API FindWindowExA(HWND arg1, HWND arg2, LPCSTR arg3, LPCSTR arg4)
597{
598#ifdef DEBUG
599 WriteLog("USER32: FindWindowExA, not completely implemented\n");
600#endif
601 return O32_FindWindow(arg3, arg4);
602}
603//******************************************************************************
604//******************************************************************************
605BOOL WIN32API FlashWindow( HWND arg1, BOOL arg2)
606{
607#ifdef DEBUG
608 WriteLog("USER32: FlashWindow\n");
609#endif
610 return O32_FlashWindow(arg1, arg2);
611}
612//******************************************************************************
613//******************************************************************************
614BOOL WIN32API EndPaint( HWND arg1, const PAINTSTRUCT * arg2)
615{
616#ifdef DEBUG
617 WriteLog("USER32: EndPaint\n");
618#endif
619 return O32_EndPaint(arg1, arg2);
620}
621//******************************************************************************
622//******************************************************************************
623BOOL WIN32API MoveWindow(HWND arg1, int arg2, int arg3, int arg4, int arg5, BOOL arg6)
624{
625 BOOL rc;
626
627 rc = O32_MoveWindow(arg1, arg2, arg3, arg4, arg5, arg6);
628 dprintf(("USER32: MoveWindow %X to (%d,%d) size (%d,%d), repaint = %d returned %d\n", arg1, arg2, arg3, arg4, arg5, arg6, rc));
629 return(rc);
630}
631//******************************************************************************
632//******************************************************************************
633HWND WIN32API CreateWindowExA(DWORD dwExStyle,
634 LPCSTR arg2,
635 LPCSTR arg3,
636 DWORD dwStyle,
637 int x,
638 int y,
639 int nWidth,
640 int nHeight,
641 HWND parent,
642 HMENU arg10,
643 HINSTANCE arg11,
644 PVOID arg12)
645{
646 HWND hwnd;
647 Win32WindowProc *window = NULL;
648
649#ifdef DEBUG
650 PrintWindowStyle(dwStyle, dwExStyle);
651#endif
652
653 /* @@@PH 98/06/12 CreateWindow crashes somewhere in Open32 */
654 if(arg3 == NULL)
655 arg3 = (LPCSTR)"CRASH, CRASH";
656
657 // 6-12-99 CB: WS_CLIPCHILDREN not set -> controls not redrawn
658 // Problems with group boxes
659 //SvL: Not necessary anymore (EB's fixes)
660// dwStyle |= WS_CLIPCHILDREN;
661
662 //SvL: Correct window style (like Wine does)
663 if(dwStyle & WS_CHILD) {
664 dwStyle |= WS_CLIPSIBLINGS;
665 if(!(dwStyle & WS_POPUP)) {
666 dwStyle |= WS_CAPTION;
667 }
668 }
669 if(dwExStyle & WS_EX_DLGMODALFRAME)
670 {
671 dwStyle &= ~WS_THICKFRAME;
672 }
673
674#ifdef DEBUG
675 WriteLog("USER32: CreateWindow: dwExStyle = %X\n", dwExStyle);
676 if((int)arg2 >> 16 != 0)
677 WriteLog("USER32: CreateWindow: classname = %s\n", arg2);
678 else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
679 WriteLog("USER32: CreateWindow: windowname= %s\n", arg3);
680 WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
681 WriteLog("USER32: CreateWindow: x = %d\n", x);
682 WriteLog("USER32: CreateWindow: y = %d\n", y);
683 WriteLog("USER32: CreateWindow: nWidth = %d\n", nWidth);
684 WriteLog("USER32: CreateWindow: nHeight = %d\n", nHeight);
685 WriteLog("USER32: CreateWindow: parent = %X\n", parent);
686 WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
687 WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
688 WriteLog("USER32: CreateWindow: param = %X\n", arg12);
689 #endif
690
691 if((int) arg2 >> 16 != 0 && strcmp(arg2, "COMBOBOX") == 0)
692 {
693 dprintf(("COMBOBOX creation"));
694 //TODO: #%@#%$ Open32 doesn't support this
695 dwStyle &= ~(CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE);
696
697 /* @@@PH 98/06/12 drop down combos are problematic too */
698 /* so we translate the styles to OS/2 style */
699 dwStyle |= CBS_DROPDOWN | CBS_DROPDOWNLIST;
700 }
701
702 //Classname might be name of system class, in which case we don't
703 //need to use our own callback
704// if(Win32WindowClass::FindClass((LPSTR)arg2) != NULL) {
705 window = new Win32WindowProc(arg11, arg2);
706// }
707
708 hwnd = O32_CreateWindowEx(dwExStyle,
709 arg2,
710 arg3,
711 dwStyle,
712 x,
713 y,
714 nWidth,
715 nHeight,
716 parent,
717 arg10,
718 arg11,
719 arg12);
720
721 //SvL: 16-11-'97: window can be already destroyed if hwnd == 0
722 if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
723 delete(window);
724 window = 0;
725 }
726 if(window) {
727 window->SetWindowHandle(hwnd);
728 }
729
730 dprintf(("USER32: ************CreateWindowExA %s (%d,%d,%d,%d), hwnd = %X\n", arg2, x, y, nWidth, nHeight, hwnd));
731 return(hwnd);
732}
733//******************************************************************************
734//******************************************************************************
735LRESULT WIN32API SendMessageA(HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
736{
737 LRESULT rc;
738
739#ifdef DEBUG1
740 WriteLog("USER32: SendMessage....\n");
741#endif
742 rc = O32_SendMessage(arg1, arg2, arg3, arg4);
743#ifdef DEBUG1
744 WriteLog("USER32: *****SendMessage %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
745#endif
746 return(rc);
747}
748//******************************************************************************
749//******************************************************************************
750HWND WIN32API SetActiveWindow( HWND arg1)
751{
752#ifdef DEBUG
753 WriteLog("USER32: SetActiveWindow\n");
754#endif
755 return O32_SetActiveWindow(arg1);
756}
757//******************************************************************************
758//******************************************************************************
759HDC WIN32API BeginPaint(HWND arg1, PPAINTSTRUCT arg2)
760{
761 dprintf(("USER32: BeginPaint %X\n", arg2));
762 return O32_BeginPaint(arg1, arg2);
763}
764//******************************************************************************
765//******************************************************************************
766BOOL WIN32API IsDialogMessageA( HWND arg1, LPMSG arg2)
767{
768#ifdef DEBUG
769//// WriteLog("USER32: IsDialogMessage\n");
770#endif
771 return O32_IsDialogMessage(arg1, arg2);
772}
773//******************************************************************************
774//******************************************************************************
775int WIN32API DrawTextA(HDC arg1, LPCSTR arg2, int arg3, PRECT arg4, UINT arg5)
776{
777#ifdef DEBUG
778 WriteLog("USER32: DrawTextA %s", arg2);
779#endif
780 return O32_DrawText(arg1, arg2, arg3, arg4, arg5);
781}
782//******************************************************************************
783//******************************************************************************
784int WIN32API GetSystemMetrics(int arg1)
785{
786 int rc;
787
788 switch(arg1) {
789 case SM_CXICONSPACING: //TODO: size of grid cell for large icons
790 rc = O32_GetSystemMetrics(SM_CXICON);
791 break;
792 case SM_CYICONSPACING:
793 rc = O32_GetSystemMetrics(SM_CYICON);
794 break;
795 case SM_PENWINDOWS:
796 rc = FALSE;
797 break;
798 case SM_DBCSENABLED:
799 rc = FALSE;
800 break;
801 case SM_CXEDGE: //size of 3D window edge (not supported)
802 rc = 1;
803 break;
804 case SM_CYEDGE:
805 rc = 1;
806 break;
807 case SM_CXMINSPACING: //can be SM_CXMINIMIZED or larger
808 rc = O32_GetSystemMetrics(SM_CXMINIMIZED);
809 break;
810 case SM_CYMINSPACING:
811 rc = GetSystemMetrics(SM_CYMINIMIZED);
812 break;
813 case SM_CXSMICON: //recommended size of small icons (TODO: adjust to screen res.)
814 rc = 16;
815 break;
816 case SM_CYSMICON:
817 rc = 16;
818 break;
819 case SM_CYSMCAPTION: //size in pixels of a small caption (TODO: ????)
820 rc = 8;
821 break;
822 case SM_CXSMSIZE: //size of small caption buttons (pixels) (TODO: implement properly)
823 rc = 16;
824 break;
825 case SM_CYSMSIZE:
826 rc = 16;
827 break;
828 case SM_CXMENUSIZE: //TODO: size of menu bar buttons (such as MDI window close)
829 rc = 16;
830 break;
831 case SM_CYMENUSIZE:
832 rc = 16;
833 break;
834 case SM_ARRANGE:
835 rc = ARW_BOTTOMLEFT | ARW_LEFT;
836 break;
837 case SM_CXMINIMIZED:
838 break;
839 case SM_CYMINIMIZED:
840 break;
841 case SM_CXMAXTRACK: //max window size
842 case SM_CXMAXIMIZED: //max toplevel window size
843 rc = O32_GetSystemMetrics(SM_CXSCREEN);
844 break;
845 case SM_CYMAXTRACK:
846 case SM_CYMAXIMIZED:
847 rc = O32_GetSystemMetrics(SM_CYSCREEN);
848 break;
849 case SM_NETWORK:
850 rc = 0x01; //TODO: default = yes
851 break;
852 case SM_CLEANBOOT:
853 rc = 0; //normal boot
854 break;
855 case SM_CXDRAG: //nr of pixels before drag becomes a real one
856 rc = 2;
857 break;
858 case SM_CYDRAG:
859 rc = 2;
860 break;
861 case SM_SHOWSOUNDS: //show instead of play sound
862 rc = FALSE;
863 break;
864 case SM_CXMENUCHECK:
865 rc = 4; //TODO
866 break;
867 case SM_CYMENUCHECK:
868 rc = O32_GetSystemMetrics(SM_CYMENU);
869 break;
870 case SM_SLOWMACHINE:
871 rc = FALSE; //even a slow machine is fast with OS/2 :)
872 break;
873 case SM_MIDEASTENABLED:
874 rc = FALSE;
875 break;
876 case SM_CMETRICS:
877 rc = O32_GetSystemMetrics(44); //Open32 changed this one
878 break;
879 default:
880 rc = O32_GetSystemMetrics(arg1);
881 break;
882 }
883 dprintf(("USER32: GetSystemMetrics %d returned %d\n", arg1, rc));
884 return(rc);
885}
886//******************************************************************************
887//******************************************************************************
888UINT WIN32API SetTimer( HWND arg1, UINT arg2, UINT arg3, TIMERPROC arg4)
889{
890#ifdef DEBUG
891 WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
892#endif
893 //SvL: Write callback handler class for this one
894 return O32_SetTimer(arg1, arg2, arg3, (TIMERPROC_O32)arg4);
895}
896//******************************************************************************
897//******************************************************************************
898BOOL WIN32API KillTimer(HWND arg1, UINT arg2)
899{
900#ifdef DEBUG
901 WriteLog("USER32: KillTimer\n");
902#endif
903 return O32_KillTimer(arg1, arg2);
904}
905//******************************************************************************
906//******************************************************************************
907BOOL WIN32API DestroyWindow(HWND arg1)
908{
909#ifdef DEBUG
910 WriteLog("USER32: DestroyWindow\n");
911#endif
912 return O32_DestroyWindow(arg1);
913}
914//******************************************************************************
915//******************************************************************************
916BOOL WIN32API PostMessageA( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
917{
918#ifdef DEBUG
919 WriteLog("USER32: PostMessageA %X %X %X %X\n", arg1, arg2, arg3, arg4);
920#endif
921 return O32_PostMessage(arg1, arg2, arg3, arg4);
922}
923//******************************************************************************
924//******************************************************************************
925BOOL WIN32API InflateRect( PRECT arg1, int arg2, int arg3)
926{
927#ifdef DEBUG
928 WriteLog("USER32: InflateRect\n");
929#endif
930 return O32_InflateRect(arg1, arg2, arg3);
931}
932//******************************************************************************
933//TODO:How can we emulate this one in OS/2???
934//******************************************************************************
935DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
936{
937#ifdef DEBUG
938 WriteLog("USER32: WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
939#endif
940
941 if(dwTimeOut == INFINITE) return(0);
942
943// DosSleep(dwTimeOut/16);
944 return(0);
945}
946//******************************************************************************
947//******************************************************************************
948UINT WIN32API GetDlgItemTextA(HWND arg1, int arg2, LPSTR arg3, UINT arg4)
949{
950 UINT rc;
951
952 rc = O32_GetDlgItemText(arg1, arg2, arg3, arg4);
953#ifdef DEBUG
954 if(rc)
955 WriteLog("USER32: GetDlgItemTextA returned %s\n", arg3);
956 else WriteLog("USER32: GetDlgItemTextA returned 0 (%d)\n", GetLastError());
957#endif
958 return(rc);
959}
960//******************************************************************************
961//******************************************************************************
962BOOL WIN32API PeekMessageA(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
963{
964#ifdef DEBUG
965// WriteLog("USER32: PeekMessage\n");
966#endif
967 return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
968}
969//******************************************************************************
970//******************************************************************************
971int WIN32API ShowCursor( BOOL arg1)
972{
973#ifdef DEBUG
974 WriteLog("USER32: ShowCursor\n");
975#endif
976 return O32_ShowCursor(arg1);
977}
978//******************************************************************************
979//BUGBUG: UpdateWindow sends a WM_ERASEBKGRND when it shouldn't!
980// So we just do it manually
981//******************************************************************************
982BOOL WIN32API UpdateWindow(HWND hwnd)
983{
984 RECT rect;
985
986#ifdef DEBUG
987 WriteLog("USER32: UpdateWindow\n");
988#endif
989
990#if 0 // EB: ->>> doesn't work. No correct update of Winhlp32 scrolling area.
991 if(O32_GetUpdateRect(hwnd, &rect, FALSE) != FALSE) {//update region empty?
992 WndCallback(hwnd, WM_PAINT, 0, 0);
993// O32_PostMessage(hwnd, WM_PAINT, 0, 0);
994 }
995#ifdef DEBUG
996 else WriteLog("USER32: Update region empty!\n");
997#endif
998 return(TRUE);
999#endif
1000
1001 return O32_UpdateWindow(hwnd);
1002}
1003//******************************************************************************
1004//******************************************************************************
1005BOOL WIN32API AdjustWindowRect( PRECT arg1, DWORD arg2, BOOL arg3)
1006{
1007#ifdef DEBUG
1008 WriteLog("USER32: AdjustWindowRect\n");
1009#endif
1010 return O32_AdjustWindowRect(arg1, arg2, arg3);
1011}
1012//******************************************************************************
1013//******************************************************************************
1014BOOL WIN32API AdjustWindowRectEx( PRECT arg1, DWORD arg2, BOOL arg3, DWORD arg4)
1015{
1016#ifdef DEBUG
1017 WriteLog("USER32: AdjustWindowRectEx\n");
1018#endif
1019 return O32_AdjustWindowRectEx(arg1, arg2, arg3, arg4);
1020}
1021//******************************************************************************
1022//******************************************************************************
1023BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
1024{
1025#ifdef DEBUG
1026//// WriteLog("USER32: ClientToScreen\n");
1027#endif
1028 return O32_ClientToScreen(arg1, arg2);
1029}
1030//******************************************************************************
1031//******************************************************************************
1032BOOL WIN32API SetRect( PRECT arg1, int arg2, int arg3, int arg4, int arg5)
1033{
1034#ifdef DEBUG
1035 WriteLog("USER32: SetRect\n");
1036#endif
1037 return O32_SetRect(arg1, arg2, arg3, arg4, arg5);
1038}
1039//******************************************************************************
1040//******************************************************************************
1041BOOL WIN32API SetDlgItemInt( HWND arg1, int arg2, UINT arg3, BOOL arg4)
1042{
1043#ifdef DEBUG
1044 WriteLog("USER32: SetDlgItemInt\n");
1045#endif
1046 return O32_SetDlgItemInt(arg1, arg2, arg3, arg4);
1047}
1048//******************************************************************************
1049//******************************************************************************
1050BOOL WIN32API SetDlgItemTextA( HWND arg1, int arg2, LPCSTR arg3)
1051{
1052#ifdef DEBUG
1053 WriteLog("USER32: SetDlgItemText to %s\n", arg3);
1054#endif
1055 return O32_SetDlgItemText(arg1, arg2, arg3);
1056}
1057//******************************************************************************
1058//******************************************************************************
1059BOOL WIN32API WinHelpA( HWND arg1, LPCSTR arg2, UINT arg3, DWORD arg4)
1060{
1061#ifdef DEBUG
1062 WriteLog("USER32: WinHelp not implemented %s\n", arg2);
1063#endif
1064// return O32_WinHelp(arg1, arg2, arg3, arg4);
1065 return(TRUE);
1066}
1067//******************************************************************************
1068//******************************************************************************
1069BOOL WIN32API IsIconic( HWND arg1)
1070{
1071#ifdef DEBUG
1072 WriteLog("USER32: IsIconic\n");
1073#endif
1074 return O32_IsIconic(arg1);
1075}
1076//******************************************************************************
1077//******************************************************************************
1078int WIN32API TranslateAcceleratorA(HWND arg1, HACCEL arg2, LPMSG arg3)
1079{
1080#ifdef DEBUG
1081//// WriteLog("USER32: TranslateAccelerator\n");
1082#endif
1083 return O32_TranslateAccelerator(arg1, arg2, arg3);
1084}
1085//******************************************************************************
1086//******************************************************************************
1087HWND WIN32API GetWindow(HWND arg1, UINT arg2)
1088{
1089 HWND rc;
1090
1091 rc = O32_GetWindow(arg1, arg2);
1092#ifdef DEBUG
1093 WriteLog("USER32: GetWindow %X %d returned %d\n", arg1, arg2, rc);
1094#endif
1095 return(rc);
1096}
1097//******************************************************************************
1098//******************************************************************************
1099HDC WIN32API GetWindowDC(HWND arg1)
1100{
1101#ifdef DEBUG
1102 WriteLog("USER32: GetWindowDC\n");
1103#endif
1104 return O32_GetWindowDC(arg1);
1105}
1106//******************************************************************************
1107//******************************************************************************
1108BOOL WIN32API SubtractRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
1109{
1110#ifdef DEBUG
1111 WriteLog("USER32: SubtractRect");
1112#endif
1113 return O32_SubtractRect(arg1, arg2, arg3);
1114}
1115//******************************************************************************
1116//SvL: 24-6-'97 - Added
1117//******************************************************************************
1118BOOL WIN32API ClipCursor(const RECT * arg1)
1119{
1120#ifdef DEBUG
1121 WriteLog("USER32: ClipCursor\n");
1122#endif
1123 return O32_ClipCursor(arg1);
1124}
1125//******************************************************************************
1126//SvL: 24-6-'97 - Added
1127//TODO: Not implemented
1128//******************************************************************************
1129WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1130{
1131#ifdef DEBUG
1132//// WriteLog("USER32: GetAsyncKeyState Not implemented\n");
1133#endif
1134 return 0;
1135}
1136//******************************************************************************
1137//SvL: 24-6-'97 - Added
1138//******************************************************************************
1139HCURSOR WIN32API GetCursor(void)
1140{
1141#ifdef DEBUG
1142//// WriteLog("USER32: GetCursor\n");
1143#endif
1144 return O32_GetCursor();
1145}
1146//******************************************************************************
1147//SvL: 24-6-'97 - Added
1148//******************************************************************************
1149BOOL WIN32API GetCursorPos( PPOINT arg1)
1150{
1151#ifdef DEBUG
1152//// WriteLog("USER32: GetCursorPos\n");
1153#endif
1154 return O32_GetCursorPos(arg1);
1155}
1156//******************************************************************************
1157//SvL: 24-6-'97 - Added
1158//******************************************************************************
1159UINT WIN32API RegisterWindowMessageA(LPCSTR arg1)
1160{
1161 UINT rc;
1162
1163 rc = O32_RegisterWindowMessage(arg1);
1164#ifdef DEBUG
1165 WriteLog("USER32: RegisterWindowMessageA %s returned %X\n", arg1, rc);
1166#endif
1167 return(rc);
1168}
1169//******************************************************************************
1170//SvL: 24-6-'97 - Added
1171//******************************************************************************
1172WORD WIN32API VkKeyScanA( char arg1)
1173{
1174#ifdef DEBUG
1175 WriteLog("USER32: VkKeyScanA\n");
1176#endif
1177 return O32_VkKeyScan(arg1);
1178}
1179//******************************************************************************
1180//SvL: 24-6-'97 - Added
1181//******************************************************************************
1182SHORT WIN32API GetKeyState( int arg1)
1183{
1184#ifdef DEBUG
1185 WriteLog("USER32: GetKeyState %d\n", arg1);
1186#endif
1187 return O32_GetKeyState(arg1);
1188}
1189//******************************************************************************
1190//******************************************************************************
1191HCURSOR WIN32API SetCursor( HCURSOR hcur)
1192{
1193 HCURSOR rc;
1194
1195 rc = O32_SetCursor(hcur);
1196 dprintf(("USER32: SetCursor %x (prev %x (%x))\n", hcur, rc, O32_GetCursor()));
1197 return rc;
1198}
1199//******************************************************************************
1200//******************************************************************************
1201BOOL WIN32API SetCursorPos( int arg1, int arg2)
1202{
1203#ifdef DEBUG
1204 WriteLog("USER32: SetCursorPos\n");
1205#endif
1206 return O32_SetCursorPos(arg1, arg2);
1207}
1208//******************************************************************************
1209//******************************************************************************
1210BOOL WIN32API EnableScrollBar( HWND arg1, INT arg2, UINT arg3)
1211{
1212#ifdef DEBUG
1213 WriteLog("USER32: EnableScrollBar\n");
1214#endif
1215 return O32_EnableScrollBar(arg1, arg2, arg3);
1216}
1217//******************************************************************************
1218//******************************************************************************
1219BOOL WIN32API EnableWindow( HWND arg1, BOOL arg2)
1220{
1221#ifdef DEBUG
1222 WriteLog("USER32: EnableWindow\n");
1223#endif
1224 return O32_EnableWindow(arg1, arg2);
1225}
1226//******************************************************************************
1227//******************************************************************************
1228HWND WIN32API SetCapture( HWND arg1)
1229{
1230#ifdef DEBUG
1231 WriteLog("USER32: SetCapture\n");
1232#endif
1233 return O32_SetCapture(arg1);
1234}
1235//******************************************************************************
1236//******************************************************************************
1237BOOL WIN32API ReleaseCapture(void)
1238{
1239#ifdef DEBUG
1240 WriteLog("USER32: ReleaseCapture\n");
1241#endif
1242 return O32_ReleaseCapture();
1243}
1244//******************************************************************************
1245//******************************************************************************
1246DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD arg5)
1247{
1248#ifdef DEBUG
1249 WriteLog("USER32: MsgWaitForMultipleObjects\n");
1250#endif
1251 return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
1252}
1253//******************************************************************************
1254//******************************************************************************
1255HDWP WIN32API BeginDeferWindowPos( int arg1)
1256{
1257#ifdef DEBUG
1258 WriteLog("USER32: BeginDeferWindowPos\n");
1259#endif
1260 return O32_BeginDeferWindowPos(arg1);
1261}
1262//******************************************************************************
1263//******************************************************************************
1264BOOL WIN32API BringWindowToTop( HWND arg1)
1265{
1266#ifdef DEBUG
1267 WriteLog("USER32: BringWindowToTop\n");
1268#endif
1269 return O32_BringWindowToTop(arg1);
1270}
1271//******************************************************************************
1272//******************************************************************************
1273BOOL WIN32API CallMsgFilterA( LPMSG arg1, int arg2)
1274{
1275#ifdef DEBUG
1276 WriteLog("USER32: CallMsgFilterA\n");
1277#endif
1278 return O32_CallMsgFilter(arg1, arg2);
1279}
1280//******************************************************************************
1281//******************************************************************************
1282BOOL WIN32API CallMsgFilterW( LPMSG arg1, int arg2)
1283{
1284#ifdef DEBUG
1285 WriteLog("USER32: CallMsgFilterW\n");
1286#endif
1287 // NOTE: This will not work as is (needs UNICODE support)
1288 return O32_CallMsgFilter(arg1, arg2);
1289}
1290//******************************************************************************
1291//******************************************************************************
1292LRESULT WIN32API CallWindowProcA(WNDPROC wndprcPrev,
1293 HWND arg2,
1294 UINT arg3,
1295 WPARAM arg4,
1296 LPARAM arg5)
1297{
1298#ifdef DEBUG
1299//// WriteLog("USER32: CallWindowProcA %X hwnd=%X, msg = %X\n", wndprcPrev, arg2, arg3);
1300#endif
1301
1302 return wndprcPrev(arg2, arg3, arg4, arg5); //win32 callback (__stdcall)
1303}
1304//******************************************************************************
1305//******************************************************************************
1306LRESULT WIN32API CallWindowProcW(WNDPROC arg1,
1307 HWND arg2,
1308 UINT arg3,
1309 WPARAM arg4,
1310 LPARAM arg5)
1311{
1312 dprintf(("USER32: CallWindowProcW(%08xh,%08xh,%08xh,%08xh,%08xh) not properly implemented.\n",
1313 arg1,
1314 arg2,
1315 arg3,
1316 arg4,
1317 arg5));
1318
1319 return CallWindowProcA(arg1,
1320 arg2,
1321 arg3,
1322 arg4,
1323 arg5);
1324}
1325//******************************************************************************
1326//******************************************************************************
1327BOOL WIN32API ChangeClipboardChain( HWND arg1, HWND arg2)
1328{
1329#ifdef DEBUG
1330 WriteLog("USER32: ChangeClipboardChain\n");
1331#endif
1332 return O32_ChangeClipboardChain(arg1, arg2);
1333}
1334//******************************************************************************
1335//******************************************************************************
1336UINT WIN32API ArrangeIconicWindows( HWND arg1)
1337{
1338#ifdef DEBUG
1339 WriteLog("USER32: ArrangeIconicWindows\n");
1340#endif
1341 return O32_ArrangeIconicWindows(arg1);
1342}
1343//******************************************************************************
1344// Not implemented by Open32 (5-31-99 Christoph Bratschi)
1345//******************************************************************************
1346BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT arg4)
1347{
1348#ifdef DEBUG
1349 WriteLog("USER32: CheckRadioButton\n");
1350#endif
1351// return O32_CheckRadioButton(arg1, arg2, arg3, arg4);
1352 if (arg2 > arg3) return (FALSE);
1353 for (UINT x=arg2;x <= arg3;x++)
1354 {
1355 SendDlgItemMessageA(arg1,x,BM_SETCHECK,(x == arg4) ? BST_CHECKED : BST_UNCHECKED,0);
1356 }
1357 return (TRUE);
1358}
1359//******************************************************************************
1360//******************************************************************************
1361HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
1362{
1363 HWND rc;
1364
1365 rc = O32_ChildWindowFromPoint(arg1, arg2);
1366#ifdef DEBUG
1367 WriteLog("USER32: ChildWindowFromPoint %x returned %x\n", arg1, rc);
1368#endif
1369 return rc;
1370}
1371/*****************************************************************************
1372 * Name : HWND WIN32API ChildWindowFromPointEx
1373 * Purpose : The GetWindowRect function retrieves the dimensions of the
1374 * bounding rectangle of the specified window. The dimensions are
1375 * given in screen coordinates that are relative to the upper-left
1376 * corner of the screen.
1377 * Parameters:
1378 * Variables :
1379 * Result : If the function succeeds, the return value is the window handle.
1380 * If the function fails, the return value is zero
1381 * Remark :
1382 * Status : FULLY IMPLEMENTED AND TESTED
1383 *
1384 * Author : Rene Pronk [Sun, 1999/08/08 23:30]
1385 *****************************************************************************/
1386
1387
1388HWND WIN32API ChildWindowFromPointEx (HWND hwndParent, POINT pt, UINT uFlags)
1389{
1390 RECT rect;
1391 HWND hWnd;
1392 POINT absolutePt;
1393
1394 dprintf(("USER32: ChildWindowFromPointEx(%08xh,%08xh,%08xh).\n",
1395 hwndParent, pt, uFlags));
1396
1397 if (GetWindowRect (hwndParent, &rect) == 0) {
1398 // oops, invalid handle
1399 return NULL;
1400 }
1401
1402 // absolutePt has its top in the upper-left corner of the screen
1403 absolutePt = pt;
1404 ClientToScreen (hwndParent, &absolutePt);
1405
1406 // make rect the size of the parent window
1407 GetWindowRect (hwndParent, &rect);
1408 rect.right = rect.right - rect.left;
1409 rect.bottom = rect.bottom - rect.top;
1410 rect.left = 0;
1411 rect.top = 0;
1412
1413 if (PtInRect (&rect, pt) == 0) {
1414 // point is outside window
1415 return NULL;
1416 }
1417
1418 // get first child
1419 hWnd = GetWindow (hwndParent, GW_CHILD);
1420
1421 while (hWnd != NULL) {
1422
1423 // do I need to skip this window?
1424 if (((uFlags & CWP_SKIPINVISIBLE) &&
1425 (IsWindowVisible (hWnd) == FALSE)) ||
1426 ((uFlags & CWP_SKIPDISABLED) &&
1427 (IsWindowEnabled (hWnd) == FALSE)) ||
1428 ((uFlags & CWP_SKIPTRANSPARENT) &&
1429 (GetWindowLongA (hWnd, GWL_EXSTYLE) & WS_EX_TRANSPARENT)))
1430
1431 {
1432 hWnd = GetWindow (hWnd, GW_HWNDNEXT);
1433 continue;
1434 }
1435
1436 // is the point in this window's rect?
1437 GetWindowRect (hWnd, &rect);
1438 if (PtInRect (&rect, absolutePt) == FALSE) {
1439 hWnd = GetWindow (hWnd, GW_HWNDNEXT);
1440 continue;
1441 }
1442
1443 // found it!
1444 return hWnd;
1445 }
1446
1447 // the point is in the parentwindow but the parentwindow has no child
1448 // at this coordinate
1449 return hwndParent;
1450}
1451//******************************************************************************
1452//******************************************************************************
1453BOOL WIN32API CloseClipboard(void)
1454{
1455#ifdef DEBUG
1456 WriteLog("USER32: CloseClipboard\n");
1457#endif
1458 return O32_CloseClipboard();
1459}
1460//******************************************************************************
1461//******************************************************************************
1462BOOL WIN32API CloseWindow( HWND arg1)
1463{
1464#ifdef DEBUG
1465 WriteLog("USER32: CloseWindow\n");
1466#endif
1467 return O32_CloseWindow(arg1);
1468}
1469//******************************************************************************
1470//******************************************************************************
1471HICON WIN32API CopyIcon( HICON arg1)
1472{
1473#ifdef DEBUG
1474 WriteLog("USER32: CopyIcon\n");
1475#endif
1476 return O32_CopyIcon(arg1);
1477}
1478//******************************************************************************
1479//******************************************************************************
1480int WIN32API CountClipboardFormats(void)
1481{
1482#ifdef DEBUG
1483 WriteLog("USER32: CountClipboardFormats\n");
1484#endif
1485 return O32_CountClipboardFormats();
1486}
1487//******************************************************************************
1488//******************************************************************************
1489HACCEL WIN32API CreateAcceleratorTableA( LPACCEL arg1, int arg2)
1490{
1491#ifdef DEBUG
1492 WriteLog("USER32: CreateAcceleratorTableA\n");
1493#endif
1494 return O32_CreateAcceleratorTable(arg1, arg2);
1495}
1496//******************************************************************************
1497//******************************************************************************
1498HACCEL WIN32API CreateAcceleratorTableW( LPACCEL arg1, int arg2)
1499{
1500#ifdef DEBUG
1501 WriteLog("USER32: CreateAcceleratorTableW\n");
1502#endif
1503 // NOTE: This will not work as is (needs UNICODE support)
1504 return O32_CreateAcceleratorTable(arg1, arg2);
1505}
1506//******************************************************************************
1507//******************************************************************************
1508BOOL WIN32API CreateCaret( HWND arg1, HBITMAP arg2, int arg3, int arg4)
1509{
1510#ifdef DEBUG
1511 WriteLog("USER32: CreateCaret\n");
1512#endif
1513 return O32_CreateCaret(arg1, arg2, arg3, arg4);
1514}
1515//******************************************************************************
1516//******************************************************************************
1517HCURSOR WIN32API CreateCursor( HINSTANCE arg1, int arg2, int arg3, int arg4, int arg5, const VOID * arg6, const VOID * arg7)
1518{
1519#ifdef DEBUG
1520 WriteLog("USER32: CreateCursor\n");
1521#endif
1522 return O32_CreateCursor(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1523}
1524//******************************************************************************
1525//******************************************************************************
1526HICON WIN32API CreateIcon( HINSTANCE arg1, INT arg2, INT arg3, BYTE arg4, BYTE arg5, LPCVOID arg6, LPCVOID arg7)
1527{
1528#ifdef DEBUG
1529 WriteLog("USER32: CreateIcon\n");
1530#endif
1531 return O32_CreateIcon(arg1, arg2, arg3, arg4, arg5, (const BYTE *)arg6, (const BYTE *)arg7);
1532}
1533//******************************************************************************
1534//ASSERT dwVer == win31 (ok according to SDK docs)
1535//******************************************************************************
1536HICON WIN32API CreateIconFromResource(PBYTE presbits, UINT dwResSize,
1537 BOOL fIcon, DWORD dwVer)
1538{
1539 HICON hicon;
1540 DWORD OS2ResSize = 0;
1541 PBYTE OS2Icon = ConvertWin32Icon(presbits, dwResSize, &OS2ResSize);
1542
1543 hicon = O32_CreateIconFromResource(OS2Icon, OS2ResSize, fIcon, dwVer);
1544#ifdef DEBUG
1545 WriteLog("USER32: CreateIconFromResource returned %X (%X)\n", hicon, GetLastError());
1546#endif
1547 if(OS2Icon)
1548 FreeIcon(OS2Icon);
1549
1550 return(hicon);
1551}
1552//******************************************************************************
1553//******************************************************************************
1554HICON WIN32API CreateIconFromResourceEx(PBYTE presbits, UINT dwResSize,
1555 BOOL fIcon, DWORD dwVer,
1556 int cxDesired, int cyDesired,
1557 UINT Flags)
1558{
1559#ifdef DEBUG
1560 WriteLog("USER32: CreateIconFromResourceEx %X %d %d %X %d %d %X, not completely supported!\n", presbits, dwResSize, fIcon, dwVer, cxDesired, cyDesired, Flags);
1561#endif
1562 return CreateIconFromResource(presbits, dwResSize, fIcon, dwVer);
1563}
1564//******************************************************************************
1565//******************************************************************************
1566HICON WIN32API CreateIconIndirect(LPICONINFO arg1)
1567{
1568#ifdef DEBUG
1569 WriteLog("USER32: CreateIconIndirect\n");
1570#endif
1571 return O32_CreateIconIndirect(arg1);
1572}
1573//******************************************************************************
1574HWND WIN32API CreateMDIWindowA(LPCSTR arg1, LPCSTR arg2, DWORD arg3,
1575 int arg4, int arg5, int arg6, int arg7,
1576 HWND arg8, HINSTANCE arg9, LPARAM arg10)
1577{
1578 HWND hwnd;
1579
1580#ifdef DEBUG
1581 WriteLog("USER32: CreateMDIWindowA\n");
1582#endif
1583 Win32WindowProc *window = new Win32WindowProc(arg9, arg1);
1584 hwnd = O32_CreateMDIWindow((LPSTR)arg1, (LPSTR)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1585 //SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1586 if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1587 delete(window);
1588 window = 0;
1589 }
1590
1591#ifdef DEBUG
1592 WriteLog("USER32: CreateMDIWindowA returned %X\n", hwnd);
1593#endif
1594 return hwnd;
1595}
1596//******************************************************************************
1597//******************************************************************************
1598HWND WIN32API CreateMDIWindowW(LPCWSTR arg1, LPCWSTR arg2, DWORD arg3, int arg4,
1599 int arg5, int arg6, int arg7, HWND arg8, HINSTANCE arg9,
1600 LPARAM arg10)
1601{
1602 HWND hwnd;
1603 char *astring1 = NULL, *astring2 = NULL;
1604 Win32WindowProc *window = NULL;
1605
1606 if((int)arg1 >> 16 != 0) {
1607 astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1608 }
1609 else astring1 = (char *)arg2;
1610
1611 astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1612
1613 //Classname might be name of system class, in which case we don't
1614 //need to use our own callback
1615// if(Win32WindowClass::FindClass((LPSTR)astring1) != NULL) {
1616 window = new Win32WindowProc(arg9, astring1);
1617// }
1618 hwnd = O32_CreateMDIWindow(astring1, astring2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1619 //SvL: 16-11-'97: window can be already destroyed if hwnd == 0
1620 if(hwnd == 0 && window != 0 && Win32WindowProc::FindWindowProc(window)) {
1621 delete(window);
1622 window = 0;
1623 }
1624 if(window) {
1625 window->SetWindowHandle(hwnd);
1626 }
1627
1628 if(astring1) FreeAsciiString(astring1);
1629 FreeAsciiString(astring2);
1630#ifdef DEBUG
1631 WriteLog("USER32: CreateMDIWindowW hwnd = %X\n", hwnd);
1632#endif
1633 return(hwnd);
1634}
1635//******************************************************************************
1636//******************************************************************************
1637HWND WIN32API CreateWindowExW(DWORD arg1,
1638 LPCWSTR arg2,
1639 LPCWSTR arg3,
1640 DWORD dwStyle,
1641 int arg5,
1642 int arg6,
1643 int arg7,
1644 int arg8,
1645 HWND arg9,
1646 HMENU arg10,
1647 HINSTANCE arg11,
1648 PVOID arg12)
1649{
1650 HWND hwnd;
1651 char *astring1 = NULL,
1652 *astring2 = NULL;
1653 Win32WindowProc *window = NULL;
1654
1655 /* @@@PH 98/06/21 changed to call OS2CreateWindowExA */
1656 if(HIWORD(arg2) != 0)
1657 astring1 = UnicodeToAsciiString((LPWSTR)arg2);
1658 else
1659 astring1 = (char *)arg2;
1660
1661 astring2 = UnicodeToAsciiString((LPWSTR)arg3);
1662
1663#ifdef DEBUG
1664 WriteLog("USER32: CreateWindowExW: dwExStyle = %X\n", arg1);
1665 if((int)arg2 >> 16 != 0)
1666 WriteLog("USER32: CreateWindow: classname = %s\n", astring1);
1667 else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
1668 WriteLog("USER32: CreateWindow: windowname= %s\n", astring2);
1669 WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
1670 WriteLog("USER32: CreateWindow: x = %d\n", arg5);
1671 WriteLog("USER32: CreateWindow: y = %d\n", arg6);
1672 WriteLog("USER32: CreateWindow: nWidth = %d\n", arg7);
1673 WriteLog("USER32: CreateWindow: nHeight = %d\n", arg8);
1674 WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
1675 WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
1676 WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
1677 WriteLog("USER32: CreateWindow: param = %X\n", arg12);
1678 #endif
1679
1680 hwnd = CreateWindowExA(arg1,
1681 astring1,
1682 astring2,
1683 dwStyle,
1684 arg5,
1685 arg6,
1686 arg7,
1687 arg8,
1688 arg9,
1689 arg10,
1690 arg11,
1691 arg12);
1692
1693 if(HIWORD(arg1) != 0)
1694 FreeAsciiString(astring1);
1695
1696 FreeAsciiString(astring2);
1697
1698#ifdef DEBUG
1699 WriteLog("USER32: ************CreateWindowExW hwnd = %X (%X)\n", hwnd, GetLastError());
1700#endif
1701 return(hwnd);
1702}
1703//******************************************************************************
1704//******************************************************************************
1705HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
1706{
1707#ifdef DEBUG
1708 WriteLog("USER32: DeferWindowPos\n");
1709#endif
1710 return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1711}
1712//******************************************************************************
1713//******************************************************************************
1714BOOL WIN32API DestroyAcceleratorTable( HACCEL arg1)
1715{
1716#ifdef DEBUG
1717 WriteLog("USER32: DestroyAcceleratorTable\n");
1718#endif
1719 return O32_DestroyAcceleratorTable(arg1);
1720}
1721//******************************************************************************
1722//******************************************************************************
1723BOOL WIN32API DestroyCaret(void)
1724{
1725#ifdef DEBUG
1726 WriteLog("USER32: DestroyCaret\n");
1727#endif
1728 return O32_DestroyCaret();
1729}
1730//******************************************************************************
1731//******************************************************************************
1732BOOL WIN32API DestroyCursor( HCURSOR arg1)
1733{
1734#ifdef DEBUG
1735 WriteLog("USER32: DestroyCursor\n");
1736#endif
1737 return O32_DestroyCursor(arg1);
1738}
1739//******************************************************************************
1740//******************************************************************************
1741BOOL WIN32API DestroyIcon( HICON arg1)
1742{
1743#ifdef DEBUG
1744 WriteLog("USER32: DestroyIcon\n");
1745#endif
1746 return O32_DestroyIcon(arg1);
1747}
1748//******************************************************************************
1749//******************************************************************************
1750LONG WIN32API DispatchMessageW( const MSG * arg1)
1751{
1752#ifdef DEBUG
1753 WriteLog("USER32: DispatchMessageW\n");
1754#endif
1755 // NOTE: This will not work as is (needs UNICODE support)
1756 return O32_DispatchMessage(arg1);
1757}
1758//******************************************************************************
1759//******************************************************************************
1760int WIN32API DlgDirListA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1761{
1762#ifdef DEBUG
1763 WriteLog("USER32: DlgDirListA\n");
1764#endif
1765 return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1766}
1767//******************************************************************************
1768//******************************************************************************
1769int WIN32API DlgDirListComboBoxA( HWND arg1, LPSTR arg2, int arg3, int arg4, UINT arg5)
1770{
1771#ifdef DEBUG
1772 WriteLog("USER32: DlgDirListComboBoxA\n");
1773#endif
1774 return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1775}
1776//******************************************************************************
1777//******************************************************************************
1778int WIN32API DlgDirListComboBoxW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1779{
1780#ifdef DEBUG
1781 WriteLog("USER32: DlgDirListComboBoxW NOT WORKING\n");
1782#endif
1783 // NOTE: This will not work as is (needs UNICODE support)
1784 return 0;
1785// return O32_DlgDirListComboBox(arg1, arg2, arg3, arg4, arg5);
1786}
1787//******************************************************************************
1788//******************************************************************************
1789int WIN32API DlgDirListW( HWND arg1, LPWSTR arg2, int arg3, int arg4, UINT arg5)
1790{
1791#ifdef DEBUG
1792 WriteLog("USER32: DlgDirListW NOT WORKING\n");
1793#endif
1794 // NOTE: This will not work as is (needs UNICODE support)
1795 return 0;
1796// return O32_DlgDirList(arg1, arg2, arg3, arg4, arg5);
1797}
1798//******************************************************************************
1799//******************************************************************************
1800BOOL WIN32API DlgDirSelectComboBoxExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1801{
1802#ifdef DEBUG
1803 WriteLog("USER32: DlgDirSelectComboBoxExA\n");
1804#endif
1805 return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1806}
1807//******************************************************************************
1808//******************************************************************************
1809BOOL WIN32API DlgDirSelectComboBoxExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1810{
1811#ifdef DEBUG
1812 WriteLog("USER32: DlgDirSelectComboBoxExW NOT WORKING\n");
1813#endif
1814 // NOTE: This will not work as is (needs UNICODE support)
1815 return 0;
1816// return O32_DlgDirSelectComboBoxEx(arg1, arg2, arg3, arg4);
1817}
1818//******************************************************************************
1819//******************************************************************************
1820BOOL WIN32API DlgDirSelectExA( HWND arg1, LPSTR arg2, int arg3, int arg4)
1821{
1822#ifdef DEBUG
1823 WriteLog("USER32: DlgDirSelectExA\n");
1824#endif
1825 return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1826}
1827//******************************************************************************
1828//******************************************************************************
1829BOOL WIN32API DlgDirSelectExW( HWND arg1, LPWSTR arg2, int arg3, int arg4)
1830{
1831#ifdef DEBUG
1832 WriteLog("USER32: DlgDirSelectExW NOT WORKING\n");
1833#endif
1834 // NOTE: This will not work as is (needs UNICODE support)
1835 return 0;
1836// return O32_DlgDirSelectEx(arg1, arg2, arg3, arg4);
1837}
1838//******************************************************************************
1839//******************************************************************************
1840BOOL WIN32API DrawFocusRect( HDC arg1, const RECT * arg2)
1841{
1842#ifdef DEBUG
1843 WriteLog("USER32: DrawFocusRect\n");
1844#endif
1845 return O32_DrawFocusRect(arg1, arg2);
1846}
1847//******************************************************************************
1848//******************************************************************************
1849BOOL WIN32API DrawIcon( HDC arg1, int arg2, int arg3, HICON arg4)
1850{
1851#ifdef DEBUG
1852 WriteLog("USER32: DrawIcon\n");
1853#endif
1854 return O32_DrawIcon(arg1, arg2, arg3, arg4);
1855}
1856//******************************************************************************
1857//******************************************************************************
1858BOOL WIN32API DrawIconEx(HDC hdc, int xLeft, int xRight, HICON hIcon,
1859 int cxWidth, int cyWidth, UINT istepIfAniCur,
1860 HBRUSH hbrFlickerFreeDraw, UINT diFlags)
1861{
1862#ifdef DEBUG
1863 WriteLog("USER32: DrawIcon, partially implemented\n");
1864#endif
1865 return O32_DrawIcon(hdc, xLeft, xRight, hIcon);
1866}
1867//******************************************************************************
1868//******************************************************************************
1869BOOL WIN32API DrawMenuBar( HWND arg1)
1870{
1871#ifdef DEBUG
1872 WriteLog("USER32: DrawMenuBar\n");
1873#endif
1874 return O32_DrawMenuBar(arg1);
1875}
1876//******************************************************************************
1877//******************************************************************************
1878int WIN32API DrawTextW( HDC arg1, LPCWSTR arg2, int arg3, PRECT arg4, UINT arg5)
1879{
1880 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1881 int rc;
1882
1883#ifdef DEBUG
1884 WriteLog("USER32: DrawTextW %s\n", astring);
1885#endif
1886 rc = O32_DrawText(arg1, astring, arg3, arg4, arg5);
1887 FreeAsciiString(astring);
1888 return(rc);
1889}
1890//******************************************************************************
1891//******************************************************************************
1892BOOL WIN32API EmptyClipboard(void)
1893{
1894#ifdef DEBUG
1895 WriteLog("USER32: EmptyClipboard\n");
1896#endif
1897 return O32_EmptyClipboard();
1898}
1899//******************************************************************************
1900//******************************************************************************
1901BOOL WIN32API EndDeferWindowPos( HDWP arg1)
1902{
1903#ifdef DEBUG
1904 WriteLog("USER32: EndDeferWindowPos\n");
1905#endif
1906 return O32_EndDeferWindowPos(arg1);
1907}
1908//******************************************************************************
1909//******************************************************************************
1910BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1911{
1912 BOOL rc;
1913 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1914
1915#ifdef DEBUG
1916 WriteLog("USER32: EnumChildWindows\n");
1917#endif
1918 rc = O32_EnumChildWindows(hwnd, callback->GetOS2Callback(), (LPARAM)callback);
1919 if(callback)
1920 delete callback;
1921 return(rc);
1922}
1923//******************************************************************************
1924//******************************************************************************
1925UINT WIN32API EnumClipboardFormats(UINT arg1)
1926{
1927#ifdef DEBUG
1928 WriteLog("USER32: EnumClipboardFormats\n");
1929#endif
1930 return O32_EnumClipboardFormats(arg1);
1931}
1932//******************************************************************************
1933//******************************************************************************
1934int WIN32API EnumPropsA(HWND arg1, PROPENUMPROCA arg2)
1935{
1936#ifdef DEBUG
1937 WriteLog("USER32: EnumPropsA DOES NOT WORK\n");
1938#endif
1939 //calling convention problems
1940 return 0;
1941// return O32_EnumProps(arg1, (PROPENUMPROC_O32)arg2);
1942}
1943//******************************************************************************
1944//******************************************************************************
1945int WIN32API EnumPropsExA( HWND arg1, PROPENUMPROCEXA arg2, LPARAM arg3)
1946{
1947#ifdef DEBUG
1948 WriteLog("USER32: EnumPropsExA DOES NOT WORK\n");
1949#endif
1950 //calling convention problems
1951 return 0;
1952// return O32_EnumPropsEx(arg1, arg2, (PROPENUMPROCEX_O32)arg3);
1953}
1954//******************************************************************************
1955//******************************************************************************
1956int WIN32API EnumPropsExW( HWND arg1, PROPENUMPROCEXW arg2, LPARAM arg3)
1957{
1958#ifdef DEBUG
1959 WriteLog("USER32: EnumPropsExW\n");
1960#endif
1961 // NOTE: This will not work as is (needs UNICODE support)
1962 //calling convention problems
1963 return 0;
1964// return O32_EnumPropsEx(arg1, arg2, arg3);
1965}
1966//******************************************************************************
1967//******************************************************************************
1968int WIN32API EnumPropsW( HWND arg1, PROPENUMPROCW arg2)
1969{
1970#ifdef DEBUG
1971 WriteLog("USER32: EnumPropsW\n");
1972#endif
1973 // NOTE: This will not work as is (needs UNICODE support)
1974 //calling convention problems
1975 return 0;
1976// return O32_EnumProps(arg1, arg2);
1977}
1978//******************************************************************************
1979//******************************************************************************
1980BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1981{
1982 BOOL rc;
1983 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
1984
1985#ifdef DEBUG
1986 WriteLog("USER32: EnumWindows\n");
1987#endif
1988 rc = O32_EnumWindows(callback->GetOS2Callback(), (LPARAM)callback);
1989 if(callback)
1990 delete callback;
1991 return(rc);
1992}
1993//******************************************************************************
1994//******************************************************************************
1995BOOL WIN32API EqualRect( const RECT * arg1, const RECT * arg2)
1996{
1997#ifdef DEBUG
1998 WriteLog("USER32: EqualRect\n");
1999#endif
2000 return O32_EqualRect(arg1, arg2);
2001}
2002//******************************************************************************
2003//******************************************************************************
2004INT WIN32API ExcludeUpdateRgn( HDC arg1, HWND arg2)
2005{
2006#ifdef DEBUG
2007 WriteLog("USER32: ExcludeUpdateRgn\n");
2008#endif
2009 return O32_ExcludeUpdateRgn(arg1, arg2);
2010}
2011//******************************************************************************
2012//******************************************************************************
2013BOOL WIN32API ExitWindowsEx( UINT arg1, DWORD arg2)
2014{
2015#ifdef DEBUG
2016 WriteLog("USER32: ExitWindowsEx\n");
2017#endif
2018 return O32_ExitWindowsEx(arg1, arg2);
2019}
2020//******************************************************************************
2021//******************************************************************************
2022int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
2023{
2024#ifdef DEBUG
2025 WriteLog("USER32: FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
2026#endif
2027 return O32_FillRect(arg1, arg2, arg3);
2028}
2029//******************************************************************************
2030//******************************************************************************
2031HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
2032{
2033 char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
2034 char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
2035 HWND rc;
2036
2037#ifdef DEBUG
2038 WriteLog("USER32: FindWindowW\n");
2039#endif
2040 rc = O32_FindWindow(astring1, astring2);
2041 FreeAsciiString(astring1);
2042 FreeAsciiString(astring2);
2043 return rc;
2044}
2045//******************************************************************************
2046//******************************************************************************
2047int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH arg3)
2048{
2049#ifdef DEBUG
2050 WriteLog("USER32: FrameRect\n");
2051#endif
2052 return O32_FrameRect(arg1, arg2, arg3);
2053}
2054//******************************************************************************
2055//******************************************************************************
2056HWND WIN32API GetCapture(void)
2057{
2058#ifdef DEBUG
2059 WriteLog("USER32: GetCapture\n");
2060#endif
2061 return O32_GetCapture();
2062}
2063//******************************************************************************
2064//******************************************************************************
2065UINT WIN32API GetCaretBlinkTime(void)
2066{
2067#ifdef DEBUG
2068 WriteLog("USER32: GetCaretBlinkTime\n");
2069#endif
2070 return O32_GetCaretBlinkTime();
2071}
2072//******************************************************************************
2073//******************************************************************************
2074BOOL WIN32API GetCaretPos( PPOINT arg1)
2075{
2076#ifdef DEBUG
2077 WriteLog("USER32: GetCaretPos\n");
2078#endif
2079 return O32_GetCaretPos(arg1);
2080}
2081//******************************************************************************
2082//******************************************************************************
2083BOOL WIN32API GetClipCursor( PRECT arg1)
2084{
2085#ifdef DEBUG
2086 WriteLog("USER32: GetClipCursor\n");
2087#endif
2088 return O32_GetClipCursor(arg1);
2089}
2090//******************************************************************************
2091//******************************************************************************
2092HANDLE WIN32API GetClipboardData( UINT arg1)
2093{
2094#ifdef DEBUG
2095 WriteLog("USER32: GetClipboardData\n");
2096#endif
2097 return O32_GetClipboardData(arg1);
2098}
2099//******************************************************************************
2100//******************************************************************************
2101int WIN32API GetClipboardFormatNameA( UINT arg1, LPSTR arg2, int arg3)
2102{
2103#ifdef DEBUG
2104 WriteLog("USER32: GetClipboardFormatNameA %s\n", arg2);
2105#endif
2106 return O32_GetClipboardFormatName(arg1, arg2, arg3);
2107}
2108//******************************************************************************
2109//******************************************************************************
2110int WIN32API GetClipboardFormatNameW(UINT arg1, LPWSTR arg2, int arg3)
2111{
2112 int rc;
2113 char *astring = UnicodeToAsciiString(arg2);
2114
2115#ifdef DEBUG
2116 WriteLog("USER32: GetClipboardFormatNameW %s\n", astring);
2117#endif
2118 rc = O32_GetClipboardFormatName(arg1, astring, arg3);
2119 FreeAsciiString(astring);
2120 return(rc);
2121}
2122//******************************************************************************
2123//******************************************************************************
2124HWND WIN32API GetClipboardOwner(void)
2125{
2126#ifdef DEBUG
2127 WriteLog("USER32: GetClipboardOwner\n");
2128#endif
2129 return O32_GetClipboardOwner();
2130}
2131//******************************************************************************
2132//******************************************************************************
2133HWND WIN32API GetClipboardViewer(void)
2134{
2135#ifdef DEBUG
2136 WriteLog("USER32: GetClipboardViewer\n");
2137#endif
2138 return O32_GetClipboardViewer();
2139}
2140//******************************************************************************
2141//******************************************************************************
2142DWORD WIN32API GetDialogBaseUnits(void)
2143{
2144#ifdef DEBUG
2145 WriteLog("USER32: GetDialogBaseUnits\n");
2146#endif
2147 return O32_GetDialogBaseUnits();
2148}
2149//******************************************************************************
2150//******************************************************************************
2151UINT WIN32API GetDlgItemInt( HWND arg1, int arg2, PBOOL arg3, BOOL arg4)
2152{
2153#ifdef DEBUG
2154 WriteLog("USER32: GetDlgItemInt\n");
2155#endif
2156 return O32_GetDlgItemInt(arg1, arg2, arg3, arg4);
2157}
2158
2159
2160/*****************************************************************************
2161 * Name : UINT WIN32API GetDlgItemTextW
2162 * Purpose : Determine the text of a window control
2163 * Parameters: HWND arg1
2164 * int arg2
2165 * LPWSTR arg3
2166 * UINT arg4
2167 * Variables :
2168 * Result :
2169 * Remark :
2170 * Status : UNTESTED UNKNOWN STUB
2171 *
2172 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
2173 *****************************************************************************/
2174
2175UINT WIN32API GetDlgItemTextW(HWND arg1,
2176 int arg2,
2177 LPWSTR arg3,
2178 UINT arg4)
2179{
2180 LPSTR lpBuffer; /* temporary buffer for the ascii result */
2181 UINT uiResult; /* return value of the ascii variant */
2182
2183 dprintf(("USER32: GetDlgItemTextW(%08xh,%08xh,%08xh,%08xh)\n",
2184 arg1,
2185 arg2,
2186 arg3,
2187 arg4));
2188
2189
2190 lpBuffer = (LPSTR)malloc(arg4); /* allocate temporary buffer */
2191 uiResult = GetDlgItemTextA(arg1, /* call ascii variant */
2192 arg2,
2193 lpBuffer,
2194 arg4);
2195
2196 AsciiToUnicodeN(lpBuffer, /* now convert result to unicode */
2197 arg3,
2198 arg4);
2199
2200 free(lpBuffer); /* free the temporary buffer */
2201
2202 return (uiResult); /* OK, that's it */
2203}
2204
2205
2206//******************************************************************************
2207//******************************************************************************
2208UINT WIN32API GetDoubleClickTime(void)
2209{
2210#ifdef DEBUG
2211 WriteLog("USER32: GetDoubleClickTime\n");
2212#endif
2213 return O32_GetDoubleClickTime();
2214}
2215//******************************************************************************
2216//******************************************************************************
2217HWND WIN32API GetForegroundWindow(void)
2218{
2219#ifdef DEBUG
2220 WriteLog("USER32: GetForegroundWindow\n");
2221#endif
2222 return O32_GetForegroundWindow();
2223}
2224//******************************************************************************
2225//******************************************************************************
2226BOOL WIN32API GetIconInfo( HICON arg1, LPICONINFO arg2)
2227{
2228#ifdef DEBUG
2229 WriteLog("USER32: GetIconInfo\n");
2230#endif
2231 return O32_GetIconInfo(arg1, arg2);
2232}
2233//******************************************************************************
2234//******************************************************************************
2235int WIN32API GetKeyNameTextA( LPARAM arg1, LPSTR arg2, int arg3)
2236{
2237#ifdef DEBUG
2238 WriteLog("USER32: GetKeyNameTextA\n");
2239#endif
2240 return O32_GetKeyNameText(arg1, arg2, arg3);
2241}
2242//******************************************************************************
2243//******************************************************************************
2244int WIN32API GetKeyNameTextW( LPARAM arg1, LPWSTR arg2, int arg3)
2245{
2246#ifdef DEBUG
2247 WriteLog("USER32: GetKeyNameTextW DOES NOT WORK\n");
2248#endif
2249 // NOTE: This will not work as is (needs UNICODE support)
2250 return 0;
2251// return O32_GetKeyNameText(arg1, arg2, arg3);
2252}
2253//******************************************************************************
2254//******************************************************************************
2255int WIN32API GetKeyboardType( int arg1)
2256{
2257#ifdef DEBUG
2258 WriteLog("USER32: GetKeyboardType\n");
2259#endif
2260 return O32_GetKeyboardType(arg1);
2261}
2262//******************************************************************************
2263//******************************************************************************
2264HWND WIN32API GetLastActivePopup( HWND arg1)
2265{
2266#ifdef DEBUG
2267 WriteLog("USER32: GetLastActivePopup\n");
2268#endif
2269 return O32_GetLastActivePopup(arg1);
2270}
2271//******************************************************************************
2272//******************************************************************************
2273LONG WIN32API GetMessageExtraInfo(void)
2274{
2275 dprintf(("USER32: GetMessageExtraInfo\n"));
2276 return O32_GetMessageExtraInfo();
2277}
2278//******************************************************************************
2279//******************************************************************************
2280DWORD WIN32API GetMessagePos(void)
2281{
2282 dprintf(("USER32: GetMessagePos\n"));
2283 return O32_GetMessagePos();
2284}
2285//******************************************************************************
2286//******************************************************************************
2287LONG WIN32API GetMessageTime(void)
2288{
2289 dprintf(("USER32: GetMessageTime\n"));
2290 return O32_GetMessageTime();
2291}
2292//******************************************************************************
2293//******************************************************************************
2294BOOL WIN32API GetMessageW(LPMSG arg1, HWND arg2, UINT arg3, UINT arg4)
2295{
2296 BOOL rc;
2297
2298 // NOTE: This will not work as is (needs UNICODE support)
2299 rc = O32_GetMessage(arg1, arg2, arg3, arg4);
2300 dprintf(("USER32: GetMessageW %X returned %d\n", arg2, rc));
2301 return(rc);
2302}
2303//******************************************************************************
2304//******************************************************************************
2305HWND WIN32API GetNextDlgGroupItem( HWND arg1, HWND arg2, BOOL arg3)
2306{
2307#ifdef DEBUG
2308 WriteLog("USER32: GetNextDlgGroupItem\n");
2309#endif
2310 return O32_GetNextDlgGroupItem(arg1, arg2, arg3);
2311}
2312//******************************************************************************
2313//******************************************************************************
2314HWND WIN32API GetOpenClipboardWindow(void)
2315{
2316#ifdef DEBUG
2317 WriteLog("USER32: GetOpenClipboardWindow\n");
2318#endif
2319 return O32_GetOpenClipboardWindow();
2320}
2321//******************************************************************************
2322//******************************************************************************
2323HWND WIN32API GetParent( HWND arg1)
2324{
2325#ifdef DEBUG
2326//// WriteLog("USER32: GetParent\n");
2327#endif
2328 return O32_GetParent(arg1);
2329}
2330//******************************************************************************
2331//******************************************************************************
2332int WIN32API GetPriorityClipboardFormat( PUINT arg1, int arg2)
2333{
2334#ifdef DEBUG
2335 WriteLog("USER32: GetPriorityClipboardFormat\n");
2336#endif
2337 return O32_GetPriorityClipboardFormat(arg1, arg2);
2338}
2339//******************************************************************************
2340//******************************************************************************
2341HANDLE WIN32API GetPropA( HWND arg1, LPCSTR arg2)
2342{
2343#ifdef DEBUG
2344 if((int)arg2 >> 16 != 0)
2345 WriteLog("USER32: GetPropA %s\n", arg2);
2346 else WriteLog("USER32: GetPropA %X\n", arg2);
2347#endif
2348 return O32_GetProp(arg1, arg2);
2349}
2350//******************************************************************************
2351//******************************************************************************
2352HANDLE WIN32API GetPropW(HWND arg1, LPCWSTR arg2)
2353{
2354 BOOL handle;
2355 char *astring;
2356
2357 if((int)arg2 >> 16 != 0)
2358 astring = UnicodeToAsciiString((LPWSTR)arg2);
2359 else astring = (char *)arg2;
2360#ifdef DEBUG
2361 if((int)arg2 >> 16 != 0)
2362 WriteLog("USER32: GetPropW %s\n", astring);
2363 else WriteLog("USER32: GetPropW %X\n", astring);
2364#endif
2365 handle = GetPropA(arg1, (LPCSTR)astring);
2366 if((int)arg2 >> 16 != 0)
2367 FreeAsciiString(astring);
2368
2369 return(handle);
2370}
2371//******************************************************************************
2372//******************************************************************************
2373DWORD WIN32API GetQueueStatus( UINT arg1)
2374{
2375#ifdef DEBUG
2376 WriteLog("USER32: GetQueueStatus\n");
2377#endif
2378 return O32_GetQueueStatus(arg1);
2379}
2380//******************************************************************************
2381//******************************************************************************
2382int WIN32API GetScrollPos(HWND hwnd, int fnBar)
2383{
2384 int pos;
2385
2386 pos = O32_GetScrollPos(hwnd, fnBar);
2387#ifdef DEBUG
2388 WriteLog("USER32: GetScrollPos of %X type %d returned %d\n", hwnd, fnBar, pos);
2389#endif
2390 return(pos);
2391}
2392//******************************************************************************
2393//******************************************************************************
2394BOOL WIN32API GetScrollRange( HWND arg1, int arg2, int * arg3, int * arg4)
2395{
2396#ifdef DEBUG
2397 WriteLog("USER32: GetScrollRange\n");
2398#endif
2399 return O32_GetScrollRange(arg1, arg2, arg3, arg4);
2400}
2401//******************************************************************************
2402//******************************************************************************
2403DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
2404{
2405#ifdef DEBUG
2406 WriteLog("USER32: GetTabbedTextExtentA\n");
2407#endif
2408 return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
2409}
2410//******************************************************************************
2411//******************************************************************************
2412DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
2413{
2414 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2415 DWORD rc;
2416
2417#ifdef DEBUG
2418 WriteLog("USER32: GetTabbedTextExtentW\n");
2419#endif
2420 rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
2421 FreeAsciiString(astring);
2422 return rc;
2423}
2424//******************************************************************************
2425//******************************************************************************
2426HWND WIN32API GetTopWindow( HWND arg1)
2427{
2428#ifdef DEBUG
2429//// WriteLog("USER32: GetTopWindow\n");
2430#endif
2431 return O32_GetTopWindow(arg1);
2432}
2433//******************************************************************************
2434//******************************************************************************
2435int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2436{
2437#ifdef DEBUG
2438 WriteLog("USER32: GetUpdateRgn\n");
2439#endif
2440 return O32_GetUpdateRgn(arg1, arg2, arg3);
2441}
2442//******************************************************************************
2443//******************************************************************************
2444BOOL WIN32API GetWindowPlacement( HWND arg1, LPWINDOWPLACEMENT arg2)
2445{
2446#ifdef DEBUG
2447 WriteLog("USER32: GetWindowPlacement\n");
2448#endif
2449 return O32_GetWindowPlacement(arg1, arg2);
2450}
2451//******************************************************************************
2452
2453/***********************************************************************
2454 * GetInternalWindowPos (USER32.245)
2455 */
2456UINT WIN32API GetInternalWindowPos(HWND hwnd,
2457 LPRECT rectWnd,
2458 LPPOINT ptIcon )
2459{
2460 WINDOWPLACEMENT wndpl;
2461
2462 dprintf(("USER32: GetInternalWindowPos(%08xh,%08xh,%08xh)\n",
2463 hwnd,
2464 rectWnd,
2465 ptIcon));
2466
2467 if (O32_GetWindowPlacement( hwnd, &wndpl ))
2468 {
2469 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
2470 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
2471 return wndpl.showCmd;
2472 }
2473 return 0;
2474}
2475
2476
2477//******************************************************************************
2478int WIN32API GetWindowTextLengthW( HWND arg1)
2479{
2480#ifdef DEBUG
2481 WriteLog("USER32: GetWindowTextLengthW\n");
2482#endif
2483 return O32_GetWindowTextLength(arg1);
2484}
2485//******************************************************************************
2486//******************************************************************************
2487int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
2488{
2489 char title[128];
2490 int rc;
2491
2492 rc = O32_GetWindowText(hwnd, title, sizeof(title));
2493#ifdef DEBUG
2494 WriteLog("USER32: GetWindowTextW returned %s\n", title);
2495#endif
2496 if(rc > cch) {
2497 title[cch-1] = 0;
2498 rc = cch;
2499 }
2500 AsciiToUnicode(title, lpsz);
2501 return(rc);
2502}
2503//******************************************************************************
2504//******************************************************************************
2505DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD arg2)
2506{
2507#ifdef DEBUG
2508 WriteLog("USER32: GetWindowThreadProcessId\n");
2509#endif
2510 return O32_GetWindowThreadProcessId(arg1, arg2);
2511}
2512//******************************************************************************
2513//******************************************************************************
2514BOOL WIN32API HideCaret( HWND arg1)
2515{
2516#ifdef DEBUG
2517 WriteLog("USER32: HideCaret\n");
2518#endif
2519 return O32_HideCaret(arg1);
2520}
2521//******************************************************************************
2522//******************************************************************************
2523BOOL WIN32API InSendMessage(void)
2524{
2525#ifdef DEBUG
2526 WriteLog("USER32: InSendMessage\n");
2527#endif
2528 return O32_InSendMessage();
2529}
2530//******************************************************************************
2531//******************************************************************************
2532BOOL WIN32API IntersectRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
2533{
2534#ifdef DEBUG
2535//// WriteLog("USER32: IntersectRect\n");
2536#endif
2537 return O32_IntersectRect(arg1, arg2, arg3);
2538}
2539//******************************************************************************
2540//******************************************************************************
2541BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL arg3)
2542{
2543#ifdef DEBUG
2544 WriteLog("USER32: InvalidateRgn\n");
2545#endif
2546 return O32_InvalidateRgn(arg1, arg2, arg3);
2547}
2548//******************************************************************************
2549//******************************************************************************
2550BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
2551{
2552#ifdef DEBUG
2553 WriteLog("USER32: InvertRect\n");
2554#endif
2555 return O32_InvertRect(arg1, arg2);
2556}
2557//******************************************************************************
2558//******************************************************************************
2559BOOL WIN32API IsChild( HWND arg1, HWND arg2)
2560{
2561#ifdef DEBUG
2562 WriteLog("USER32: IsChild\n");
2563#endif
2564 return O32_IsChild(arg1, arg2);
2565}
2566//******************************************************************************
2567//******************************************************************************
2568BOOL WIN32API IsClipboardFormatAvailable( UINT arg1)
2569{
2570#ifdef DEBUG
2571 WriteLog("USER32: IsClipboardFormatAvailable\n");
2572#endif
2573 return O32_IsClipboardFormatAvailable(arg1);
2574}
2575//******************************************************************************
2576//******************************************************************************
2577BOOL WIN32API IsDialogMessageW( HWND arg1, LPMSG arg2)
2578{
2579#ifdef DEBUG
2580 WriteLog("USER32: IsDialogMessageW\n");
2581#endif
2582 // NOTE: This will not work as is (needs UNICODE support)
2583 return O32_IsDialogMessage(arg1, arg2);
2584}
2585
2586//******************************************************************************
2587//******************************************************************************
2588BOOL WIN32API IsRectEmpty( const RECT * arg1)
2589{
2590#ifdef DEBUG
2591 WriteLog("USER32: IsRectEmpty\n");
2592#endif
2593 return O32_IsRectEmpty(arg1);
2594}
2595//******************************************************************************
2596//******************************************************************************
2597BOOL WIN32API IsWindow( HWND arg1)
2598{
2599#ifdef DEBUG
2600 WriteLog("USER32: IsWindow\n");
2601#endif
2602 return O32_IsWindow(arg1);
2603}
2604//******************************************************************************
2605//******************************************************************************
2606BOOL WIN32API IsWindowEnabled( HWND arg1)
2607{
2608#ifdef DEBUG
2609 WriteLog("USER32: IsWindowEnabled\n");
2610#endif
2611 return O32_IsWindowEnabled(arg1);
2612}
2613//******************************************************************************
2614//******************************************************************************
2615BOOL WIN32API IsWindowVisible( HWND arg1)
2616{
2617#ifdef DEBUG
2618 WriteLog("USER32: IsWindowVisible\n");
2619#endif
2620 return O32_IsWindowVisible(arg1);
2621}
2622//******************************************************************************
2623//******************************************************************************
2624BOOL WIN32API IsZoomed( HWND arg1)
2625{
2626#ifdef DEBUG
2627 WriteLog("USER32: IsZoomed\n");
2628#endif
2629 return O32_IsZoomed(arg1);
2630}
2631//******************************************************************************
2632//******************************************************************************
2633BOOL WIN32API LockWindowUpdate( HWND arg1)
2634{
2635#ifdef DEBUG
2636 WriteLog("USER32: LockWindowUpdate\n");
2637#endif
2638 return O32_LockWindowUpdate(arg1);
2639}
2640//******************************************************************************
2641//******************************************************************************
2642BOOL WIN32API MapDialogRect( HWND arg1, PRECT arg2)
2643{
2644#ifdef DEBUG
2645 WriteLog("USER32: MapDialogRect\n");
2646#endif
2647 return O32_MapDialogRect(arg1, arg2);
2648}
2649//******************************************************************************
2650//******************************************************************************
2651UINT WIN32API MapVirtualKeyA( UINT arg1, UINT arg2)
2652{
2653#ifdef DEBUG
2654 WriteLog("USER32: MapVirtualKeyA\n");
2655#endif
2656 return O32_MapVirtualKey(arg1, arg2);
2657}
2658//******************************************************************************
2659//******************************************************************************
2660UINT WIN32API MapVirtualKeyW( UINT arg1, UINT arg2)
2661{
2662#ifdef DEBUG
2663 WriteLog("USER32: MapVirtualKeyW\n");
2664#endif
2665 // NOTE: This will not work as is (needs UNICODE support)
2666 return O32_MapVirtualKey(arg1, arg2);
2667}
2668//******************************************************************************
2669//******************************************************************************
2670int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
2671{
2672#ifdef DEBUG
2673 WriteLog("USER32: MapWindowPoints\n");
2674#endif
2675 return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
2676}
2677//******************************************************************************
2678//******************************************************************************
2679int WIN32API MessageBoxW(HWND arg1, LPCWSTR arg2, LPCWSTR arg3, UINT arg4)
2680{
2681 char *astring1, *astring2;
2682 int rc;
2683
2684 astring1 = UnicodeToAsciiString((LPWSTR)arg2);
2685 astring2 = UnicodeToAsciiString((LPWSTR)arg3);
2686#ifdef DEBUG
2687 WriteLog("USER32: MessageBoxW %s %s\n", astring1, astring2);
2688#endif
2689 rc = O32_MessageBox(arg1, astring1, astring2, arg4);
2690 FreeAsciiString(astring1);
2691 FreeAsciiString(astring2);
2692 return(rc);
2693}
2694//******************************************************************************
2695//******************************************************************************
2696BOOL WIN32API OpenClipboard( HWND arg1)
2697{
2698#ifdef DEBUG
2699 WriteLog("USER32: OpenClipboard\n");
2700#endif
2701 return O32_OpenClipboard(arg1);
2702}
2703//******************************************************************************
2704//******************************************************************************
2705BOOL WIN32API PeekMessageW( LPMSG arg1, HWND arg2, UINT arg3, UINT arg4, UINT arg5)
2706{
2707#ifdef DEBUG
2708 WriteLog("USER32: PeekMessageW\n");
2709#endif
2710 // NOTE: This will not work as is (needs UNICODE support)
2711 return O32_PeekMessage(arg1, arg2, arg3, arg4, arg5);
2712}
2713//******************************************************************************
2714//******************************************************************************
2715// NOTE: Open32 function doesn't have the 'W'.
2716BOOL WIN32API PostMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2717{
2718#ifdef DEBUG
2719 WriteLog("USER32: PostMessageW\n");
2720#endif
2721 // NOTE: This will not work as is (needs UNICODE support)
2722 return O32_PostMessage(arg1, arg2, arg3, arg4);
2723}
2724//******************************************************************************
2725//******************************************************************************
2726BOOL WIN32API PostThreadMessageA( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2727{
2728#ifdef DEBUG
2729 WriteLog("USER32: PostThreadMessageA\n");
2730#endif
2731 return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2732}
2733//******************************************************************************
2734//******************************************************************************
2735BOOL WIN32API PostThreadMessageW( DWORD arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2736{
2737#ifdef DEBUG
2738 WriteLog("USER32: PostThreadMessageW\n");
2739#endif
2740 // NOTE: This will not work as is (needs UNICODE support)
2741 return O32_PostThreadMessage(arg1, arg2, arg3, arg4);
2742}
2743//******************************************************************************
2744//******************************************************************************
2745BOOL WIN32API PtInRect( const RECT * arg1, POINT arg2)
2746{
2747#ifdef DEBUG1
2748 WriteLog("USER32: PtInRect\n");
2749#endif
2750 return O32_PtInRect(arg1, arg2);
2751}
2752//******************************************************************************
2753//******************************************************************************
2754BOOL WIN32API RedrawWindow( HWND arg1, const RECT * arg2, HRGN arg3, UINT arg4)
2755{
2756 BOOL rc;
2757
2758 rc = O32_RedrawWindow(arg1, arg2, arg3, arg4);
2759#ifdef DEBUG
2760 WriteLog("USER32: RedrawWindow %X , %X, %X, %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2761#endif
2762 InvalidateRect(arg1, arg2, TRUE);
2763 UpdateWindow(arg1);
2764 SendMessageA(arg1, WM_PAINT, 0, 0);
2765 return(rc);
2766}
2767//******************************************************************************
2768//******************************************************************************
2769UINT WIN32API RegisterClipboardFormatA( LPCSTR arg1)
2770{
2771#ifdef DEBUG
2772 WriteLog("USER32: RegisterClipboardFormatA\n");
2773#endif
2774 return O32_RegisterClipboardFormat(arg1);
2775}
2776//******************************************************************************
2777//******************************************************************************
2778UINT WIN32API RegisterClipboardFormatW(LPCWSTR arg1)
2779{
2780 UINT rc;
2781 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2782
2783#ifdef DEBUG
2784 WriteLog("USER32: RegisterClipboardFormatW %s\n", astring);
2785#endif
2786 rc = O32_RegisterClipboardFormat(astring);
2787 FreeAsciiString(astring);
2788#ifdef DEBUG
2789 WriteLog("USER32: RegisterClipboardFormatW returned %d\n", rc);
2790#endif
2791 return(rc);
2792}
2793//******************************************************************************
2794//******************************************************************************
2795UINT WIN32API RegisterWindowMessageW( LPCWSTR arg1)
2796{
2797 char *astring = UnicodeToAsciiString((LPWSTR)arg1);
2798 UINT rc;
2799
2800#ifdef DEBUG
2801 WriteLog("USER32: RegisterWindowMessageW\n");
2802#endif
2803 rc = O32_RegisterWindowMessage(astring);
2804 FreeAsciiString(astring);
2805 return rc;
2806}
2807//******************************************************************************
2808//******************************************************************************
2809HANDLE WIN32API RemovePropA( HWND arg1, LPCSTR arg2)
2810{
2811#ifdef DEBUG
2812 WriteLog("USER32: RemovePropA\n");
2813#endif
2814 return O32_RemoveProp(arg1, arg2);
2815}
2816//******************************************************************************
2817//******************************************************************************
2818HANDLE WIN32API RemovePropW( HWND arg1, LPCWSTR arg2)
2819{
2820 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
2821 HANDLE rc;
2822
2823#ifdef DEBUG
2824 WriteLog("USER32: RemovePropW\n");
2825#endif
2826 rc = O32_RemoveProp(arg1, astring);
2827 FreeAsciiString(astring);
2828 return rc;
2829}
2830//******************************************************************************
2831//******************************************************************************
2832BOOL WIN32API ReplyMessage( LRESULT arg1)
2833{
2834#ifdef DEBUG
2835 WriteLog("USER32: ReplyMessage\n");
2836#endif
2837 return O32_ReplyMessage(arg1);
2838}
2839//******************************************************************************
2840//******************************************************************************
2841BOOL WIN32API ScreenToClient( HWND arg1, LPPOINT arg2)
2842{
2843#ifdef DEBUG
2844 WriteLog("USER32: ScreenToClient\n");
2845#endif
2846 return O32_ScreenToClient(arg1, arg2);
2847}
2848//******************************************************************************
2849//******************************************************************************
2850BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7)
2851{
2852#ifdef DEBUG
2853 WriteLog("USER32: ScrollDC\n");
2854#endif
2855 return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2856}
2857//******************************************************************************
2858//******************************************************************************
2859BOOL WIN32API ScrollWindow( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5)
2860{
2861#ifdef DEBUG
2862 WriteLog("USER32: ScrollWindow\n");
2863#endif
2864 return O32_ScrollWindow(arg1, arg2, arg3, arg4, arg5);
2865}
2866//******************************************************************************
2867//******************************************************************************
2868INT WIN32API ScrollWindowEx( HWND arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7, UINT arg8)
2869{
2870#ifdef DEBUG
2871 WriteLog("USER32: ScrollWindowEx\n");
2872#endif
2873 return O32_ScrollWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2874}
2875//******************************************************************************
2876//******************************************************************************
2877LONG WIN32API SendDlgItemMessageW( HWND arg1, int arg2, UINT arg3, WPARAM arg4, LPARAM arg5)
2878{
2879#ifdef DEBUG
2880 WriteLog("USER32: SendDlgItemMessageW\n");
2881#endif
2882 return O32_SendDlgItemMessage(arg1, arg2, arg3, arg4, arg5);
2883}
2884//******************************************************************************
2885//******************************************************************************
2886LRESULT WIN32API SendMessageW( HWND arg1, UINT arg2, WPARAM arg3, LPARAM arg4)
2887{
2888LRESULT rc;
2889
2890#ifdef DEBUG
2891 WriteLog("USER32: SendMessageW....\n");
2892#endif
2893 rc = O32_SendMessage(arg1, arg2, arg3, arg4);
2894#ifdef DEBUG
2895 WriteLog("USER32: SendMessageW %X %X %X %X returned %d\n", arg1, arg2, arg3, arg4, rc);
2896#endif
2897 return(rc);
2898}
2899//******************************************************************************
2900//******************************************************************************
2901BOOL WIN32API SetCaretBlinkTime( UINT arg1)
2902{
2903#ifdef DEBUG
2904 WriteLog("USER32: SetCaretBlinkTime\n");
2905#endif
2906 return O32_SetCaretBlinkTime(arg1);
2907}
2908//******************************************************************************
2909//******************************************************************************
2910BOOL WIN32API SetCaretPos( int arg1, int arg2)
2911{
2912 dprintf(("USER32: SetCaretPos\n"));
2913 return O32_SetCaretPos(arg1, arg2);
2914}
2915//******************************************************************************
2916//******************************************************************************
2917HANDLE WIN32API SetClipboardData( UINT arg1, HANDLE arg2)
2918{
2919 dprintf(("USER32: SetClipboardData\n"));
2920 return O32_SetClipboardData(arg1, arg2);
2921}
2922//******************************************************************************
2923//******************************************************************************
2924HWND WIN32API SetClipboardViewer( HWND arg1)
2925{
2926 dprintf(("USER32: SetClipboardViewer\n"));
2927 return O32_SetClipboardViewer(arg1);
2928}
2929//******************************************************************************
2930//******************************************************************************
2931BOOL WIN32API SetDlgItemTextW( HWND arg1, int arg2, LPCWSTR arg3)
2932{
2933char *astring = UnicodeToAsciiString((LPWSTR)arg3);
2934BOOL rc;
2935
2936#ifdef DEBUG
2937 WriteLog("USER32: SetDlgItemTextW\n");
2938#endif
2939 // NOTE: This will not work as is (needs UNICODE support)
2940 rc = O32_SetDlgItemText(arg1, arg2, astring);
2941 FreeAsciiString(astring);
2942 return rc;
2943}
2944//******************************************************************************
2945//******************************************************************************
2946BOOL WIN32API SetDoubleClickTime( UINT arg1)
2947{
2948#ifdef DEBUG
2949 WriteLog("USER32: SetDoubleClickTime\n");
2950#endif
2951 return O32_SetDoubleClickTime(arg1);
2952}
2953//******************************************************************************
2954//******************************************************************************
2955HWND WIN32API SetParent( HWND arg1, HWND arg2)
2956{
2957#ifdef DEBUG
2958 WriteLog("USER32: SetParent\n");
2959#endif
2960 return O32_SetParent(arg1, arg2);
2961}
2962//******************************************************************************
2963//******************************************************************************
2964BOOL WIN32API SetPropA( HWND arg1, LPCSTR arg2, HANDLE arg3)
2965{
2966#ifdef DEBUG
2967 if((int)arg2 >> 16 != 0)
2968 WriteLog("USER32: SetPropA %S\n", arg2);
2969 else WriteLog("USER32: SetPropA %X\n", arg2);
2970#endif
2971 return O32_SetProp(arg1, arg2, arg3);
2972}
2973//******************************************************************************
2974//******************************************************************************
2975BOOL WIN32API SetPropW(HWND arg1, LPCWSTR arg2, HANDLE arg3)
2976{
2977 BOOL rc;
2978 char *astring;
2979
2980 if((int)arg2 >> 16 != 0)
2981 astring = UnicodeToAsciiString((LPWSTR)arg2);
2982 else astring = (char *)arg2;
2983
2984#ifdef DEBUG
2985 if((int)arg2 >> 16 != 0)
2986 WriteLog("USER32: SetPropW %S\n", astring);
2987 else WriteLog("USER32: SetPropW %X\n", astring);
2988#endif
2989 rc = O32_SetProp(arg1, astring, arg3);
2990 if((int)astring >> 16 != 0)
2991 FreeAsciiString(astring);
2992 return(rc);
2993}
2994//******************************************************************************
2995//******************************************************************************
2996BOOL WIN32API SetRectEmpty( PRECT arg1)
2997{
2998#ifdef DEBUG
2999 WriteLog("USER32: SetRectEmpty\n");
3000#endif
3001 return O32_SetRectEmpty(arg1);
3002}
3003//******************************************************************************
3004//******************************************************************************
3005int WIN32API SetScrollPos( HWND arg1, int arg2, int arg3, BOOL arg4)
3006{
3007#ifdef DEBUG
3008 WriteLog("USER32: SetScrollPos\n");
3009#endif
3010 return O32_SetScrollPos(arg1, arg2, arg3, arg4);
3011}
3012//******************************************************************************
3013//******************************************************************************
3014BOOL WIN32API SetScrollRange( HWND arg1, int arg2, int arg3, int arg4, BOOL arg5)
3015{
3016#ifdef DEBUG
3017 WriteLog("USER32: SetScrollRange\n");
3018#endif
3019 return O32_SetScrollRange(arg1, arg2, arg3, arg4, arg5);
3020}
3021//******************************************************************************
3022//******************************************************************************
3023BOOL WIN32API SetWindowPlacement( HWND arg1, const WINDOWPLACEMENT * arg2)
3024{
3025 dprintf(("USER32: SetWindowPlacement\n"));
3026 return O32_SetWindowPlacement(arg1, arg2);
3027}
3028//******************************************************************************
3029//******************************************************************************
3030BOOL WIN32API SetWindowTextW( HWND arg1, LPCWSTR arg2)
3031{
3032 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
3033 BOOL rc;
3034
3035 rc = SetWindowTextA(arg1, (LPCSTR)astring);
3036 dprintf(("USER32: SetWindowTextW %X %s returned %d\n", arg1, astring, rc));
3037 FreeAsciiString(astring);
3038 return(rc);
3039}
3040//******************************************************************************
3041//******************************************************************************
3042BOOL WIN32API ShowCaret( HWND arg1)
3043{
3044 dprintf(("USER32: ShowCaret\n"));
3045 return O32_ShowCaret(arg1);
3046}
3047//******************************************************************************
3048//******************************************************************************
3049BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
3050{
3051 dprintf(("USER32: ShowOwnedPopups\n"));
3052 return O32_ShowOwnedPopups(arg1, arg2);
3053}
3054//******************************************************************************
3055//******************************************************************************
3056BOOL WIN32API ShowScrollBar( HWND arg1, int arg2, BOOL arg3)
3057{
3058#ifdef DEBUG
3059 WriteLog("USER32: ShowScrollBar\n");
3060#endif
3061 return O32_ShowScrollBar(arg1, arg2, arg3);
3062}
3063//******************************************************************************
3064//******************************************************************************
3065BOOL WIN32API SwapMouseButton( BOOL arg1)
3066{
3067#ifdef DEBUG
3068 WriteLog("USER32: SwapMouseButton\n");
3069#endif
3070 return O32_SwapMouseButton(arg1);
3071}
3072//******************************************************************************
3073//******************************************************************************
3074BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
3075{
3076 BOOL rc;
3077 NONCLIENTMETRICSA *cmetric = (NONCLIENTMETRICSA *)pvParam;
3078
3079 switch(uiAction) {
3080 case SPI_SCREENSAVERRUNNING:
3081 *(BOOL *)pvParam = FALSE;
3082 rc = TRUE;
3083 break;
3084 case SPI_GETDRAGFULLWINDOWS:
3085 *(BOOL *)pvParam = FALSE;
3086 rc = TRUE;
3087 break;
3088 case SPI_GETNONCLIENTMETRICS:
3089 memset(cmetric, 0, sizeof(NONCLIENTMETRICSA));
3090 cmetric->cbSize = sizeof(NONCLIENTMETRICSA);
3091 //CB: font info not valid, needs improvements
3092 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfCaptionFont),0);
3093 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMenuFont),0);
3094 //CB: experimental change for statusbar (and tooltips)
3095
3096 //O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfStatusFont),0);
3097 lstrcpyA(cmetric->lfStatusFont.lfFaceName,"WarpSans");
3098 cmetric->lfStatusFont.lfHeight = 9;
3099
3100 O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMessageFont),0);
3101 cmetric->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
3102 cmetric->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
3103 cmetric->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
3104 cmetric->iCaptionWidth = 32; //TODO
3105 cmetric->iCaptionHeight = 16; //TODO
3106 cmetric->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
3107 cmetric->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
3108 cmetric->iMenuWidth = 32; //TODO
3109 cmetric->iMenuHeight = GetSystemMetrics(SM_CYMENU);
3110 rc = TRUE;
3111 break;
3112 case 104: //TODO: Undocumented
3113 rc = 16;
3114 break;
3115 default:
3116 rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
3117 break;
3118 }
3119#ifdef DEBUG
3120 WriteLog("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc);
3121#endif
3122 return(rc);
3123}
3124//******************************************************************************
3125//TODO: Check for more options that have different structs for Unicode!!!!
3126//******************************************************************************
3127BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
3128{
3129 BOOL rc;
3130 NONCLIENTMETRICSW *clientMetricsW = (NONCLIENTMETRICSW *)pvParam;
3131 NONCLIENTMETRICSA clientMetricsA = {0};
3132 PVOID pvParamA;
3133 UINT uiParamA;
3134
3135 switch(uiAction) {
3136 case SPI_SETNONCLIENTMETRICS:
3137 clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
3138 clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
3139 clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
3140 clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
3141 clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
3142 clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
3143 ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
3144 clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
3145 clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
3146 ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
3147 clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
3148 clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
3149 ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
3150 ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
3151 ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
3152 //no break
3153 case SPI_GETNONCLIENTMETRICS:
3154 uiParamA = sizeof(NONCLIENTMETRICSA);
3155 pvParamA = &clientMetricsA;
3156 break;
3157 default:
3158 pvParamA = pvParam;
3159 uiParamA = uiParam;
3160 break;
3161 }
3162 rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
3163
3164 switch(uiAction) {
3165 case SPI_GETNONCLIENTMETRICS:
3166 clientMetricsW->cbSize = sizeof(*clientMetricsW);
3167 clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
3168 clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
3169 clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
3170 clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
3171 clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
3172 ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
3173
3174 clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
3175 clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
3176 ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
3177
3178 clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
3179 clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
3180 ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
3181 ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
3182 ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
3183 break;
3184 }
3185#ifdef DEBUG
3186 WriteLog("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc);
3187#endif
3188 return(rc);
3189}
3190//******************************************************************************
3191//******************************************************************************
3192LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3193{
3194#ifdef DEBUG
3195 WriteLog("USER32: TabbedTextOutA\n");
3196#endif
3197 return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
3198}
3199//******************************************************************************
3200//******************************************************************************
3201LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int arg8)
3202{
3203 char *astring = UnicodeToAsciiString((LPWSTR)arg4);
3204 LONG rc;
3205
3206#ifdef DEBUG
3207 WriteLog("USER32: TabbedTextOutW\n");
3208#endif
3209 rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
3210 FreeAsciiString(astring);
3211 return rc;
3212}
3213//******************************************************************************
3214//******************************************************************************
3215int WIN32API TranslateAccelerator( HWND arg1, HACCEL arg2, LPMSG arg3)
3216{
3217#ifdef DEBUG
3218 WriteLog("USER32: TranslateAccelerator\n");
3219#endif
3220 return O32_TranslateAccelerator(arg1, arg2, arg3);
3221}
3222//******************************************************************************
3223//******************************************************************************
3224int WIN32API TranslateAcceleratorW( HWND arg1, HACCEL arg2, LPMSG arg3)
3225{
3226#ifdef DEBUG
3227 WriteLog("USER32: TranslateAcceleratorW\n");
3228#endif
3229 // NOTE: This will not work as is (needs UNICODE support)
3230 return O32_TranslateAccelerator(arg1, arg2, arg3);
3231}
3232//******************************************************************************
3233//******************************************************************************
3234BOOL WIN32API TranslateMDISysAccel( HWND arg1, LPMSG arg2)
3235{
3236#ifdef DEBUG
3237//// WriteLog("USER32: TranslateMDISysAccel\n");
3238#endif
3239 return O32_TranslateMDISysAccel(arg1, arg2);
3240}
3241//******************************************************************************
3242//******************************************************************************
3243BOOL WIN32API UnionRect( PRECT arg1, const RECT * arg2, const RECT * arg3)
3244{
3245#ifdef DEBUG
3246 WriteLog("USER32: UnionRect\n");
3247#endif
3248 return O32_UnionRect(arg1, arg2, arg3);
3249}
3250//******************************************************************************
3251//******************************************************************************
3252BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
3253{
3254#ifdef DEBUG
3255 WriteLog("USER32: ValidateRect\n");
3256#endif
3257 return O32_ValidateRect(arg1, arg2);
3258}
3259//******************************************************************************
3260//******************************************************************************
3261BOOL WIN32API ValidateRgn( HWND arg1, HRGN arg2)
3262{
3263#ifdef DEBUG
3264 WriteLog("USER32: ValidateRgn\n");
3265#endif
3266 return O32_ValidateRgn(arg1, arg2);
3267}
3268//******************************************************************************
3269//******************************************************************************
3270WORD WIN32API VkKeyScanW( WCHAR arg1)
3271{
3272#ifdef DEBUG
3273 WriteLog("USER32: VkKeyScanW\n");
3274#endif
3275 // NOTE: This will not work as is (needs UNICODE support)
3276 return O32_VkKeyScan((char)arg1);
3277}
3278//******************************************************************************
3279//******************************************************************************
3280BOOL WIN32API WaitMessage(void)
3281{
3282#ifdef DEBUG
3283 WriteLog("USER32: WaitMessage\n");
3284#endif
3285 return O32_WaitMessage();
3286}
3287//******************************************************************************
3288//******************************************************************************
3289BOOL WIN32API WinHelpW( HWND arg1, LPCWSTR arg2, UINT arg3, DWORD arg4)
3290{
3291 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
3292 BOOL rc;
3293
3294#ifdef DEBUG
3295 WriteLog("USER32: WinHelpW\n");
3296#endif
3297 rc = WinHelpA(arg1, astring, arg3, arg4);
3298 FreeAsciiString(astring);
3299 return rc;
3300}
3301//******************************************************************************
3302//******************************************************************************
3303HWND WIN32API WindowFromDC( HDC arg1)
3304{
3305#ifdef DEBUG
3306 WriteLog("USER32: WindowFromDC\n");
3307#endif
3308 return O32_WindowFromDC(arg1);
3309}
3310//******************************************************************************
3311//******************************************************************************
3312HWND WIN32API WindowFromPoint( POINT arg1)
3313{
3314#ifdef DEBUG
3315 WriteLog("USER32: WindowFromPoint\n");
3316#endif
3317 return O32_WindowFromPoint(arg1);
3318}
3319//******************************************************************************
3320//******************************************************************************
3321int WIN32API wvsprintfA( LPSTR arg1, LPCSTR arg2, va_list arg3)
3322{
3323#ifdef DEBUG
3324 WriteLog("USER32: wvsprintfA\n");
3325#endif
3326 return O32_wvsprintf(arg1, arg2, (LPCVOID *)arg3);
3327}
3328//******************************************************************************
3329//******************************************************************************
3330int WIN32API wvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, va_list argptr)
3331{
3332 int rc;
3333 char szOut[256];
3334 char *lpFmtA;
3335
3336 lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
3337#ifdef DEBUG
3338 WriteLog("USER32: wvsprintfW, DOES NOT HANDLE UNICODE STRINGS!\n");
3339 WriteLog("USER32: %s\n", lpFmt);
3340#endif
3341 rc = O32_wvsprintf(szOut, lpFmtA, (LPCVOID)argptr);
3342
3343 AsciiToUnicode(szOut, lpOut);
3344#ifdef DEBUG
3345 WriteLog("USER32: %s\n", lpOut);
3346#endif
3347 FreeAsciiString(lpFmtA);
3348 return(rc);
3349}
3350//******************************************************************************
3351//No need to support this
3352//******************************************************************************
3353BOOL WIN32API SetMessageQueue(int cMessagesMax)
3354{
3355#ifdef DEBUG
3356 WriteLog("USER32: SetMessageQueue\n");
3357#endif
3358 return(TRUE);
3359}
3360//******************************************************************************
3361//TODO: Not complete
3362//******************************************************************************
3363BOOL WIN32API GetScrollInfo(HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
3364{
3365#ifdef DEBUG
3366 WriteLog("USER32: GetScrollInfo\n");
3367#endif
3368 if(lpsi == NULL)
3369 return(FALSE);
3370
3371 if(lpsi->fMask & SIF_POS)
3372 lpsi->nPos = GetScrollPos(hwnd, fnBar);
3373 if(lpsi->fMask & SIF_RANGE)
3374 GetScrollRange(hwnd, fnBar, &lpsi->nMin, &lpsi->nMax);
3375 if(lpsi->fMask & SIF_PAGE) {
3376#ifdef DEBUG
3377 WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3378#endif
3379 lpsi->nPage = 25;
3380 }
3381 return(TRUE);
3382}
3383//******************************************************************************
3384//TODO: Not complete
3385//******************************************************************************
3386INT WIN32API SetScrollInfo(HWND hwnd, INT fnBar, const SCROLLINFO *lpsi, BOOL fRedraw)
3387{
3388 int smin, smax;
3389
3390#ifdef DEBUG
3391 WriteLog("USER32: SetScrollInfo\n");
3392#endif
3393 if(lpsi == NULL)
3394 return(FALSE);
3395
3396 if(lpsi->fMask & SIF_POS)
3397 SetScrollPos(hwnd, fnBar, lpsi->nPos, fRedraw);
3398 if(lpsi->fMask & SIF_RANGE)
3399 SetScrollRange(hwnd, fnBar, lpsi->nMin, lpsi->nMax, fRedraw);
3400 if(lpsi->fMask & SIF_PAGE) {
3401#ifdef DEBUG
3402 WriteLog("USER32: GetScrollInfo, page info not implemented\n");
3403#endif
3404 }
3405 if(lpsi->fMask & SIF_DISABLENOSCROLL) {
3406#ifdef DEBUG
3407 WriteLog("USER32: GetScrollInfo, disable scrollbar not yet implemented\n");
3408#endif
3409 }
3410 return(TRUE);
3411}
3412//******************************************************************************
3413//******************************************************************************
3414BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3415 LPARAM lpData, int nCount, int X, int Y, int nWidth,
3416 int nHeight)
3417{
3418 BOOL rc;
3419 COLORREF curclr;
3420
3421#ifdef DEBUG
3422 WriteLog("USER32: GrayStringA, not completely implemented\n");
3423#endif
3424 if(lpOutputFunc == NULL && lpData == NULL) {
3425#ifdef DEBUG
3426 WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3427#endif
3428 return(FALSE);
3429 }
3430 if(lpOutputFunc) {
3431 return(lpOutputFunc(hdc, lpData, nCount));
3432 }
3433 curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3434 rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
3435 SetTextColor(hdc, curclr);
3436
3437 return(rc);
3438}
3439//******************************************************************************
3440//******************************************************************************
3441BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
3442 LPARAM lpData, int nCount, int X, int Y, int nWidth,
3443 int nHeight)
3444{
3445 BOOL rc;
3446 char *astring;
3447 COLORREF curclr;
3448
3449#ifdef DEBUG
3450 WriteLog("USER32: GrayStringW, not completely implemented\n");
3451#endif
3452
3453 if(lpOutputFunc == NULL && lpData == NULL) {
3454#ifdef DEBUG
3455 WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
3456#endif
3457 return(FALSE);
3458 }
3459 if(nCount == 0)
3460 nCount = UniStrlen((UniChar*)lpData);
3461
3462 if(lpOutputFunc) {
3463 return(lpOutputFunc(hdc, lpData, nCount));
3464 }
3465 astring = UnicodeToAsciiString((LPWSTR)lpData);
3466
3467 curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
3468 rc = TextOutA(hdc, X, Y, astring, nCount);
3469 SetTextColor(hdc, curclr);
3470
3471 FreeAsciiString(astring);
3472 return(rc);
3473}
3474//******************************************************************************
3475//TODO:
3476//******************************************************************************
3477int WIN32API CopyAcceleratorTableA(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3478 int cAccelEntries)
3479{
3480#ifdef DEBUG
3481 WriteLog("USER32: CopyAcceleratorTableA, not implemented\n");
3482#endif
3483 return(0);
3484}
3485//******************************************************************************
3486//TODO:
3487//******************************************************************************
3488int WIN32API CopyAcceleratorTableW(HACCEL hAccelSrc, LPACCEL lpAccelDest,
3489 int cAccelEntries)
3490{
3491#ifdef DEBUG
3492 WriteLog("USER32: CopyAcceleratorTableW, not implemented\n");
3493#endif
3494 return(0);
3495}
3496//******************************************************************************
3497//******************************************************************************
3498LRESULT WIN32API SendMessageTimeoutA(HWND hwnd, UINT Msg, WPARAM wParam,
3499 LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3500 LPDWORD lpdwResult)
3501{
3502#ifdef DEBUG
3503 WriteLog("USER32: SendMessageTimeoutA, partially implemented\n");
3504#endif
3505 //ignore fuFlags & wTimeOut
3506 *lpdwResult = SendMessageA(hwnd, Msg, wParam, lParam);
3507 return(TRUE);
3508}
3509//******************************************************************************
3510//******************************************************************************
3511LRESULT WIN32API SendMessageTimeoutW(HWND hwnd, UINT Msg, WPARAM wParam,
3512 LPARAM lParam, UINT fuFlags, UINT uTimeOut,
3513 LPDWORD lpdwResult)
3514{
3515#ifdef DEBUG
3516 WriteLog("USER32: SendMessageTimeoutW, partially implemented\n");
3517#endif
3518 return(SendMessageTimeoutA(hwnd, Msg, wParam, lParam, fuFlags, uTimeOut, lpdwResult));
3519}
3520//******************************************************************************
3521//******************************************************************************
3522HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
3523{
3524#ifdef DEBUG
3525 WriteLog("USER32: CopyImage, not implemented\n");
3526#endif
3527 switch(uType) {
3528 case IMAGE_BITMAP:
3529 case IMAGE_CURSOR:
3530 case IMAGE_ICON:
3531 default:
3532#ifdef DEBUG
3533 WriteLog("USER32: CopyImage, unknown type\n");
3534#endif
3535 return(NULL);
3536 }
3537 return(NULL);
3538}
3539//******************************************************************************
3540//******************************************************************************
3541BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
3542{
3543#ifdef DEBUG
3544 WriteLog("USER32: GetKeyboardState, not properly implemented\n");
3545#endif
3546 memset(lpKeyState, 0, 256);
3547 return(TRUE);
3548}
3549//******************************************************************************
3550//******************************************************************************
3551BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
3552{
3553#ifdef DEBUG
3554 WriteLog("USER32: SetKeyboardState, not implemented\n");
3555#endif
3556 return(TRUE);
3557}
3558//******************************************************************************
3559//******************************************************************************
3560BOOL WIN32API SendNotifyMessageA(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3561{
3562#ifdef DEBUG
3563 WriteLog("USER32: SendNotifyMessageA, not completely implemented\n");
3564#endif
3565 return(SendMessageA(hwnd, Msg, wParam, lParam));
3566}
3567//******************************************************************************
3568//******************************************************************************
3569BOOL WIN32API SendNotifyMessageW(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
3570{
3571#ifdef DEBUG
3572 WriteLog("USER32: SendNotifyMessageW, not completely implemented\n");
3573#endif
3574 return(SendMessageA(hwnd, Msg, wParam, lParam));
3575}
3576//******************************************************************************
3577//2nd parameter not used according to SDK (yet?)
3578//******************************************************************************
3579VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
3580{
3581#ifdef DEBUG
3582 WriteLog("USER32: SetLastErrorEx\n");
3583#endif
3584 SetLastError(dwErrCode);
3585}
3586//******************************************************************************
3587//******************************************************************************
3588LPARAM WIN32API SetMessageExtraInfo(LPARAM lParam)
3589{
3590#ifdef DEBUG
3591 WriteLog("USER32: SetMessageExtraInfo, not implemented\n");
3592#endif
3593 return(0);
3594}
3595//******************************************************************************
3596//******************************************************************************
3597BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
3598{
3599#ifdef DEBUG
3600 WriteLog("USER32: ActivateKeyboardLayout, not implemented\n");
3601#endif
3602 return(TRUE);
3603}
3604//******************************************************************************
3605//******************************************************************************
3606int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
3607{
3608#ifdef DEBUG
3609 WriteLog("USER32: GetKeyboardLayoutList, not implemented\n");
3610#endif
3611 return(0);
3612}
3613//******************************************************************************
3614//******************************************************************************
3615HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
3616{
3617#ifdef DEBUG
3618 WriteLog("USER32: GetKeyboardLayout, not implemented\n");
3619#endif
3620 return(0);
3621}
3622//******************************************************************************
3623//******************************************************************************
3624int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
3625{
3626#ifdef DEBUG
3627 WriteLog("USER32: LookupIconIdFromDirectory, not implemented\n");
3628#endif
3629 return(0);
3630}
3631//******************************************************************************
3632//******************************************************************************
3633int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL fIcon,
3634 int cxDesired, int cyDesired,
3635 UINT Flags)
3636{
3637#ifdef DEBUG
3638 WriteLog("USER32: LookupIconIdFromDirectoryEx, not implemented\n");
3639#endif
3640 return(0);
3641}
3642//******************************************************************************
3643//DWORD idAttach; /* thread to attach */
3644//DWORD idAttachTo; /* thread to attach to */
3645//BOOL fAttach; /* attach or detach */
3646//******************************************************************************
3647BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
3648{
3649#ifdef DEBUG
3650 WriteLog("USER32: AttachThreadInput, not implemented\n");
3651#endif
3652 return(TRUE);
3653}
3654//******************************************************************************
3655//******************************************************************************
3656BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
3657{
3658#ifdef DEBUG
3659 WriteLog("USER32: RegisterHotKey, not implemented\n");
3660#endif
3661 return(TRUE);
3662}
3663//******************************************************************************
3664//******************************************************************************
3665BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
3666{
3667#ifdef DEBUG
3668 WriteLog("USER32: UnregisterHotKey, not implemented\n");
3669#endif
3670 return(TRUE);
3671}
3672//******************************************************************************
3673//******************************************************************************
3674//******************************************************************************
3675//******************************************************************************
3676BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
3677{
3678#ifdef DEBUG
3679 WriteLog("USER32: SetWindowContextHelpId, not implemented\n");
3680#endif
3681 return(TRUE);
3682}
3683//******************************************************************************
3684//******************************************************************************
3685DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
3686{
3687#ifdef DEBUG
3688 WriteLog("USER32: GetWindowContextHelpId, not implemented\n");
3689#endif
3690 return(0);
3691}
3692//******************************************************************************
3693//restores iconized window to previous size/position
3694//******************************************************************************
3695BOOL WIN32API OpenIcon(HWND hwnd)
3696{
3697#ifdef DEBUG
3698 WriteLog("USER32: OpenIcon\n");
3699#endif
3700 if(!IsIconic(hwnd))
3701 return FALSE;
3702 ShowWindow(hwnd, SW_SHOWNORMAL);
3703 return TRUE;
3704}
3705//******************************************************************************
3706//******************************************************************************
3707BOOL WIN32API IsWindowUnicode(HWND hwnd)
3708{
3709#ifdef DEBUG
3710 WriteLog("USER32: IsWindowUnicode, not implemented\n");
3711#endif
3712 return(FALSE);
3713}
3714//******************************************************************************
3715//******************************************************************************
3716BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
3717{
3718#ifdef DEBUG
3719 WriteLog("USER32: GetMonitorInfoA not supported!!\n");
3720#endif
3721 return(FALSE);
3722}
3723//******************************************************************************
3724//******************************************************************************
3725BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
3726{
3727#ifdef DEBUG
3728 WriteLog("USER32: GetMonitorInfoW not supported!!\n");
3729#endif
3730 return(FALSE);
3731}
3732//******************************************************************************
3733//******************************************************************************
3734HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
3735{
3736#ifdef DEBUG
3737 WriteLog("USER32: MonitorFromWindow not correctly supported??\n");
3738#endif
3739 return(0);
3740}
3741//******************************************************************************
3742//******************************************************************************
3743HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
3744{
3745#ifdef DEBUG
3746 WriteLog("USER32: MonitorFromRect not correctly supported??\n");
3747#endif
3748 return(0);
3749}
3750//******************************************************************************
3751//******************************************************************************
3752HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
3753{
3754#ifdef DEBUG
3755 WriteLog("USER32: MonitorFromPoint not correctly supported??\n");
3756#endif
3757 return(0);
3758}
3759//******************************************************************************
3760//******************************************************************************
3761BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
3762{
3763#ifdef DEBUG
3764 WriteLog("USER32: EnumDisplayMonitors not supported??\n");
3765#endif
3766 return(FALSE);
3767}
3768//******************************************************************************
3769//******************************************************************************
3770BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
3771 LPDEVMODEA lpDevMode)
3772{
3773#ifdef DEBUG
3774 WriteLog("USER32: EnumDisplaySettingsA FAKED\n");
3775#endif
3776 switch(iModeNum) {
3777 case 0:
3778 lpDevMode->dmBitsPerPel = 16;
3779 lpDevMode->dmPelsWidth = 768;
3780 lpDevMode->dmPelsHeight = 1024;
3781 lpDevMode->dmDisplayFlags = 0;
3782 lpDevMode->dmDisplayFrequency = 70;
3783 break;
3784 case 1:
3785 lpDevMode->dmBitsPerPel = 16;
3786 lpDevMode->dmPelsWidth = 640;
3787 lpDevMode->dmPelsHeight = 480;
3788 lpDevMode->dmDisplayFlags = 0;
3789 lpDevMode->dmDisplayFrequency = 70;
3790 break;
3791 default:
3792 return(FALSE);
3793 }
3794 return(TRUE);
3795}
3796//******************************************************************************
3797//******************************************************************************
3798LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA lpDevMode, DWORD dwFlags)
3799{
3800#ifdef DEBUG
3801 if(lpDevMode) {
3802 WriteLog("USER32: ChangeDisplaySettingsA FAKED %X\n", dwFlags);
3803 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
3804 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsWidth %d\n", lpDevMode->dmPelsWidth);
3805 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
3806 }
3807#endif
3808 return(DISP_CHANGE_SUCCESSFUL);
3809}
3810//******************************************************************************
3811//******************************************************************************
3812
3813
3814/*****************************************************************************
3815 * Name : BOOL WIN32API AnyPopup
3816 * Purpose : The AnyPopup function indicates whether an owned, visible,
3817 * top-level pop-up, or overlapped window exists on the screen. The
3818 * function searches the entire Windows screen, not just the calling
3819 * application's client area.
3820 * Parameters: VOID
3821 * Variables :
3822 * Result : If a pop-up window exists, the return value is TRUE even if the
3823 * pop-up window is completely covered by other windows. Otherwise,
3824 * it is FALSE.
3825 * Remark : AnyPopup is a Windows version 1.x function and is retained for
3826 * compatibility purposes. It is generally not useful.
3827 * Status : UNTESTED STUB
3828 *
3829 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3830 *****************************************************************************/
3831
3832BOOL WIN32API AnyPopup(VOID)
3833{
3834 dprintf(("USER32:AnyPopup() not implemented.\n"));
3835
3836 return (FALSE);
3837}
3838
3839
3840/*****************************************************************************
3841 * Name : long WIN32API BroadcastSystemMessage
3842 * Purpose : The BroadcastSystemMessage function sends a message to the given
3843 * recipients. The recipients can be applications, installable
3844 * drivers, Windows-based network drivers, system-level device
3845 * drivers, or any combination of these system components.
3846 * Parameters: DWORD dwFlags,
3847 LPDWORD lpdwRecipients,
3848 UINT uiMessage,
3849 WPARAM wParam,
3850 LPARAM lParam
3851 * Variables :
3852 * Result : If the function succeeds, the return value is a positive value.
3853 * If the function is unable to broadcast the message, the return value is -1.
3854 * If the dwFlags parameter is BSF_QUERY and at least one recipient returned FALSE to the corresponding message, the return value is zero.
3855 * Remark :
3856 * Status : UNTESTED STUB
3857 *
3858 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3859 *****************************************************************************/
3860
3861long WIN32API BroadcastSystemMessage(DWORD dwFlags,
3862 LPDWORD lpdwRecipients,
3863 UINT uiMessage,
3864 WPARAM wParam,
3865 LPARAM lParam)
3866{
3867 dprintf(("USER32:BroadcastSystemMessage(%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
3868 dwFlags,
3869 lpdwRecipients,
3870 uiMessage,
3871 wParam,
3872 lParam));
3873
3874 return (-1);
3875}
3876
3877
3878/*****************************************************************************
3879 * Name : WORD WIN32API CascadeWindows
3880 * Purpose : The CascadeWindows function cascades the specified windows or
3881 * the child windows of the specified parent window.
3882 * Parameters: HWND hwndParent handle of parent window
3883 * UINT wHow types of windows not to arrange
3884 * CONST RECT * lpRect rectangle to arrange windows in
3885 * UINT cKids number of windows to arrange
3886 * const HWND FAR * lpKids array of window handles
3887 * Variables :
3888 * Result : If the function succeeds, the return value is the number of windows arranged.
3889 * If the function fails, the return value is zero.
3890 * Remark :
3891 * Status : UNTESTED STUB
3892 *
3893 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3894 *****************************************************************************/
3895
3896WORD WIN32API CascadeWindows(HWND hwndParent,
3897 UINT wHow,
3898 CONST LPRECT lpRect,
3899 UINT cKids,
3900 const HWND *lpKids)
3901{
3902 dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
3903 hwndParent,
3904 wHow,
3905 lpRect,
3906 cKids,
3907 lpKids));
3908
3909 return (0);
3910}
3911
3912
3913/*****************************************************************************
3914 * Name : LONG WIN32API ChangeDisplaySettingsW
3915 * Purpose : The ChangeDisplaySettings function changes the display settings
3916 * to the specified graphics mode.
3917 * Parameters: LPDEVMODEW lpDevModeW
3918 * DWORD dwFlags
3919 * Variables :
3920 * Result : DISP_CHANGE_SUCCESSFUL The settings change was successful.
3921 * DISP_CHANGE_RESTART The computer must be restarted in order for the graphics mode to work.
3922 * DISP_CHANGE_BADFLAGS An invalid set of flags was passed in.
3923 * DISP_CHANGE_FAILED The display driver failed the specified graphics mode.
3924 * DISP_CHANGE_BADMODE The graphics mode is not supported.
3925 * DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
3926 * Remark :
3927 * Status : UNTESTED STUB
3928 *
3929 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3930 *****************************************************************************/
3931
3932LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
3933 DWORD dwFlags)
3934{
3935 dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
3936 lpDevMode,
3937 dwFlags));
3938
3939 return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
3940 dwFlags));
3941}
3942
3943/*****************************************************************************
3944 * Name : BOOL WIN32API CloseDesktop
3945 * Purpose : The CloseDesktop function closes an open handle of a desktop
3946 * object. A desktop is a secure object contained within a window
3947 * station object. A desktop has a logical display surface and
3948 * contains windows, menus and hooks.
3949 * Parameters: HDESK hDesktop
3950 * Variables :
3951 * Result : If the function succeeds, the return value is TRUE.
3952 * If the functions fails, the return value is FALSE. To get
3953 * extended error information, call GetLastError.
3954 * Remark :
3955 * Status : UNTESTED STUB
3956 *
3957 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3958 *****************************************************************************/
3959
3960BOOL WIN32API CloseDesktop(HDESK hDesktop)
3961{
3962 dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
3963 hDesktop));
3964
3965 return (FALSE);
3966}
3967
3968
3969/*****************************************************************************
3970 * Name : BOOL WIN32API CloseWindowStation
3971 * Purpose : The CloseWindowStation function closes an open window station handle.
3972 * Parameters: HWINSTA hWinSta
3973 * Variables :
3974 * Result :
3975 * Remark : If the function succeeds, the return value is TRUE.
3976 * If the functions fails, the return value is FALSE. To get
3977 * extended error information, call GetLastError.
3978 * Status : UNTESTED STUB
3979 *
3980 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3981 *****************************************************************************/
3982
3983BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
3984{
3985 dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
3986 hWinSta));
3987
3988 return (FALSE);
3989}
3990
3991
3992/*****************************************************************************
3993 * Name : HDESK WIN32API CreateDesktopA
3994 * Purpose : The CreateDesktop function creates a new desktop on the window
3995 * station associated with the calling process.
3996 * Parameters: LPCTSTR lpszDesktop name of the new desktop
3997 * LPCTSTR lpszDevice name of display device to assign to the desktop
3998 * LPDEVMODE pDevMode reserved; must be NULL
3999 * DWORD dwFlags flags to control interaction with other applications
4000 * DWORD dwDesiredAccess specifies access of returned handle
4001 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
4002 * Variables :
4003 * Result : If the function succeeds, the return value is a handle of the
4004 * newly created desktop.
4005 * If the function fails, the return value is NULL. To get extended
4006 * error information, call GetLastError.
4007 * Remark :
4008 * Status : UNTESTED STUB
4009 *
4010 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4011 *****************************************************************************/
4012
4013HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
4014 LPCTSTR lpszDevice,
4015 LPDEVMODEA pDevMode,
4016 DWORD dwFlags,
4017 DWORD dwDesiredAccess,
4018 LPSECURITY_ATTRIBUTES lpsa)
4019{
4020 dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4021 lpszDesktop,
4022 lpszDevice,
4023 pDevMode,
4024 dwFlags,
4025 dwDesiredAccess,
4026 lpsa));
4027
4028 return (NULL);
4029}
4030
4031
4032/*****************************************************************************
4033 * Name : HDESK WIN32API CreateDesktopW
4034 * Purpose : The CreateDesktop function creates a new desktop on the window
4035 * station associated with the calling process.
4036 * Parameters: LPCTSTR lpszDesktop name of the new desktop
4037 * LPCTSTR lpszDevice name of display device to assign to the desktop
4038 * LPDEVMODE pDevMode reserved; must be NULL
4039 * DWORD dwFlags flags to control interaction with other applications
4040 * DWORD dwDesiredAccess specifies access of returned handle
4041 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
4042 * Variables :
4043 * Result : If the function succeeds, the return value is a handle of the
4044 * newly created desktop.
4045 * If the function fails, the return value is NULL. To get extended
4046 * error information, call GetLastError.
4047 * Remark :
4048 * Status : UNTESTED STUB
4049 *
4050 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4051 *****************************************************************************/
4052
4053HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
4054 LPCTSTR lpszDevice,
4055 LPDEVMODEW pDevMode,
4056 DWORD dwFlags,
4057 DWORD dwDesiredAccess,
4058 LPSECURITY_ATTRIBUTES lpsa)
4059{
4060 dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
4061 lpszDesktop,
4062 lpszDevice,
4063 pDevMode,
4064 dwFlags,
4065 dwDesiredAccess,
4066 lpsa));
4067
4068 return (NULL);
4069}
4070
4071
4072/*****************************************************************************
4073 * Name : HWINSTA WIN32API CreateWindowStationA
4074 * Purpose : The CreateWindowStation function creates a window station object.
4075 * It returns a handle that can be used to access the window station.
4076 * A window station is a secure object that contains a set of global
4077 * atoms, a clipboard, and a set of desktop objects.
4078 * Parameters: LPTSTR lpwinsta name of the new window station
4079 * DWORD dwReserved reserved; must be NULL
4080 * DWORD dwDesiredAccess specifies access of returned handle
4081 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4082 * Variables :
4083 * Result : If the function succeeds, the return value is the handle to the
4084 * newly created window station.
4085 * If the function fails, the return value is NULL. To get extended
4086 * error information, call GetLastError.
4087 * Remark :
4088 * Status : UNTESTED STUB
4089 *
4090 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4091 *****************************************************************************/
4092
4093HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
4094 DWORD dwReserved,
4095 DWORD dwDesiredAccess,
4096 LPSECURITY_ATTRIBUTES lpsa)
4097{
4098 dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
4099 lpWinSta,
4100 dwReserved,
4101 dwDesiredAccess,
4102 lpsa));
4103
4104 return (NULL);
4105}
4106
4107
4108/*****************************************************************************
4109 * Name : HWINSTA WIN32API CreateWindowStationW
4110 * Purpose : The CreateWindowStation function creates a window station object.
4111 * It returns a handle that can be used to access the window station.
4112 * A window station is a secure object that contains a set of global
4113 * atoms, a clipboard, and a set of desktop objects.
4114 * Parameters: LPTSTR lpwinsta name of the new window station
4115 * DWORD dwReserved reserved; must be NULL
4116 * DWORD dwDesiredAccess specifies access of returned handle
4117 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
4118 * Variables :
4119 * Result : If the function succeeds, the return value is the handle to the
4120 * newly created window station.
4121 * If the function fails, the return value is NULL. To get extended
4122 * error information, call GetLastError.
4123 * Remark :
4124 * Status : UNTESTED STUB
4125 *
4126 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4127 *****************************************************************************/
4128
4129HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
4130 DWORD dwReserved,
4131 DWORD dwDesiredAccess,
4132 LPSECURITY_ATTRIBUTES lpsa)
4133{
4134 dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
4135 lpWinSta,
4136 dwReserved,
4137 dwDesiredAccess,
4138 lpsa));
4139
4140 return (NULL);
4141}
4142
4143/*****************************************************************************
4144 * Name : BOOL WIN32API DragDetect
4145 * Purpose : The DragDetect function captures the mouse and tracks its movement
4146 * Parameters: HWND hwnd
4147 * POINT pt
4148 * Variables :
4149 * Result : If the user moved the mouse outside of the drag rectangle while
4150 * holding the left button down, the return value is TRUE.
4151 * If the user did not move the mouse outside of the drag rectangle
4152 * while holding the left button down, the return value is FALSE.
4153 * Remark :
4154 * Status : UNTESTED STUB
4155 *
4156 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4157 *****************************************************************************/
4158
4159BOOL WIN32API DragDetect(HWND hwnd,
4160 POINT pt)
4161{
4162 dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
4163 hwnd));
4164
4165 return (FALSE);
4166}
4167
4168
4169/*****************************************************************************
4170 * Name : BOOL WIN32API DrawAnimatedRects
4171 * Purpose : The DrawAnimatedRects function draws a wire-frame rectangle
4172 * and animates it to indicate the opening of an icon or the
4173 * minimizing or maximizing of a window.
4174 * Parameters: HWND hwnd handle of clipping window
4175 * int idAni type of animation
4176 * CONST RECT * lprcFrom address of rectangle coordinates (minimized)
4177 * CONST RECT * lprcTo address of rectangle coordinates (restored)
4178 * Variables :
4179 * Result : If the function succeeds, the return value is TRUE.
4180 * If the function fails, the return value is FALSE.
4181 * Remark :
4182 * Status : UNTESTED STUB
4183 *
4184 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4185 *****************************************************************************/
4186
4187BOOL WIN32API DrawAnimatedRects(HWND hwnd,
4188 int idAni,
4189 CONST RECT *lprcFrom,
4190 CONST RECT *lprcTo)
4191{
4192 dprintf(("USER32:DrawAnimatedRects (%08xh,%u,%08xh,%08x) not implemented.\n",
4193 hwnd,
4194 idAni,
4195 lprcFrom,
4196 lprcTo));
4197
4198 return (TRUE);
4199}
4200
4201
4202/*****************************************************************************
4203 * Name : VOID WIN32API DrawCaption
4204 * Purpose : The DrawCaption function draws a window caption.
4205 * Parameters: HDC hdc handle of device context
4206 * LPRECT lprc address of bounding rectangle coordinates
4207 * HFONT hfont handle of font for caption
4208 * HICON hicon handle of icon in caption
4209 * LPSTR lpszText address of caption string
4210 * WORD wFlags drawing options
4211 * Variables :
4212 * Result :
4213 * Remark :
4214 * Status : UNTESTED STUB
4215 *
4216 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4217 *****************************************************************************/
4218
4219BOOL WIN32API DrawCaption (HWND hwnd,
4220 HDC hdc,
4221 const RECT *lprc,
4222 UINT wFlags)
4223{
4224 dprintf(("USER32:DrawCaption (%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4225 hwnd,
4226 hdc,
4227 lprc,
4228 wFlags));
4229
4230 return FALSE;
4231}
4232
4233
4234/*****************************************************************************
4235 * Name :
4236 * Purpose :
4237 * Parameters:
4238 * Variables :
4239 * Result :
4240 * Remark :
4241 * Status : UNTESTED STUB
4242 *
4243 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4244 *****************************************************************************/
4245
4246/*****************************************************************************
4247 * Name : BOOL WIN32API EnumDesktopWindows
4248 * Purpose : The EnumDesktopWindows function enumerates all windows in a
4249 * desktop by passing the handle of each window, in turn, to an
4250 * application-defined callback function.
4251 * Parameters: HDESK hDesktop handle of desktop to enumerate
4252 * WNDENUMPROC lpfn points to application's callback function
4253 * LPARAM lParam 32-bit value to pass to the callback function
4254 * Variables :
4255 * Result : If the function succeeds, the return value is TRUE.
4256 * If the function fails, the return value is FALSE. To get
4257 * extended error information, call GetLastError.
4258 * Remark :
4259 * Status : UNTESTED STUB
4260 *
4261 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4262 *****************************************************************************/
4263
4264BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
4265 WNDENUMPROC lpfn,
4266 LPARAM lParam)
4267{
4268 dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
4269 hDesktop,
4270 lpfn,
4271 lParam));
4272
4273 return (FALSE);
4274}
4275
4276
4277/*****************************************************************************
4278 * Name : BOOL WIN32API EnumDesktopsA
4279 * Purpose : The EnumDesktops function enumerates all desktops in the window
4280 * station assigned to the calling process. The function does so by
4281 * passing the name of each desktop, in turn, to an application-
4282 * defined callback function.
4283 * Parameters: HWINSTA hwinsta handle of window station to enumerate
4284 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
4285 * LPARAM lParam 32-bit value to pass to the callback function
4286 * Variables :
4287 * Result : If the function succeeds, the return value is TRUE.
4288 * If the function fails, the return value is FALSE. To get extended
4289 * error information, call GetLastError.
4290 * Remark :
4291 * Status : UNTESTED STUB
4292 *
4293 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4294 *****************************************************************************/
4295
4296BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
4297 DESKTOPENUMPROCA lpEnumFunc,
4298 LPARAM lParam)
4299{
4300 dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
4301 hWinSta,
4302 lpEnumFunc,
4303 lParam));
4304
4305 return (FALSE);
4306}
4307
4308
4309/*****************************************************************************
4310 * Name : BOOL WIN32API EnumDesktopsW
4311 * Purpose : The EnumDesktops function enumerates all desktops in the window
4312 * station assigned to the calling process. The function does so by
4313 * passing the name of each desktop, in turn, to an application-
4314 * defined callback function.
4315 * Parameters: HWINSTA hwinsta handle of window station to enumerate
4316 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
4317 * LPARAM lParam 32-bit value to pass to the callback function
4318 * Variables :
4319 * Result : If the function succeeds, the return value is TRUE.
4320 * If the function fails, the return value is FALSE. To get extended
4321 * error information, call GetLastError.
4322 * Remark :
4323 * Status : UNTESTED STUB
4324 *
4325 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4326 *****************************************************************************/
4327
4328BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
4329 DESKTOPENUMPROCW lpEnumFunc,
4330 LPARAM lParam)
4331{
4332 dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
4333 hWinSta,
4334 lpEnumFunc,
4335 lParam));
4336
4337 return (FALSE);
4338}
4339
4340
4341
4342/*****************************************************************************
4343 * Name : BOOL WIN32API EnumDisplaySettingsW
4344 * Purpose : The EnumDisplaySettings function obtains information about one
4345 * of a display device's graphics modes. You can obtain information
4346 * for all of a display device's graphics modes by making a series
4347 * of calls to this function.
4348 * Parameters: LPCTSTR lpszDeviceName specifies the display device
4349 * DWORD iModeNum specifies the graphics mode
4350 * LPDEVMODE lpDevMode points to structure to receive settings
4351 * Variables :
4352 * Result : If the function succeeds, the return value is TRUE.
4353 * If the function fails, the return value is FALSE.
4354 * Remark :
4355 * Status : UNTESTED STUB
4356 *
4357 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4358 *****************************************************************************/
4359
4360BOOL WIN32API EnumDisplaySettingsW(LPCSTR lpszDeviceName,
4361 DWORD iModeNum,
4362 LPDEVMODEW lpDevMode)
4363{
4364 dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
4365 lpszDeviceName,
4366 iModeNum,
4367 lpDevMode));
4368
4369 return (EnumDisplaySettingsA(lpszDeviceName,
4370 iModeNum,
4371 (LPDEVMODEA)lpDevMode));
4372}
4373
4374
4375/*****************************************************************************
4376 * Name : BOOL WIN32API EnumWindowStationsA
4377 * Purpose : The EnumWindowStations function enumerates all windowstations
4378 * in the system by passing the name of each window station, in
4379 * turn, to an application-defined callback function.
4380 * Parameters:
4381 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4382 * LPARAM lParam 32-bit value to pass to the callback function
4383 * Result : If the function succeeds, the return value is TRUE.
4384 * If the function fails the return value is FALSE. To get extended
4385 * error information, call GetLastError.
4386 * Remark :
4387 * Status : UNTESTED STUB
4388 *
4389 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4390 *****************************************************************************/
4391
4392BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
4393 LPARAM lParam)
4394{
4395 dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
4396 lpEnumFunc,
4397 lParam));
4398
4399 return (FALSE);
4400}
4401
4402
4403/*****************************************************************************
4404 * Name : BOOL WIN32API EnumWindowStationsW
4405 * Purpose : The EnumWindowStations function enumerates all windowstations
4406 * in the system by passing the name of each window station, in
4407 * turn, to an application-defined callback function.
4408 * Parameters:
4409 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
4410 * LPARAM lParam 32-bit value to pass to the callback function
4411 * Result : If the function succeeds, the return value is TRUE.
4412 * If the function fails the return value is FALSE. To get extended
4413 * error information, call GetLastError.
4414 * Remark :
4415 * Status : UNTESTED STUB
4416 *
4417 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4418 *****************************************************************************/
4419
4420BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
4421 LPARAM lParam)
4422{
4423 dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
4424 lpEnumFunc,
4425 lParam));
4426
4427 return (FALSE);
4428}
4429
4430
4431/*****************************************************************************
4432 * Name : HWND WIN32API FindWindowExW
4433 * Purpose : The FindWindowEx function retrieves the handle of a window whose
4434 * class name and window name match the specified strings. The
4435 * function searches child windows, beginning with the one following
4436 * the given child window.
4437 * Parameters: HWND hwndParent handle of parent window
4438 * HWND hwndChildAfter handle of a child window
4439 * LPCTSTR lpszClass address of class name
4440 * LPCTSTR lpszWindow address of window name
4441 * Variables :
4442 * Result : If the function succeeds, the return value is the handle of the
4443 * window that has the specified class and window names.
4444 * If the function fails, the return value is NULL. To get extended
4445 * error information, call GetLastError.
4446 * Remark :
4447 * Status : UNTESTED STUB
4448 *
4449 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4450 *****************************************************************************/
4451
4452HWND WIN32API FindWindowExW(HWND hwndParent,
4453 HWND hwndChildAfter,
4454 LPCWSTR lpszClass,
4455 LPCWSTR lpszWindow)
4456{
4457 dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
4458 hwndParent,
4459 hwndChildAfter,
4460 lpszClass,
4461 lpszWindow));
4462
4463 return (NULL);
4464}
4465
4466/*****************************************************************************
4467 * Name : BOOL WIN32API GetInputState
4468 * Purpose : The GetInputState function determines whether there are
4469 * mouse-button or keyboard messages in the calling thread's message queue.
4470 * Parameters:
4471 * Variables :
4472 * Result : If the queue contains one or more new mouse-button or keyboard
4473 * messages, the return value is TRUE.
4474 * If the function fails, the return value is FALSE.
4475 * Remark :
4476 * Status : UNTESTED STUB
4477 *
4478 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4479 *****************************************************************************/
4480
4481BOOL WIN32API GetInputState(VOID)
4482{
4483 dprintf(("USER32:GetInputState () not implemented.\n"));
4484
4485 return (FALSE);
4486}
4487
4488
4489/*****************************************************************************
4490 * Name : UINT WIN32API GetKBCodePage
4491 * Purpose : The GetKBCodePage function is provided for compatibility with
4492 * earlier versions of Windows. In the Win32 application programming
4493 * interface (API) it just calls the GetOEMCP function.
4494 * Parameters:
4495 * Variables :
4496 * Result : If the function succeeds, the return value is an OEM code-page
4497 * identifier, or it is the default identifier if the registry
4498 * value is not readable. For a list of OEM code-page identifiers,
4499 * see GetOEMCP.
4500 * Remark :
4501 * Status : UNTESTED
4502 *
4503 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4504 *****************************************************************************/
4505
4506UINT WIN32API GetKBCodePage(VOID)
4507{
4508 return (GetOEMCP());
4509}
4510
4511
4512/*****************************************************************************
4513 * Name : BOOL WIN32API GetKeyboardLayoutNameA
4514 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
4515 * active keyboard layout.
4516 * Parameters: LPTSTR pwszKLID address of buffer for layout name
4517 * Variables :
4518 * Result : If the function succeeds, the return value is TRUE.
4519 * If the function fails, the return value is FALSE. To get extended
4520 * error information, call GetLastError.
4521 * Remark :
4522 * Status : UNTESTED STUB
4523 *
4524 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4525 *****************************************************************************/
4526
4527//@@@PH Win32 BOOLs are casted to INTs.
4528INT WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
4529{
4530 dprintf(("USER32:GetKeyboardLayoutNameA (%08x) not implemented.",
4531 pwszKLID));
4532
4533 return(FALSE);
4534}
4535
4536
4537/*****************************************************************************
4538 * Name : BOOL WIN32API GetKeyboardLayoutNameW
4539 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
4540 * active keyboard layout.
4541 * Parameters: LPTSTR pwszKLID address of buffer for layout name
4542 * Variables :
4543 * Result : If the function succeeds, the return value is TRUE.
4544 * If the function fails, the return value is FALSE. To get extended
4545 * error information, call GetLastError.
4546 * Remark :
4547 * Status : UNTESTED STUB
4548 *
4549 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4550 *****************************************************************************/
4551
4552//@@@PH Win32 BOOLs are casted to INTs.
4553INT WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
4554{
4555 dprintf(("USER32:GetKeyboardLayoutNameW (%08x) not implemented.",
4556 pwszKLID));
4557
4558 return(FALSE);
4559}
4560
4561
4562
4563
4564/*****************************************************************************
4565 * Name : HWINSTA WIN32API GetProcessWindowStation
4566 * Purpose : The GetProcessWindowStation function returns a handle of the
4567 * window station associated with the calling process.
4568 * Parameters:
4569 * Variables :
4570 * Result : If the function succeeds, the return value is a handle of the
4571 * window station associated with the calling process.
4572 * If the function fails, the return value is NULL. This can occur
4573 * if the calling process is not an application written for Windows
4574 * NT. To get extended error information, call GetLastError.
4575 * Remark :
4576 * Status : UNTESTED STUB
4577 *
4578 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4579 *****************************************************************************/
4580
4581HWINSTA WIN32API GetProcessWindowStation(VOID)
4582{
4583 dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
4584
4585 return (NULL);
4586}
4587
4588
4589
4590/*****************************************************************************
4591 * Name : HDESK WIN32API GetThreadDesktop
4592 * Purpose : The GetThreadDesktop function returns a handle to the desktop
4593 * associated with a specified thread.
4594 * Parameters: DWORD dwThreadId thread identifier
4595 * Variables :
4596 * Result : If the function succeeds, the return value is the handle of the
4597 * desktop associated with the specified thread.
4598 * Remark :
4599 * Status : UNTESTED STUB
4600 *
4601 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4602 *****************************************************************************/
4603
4604HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
4605{
4606 dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
4607 dwThreadId));
4608
4609 return (NULL);
4610}
4611
4612
4613/*****************************************************************************
4614 * Name : BOOL WIN32API GetUserObjectInformationA
4615 * Purpose : The GetUserObjectInformation function returns information about
4616 * a window station or desktop object.
4617 * Parameters: HANDLE hObj handle of object to get information for
4618 * int nIndex type of information to get
4619 * PVOID pvInfo points to buffer that receives the information
4620 * DWORD nLength size, in bytes, of pvInfo buffer
4621 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4622 * Variables :
4623 * Result : If the function succeeds, the return value is TRUE.
4624 * If the function fails, the return value is FALSE. To get extended
4625 * error information, call GetLastError.
4626 * Remark :
4627 * Status : UNTESTED STUB
4628 *
4629 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4630 *****************************************************************************/
4631
4632BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
4633 int nIndex,
4634 PVOID pvInfo,
4635 DWORD nLength,
4636 LPDWORD lpnLengthNeeded)
4637{
4638 dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4639 hObj,
4640 nIndex,
4641 pvInfo,
4642 nLength,
4643 lpnLengthNeeded));
4644
4645 return (FALSE);
4646}
4647
4648
4649/*****************************************************************************
4650 * Name : BOOL WIN32API GetUserObjectInformationW
4651 * Purpose : The GetUserObjectInformation function returns information about
4652 * a window station or desktop object.
4653 * Parameters: HANDLE hObj handle of object to get information for
4654 * int nIndex type of information to get
4655 * PVOID pvInfo points to buffer that receives the information
4656 * DWORD nLength size, in bytes, of pvInfo buffer
4657 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
4658 * Variables :
4659 * Result : If the function succeeds, the return value is TRUE.
4660 * If the function fails, the return value is FALSE. To get extended
4661 * error information, call GetLastError.
4662 * Remark :
4663 * Status : UNTESTED STUB
4664 *
4665 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4666 *****************************************************************************/
4667
4668BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
4669 int nIndex,
4670 PVOID pvInfo,
4671 DWORD nLength,
4672 LPDWORD lpnLengthNeeded)
4673{
4674 dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4675 hObj,
4676 nIndex,
4677 pvInfo,
4678 nLength,
4679 lpnLengthNeeded));
4680
4681 return (FALSE);
4682}
4683
4684
4685/*****************************************************************************
4686 * Name : BOOL WIN32API GetUserObjectSecurity
4687 * Purpose : The GetUserObjectSecurity function retrieves security information
4688 * for the specified user object.
4689 * Parameters: HANDLE hObj handle of user object
4690 * SECURITY_INFORMATION * pSIRequested address of requested security information
4691 * LPSECURITY_DESCRIPTOR pSID address of security descriptor
4692 * DWORD nLength size of buffer for security descriptor
4693 * LPDWORD lpnLengthNeeded address of required size of buffer
4694 * Variables :
4695 * Result : If the function succeeds, the return value is TRUE.
4696 * If the function fails, the return value is FALSE. To get extended
4697 * error information, call GetLastError.
4698 * Remark :
4699 * Status : UNTESTED STUB
4700 *
4701 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4702 *****************************************************************************/
4703
4704BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
4705 SECURITY_INFORMATION * pSIRequested,
4706 LPSECURITY_DESCRIPTOR pSID,
4707 DWORD nLength,
4708 LPDWORD lpnLengthNeeded)
4709{
4710 dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
4711 hObj,
4712 pSIRequested,
4713 pSID,
4714 nLength,
4715 lpnLengthNeeded));
4716
4717 return (FALSE);
4718}
4719
4720
4721
4722/*****************************************************************************
4723 * Name : int WIN32API GetWindowRgn
4724 * Purpose : The GetWindowRgn function obtains a copy of the window region of a window.
4725 * Parameters: HWND hWnd handle to window whose window region is to be obtained
4726 * HRGN hRgn handle to region that receives a copy of the window region
4727 * Variables :
4728 * Result : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
4729 * Remark :
4730 * Status : UNTESTED STUB
4731 *
4732 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4733 *****************************************************************************/
4734
4735int WIN32API GetWindowRgn (HWND hWnd,
4736 HRGN hRgn)
4737{
4738 dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
4739 hWnd,
4740 hRgn));
4741
4742 return (NULLREGION);
4743}
4744
4745
4746
4747/*****************************************************************************
4748 * Name : HCURSOR WIN32API LoadCursorFromFileA
4749 * Purpose : The LoadCursorFromFile function creates a cursor based on data
4750 * contained in a file. The file is specified by its name or by a
4751 * system cursor identifier. The function returns a handle to the
4752 * newly created cursor. Files containing cursor data may be in
4753 * either cursor (.CUR) or animated cursor (.ANI) format.
4754 * Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4755 * Variables :
4756 * Result : If the function is successful, the return value is a handle to
4757 * the new cursor.
4758 * If the function fails, the return value is NULL. To get extended
4759 * error information, call GetLastError. GetLastError may return
4760 * the following
4761 * Remark :
4762 * Status : UNTESTED STUB
4763 *
4764 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4765 *****************************************************************************/
4766
4767HCURSOR WIN32API LoadCursorFromFileA(LPCTSTR lpFileName)
4768{
4769 dprintf(("USER32:LoadCursorFromFileA (%s) not implemented.\n",
4770 lpFileName));
4771
4772 return (NULL);
4773}
4774
4775
4776/*****************************************************************************
4777 * Name : HCURSOR WIN32API LoadCursorFromFileW
4778 * Purpose : The LoadCursorFromFile function creates a cursor based on data
4779 * contained in a file. The file is specified by its name or by a
4780 * system cursor identifier. The function returns a handle to the
4781 * newly created cursor. Files containing cursor data may be in
4782 * either cursor (.CUR) or animated cursor (.ANI) format.
4783 * Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
4784 * Variables :
4785 * Result : If the function is successful, the return value is a handle to
4786 * the new cursor.
4787 * If the function fails, the return value is NULL. To get extended
4788 * error information, call GetLastError. GetLastError may return
4789 * the following
4790 * Remark :
4791 * Status : UNTESTED STUB
4792 *
4793 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4794 *****************************************************************************/
4795
4796HCURSOR WIN32API LoadCursorFromFileW(LPCWSTR lpFileName)
4797{
4798 dprintf(("USER32:LoadCursorFromFileW (%s) not implemented.\n",
4799 lpFileName));
4800
4801 return (NULL);
4802}
4803
4804
4805/*****************************************************************************
4806 * Name : HLK WIN32API LoadKeyboardLayoutA
4807 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
4808 * the system. Several keyboard layouts can be loaded at a time, but
4809 * only one per process is active at a time. Loading multiple keyboard
4810 * layouts makes it possible to rapidly switch between layouts.
4811 * Parameters:
4812 * Variables :
4813 * Result : If the function succeeds, the return value is the handle of the
4814 * keyboard layout.
4815 * If the function fails, the return value is NULL. To get extended
4816 * error information, call GetLastError.
4817 * Remark :
4818 * Status : UNTESTED STUB
4819 *
4820 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4821 *****************************************************************************/
4822
4823HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
4824 UINT Flags)
4825{
4826 dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
4827 pwszKLID,
4828 Flags));
4829
4830 return (NULL);
4831}
4832
4833
4834/*****************************************************************************
4835 * Name : HLK WIN32API LoadKeyboardLayoutW
4836 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
4837 * the system. Several keyboard layouts can be loaded at a time, but
4838 * only one per process is active at a time. Loading multiple keyboard
4839 * layouts makes it possible to rapidly switch between layouts.
4840 * Parameters:
4841 * Variables :
4842 * Result : If the function succeeds, the return value is the handle of the
4843 * keyboard layout.
4844 * If the function fails, the return value is NULL. To get extended
4845 * error information, call GetLastError.
4846 * Remark :
4847 * Status : UNTESTED STUB
4848 *
4849 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4850 *****************************************************************************/
4851
4852HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
4853 UINT Flags)
4854{
4855 dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
4856 pwszKLID,
4857 Flags));
4858
4859 return (NULL);
4860}
4861
4862
4863/*****************************************************************************
4864 * Name : UINT WIN32API MapVirtualKeyExA
4865 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
4866 * code into a scan code or character value, or translates a scan
4867 * code into a virtual-key code. The function translates the codes
4868 * using the input language and physical keyboard layout identified
4869 * by the given keyboard layout handle.
4870 * Parameters:
4871 * Variables :
4872 * Result : The return value is either a scan code, a virtual-key code, or
4873 * a character value, depending on the value of uCode and uMapType.
4874 * If there is no translation, the return value is zero.
4875 * Remark :
4876 * Status : UNTESTED STUB
4877 *
4878 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4879 *****************************************************************************/
4880
4881UINT WIN32API MapVirtualKeyExA(UINT uCode,
4882 UINT uMapType,
4883 HKL dwhkl)
4884{
4885 dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
4886 uCode,
4887 uMapType,
4888 dwhkl));
4889
4890 return (0);
4891}
4892
4893
4894/*****************************************************************************
4895 * Name : UINT WIN32API MapVirtualKeyExW
4896 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
4897 * code into a scan code or character value, or translates a scan
4898 * code into a virtual-key code. The function translates the codes
4899 * using the input language and physical keyboard layout identified
4900 * by the given keyboard layout handle.
4901 * Parameters:
4902 * Variables :
4903 * Result : The return value is either a scan code, a virtual-key code, or
4904 * a character value, depending on the value of uCode and uMapType.
4905 * If there is no translation, the return value is zero.
4906 * Remark :
4907 * Status : UNTESTED STUB
4908
4909 *
4910 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4911 *****************************************************************************/
4912
4913UINT WIN32API MapVirtualKeyExW(UINT uCode,
4914 UINT uMapType,
4915 HKL dwhkl)
4916{
4917 dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
4918 uCode,
4919 uMapType,
4920 dwhkl));
4921
4922 return (0);
4923}
4924
4925
4926/*****************************************************************************
4927 * Name : int WIN32API MessageBoxExA
4928 * Purpose : The MessageBoxEx function creates, displays, and operates a message box.
4929 * Parameters: HWND hWnd handle of owner window
4930 * LPCTSTR lpText address of text in message box
4931 * LPCTSTR lpCaption address of title of message box
4932 * UINT uType style of message box
4933 * WORD wLanguageId language identifier
4934 * Variables :
4935 * Result : If the function succeeds, the return value is a nonzero menu-item
4936 * value returned by the dialog box.
4937 * Remark :
4938 * Status : UNTESTED STUB
4939 *
4940 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4941 *****************************************************************************/
4942
4943int WIN32API MessageBoxExA(HWND hWnd,
4944 LPCTSTR lpText,
4945 LPCTSTR lpCaption,
4946 UINT uType,
4947 WORD wLanguageId)
4948{
4949 dprintf(("USER32:MessageBoxExA (%08xh,%s,%s,%u,%08w) not implemented.\n",
4950 hWnd,
4951 lpText,
4952 lpCaption,
4953 uType,
4954 wLanguageId));
4955
4956 return (MessageBoxA(hWnd,
4957 lpText,
4958 lpCaption,
4959 uType));
4960}
4961
4962
4963/*****************************************************************************
4964 * Name : int WIN32API MessageBoxExW
4965 * Purpose : The MessageBoxEx function creates, displays, and operates a message box.
4966 * Parameters: HWND hWnd handle of owner window
4967 * LPCTSTR lpText address of text in message box
4968 * LPCTSTR lpCaption address of title of message box
4969 * UINT uType style of message box
4970 * WORD wLanguageId language identifier
4971 * Variables :
4972 * Result : If the function succeeds, the return value is a nonzero menu-item
4973 * value returned by the dialog box.
4974 * Remark :
4975 * Status : UNTESTED STUB
4976 *
4977 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
4978 *****************************************************************************/
4979
4980int WIN32API MessageBoxExW(HWND hWnd,
4981 LPCWSTR lpText,
4982 LPCWSTR lpCaption,
4983 UINT uType,
4984 WORD wLanguageId)
4985{
4986
4987 dprintf(("USER32:MessageBoxExW (%08xh,%x,%x,%u,%08w) not implemented.\n",
4988 hWnd,
4989 lpText,
4990 lpCaption,
4991 uType,
4992 wLanguageId));
4993
4994 return MessageBoxW(hWnd, lpText, lpCaption, uType);
4995}
4996
4997
4998/*****************************************************************************
4999 * Name : BOOL WIN32API MessageBoxIndirectW
5000 * Purpose : The MessageBoxIndirect function creates, displays, and operates
5001 * a message box. The message box contains application-defined
5002 * message text and title, any icon, and any combination of
5003 * predefined push buttons.
5004 * Parameters:
5005 * Variables :
5006 * Result :
5007 * Remark :
5008 * Status : UNTESTED STUB
5009 *
5010 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5011 *****************************************************************************/
5012
5013//@@@PH Win32 BOOLs are casted to INTs.
5014INT WIN32API MessageBoxIndirectW(LPMSGBOXPARAMSW lpMsgBoxParams)
5015{
5016 dprintf(("USER32:MessageBoxIndirectW (%08x) not implemented.\n",
5017 lpMsgBoxParams));
5018
5019 return (FALSE);
5020}
5021
5022
5023/*****************************************************************************
5024 * Name : BOOL WIN32API MessageBoxIndirectA
5025 * Purpose : The MessageBoxIndirect function creates, displays, and operates
5026 * a message box. The message box contains application-defined
5027 * message text and title, any icon, and any combination of
5028 * predefined push buttons.
5029 * Parameters:
5030 * Variables :
5031 * Result :
5032 * Remark :
5033 * Status : UNTESTED STUB
5034 *
5035 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5036 *****************************************************************************/
5037
5038//@@@PH Win32 BOOLs are casted to INTs.
5039INT WIN32API MessageBoxIndirectA(LPMSGBOXPARAMSA lpMsgBoxParams)
5040{
5041 dprintf(("USER32:MessageBoxIndirectA (%08x) not implemented.\n",
5042 lpMsgBoxParams));
5043
5044 return (FALSE);
5045}
5046
5047
5048/*****************************************************************************
5049 * Name : DWORD WIN32API OemKeyScan
5050 * Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
5051 * into the OEM scan codes and shift states. The function provides
5052 * information that allows a program to send OEM text to another
5053 * program by simulating keyboard input.
5054 * Parameters:
5055 * Variables :
5056 * Result :
5057 * Remark :
5058 * Status : UNTESTED STUB
5059 *
5060 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5061 *****************************************************************************/
5062
5063DWORD WIN32API OemKeyScan(WORD wOemChar)
5064{
5065 dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
5066 wOemChar));
5067
5068 return (wOemChar);
5069}
5070
5071
5072/*****************************************************************************
5073 * Name : HDESK WIN32API OpenDesktopA
5074 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
5075 * A desktop is a secure object contained within a window station
5076 * object. A desktop has a logical display surface and contains
5077 * windows, menus and hooks.
5078 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5079 * DWORD dwFlags flags to control interaction with other applications
5080 * BOOL fInherit specifies whether returned handle is inheritable
5081 * DWORD dwDesiredAccess specifies access of returned handle
5082 * Variables :
5083 * Result : If the function succeeds, the return value is the handle to the
5084 * opened desktop.
5085 * If the function fails, the return value is NULL. To get extended
5086 * error information, call GetLastError.
5087 * Remark :
5088 * Status : UNTESTED STUB
5089 *
5090 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5091 *****************************************************************************/
5092
5093HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
5094 DWORD dwFlags,
5095 BOOL fInherit,
5096 DWORD dwDesiredAccess)
5097{
5098 dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
5099 lpszDesktopName,
5100 dwFlags,
5101 fInherit,
5102 dwDesiredAccess));
5103
5104 return (NULL);
5105}
5106
5107
5108/*****************************************************************************
5109 * Name : HDESK WIN32API OpenDesktopW
5110 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
5111 * A desktop is a secure object contained within a window station
5112 * object. A desktop has a logical display surface and contains
5113 * windows, menus and hooks.
5114 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
5115 * DWORD dwFlags flags to control interaction with other applications
5116 * BOOL fInherit specifies whether returned handle is inheritable
5117 * DWORD dwDesiredAccess specifies access of returned handle
5118 * Variables :
5119 * Result : If the function succeeds, the return value is the handle to the
5120 * opened desktop.
5121 * If the function fails, the return value is NULL. To get extended
5122 * error information, call GetLastError.
5123 * Remark :
5124 * Status : UNTESTED STUB
5125 *
5126 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5127 *****************************************************************************/
5128
5129HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
5130 DWORD dwFlags,
5131 BOOL fInherit,
5132 DWORD dwDesiredAccess)
5133{
5134 dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
5135 lpszDesktopName,
5136 dwFlags,
5137 fInherit,
5138 dwDesiredAccess));
5139
5140 return (NULL);
5141}
5142
5143
5144/*****************************************************************************
5145 * Name : HDESK WIN32API OpenInputDesktop
5146 * Purpose : The OpenInputDesktop function returns a handle to the desktop
5147 * that receives user input. The input desktop is a desktop on the
5148 * window station associated with the logged-on user.
5149 * Parameters: DWORD dwFlags flags to control interaction with other applications
5150 * BOOL fInherit specifies whether returned handle is inheritable
5151 * DWORD dwDesiredAccess specifies access of returned handle
5152 * Variables :
5153 * Result : If the function succeeds, the return value is a handle of the
5154 * desktop that receives user input.
5155 * If the function fails, the return value is NULL. To get extended
5156 * error information, call GetLastError.
5157 * Remark :
5158 * Status : UNTESTED STUB
5159 *
5160 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5161 *****************************************************************************/
5162
5163HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
5164 BOOL fInherit,
5165 DWORD dwDesiredAccess)
5166{
5167 dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
5168 dwFlags,
5169 fInherit,
5170 dwDesiredAccess));
5171
5172 return (NULL);
5173}
5174
5175
5176/*****************************************************************************
5177 * Name : HWINSTA WIN32API OpenWindowStationA
5178 * Purpose : The OpenWindowStation function returns a handle to an existing
5179 * window station.
5180 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
5181 * BOOL fInherit specifies whether returned handle is inheritable
5182 * DWORD dwDesiredAccess specifies access of returned handle
5183 * Variables :
5184 * Result : If the function succeeds, the return value is the handle to the
5185 * specified window station.
5186 * If the function fails, the return value is NULL. To get extended
5187 * error information, call GetLastError.
5188 * Remark :
5189 * Status : UNTESTED STUB
5190 *
5191 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5192 *****************************************************************************/
5193
5194HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
5195 BOOL fInherit,
5196 DWORD dwDesiredAccess)
5197{
5198 dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
5199 lpszWinStaName,
5200 fInherit,
5201 dwDesiredAccess));
5202
5203 return (NULL);
5204}
5205
5206
5207/*****************************************************************************
5208 * Name : HWINSTA WIN32API OpenWindowStationW
5209 * Purpose : The OpenWindowStation function returns a handle to an existing
5210 * window station.
5211 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
5212 * BOOL fInherit specifies whether returned handle is inheritable
5213 * DWORD dwDesiredAccess specifies access of returned handle
5214 * Variables :
5215 * Result : If the function succeeds, the return value is the handle to the
5216 * specified window station.
5217 * If the function fails, the return value is NULL. To get extended
5218 * error information, call GetLastError.
5219
5220
5221 * Remark :
5222 * Status : UNTESTED STUB
5223 *
5224 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5225 *****************************************************************************/
5226
5227HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
5228 BOOL fInherit,
5229 DWORD dwDesiredAccess)
5230{
5231 dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
5232 lpszWinStaName,
5233 fInherit,
5234 dwDesiredAccess));
5235
5236 return (NULL);
5237}
5238
5239
5240/*****************************************************************************
5241 * Name : BOOL WIN32API PaintDesktop
5242 * Purpose : The PaintDesktop function fills the clipping region in the
5243 * specified device context with the desktop pattern or wallpaper.
5244 * The function is provided primarily for shell desktops.
5245 * Parameters:
5246 * Variables :
5247 * Result : If the function succeeds, the return value is TRUE.
5248 * If the function fails, the return value is FALSE.
5249 * Remark :
5250 * Status : UNTESTED STUB
5251 *
5252 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5253 *****************************************************************************/
5254
5255BOOL WIN32API PaintDesktop(HDC hdc)
5256{
5257 dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
5258 hdc));
5259
5260 return (FALSE);
5261}
5262
5263
5264/*****************************************************************************
5265 * Name : BOOL WIN32API SendMessageCallbackA
5266 * Purpose : The SendMessageCallback function sends the specified message to
5267 * a window or windows. The function calls the window procedure for
5268 * the specified window and returns immediately. After the window
5269 * procedure processes the message, the system calls the specified
5270 * callback function, passing the result of the message processing
5271 * and an application-defined value to the callback function.
5272 * Parameters: HWND hwnd handle of destination window
5273 * UINT uMsg message to send
5274 * WPARAM wParam first message parameter
5275 * LPARAM lParam second message parameter
5276 * SENDASYNCPROC lpResultCallBack function to receive message value
5277 * DWORD dwData value to pass to callback function
5278 * Variables :
5279 * Result : If the function succeeds, the return value is TRUE.
5280 * If the function fails, the return value is FALSE. To get extended
5281 * error information, call GetLastError.
5282 * Remark :
5283 * Status : UNTESTED STUB
5284 *
5285 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5286 *****************************************************************************/
5287
5288BOOL WIN32API SendMessageCallbackA(HWND hWnd,
5289 UINT uMsg,
5290 WPARAM wParam,
5291 LPARAM lParam,
5292 SENDASYNCPROC lpResultCallBack,
5293 DWORD dwData)
5294{
5295 dprintf(("USER32:SendMessageCallBackA (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5296 hWnd,
5297 uMsg,
5298 wParam,
5299 lParam,
5300 lpResultCallBack,
5301 dwData));
5302
5303 return (FALSE);
5304}
5305
5306
5307/*****************************************************************************
5308 * Name : BOOL WIN32API SendMessageCallbackW
5309 * Purpose : The SendMessageCallback function sends the specified message to
5310 * a window or windows. The function calls the window procedure for
5311 * the specified window and returns immediately. After the window
5312 * procedure processes the message, the system calls the specified
5313 * callback function, passing the result of the message processing
5314 * and an application-defined value to the callback function.
5315 * Parameters: HWND hwnd handle of destination window
5316 * UINT uMsg message to send
5317 * WPARAM wParam first message parameter
5318 * LPARAM lParam second message parameter
5319 * SENDASYNCPROC lpResultCallBack function to receive message value
5320 * DWORD dwData value to pass to callback function
5321 * Variables :
5322 * Result : If the function succeeds, the return value is TRUE.
5323 * If the function fails, the return value is FALSE. To get extended
5324 * error information, call GetLastError.
5325 * Remark :
5326 * Status : UNTESTED STUB
5327 *
5328 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5329 *****************************************************************************/
5330
5331BOOL WIN32API SendMessageCallbackW(HWND hWnd,
5332 UINT uMsg,
5333 WPARAM wParam,
5334 LPARAM lParam,
5335 SENDASYNCPROC lpResultCallBack,
5336 DWORD dwData)
5337{
5338 dprintf(("USER32:SendMessageCallBackW (%08xh,%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5339 hWnd,
5340 uMsg,
5341 wParam,
5342 lParam,
5343 lpResultCallBack,
5344 dwData));
5345
5346 return (FALSE);
5347}
5348
5349
5350/*****************************************************************************
5351 * Name : VOID WIN32API SetDebugErrorLevel
5352 * Purpose : The SetDebugErrorLevel function sets the minimum error level at
5353 * which Windows will generate debugging events and pass them to a debugger.
5354 * Parameters: DWORD dwLevel debugging error level
5355 * Variables :
5356 * Result :
5357 * Remark :
5358 * Status : UNTESTED STUB
5359 *
5360 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5361 *****************************************************************************/
5362
5363VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
5364{
5365 dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
5366 dwLevel));
5367}
5368
5369
5370/*****************************************************************************
5371 * Name : BOOL WIN32API SetProcessWindowStation
5372 * Purpose : The SetProcessWindowStation function assigns a window station
5373 * to the calling process. This enables the process to access
5374 * objects in the window station such as desktops, the clipboard,
5375 * and global atoms. All subsequent operations on the window station
5376 * use the access rights granted to hWinSta.
5377 * Parameters:
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 SetProcessWindowStation(HWINSTA hWinSta)
5389{
5390 dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
5391 hWinSta));
5392
5393 return (FALSE);
5394}
5395
5396
5397/*****************************************************************************
5398 * Name : BOOL WIN32API SetSystemCursor
5399 * Purpose : The SetSystemCursor function replaces the contents of the system
5400 * cursor specified by dwCursorId with the contents of the cursor
5401 * specified by hCursor, and then destroys hCursor. This function
5402 * lets an application customize the system cursors.
5403 * Parameters: HCURSOR hCursor set specified system cursor to this cursor's
5404 * contents, then destroy this
5405 * DWORD dwCursorID system cursor specified by its identifier
5406 * Variables :
5407 * Result : If the function succeeds, the return value is TRUE.
5408 * If the function fails, the return value is FALSE. To get extended
5409 * error information, call GetLastError.
5410 * Remark :
5411 * Status : UNTESTED STUB
5412 *
5413 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5414 *****************************************************************************/
5415
5416BOOL WIN32API SetSystemCursor(HCURSOR hCursor,
5417 DWORD dwCursorId)
5418{
5419 dprintf(("USER32:SetSystemCursor (%08xh,%08x) not implemented.\n",
5420 hCursor,
5421 dwCursorId));
5422
5423 return (FALSE);
5424}
5425
5426
5427/*****************************************************************************
5428 * Name : BOOL WIN32API SetThreadDesktop
5429 * Purpose : The SetThreadDesktop function assigns a desktop to the calling
5430 * thread. All subsequent operations on the desktop use the access
5431 * rights granted to hDesk.
5432 * Parameters: HDESK hDesk handle of the desktop to assign to this thread
5433 * Variables :
5434 * Result : If the function succeeds, the return value is TRUE.
5435 * If the function fails, the return value is FALSE. To get extended
5436 * error information, call GetLastError.
5437 * Remark :
5438 * Status : UNTESTED STUB
5439 *
5440 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5441 *****************************************************************************/
5442
5443BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
5444{
5445 dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
5446 hDesktop));
5447
5448 return (FALSE);
5449}
5450
5451
5452/*****************************************************************************
5453 * Name : BOOL WIN32API SetUserObjectInformationA
5454 * Purpose : The SetUserObjectInformation function sets information about a
5455 * window station or desktop object.
5456 * Parameters: HANDLE hObject handle of the object for which to set information
5457 * int nIndex type of information to set
5458 * PVOID lpvInfo points to a buffer that contains the information
5459 * DWORD cbInfo size, in bytes, of lpvInfo buffer
5460 * Variables :
5461 * Result : If the function succeeds, the return value is TRUE.
5462 * If the function fails the return value is FALSE. To get extended
5463 * error information, call GetLastError.
5464 * Remark :
5465 * Status : UNTESTED STUB
5466 *
5467 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5468 *****************************************************************************/
5469
5470BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
5471 int nIndex,
5472 PVOID lpvInfo,
5473 DWORD cbInfo)
5474{
5475 dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
5476 hObject,
5477 nIndex,
5478 lpvInfo,
5479 cbInfo));
5480
5481 return (FALSE);
5482}
5483
5484
5485/*****************************************************************************
5486 * Name : BOOL WIN32API SetUserObjectInformationW
5487 * Purpose : The SetUserObjectInformation function sets information about a
5488 * window station or desktop object.
5489 * Parameters: HANDLE hObject handle of the object for which to set information
5490 * int nIndex type of information to set
5491 * PVOID lpvInfo points to a buffer that contains the information
5492 * DWORD cbInfo size, in bytes, of lpvInfo buffer
5493 * Variables :
5494 * Result : If the function succeeds, the return value is TRUE.
5495 * If the function fails the return value is FALSE. To get extended
5496 * error information, call GetLastError.
5497 * Remark :
5498 * Status : UNTESTED STUB
5499 *
5500 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5501 *****************************************************************************/
5502
5503BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
5504 int nIndex,
5505 PVOID lpvInfo,
5506 DWORD cbInfo)
5507{
5508 dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
5509 hObject,
5510 nIndex,
5511 lpvInfo,
5512 cbInfo));
5513
5514 return (FALSE);
5515}
5516
5517
5518/*****************************************************************************
5519 * Name : BOOL WIN32API SetUserObjectSecurity
5520 * Purpose : The SetUserObjectSecurity function sets the security of a user
5521 * object. This can be, for example, a window or a DDE conversation
5522 * Parameters: HANDLE hObject handle of user object
5523 * SECURITY_INFORMATION * psi address of security information
5524 * LPSECURITY_DESCRIPTOR psd address of security descriptor
5525 * Variables :
5526 * Result : If the function succeeds, the return value is TRUE.
5527 * If the function fails, the return value is FALSE. To get extended
5528 * error information, call GetLastError.
5529 * Remark :
5530 * Status : UNTESTED STUB
5531 *
5532 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5533 *****************************************************************************/
5534
5535BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
5536 SECURITY_INFORMATION * psi,
5537 LPSECURITY_DESCRIPTOR psd)
5538{
5539 dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
5540 hObject,
5541 psi,
5542 psd));
5543
5544 return (FALSE);
5545}
5546
5547
5548/*****************************************************************************
5549 * Name : int WIN32API SetWindowRgn
5550 * Purpose : The SetWindowRgn function sets the window region of a window. The
5551 * window region determines the area within the window where the
5552 * operating system permits drawing. The operating system does not
5553 * display any portion of a window that lies outside of the window region
5554 * Parameters: HWND hWnd handle to window whose window region is to be set
5555 * HRGN hRgn handle to region
5556 * BOOL bRedraw window redraw flag
5557 * Variables :
5558 * Result : If the function succeeds, the return value is non-zero.
5559 * If the function fails, the return value is zero.
5560 * Remark :
5561 * Status : UNTESTED STUB
5562 *
5563 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5564 *****************************************************************************/
5565
5566int WIN32API SetWindowRgn(HWND hWnd,
5567 HRGN hRgn,
5568 BOOL bRedraw)
5569{
5570 dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
5571 hWnd,
5572 hRgn,
5573 bRedraw));
5574
5575 return (0);
5576}
5577
5578
5579/*****************************************************************************
5580 * Name : BOOL WIN32API SetWindowsHookW
5581 * Purpose : The SetWindowsHook function is not implemented in the Win32 API.
5582 * Win32-based applications should use the SetWindowsHookEx function.
5583 * Parameters:
5584 * Variables :
5585 * Result :
5586 * Remark : ARGH ! MICROSOFT !
5587 * Status : UNTESTED STUB
5588 *
5589 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5590 *****************************************************************************/
5591
5592HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
5593
5594{
5595 return (FALSE);
5596}
5597
5598
5599/*****************************************************************************
5600 * Name : BOOL WIN32API ShowWindowAsync
5601 * Purpose : The ShowWindowAsync function sets the show state of a window
5602 * created by a different thread.
5603 * Parameters: HWND hwnd handle of window
5604 * int nCmdShow show state of window
5605 * Variables :
5606 * Result : If the window was previously visible, the return value is TRUE.
5607 * If the window was previously hidden, the return value is FALSE.
5608 * Remark :
5609 * Status : UNTESTED STUB
5610 *
5611 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5612 *****************************************************************************/
5613
5614BOOL WIN32API ShowWindowAsync (HWND hWnd,
5615 int nCmdShow)
5616{
5617 dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
5618 hWnd,
5619 nCmdShow));
5620
5621 return (FALSE);
5622}
5623
5624
5625/*****************************************************************************
5626 * Name : BOOL WIN32API SwitchDesktop
5627 * Purpose : The SwitchDesktop function makes a desktop visible and activates
5628 * it. This enables the desktop to receive input from the user. The
5629 * calling process must have DESKTOP_SWITCHDESKTOP access to the
5630 * desktop for the SwitchDesktop function to succeed.
5631 * Parameters:
5632 * Variables :
5633 * Result : If the function succeeds, the return value is TRUE.
5634 * If the function fails, the return value is FALSE. To get extended
5635 * error information, call GetLastError.
5636 * Remark :
5637 * Status : UNTESTED STUB
5638 *
5639 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5640 *****************************************************************************/
5641
5642BOOL WIN32API SwitchDesktop(HDESK hDesktop)
5643{
5644 dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
5645 hDesktop));
5646
5647 return (FALSE);
5648}
5649
5650
5651/*****************************************************************************
5652 * Name : WORD WIN32API TileWindows
5653 * Purpose : The TileWindows function tiles the specified windows, or the child
5654 * windows of the specified parent window.
5655 * Parameters: HWND hwndParent handle of parent window
5656 * WORD wFlags types of windows not to arrange
5657 * LPCRECT lpRect rectangle to arrange windows in
5658 * WORD cChildrenb number of windows to arrange
5659 * const HWND *ahwndChildren array of window handles
5660 * Variables :
5661 * Result : If the function succeeds, the return value is the number of
5662 * windows arranged.
5663 * If the function fails, the return value is zero.
5664 * Remark :
5665 * Status : UNTESTED STUB
5666 *
5667 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5668 *****************************************************************************/
5669
5670WORD WIN32API TileWindows(HWND hwndParent,
5671 UINT wFlags,
5672 const LPRECT lpRect,
5673 UINT cChildrenb,
5674 const HWND *ahwndChildren)
5675{
5676 dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
5677 hwndParent,
5678 wFlags,
5679 lpRect,
5680 cChildrenb,
5681 ahwndChildren));
5682
5683 return (0);
5684}
5685
5686
5687/*****************************************************************************
5688 * Name : int WIN32API ToAscii
5689 * Purpose : The ToAscii function translates the specified virtual-key code
5690 * and keyboard state to the corresponding Windows character or characters.
5691 * Parameters: UINT uVirtKey virtual-key code
5692 * UINT uScanCode scan code
5693 * PBYTE lpbKeyState address of key-state array
5694 * LPWORD lpwTransKey buffer for translated key
5695 * UINT fuState active-menu flag
5696 * Variables :
5697 * Result : 0 The specified virtual key has no translation for the current
5698 * state of the keyboard.
5699 * 1 One Windows character was copied to the buffer.
5700 * 2 Two characters were copied to the buffer. This usually happens
5701 * when a dead-key character (accent or diacritic) stored in the
5702 * keyboard layout cannot be composed with the specified virtual
5703 * key to form a single character.
5704 * Remark :
5705 * Status : UNTESTED STUB
5706 *
5707 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5708 *****************************************************************************/
5709
5710int WIN32API ToAscii(UINT uVirtKey,
5711 UINT uScanCode,
5712 PBYTE lpbKeyState,
5713 LPWORD lpwTransKey,
5714 UINT fuState)
5715{
5716 dprintf(("USER32:ToAscii (%u,%u,%08xh,%08xh,%u) not implemented.\n",
5717 uVirtKey,
5718 uScanCode,
5719 lpbKeyState,
5720 lpwTransKey,
5721 fuState));
5722
5723 return (0);
5724}
5725
5726
5727/*****************************************************************************
5728 * Name : int WIN32API ToAsciiEx
5729 * Purpose : The ToAscii function translates the specified virtual-key code
5730 * and keyboard state to the corresponding Windows character or characters.
5731 * Parameters: UINT uVirtKey virtual-key code
5732 * UINT uScanCode scan code
5733 * PBYTE lpbKeyState address of key-state array
5734 * LPWORD lpwTransKey buffer for translated key
5735 * UINT fuState active-menu flag
5736 * HLK hlk keyboard layout handle
5737 * Variables :
5738 * Result : 0 The specified virtual key has no translation for the current
5739 * state of the keyboard.
5740 * 1 One Windows character was copied to the buffer.
5741 * 2 Two characters were copied to the buffer. This usually happens
5742 * when a dead-key character (accent or diacritic) stored in the
5743 * keyboard layout cannot be composed with the specified virtual
5744 * key to form a single character.
5745 * Remark :
5746 * Status : UNTESTED STUB
5747 *
5748 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5749 *****************************************************************************/
5750
5751int WIN32API ToAsciiEx(UINT uVirtKey,
5752 UINT uScanCode,
5753 PBYTE lpbKeyState,
5754 LPWORD lpwTransKey,
5755 UINT fuState,
5756 HKL hkl)
5757{
5758 dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5759 uVirtKey,
5760 uScanCode,
5761 lpbKeyState,
5762 lpwTransKey,
5763 fuState,
5764 hkl));
5765
5766 return (0);
5767}
5768
5769
5770/*****************************************************************************
5771 * Name : int WIN32API ToUnicode
5772 * Purpose : The ToUnicode function translates the specified virtual-key code
5773 * and keyboard state to the corresponding Unicode character or characters.
5774 * Parameters: UINT wVirtKey virtual-key code
5775 * UINT wScanCode scan code
5776 * PBYTE lpKeyState address of key-state array
5777 * LPWSTR pwszBuff buffer for translated key
5778 * int cchBuff size of translated key buffer
5779 * UINT wFlags set of function-conditioning flags
5780 * Variables :
5781 * Result : - 1 The specified virtual key is a dead-key character (accent or
5782 * diacritic). This value is returned regardless of the keyboard
5783 * layout, even if several characters have been typed and are
5784 * stored in the keyboard state. If possible, even with Unicode
5785 * keyboard layouts, the function has written a spacing version of
5786 * the dead-key character to the buffer specified by pwszBuffer.
5787 * For example, the function writes the character SPACING ACUTE
5788 * (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
5789 * 0 The specified virtual key has no translation for the current
5790 * state of the keyboard. Nothing was written to the buffer
5791 * specified by pwszBuffer.
5792 * 1 One character was written to the buffer specified by pwszBuffer.
5793 * 2 or more Two or more characters were written to the buffer specified by
5794 * pwszBuff. The most common cause for this is that a dead-key
5795 * character (accent or diacritic) stored in the keyboard layout
5796 * could not be combined with the specified virtual key to form a
5797 * single character.
5798 * Remark :
5799 * Status : UNTESTED STUB
5800 *
5801 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5802 *****************************************************************************/
5803
5804int WIN32API ToUnicode(UINT uVirtKey,
5805 UINT uScanCode,
5806 PBYTE lpKeyState,
5807 LPWSTR pwszBuff,
5808 int cchBuff,
5809 UINT wFlags)
5810{
5811 dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
5812 uVirtKey,
5813 uScanCode,
5814 lpKeyState,
5815 pwszBuff,
5816 cchBuff,
5817 wFlags));
5818
5819 return (0);
5820}
5821
5822
5823/*****************************************************************************
5824 * Name : BOOL WIN32API UnloadKeyboardLayout
5825 * Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
5826 * Parameters: HKL hkl handle of keyboard layout
5827 * Variables :
5828 * Result : If the function succeeds, the return value is the handle of the
5829 * keyboard layout; otherwise, it is NULL. To get extended error
5830 * information, use the GetLastError function.
5831 * Remark :
5832 * Status : UNTESTED STUB
5833 *
5834 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5835 *****************************************************************************/
5836
5837BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
5838{
5839 dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
5840 hkl));
5841
5842 return (0);
5843}
5844
5845
5846/*****************************************************************************
5847 * Name : SHORT WIN32API VkKeyScanExW
5848 * Purpose : The VkKeyScanEx function translates a character to the
5849 * corresponding virtual-key code and shift state. The function
5850 * translates the character using the input language and physical
5851 * keyboard layout identified by the given keyboard layout handle.
5852 * Parameters: UINT uChar character to translate
5853 * HKL hkl keyboard layout handle
5854 * Variables :
5855 * Result : see docs
5856 * Remark :
5857 * Status : UNTESTED STUB
5858 *
5859 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5860 *****************************************************************************/
5861
5862WORD WIN32API VkKeyScanExW(WCHAR uChar,
5863 HKL hkl)
5864{
5865 dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
5866 uChar,
5867 hkl));
5868
5869 return (uChar);
5870}
5871
5872
5873/*****************************************************************************
5874 * Name : SHORT WIN32API VkKeyScanExA
5875 * Purpose : The VkKeyScanEx function translates a character to the
5876 * corresponding virtual-key code and shift state. The function
5877 * translates the character using the input language and physical
5878 * keyboard layout identified by the given keyboard layout handle.
5879 * Parameters: UINT uChar character to translate
5880 * HKL hkl keyboard layout handle
5881 * Variables :
5882 * Result : see docs
5883 * Remark :
5884 * Status : UNTESTED STUB
5885 *
5886 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5887 *****************************************************************************/
5888
5889WORD WIN32API VkKeyScanExA(CHAR uChar,
5890 HKL hkl)
5891{
5892 dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
5893 uChar,
5894 hkl));
5895
5896 return (uChar);
5897}
5898
5899
5900/*****************************************************************************
5901 * Name : VOID WIN32API keybd_event
5902 * Purpose : The keybd_event function synthesizes a keystroke. The system
5903 * can use such a synthesized keystroke to generate a WM_KEYUP or
5904 * WM_KEYDOWN message. The keyboard driver's interrupt handler calls
5905 * the keybd_event function.
5906 * Parameters: BYTE bVk virtual-key code
5907
5908 * BYTE bScan hardware scan code
5909 * DWORD dwFlags flags specifying various function options
5910 * DWORD dwExtraInfo additional data associated with keystroke
5911 * Variables :
5912 * Result :
5913 * Remark :
5914 * Status : UNTESTED STUB
5915 *
5916 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5917 *****************************************************************************/
5918
5919VOID WIN32API keybd_event (BYTE bVk,
5920 BYTE bScan,
5921 DWORD dwFlags,
5922 DWORD dwExtraInfo)
5923{
5924 dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
5925 bVk,
5926 bScan,
5927 dwFlags,
5928 dwExtraInfo));
5929}
5930
5931
5932/*****************************************************************************
5933 * Name : VOID WIN32API mouse_event
5934 * Purpose : The mouse_event function synthesizes mouse motion and button clicks.
5935 * Parameters: DWORD dwFlags flags specifying various motion/click variants
5936 * DWORD dx horizontal mouse position or position change
5937 * DWORD dy vertical mouse position or position change
5938 * DWORD cButtons unused, reserved for future use, set to zero
5939 * DWORD dwExtraInfo 32 bits of application-defined information
5940 * Variables :
5941 * Result :
5942 * Remark :
5943 * Status : UNTESTED STUB
5944 *
5945 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
5946 *****************************************************************************/
5947
5948VOID WIN32API mouse_event(DWORD dwFlags,
5949 DWORD dx,
5950 DWORD dy,
5951 DWORD cButtons,
5952 DWORD dwExtraInfo)
5953{
5954 dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
5955 dwFlags,
5956 dx,
5957 dy,
5958 cButtons,
5959 dwExtraInfo));
5960}
5961
5962
5963/*****************************************************************************
5964 * Name : BOOL WIN32API SetShellWindow
5965 * Purpose : Unknown
5966 * Parameters: Unknown
5967 * Variables :
5968 * Result :
5969 * Remark :
5970 * Status : UNTESTED UNKNOWN STUB
5971 *
5972 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
5973 *****************************************************************************/
5974
5975BOOL WIN32API SetShellWindow(DWORD x1)
5976{
5977 dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
5978 x1));
5979
5980 return (FALSE); /* default */
5981}
5982
5983
5984/*****************************************************************************
5985 * Name : BOOL WIN32API PlaySoundEvent
5986 * Purpose : Unknown
5987 * Parameters: Unknown
5988 * Variables :
5989 * Result :
5990 * Remark :
5991 * Status : UNTESTED UNKNOWN STUB
5992 *
5993 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
5994 *****************************************************************************/
5995
5996BOOL WIN32API PlaySoundEvent(DWORD x1)
5997{
5998 dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
5999 x1));
6000
6001 return (FALSE); /* default */
6002}
6003
6004
6005/*****************************************************************************
6006 * Name : BOOL WIN32API TileChildWindows
6007 * Purpose : Unknown
6008 * Parameters: Unknown
6009 * Variables :
6010 * Result :
6011 * Remark :
6012 * Status : UNTESTED UNKNOWN STUB
6013 *
6014 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6015 *****************************************************************************/
6016
6017BOOL WIN32API TileChildWindows(DWORD x1,
6018 DWORD x2)
6019{
6020 dprintf(("USER32: TileChildWindows(%08xh,%08xh) not implemented.\n",
6021 x1,
6022 x2));
6023
6024 return (FALSE); /* default */
6025}
6026
6027
6028/*****************************************************************************
6029 * Name : BOOL WIN32API SetSysColorsTemp
6030 * Purpose : Unknown
6031 * Parameters: Unknown
6032 * Variables :
6033 * Result :
6034 * Remark :
6035 * Status : UNTESTED UNKNOWN STUB
6036 *
6037 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6038 *****************************************************************************/
6039
6040BOOL WIN32API SetSysColorsTemp(void)
6041{
6042 dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
6043
6044 return (FALSE); /* default */
6045}
6046
6047
6048/*****************************************************************************
6049 * Name : BOOL WIN32API RegisterNetworkCapabilities
6050 * Purpose : Unknown
6051 * Parameters: Unknown
6052 * Variables :
6053 * Result :
6054 * Remark :
6055 * Status : UNTESTED UNKNOWN STUB
6056 *
6057 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6058 *****************************************************************************/
6059
6060BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
6061 DWORD x2)
6062{
6063 dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
6064 x1,
6065 x2));
6066
6067 return (FALSE); /* default */
6068}
6069
6070
6071/*****************************************************************************
6072 * Name : BOOL WIN32API EndTask
6073 * Purpose : Unknown
6074 * Parameters: Unknown
6075 * Variables :
6076 * Result :
6077 * Remark :
6078 * Status : UNTESTED UNKNOWN STUB
6079 *
6080 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6081 *****************************************************************************/
6082
6083BOOL WIN32API EndTask(DWORD x1,
6084 DWORD x2,
6085 DWORD x3)
6086{
6087 dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
6088 x1,
6089 x2,
6090 x3));
6091
6092 return (FALSE); /* default */
6093}
6094
6095
6096/*****************************************************************************
6097 * Name : BOOL WIN32API SwitchToThisWindow
6098 * Purpose : Unknown
6099 * Parameters: Unknown
6100 * Variables :
6101 * Result :
6102 * Remark :
6103 * Status : UNTESTED UNKNOWN STUB
6104 *
6105 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6106 *****************************************************************************/
6107
6108BOOL WIN32API SwitchToThisWindow(HWND hwnd,
6109 BOOL x2)
6110{
6111 dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
6112 hwnd,
6113 x2));
6114
6115 return (FALSE); /* default */
6116}
6117
6118
6119/*****************************************************************************
6120 * Name : BOOL WIN32API GetNextQueueWindow
6121 * Purpose : Unknown
6122 * Parameters: Unknown
6123 * Variables :
6124 * Result :
6125 * Remark :
6126 * Status : UNTESTED UNKNOWN STUB
6127 *
6128 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6129 *****************************************************************************/
6130
6131BOOL WIN32API GetNextQueueWindow(DWORD x1,
6132 DWORD x2)
6133{
6134 dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
6135 x1,
6136 x2));
6137
6138 return (FALSE); /* default */
6139}
6140
6141
6142/*****************************************************************************
6143 * Name : BOOL WIN32API YieldTask
6144 * Purpose : Unknown
6145 * Parameters: Unknown
6146 * Variables :
6147 * Result :
6148 * Remark :
6149 * Status : UNTESTED UNKNOWN STUB
6150 *
6151 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6152 *****************************************************************************/
6153
6154BOOL WIN32API YieldTask(void)
6155{
6156 dprintf(("USER32: YieldTask() not implemented.\n"));
6157
6158 return (FALSE); /* default */
6159}
6160
6161
6162/*****************************************************************************
6163 * Name : BOOL WIN32API WinOldAppHackoMatic
6164 * Purpose : Unknown
6165 * Parameters: Unknown
6166 * Variables :
6167 * Result :
6168 * Remark :
6169 * Status : UNTESTED UNKNOWN STUB
6170 *
6171 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6172 *****************************************************************************/
6173
6174BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
6175{
6176 dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
6177 x1));
6178
6179 return (FALSE); /* default */
6180}
6181
6182
6183/*****************************************************************************
6184 * Name : BOOL WIN32API DragObject
6185 * Purpose : Unknown
6186 * Parameters: Unknown
6187 * Variables :
6188 * Result :
6189 * Remark :
6190 * Status : UNTESTED UNKNOWN STUB
6191 *
6192 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6193 *****************************************************************************/
6194
6195DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
6196{
6197 dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6198 x1,
6199 x2,
6200 x3,
6201 x4,
6202 x5));
6203
6204 return (FALSE); /* default */
6205}
6206
6207
6208/*****************************************************************************
6209 * Name : BOOL WIN32API CascadeChildWindows
6210 * Purpose : Unknown
6211 * Parameters: Unknown
6212 * Variables :
6213 * Result :
6214 * Remark :
6215 * Status : UNTESTED UNKNOWN STUB
6216 *
6217 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6218 *****************************************************************************/
6219
6220BOOL WIN32API CascadeChildWindows(DWORD x1,
6221 DWORD x2)
6222{
6223 dprintf(("USER32: CascadeChildWindows(%08xh,%08xh) not implemented.\n",
6224 x1,
6225 x2));
6226
6227 return (FALSE); /* default */
6228}
6229
6230
6231/*****************************************************************************
6232 * Name : BOOL WIN32API RegisterSystemThread
6233 * Purpose : Unknown
6234 * Parameters: Unknown
6235 * Variables :
6236 * Result :
6237 * Remark :
6238 * Status : UNTESTED UNKNOWN STUB
6239 *
6240 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6241 *****************************************************************************/
6242
6243BOOL WIN32API RegisterSystemThread(DWORD x1,
6244 DWORD x2)
6245{
6246 dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
6247 x1,
6248 x2));
6249
6250 return (FALSE); /* default */
6251}
6252
6253
6254/*****************************************************************************
6255 * Name : BOOL WIN32API IsHungThread
6256 * Purpose : Unknown
6257 * Parameters: Unknown
6258 * Variables :
6259 * Result :
6260 * Remark :
6261 * Status : UNTESTED UNKNOWN STUB
6262 *
6263 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6264 *****************************************************************************/
6265
6266BOOL WIN32API IsHungThread(DWORD x1)
6267{
6268 dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
6269 x1));
6270
6271 return (FALSE); /* default */
6272}
6273
6274
6275/*****************************************************************************
6276 * Name : BOOL WIN32API SysErrorBox
6277 * Purpose : Unknown
6278 * Parameters: Unknown
6279 * Variables :
6280 * Result :
6281 * Remark : HARDERR like ?
6282 * Status : UNTESTED UNKNOWN STUB
6283 *
6284 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6285 *****************************************************************************/
6286
6287BOOL WIN32API SysErrorBox(DWORD x1,
6288 DWORD x2,
6289 DWORD x3)
6290{
6291 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh) not implemented.\n",
6292 x1,
6293 x2,
6294 x3));
6295
6296 return (FALSE); /* default */
6297}
6298
6299
6300/*****************************************************************************
6301 * Name : BOOL WIN32API UserSignalProc
6302 * Purpose : Unknown
6303 * Parameters: Unknown
6304 * Variables :
6305 * Result :
6306 * Remark :
6307 * Status : UNTESTED UNKNOWN STUB
6308 *
6309 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6310 *****************************************************************************/
6311
6312BOOL WIN32API UserSignalProc(DWORD x1,
6313 DWORD x2,
6314 DWORD x3,
6315 DWORD x4)
6316{
6317 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
6318 x1,
6319 x2,
6320 x3,
6321 x4));
6322
6323 return (FALSE); /* default */
6324}
6325
6326
6327/*****************************************************************************
6328 * Name : BOOL WIN32API GetShellWindow
6329 * Purpose : Unknown
6330 * Parameters: Unknown
6331 * Variables :
6332 * Result :
6333 * Remark :
6334 * Status : UNTESTED UNKNOWN STUB
6335 *
6336 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
6337 *****************************************************************************/
6338
6339HWND WIN32API GetShellWindow(void)
6340{
6341 dprintf(("USER32: GetShellWindow() not implemented.\n"));
6342
6343 return (0); /* default */
6344}
6345
6346
6347
6348/***********************************************************************
6349 * RegisterTasklist32 [USER32.436]
6350 */
6351DWORD WIN32API RegisterTasklist (DWORD x)
6352{
6353 dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
6354 x));
6355
6356 return TRUE;
6357}
6358
6359
6360/***********************************************************************
6361 * DrawCaptionTemp32A [USER32.599]
6362 *
6363 * PARAMS
6364 *
6365 * RETURNS
6366 * Success:
6367 * Failure:
6368 */
6369
6370BOOL WIN32API DrawCaptionTempA(HWND hwnd,
6371 HDC hdc,
6372 const RECT *rect,
6373 HFONT hFont,
6374 HICON hIcon,
6375 LPCSTR str,
6376 UINT uFlags)
6377{
6378 RECT rc = *rect;
6379
6380 dprintf(("USER32: DrawCaptionTempA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
6381 hwnd,
6382 hdc,
6383 rect,
6384 hFont,
6385 hIcon,
6386 str,
6387 uFlags));
6388
6389 /* drawing background */
6390 if (uFlags & DC_INBUTTON)
6391 {
6392 O32_FillRect (hdc,
6393 &rc,
6394 GetSysColorBrush (COLOR_3DFACE));
6395
6396 if (uFlags & DC_ACTIVE)
6397 {
6398 HBRUSH hbr = O32_SelectObject (hdc,
6399 GetSysColorBrush (COLOR_ACTIVECAPTION));
6400 O32_PatBlt (hdc,
6401 rc.left,
6402 rc.top,
6403 rc.right - rc.left,
6404 rc.bottom - rc.top,
6405 0xFA0089);
6406
6407 O32_SelectObject (hdc,
6408 hbr);
6409 }
6410 }
6411 else
6412 {
6413 O32_FillRect (hdc,
6414 &rc,
6415 GetSysColorBrush ((uFlags & DC_ACTIVE) ?
6416 COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
6417 }
6418
6419
6420 /* drawing icon */
6421 if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP))
6422 {
6423 POINT pt;
6424
6425 pt.x = rc.left + 2;
6426 pt.y = (rc.bottom + rc.top - O32_GetSystemMetrics(SM_CYSMICON)) / 2;
6427
6428 if (hIcon)
6429 {
6430 DrawIconEx (hdc,
6431 pt.x,
6432 pt.y,
6433 hIcon,
6434 O32_GetSystemMetrics(SM_CXSMICON),
6435 O32_GetSystemMetrics(SM_CYSMICON),
6436 0,
6437 0,
6438 DI_NORMAL);
6439 }
6440 else
6441 {
6442 /* @@@PH 1999/06/08 not ported yet, just don't draw any icon
6443 WND *wndPtr = WIN_FindWndPtr(hwnd);
6444 HICON hAppIcon = 0;
6445
6446 if (wndPtr->class->hIconSm)
6447 hAppIcon = wndPtr->class->hIconSm;
6448 else
6449 if (wndPtr->class->hIcon)
6450 hAppIcon = wndPtr->class->hIcon;
6451
6452 DrawIconEx (hdc,
6453 pt.x,
6454 pt.y,
6455 hAppIcon,
6456 GetSystemMetrics(SM_CXSMICON),
6457 GetSystemMetrics(SM_CYSMICON),
6458 0,
6459 0,
6460 DI_NORMAL);
6461
6462 WIN_ReleaseWndPtr(wndPtr);
6463 */
6464 }
6465
6466 rc.left += (rc.bottom - rc.top);
6467 }
6468
6469 /* drawing text */
6470 if (uFlags & DC_TEXT)
6471 {
6472 HFONT hOldFont;
6473
6474 if (uFlags & DC_INBUTTON)
6475 O32_SetTextColor (hdc,
6476 O32_GetSysColor (COLOR_BTNTEXT));
6477 else
6478 if (uFlags & DC_ACTIVE)
6479 O32_SetTextColor (hdc,
6480 O32_GetSysColor (COLOR_CAPTIONTEXT));
6481 else
6482 O32_SetTextColor (hdc,
6483 O32_GetSysColor (COLOR_INACTIVECAPTIONTEXT));
6484
6485 O32_SetBkMode (hdc,
6486 TRANSPARENT);
6487
6488 if (hFont)
6489 hOldFont = O32_SelectObject (hdc,
6490 hFont);
6491 else
6492 {
6493 NONCLIENTMETRICSA nclm;
6494 HFONT hNewFont;
6495
6496 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
6497 O32_SystemParametersInfo (SPI_GETNONCLIENTMETRICS,
6498 0,
6499 &nclm,
6500 0);
6501 hNewFont = O32_CreateFontIndirect ((uFlags & DC_SMALLCAP) ?
6502 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
6503 hOldFont = O32_SelectObject (hdc,
6504 hNewFont);
6505 }
6506
6507 if (str)
6508 O32_DrawText (hdc,
6509 str,
6510 -1,
6511 &rc,
6512 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
6513 else
6514 {
6515 CHAR szText[128];
6516 INT nLen;
6517
6518 nLen = O32_GetWindowText (hwnd,
6519 szText,
6520 128);
6521
6522 O32_DrawText (hdc,
6523 szText,
6524 nLen,
6525 &rc,
6526 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
6527 }
6528
6529 if (hFont)
6530 O32_SelectObject (hdc,
6531 hOldFont);
6532 else
6533 O32_DeleteObject (O32_SelectObject (hdc,
6534 hOldFont));
6535 }
6536
6537 /* drawing focus ??? */
6538 if (uFlags & 0x2000)
6539 {
6540 dprintf(("USER32: DrawCaptionTempA undocumented flag (0x2000)!\n"));
6541 }
6542
6543 return 0;
6544}
6545
6546
6547/***********************************************************************
6548 * DrawCaptionTemp32W [USER32.602]
6549 *
6550 * PARAMS
6551 *
6552 * RETURNS
6553 * Success:
6554 * Failure:
6555 */
6556
6557BOOL WIN32API DrawCaptionTempW (HWND hwnd,
6558 HDC hdc,
6559 const RECT *rect,
6560 HFONT hFont,
6561 HICON hIcon,
6562 LPCWSTR str,
6563 UINT uFlags)
6564{
6565 LPSTR strAscii = UnicodeToAsciiString((LPWSTR)str);
6566
6567 BOOL res = DrawCaptionTempA (hwnd,
6568 hdc,
6569 rect,
6570 hFont,
6571 hIcon,
6572 strAscii,
6573 uFlags);
6574
6575 FreeAsciiString(strAscii);
6576
6577 return res;
6578}
6579
Note: See TracBrowser for help on using the repository browser.