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

Last change on this file since 1088 was 1084, checked in by cbratschi, 26 years ago

functions sorted and fixed
File size: 136.1 KB
Line 
1/* $Id: user32.cpp,v 1.36 1999-09-28 16:35:06 cbratschi Exp $ */
2
3/*
4 * Win32 misc user32 API functions for OS/2
5 *
6 * Copyright 1998 Sander van Leeuwen
7 * Copyright 1998 Patrick Haller
8 * Copyright 1998 Peter Fitzsimmons
9 * Copyright 1999 Christoph Bratschi
10 * Copyright 1999 Daniela Engert (dani@ngrt.de)
11 *
12 *
13 * Project Odin Software License can be found in LICENSE.TXT
14 *
15 */
16/*****************************************************************************
17 * Name : USER32.CPP
18 * Purpose : This module maps all Win32 functions contained in USER32.DLL
19 * to their OS/2-specific counterparts as far as possible.
20 *****************************************************************************/
21
22/*
23 CB:
24 - don't replace GDI functions (hdc), only convert window handle
25 - always use OSRECTL for PM functions
26 - POINT == POINTL
27*/
28
29#include <os2win.h>
30#include "misc.h"
31
32#include "user32.h"
33#include <winicon.h>
34#include "syscolor.h"
35
36#include <wchar.h>
37#include <stdlib.h>
38#include <string.h>
39#include <oslibwin.h>
40#include <win32wnd.h>
41#include <winuser.h>
42
43//undocumented stuff
44// WIN32API CalcChildScroll
45// WIN32API CascadeChildWindows
46// WIN32API ClientThreadConnect
47// WIN32API DragObject
48// WIN32API DrawFrame
49// WIN32API EditWndProc
50// WIN32API EndTask
51// WIN32API GetInputDesktop
52// WIN32API GetNextQueueWindow
53// WIN32API GetShellWindow
54// WIN32API InitSharedTable
55// WIN32API InitTask
56// WIN32API IsHungThread
57// WIN32API LockWindowStation
58// WIN32API ModifyAccess
59// WIN32API PlaySoundEvent
60// WIN32API RegisterLogonProcess
61// WIN32API RegisterNetworkCapabilities
62// WIN32API RegisterSystemThread
63// WIN32API SetDeskWallpaper
64// WIN32API SetDesktopBitmap
65// WIN32API SetInternalWindowPos
66// WIN32API SetLogonNotifyWindow
67// WIN32API SetShellWindow
68// WIN32API SetSysColorsTemp
69// WIN32API SetWindowFullScreenState
70// WIN32API SwitchToThisWindow
71// WIN32API SysErrorBox
72// WIN32API TileChildWindows
73// WIN32API UnlockWindowStation
74// WIN32API UserClientDllInitialize
75// WIN32API UserSignalProc
76// WIN32API WinOldAppHackoMatic
77// WIN32API WNDPROC_CALLBACK
78// WIN32API YieldTask
79
80/* Coordinate Transformation */
81
82inline void OS2ToWin32ScreenPos(POINT *dest,POINT *source)
83{
84 dest->x = source->x;
85 dest->y = OSLibWinQuerySysValue(OSLIB_HWND_DESKTOP,SVOS_CYSCREEN)-1-source->y;
86}
87
88inline void Win32ToOS2ScreenPos(POINT *dest,POINT *source)
89{
90 OS2ToWin32ScreenPos(dest,source); //transform back
91}
92
93/* Rectangle Functions - parts from wine/windows/rect.c */
94
95BOOL WIN32API CopyRect( PRECT lprcDst, const RECT * lprcSrc)
96{
97// ddprintf(("USER32: CopyRect\n"));
98 if (!lprcDst || !lprcSrc) {
99 SetLastError(ERROR_INVALID_PARAMETER);
100 return FALSE;
101 }
102
103 memcpy(lprcDst,lprcSrc,sizeof(RECT));
104
105 return TRUE;
106}
107//******************************************************************************
108//******************************************************************************
109BOOL WIN32API EqualRect( const RECT *lprc1, const RECT *lprc2)
110{
111#ifdef DEBUG
112 WriteLog("USER32: EqualRect\n");
113#endif
114 if (!lprc1 || !lprc2)
115 {
116 SetLastError(ERROR_INVALID_PARAMETER);
117 return FALSE;
118 }
119
120 return (lprc1->left == lprc2->left &&
121 lprc1->right == lprc2->right &&
122 lprc1->top == lprc2->top &&
123 lprc1->bottom == lprc2->bottom);
124}
125//******************************************************************************
126//******************************************************************************
127BOOL WIN32API InflateRect( PRECT lprc, int dx, int dy)
128{
129#ifdef DEBUG
130 WriteLog("USER32: InflateRect\n");
131#endif
132 if (!lprc)
133 {
134 SetLastError(ERROR_INVALID_PARAMETER);
135 return FALSE;
136 }
137
138 lprc->left -= dx;
139 lprc->right += dx;
140 lprc->top -= dy;
141 lprc->bottom += dy;
142
143 return TRUE;
144}
145//******************************************************************************
146//******************************************************************************
147BOOL WIN32API IntersectRect( PRECT lprcDst, const RECT * lprcSrc1, const RECT * lprcSrc2)
148{
149#ifdef DEBUG
150//// WriteLog("USER32: IntersectRect\n");
151#endif
152 if (!lprcDst || !lprcSrc1 || !lprcSrc2)
153 {
154 SetLastError(ERROR_INVALID_PARAMETER);
155 return FALSE;
156 }
157
158 if (IsRectEmpty(lprcSrc1) || IsRectEmpty(lprcSrc2) ||
159 (lprcSrc1->left >= lprcSrc2->right) || (lprcSrc2->left >= lprcSrc1->right) ||
160 (lprcSrc1->top >= lprcSrc2->bottom) || (lprcSrc2->top >= lprcSrc1->bottom))
161 {
162 SetLastError(ERROR_INVALID_PARAMETER);
163 SetRectEmpty(lprcDst);
164 return FALSE;
165 }
166 lprcDst->left = MAX(lprcSrc1->left,lprcSrc2->left);
167 lprcDst->right = MIN(lprcSrc1->right,lprcSrc2->right);
168 lprcDst->top = MAX(lprcSrc1->top,lprcSrc2->top);
169 lprcDst->bottom = MIN(lprcSrc1->bottom,lprcSrc2->bottom);
170
171 return TRUE;
172}
173//******************************************************************************
174//******************************************************************************
175BOOL WIN32API IsRectEmpty( const RECT * lprc)
176{
177 if (!lprc)
178 {
179 SetLastError(ERROR_INVALID_PARAMETER);
180 return FALSE;
181 }
182
183 return (lprc->left == lprc->right || lprc->top == lprc->bottom);
184}
185//******************************************************************************
186//******************************************************************************
187BOOL WIN32API OffsetRect( PRECT lprc, int x, int y)
188{
189#ifdef DEBUG
190//// WriteLog("USER32: OffsetRect\n");
191#endif
192 if (!lprc)
193 {
194 SetLastError(ERROR_INVALID_PARAMETER);
195 return FALSE;
196 }
197
198 lprc->left += x;
199 lprc->right += x;
200 lprc->top += y;
201 lprc->bottom += y;
202
203 return TRUE;
204}
205//******************************************************************************
206//******************************************************************************
207BOOL WIN32API PtInRect( const RECT *lprc, POINT pt)
208{
209#ifdef DEBUG1
210 WriteLog("USER32: PtInRect\n");
211#endif
212 if (!lprc)
213 {
214 SetLastError(ERROR_INVALID_PARAMETER);
215 return FALSE;
216 }
217
218 return (pt.x >= lprc->left &&
219 pt.x < lprc->right &&
220 pt.y >= lprc->top &&
221 pt.y < lprc->bottom);
222}
223//******************************************************************************
224//******************************************************************************
225BOOL WIN32API SetRect( PRECT lprc, int nLeft, int nTop, int nRight, int nBottom)
226{
227 if (!lprc)
228 {
229 SetLastError(ERROR_INVALID_PARAMETER);
230 return FALSE;
231 }
232
233 lprc->left = nLeft;
234 lprc->top = nTop;
235 lprc->right = nRight;
236 lprc->bottom = nBottom;
237
238 return TRUE;
239}
240//******************************************************************************
241//******************************************************************************
242BOOL WIN32API SetRectEmpty( PRECT lprc)
243{
244 if (!lprc)
245 {
246 SetLastError(ERROR_INVALID_PARAMETER);
247 return FALSE;
248 }
249
250 lprc->left = lprc->right = lprc->top = lprc->bottom = 0;
251
252 return TRUE;
253}
254//******************************************************************************
255//******************************************************************************
256BOOL WIN32API SubtractRect( PRECT lprcDest, const RECT * lprcSrc1, const RECT * lprcSrc2)
257{
258#ifdef DEBUG
259 WriteLog("USER32: SubtractRect");
260#endif
261 RECT tmp;
262
263 if (!lprcDest || !lprcSrc1 || !lprcSrc2)
264 {
265 SetLastError(ERROR_INVALID_PARAMETER);
266 return FALSE;
267 }
268
269 if (IsRectEmpty(lprcSrc1))
270 {
271 SetLastError(ERROR_INVALID_PARAMETER);
272 SetRectEmpty(lprcDest);
273 return FALSE;
274 }
275 *lprcDest = *lprcSrc1;
276 if (IntersectRect(&tmp,lprcSrc1,lprcSrc2))
277 {
278 if (EqualRect(&tmp,lprcDest))
279 {
280 SetRectEmpty(lprcDest);
281 return FALSE;
282 }
283 if ((tmp.top == lprcDest->top) && (tmp.bottom == lprcDest->bottom))
284 {
285 if (tmp.left == lprcDest->left) lprcDest->left = tmp.right;
286 else if (tmp.right == lprcDest->right) lprcDest->right = tmp.left;
287 }
288 else if ((tmp.left == lprcDest->left) && (tmp.right == lprcDest->right))
289 {
290 if (tmp.top == lprcDest->top) lprcDest->top = tmp.bottom;
291 else if (tmp.bottom == lprcDest->bottom) lprcDest->bottom = tmp.top;
292 }
293 }
294
295 return TRUE;
296}
297//******************************************************************************
298//******************************************************************************
299BOOL WIN32API UnionRect( PRECT lprcDst, const RECT *lprcSrc1, const RECT *lprcSrc2)
300{
301#ifdef DEBUG
302 WriteLog("USER32: UnionRect\n");
303#endif
304 if (!lprcDst || !lprcSrc1 || !lprcSrc2)
305 {
306 SetLastError(ERROR_INVALID_PARAMETER);
307 return FALSE;
308 }
309
310 if (IsRectEmpty(lprcSrc1))
311 {
312 if (IsRectEmpty(lprcSrc2))
313 {
314 SetLastError(ERROR_INVALID_PARAMETER);
315 SetRectEmpty(lprcDst);
316 return FALSE;
317 }
318 else *lprcDst = *lprcSrc2;
319 }
320 else
321 {
322 if (IsRectEmpty(lprcSrc2)) *lprcDst = *lprcSrc1;
323 else
324 {
325 lprcDst->left = MIN(lprcSrc1->left,lprcSrc2->left);
326 lprcDst->right = MAX(lprcSrc1->right,lprcSrc2->right);
327 lprcDst->top = MIN(lprcSrc1->top,lprcSrc2->top);
328 lprcDst->bottom = MAX(lprcSrc1->bottom,lprcSrc2->bottom);
329 }
330 }
331
332 return TRUE;
333}
334
335/* String Manipulation Functions */
336
337int __cdecl wsprintfA(char *lpOut, LPCSTR lpFmt, ...)
338{
339 int rc;
340 va_list argptr;
341
342#ifdef DEBUG
343 WriteLog("USER32: wsprintfA\n");
344 WriteLog("USER32: %s\n", lpFmt);
345#endif
346 va_start(argptr, lpFmt);
347 rc = O32_wvsprintf(lpOut, (char *)lpFmt, argptr);
348 va_end(argptr);
349#ifdef DEBUG
350 WriteLog("USER32: %s\n", lpOut);
351#endif
352 return(rc);
353}
354//******************************************************************************
355//******************************************************************************
356int __cdecl wsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, ...)
357{
358 int rc;
359 char *lpFmtA;
360 char szOut[512];
361 va_list argptr;
362
363 dprintf(("USER32: wsprintfW(%08xh,%08xh).\n",
364 lpOut,
365 lpFmt));
366
367 lpFmtA = UnicodeToAsciiString((LPWSTR)lpFmt);
368
369 /* @@@PH 98/07/13 transform "%s" to "%ls" does the unicode magic */
370 {
371 PCHAR pszTemp;
372 PCHAR pszTemp1;
373 ULONG ulStrings;
374 ULONG ulIndex; /* temporary string counter */
375
376 for (ulStrings = 0, /* determine number of placeholders */
377 pszTemp = lpFmtA;
378
379 (pszTemp != NULL) &&
380 (*pszTemp != 0);
381
382 ulStrings++)
383 {
384 pszTemp = strstr(pszTemp,
385 "%s");
386 if (pszTemp != NULL) /* skip 2 characters */
387 {
388 pszTemp++;
389 pszTemp++;
390 }
391 else
392 break; /* leave loop immediately */
393 }
394
395 if (ulStrings != 0) /* transformation required ? */
396 {
397 /* now reallocate lpFmt */
398 ulStrings += strlen(lpFmtA); /* calculate total string length */
399 pszTemp = lpFmtA; /* save string pointer */
400 pszTemp1 = lpFmtA; /* save string pointer */
401
402 /* @@@PH allocation has to be compatible to FreeAsciiString !!! */
403 lpFmtA = (char *)malloc(ulStrings + 1);
404 if (lpFmtA == NULL) /* check proper allocation */
405 return (0); /* raise error condition */
406
407 for (ulIndex = 0;
408 ulIndex <= ulStrings;
409 ulIndex++,
410 pszTemp++)
411 {
412 if ((pszTemp[0] == '%') &&
413 (pszTemp[1] == 's') )
414 {
415 /* replace %s by %ls */
416 lpFmtA[ulIndex++] = '%';
417 lpFmtA[ulIndex ] = 'l';
418 lpFmtA[ulIndex+1] = 's';
419 }
420 else
421 lpFmtA[ulIndex] = *pszTemp; /* just copy over the character */
422 }
423
424 lpFmtA[ulStrings] = 0; /* string termination */
425
426 FreeAsciiString(pszTemp1); /* the original string is obsolete */
427 }
428 }
429
430 dprintf(("USER32: wsprintfW (%s).\n",
431 lpFmt));
432
433 va_start(argptr,
434 lpFmt);
435
436 rc = O32_wvsprintf(szOut,
437 lpFmtA,
438 argptr);
439
440 AsciiToUnicode(szOut,
441 lpOut);
442
443 FreeAsciiString(lpFmtA);
444 return(rc);
445}
446//******************************************************************************
447//******************************************************************************
448int WIN32API wvsprintfA( LPSTR lpOutput, LPCSTR lpFormat, va_list arglist)
449{
450#ifdef DEBUG
451 WriteLog("USER32: wvsprintfA\n");
452#endif
453 return O32_wvsprintf(lpOutput,lpFormat,(LPCVOID*)arglist);
454}
455//******************************************************************************
456//******************************************************************************
457int WIN32API wvsprintfW(LPWSTR lpOutput, LPCWSTR lpFormat, va_list arglist)
458{
459 int rc;
460 char szOut[256];
461 char *lpFmtA;
462
463 lpFmtA = UnicodeToAsciiString((LPWSTR)lpFormat);
464#ifdef DEBUG
465 WriteLog("USER32: wvsprintfW, DOES NOT HANDLE UNICODE STRINGS!\n");
466 WriteLog("USER32: %s\n", lpFormat);
467#endif
468 rc = O32_wvsprintf(szOut, lpFmtA, (LPCVOID)arglist);
469
470 AsciiToUnicode(szOut, lpOutput);
471#ifdef DEBUG
472 WriteLog("USER32: %s\n", lpOutput);
473#endif
474 FreeAsciiString(lpFmtA);
475 return(rc);
476}
477
478#if 0
479/* Caret Functions */
480
481BOOL WIN32API CreateCaret( HWND hWnd, HBITMAP hBitmap, int nWidth, int nHeight)
482{
483#ifdef DEBUG
484 WriteLog("USER32: CreateCaret\n");
485#endif
486 hWnd = Win32Window::Win32ToOS2Handle(hWnd);
487 return O32_CreateCaret(hWnd,hBitmap,nWidth,nHeight);
488}
489//******************************************************************************
490//******************************************************************************
491BOOL WIN32API DestroyCaret(void)
492{
493#ifdef DEBUG
494 WriteLog("USER32: DestroyCaret\n");
495#endif
496 return O32_DestroyCaret();
497}
498//******************************************************************************
499//******************************************************************************
500UINT WIN32API GetCaretBlinkTime(void)
501{
502#ifdef DEBUG
503 WriteLog("USER32: GetCaretBlinkTime\n");
504#endif
505 return O32_GetCaretBlinkTime();
506}
507//******************************************************************************
508//******************************************************************************
509BOOL WIN32API GetCaretPos( LPPOINT lpPoint)
510{
511#ifdef DEBUG
512 WriteLog("USER32: GetCaretPos\n");
513#endif
514 return O32_GetCaretPos(lpPoint);
515}
516//******************************************************************************
517//******************************************************************************
518BOOL WIN32API HideCaret( HWND hWnd)
519{
520#ifdef DEBUG
521 WriteLog("USER32: HideCaret\n");
522#endif
523 hWnd = Win32Window::Win32ToOS2Handle(hWnd);
524 return O32_HideCaret(hWnd);
525}
526//******************************************************************************
527//******************************************************************************
528BOOL WIN32API SetCaretBlinkTime( UINT wMSeconds)
529{
530#ifdef DEBUG
531 WriteLog("USER32: SetCaretBlinkTime\n");
532#endif
533 return O32_SetCaretBlinkTime(wMSeconds);
534}
535//******************************************************************************
536//******************************************************************************
537BOOL WIN32API SetCaretPos( int nX, int nY)
538{
539 dprintf(("USER32: SetCaretPos\n"));
540 return O32_SetCaretPos(nX,nY);
541}
542//******************************************************************************
543//******************************************************************************
544BOOL WIN32API ShowCaret( HWND hwnd)
545{
546 dprintf(("USER32: ShowCaret\n"));
547 hwnd = Win32Window::Win32ToOS2Handle(hwnd);
548 return O32_ShowCaret(hwnd);
549}
550#endif
551
552/* Cursor Functions */
553
554BOOL WIN32API ClipCursor(const RECT * lpRect)
555{
556#ifdef DEBUG
557 WriteLog("USER32: ClipCursor\n");
558#endif
559 return O32_ClipCursor(lpRect);
560}
561//******************************************************************************
562//******************************************************************************
563HCURSOR WIN32API CreateCursor( HINSTANCE hInst, int xHotSpot, int yHotSpot, int nWidth, int nHeight, const VOID *pvANDPlane, const VOID *pvXORPlane)
564{
565#ifdef DEBUG
566 WriteLog("USER32: CreateCursor\n");
567#endif
568 return O32_CreateCursor(hInst,xHotSpot,yHotSpot,nWidth,nHeight,pvANDPlane,pvXORPlane);
569}
570//******************************************************************************
571//******************************************************************************
572BOOL WIN32API DestroyCursor( HCURSOR hCursor)
573{
574#ifdef DEBUG
575 WriteLog("USER32: DestroyCursor\n");
576#endif
577 return O32_DestroyCursor(hCursor);
578}
579//******************************************************************************
580//******************************************************************************
581BOOL WIN32API GetClipCursor( LPRECT lpRect)
582{
583#ifdef DEBUG
584 WriteLog("USER32: GetClipCursor\n");
585#endif
586 return O32_GetClipCursor(lpRect);
587}
588//******************************************************************************
589//******************************************************************************
590HCURSOR WIN32API GetCursor(void)
591{
592#ifdef DEBUG
593//// WriteLog("USER32: GetCursor\n");
594#endif
595 return O32_GetCursor();
596}
597//******************************************************************************
598//******************************************************************************
599BOOL WIN32API GetCursorPos( PPOINT lpPoint)
600{
601 BOOL rc;
602 POINT point;
603#ifdef DEBUG
604//// WriteLog("USER32: GetCursorPos\n");
605#endif
606 if (!lpPoint) return FALSE;
607 if (OSLibWinQueryPointerPos(OSLIB_HWND_DESKTOP,&point)) //POINT == POINTL
608 {
609 OS2ToWin32ScreenPos(lpPoint,&point);
610 return TRUE;
611 } else return FALSE;
612}
613/*****************************************************************************
614 * Name : HCURSOR WIN32API LoadCursorFromFileA
615 * Purpose : The LoadCursorFromFile function creates a cursor based on data
616 * contained in a file. The file is specified by its name or by a
617 * system cursor identifier. The function returns a handle to the
618 * newly created cursor. Files containing cursor data may be in
619 * either cursor (.CUR) or animated cursor (.ANI) format.
620 * Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
621 * Variables :
622 * Result : If the function is successful, the return value is a handle to
623 * the new cursor.
624 * If the function fails, the return value is NULL. To get extended
625 * error information, call GetLastError. GetLastError may return
626 * the following
627 * Remark :
628 * Status : UNTESTED STUB
629 *
630 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
631 *****************************************************************************/
632HCURSOR WIN32API LoadCursorFromFileA(LPCTSTR lpFileName)
633{
634 if (!HIWORD(lpFileName))
635 {
636 return LoadCursorA(NULL,lpFileName);
637 } else
638 {
639 dprintf(("USER32:LoadCursorFromFileA (%s) not implemented.\n",
640 lpFileName));
641
642 return (NULL);
643 }
644}
645/*****************************************************************************
646 * Name : HCURSOR WIN32API LoadCursorFromFileW
647 * Purpose : The LoadCursorFromFile function creates a cursor based on data
648 * contained in a file. The file is specified by its name or by a
649 * system cursor identifier. The function returns a handle to the
650 * newly created cursor. Files containing cursor data may be in
651 * either cursor (.CUR) or animated cursor (.ANI) format.
652 * Parameters: LPCTSTR lpFileName pointer to cursor file, or system cursor id
653 * Variables :
654 * Result : If the function is successful, the return value is a handle to
655 * the new cursor.
656 * If the function fails, the return value is NULL. To get extended
657 * error information, call GetLastError. GetLastError may return
658 * the following
659 * Remark :
660 * Status : UNTESTED STUB
661 *
662 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
663 *****************************************************************************/
664HCURSOR WIN32API LoadCursorFromFileW(LPCWSTR lpFileName)
665{
666 if (!HIWORD(lpFileName))
667 {
668 return LoadCursorW(NULL,lpFileName);
669 } else
670 {
671 dprintf(("USER32:LoadCursorFromFileW (%s) not implemented.\n",
672 lpFileName));
673
674 return (NULL);
675 }
676}
677//******************************************************************************
678//******************************************************************************
679HCURSOR WIN32API SetCursor( HCURSOR hcur)
680{
681 HCURSOR rc;
682
683 rc = O32_SetCursor(hcur);
684 dprintf(("USER32: SetCursor %x (prev %x (%x))\n", hcur, rc, O32_GetCursor()));
685 return rc;
686}
687//******************************************************************************
688//******************************************************************************
689BOOL WIN32API SetCursorPos( int X, int Y)
690{
691#ifdef DEBUG
692 WriteLog("USER32: SetCursorPos\n");
693#endif
694 return O32_SetCursorPos(X,Y);
695}
696/*****************************************************************************
697 * Name : BOOL WIN32API SetSystemCursor
698 * Purpose : The SetSystemCursor function replaces the contents of the system
699 * cursor specified by dwCursorId with the contents of the cursor
700 * specified by hCursor, and then destroys hCursor. This function
701 * lets an application customize the system cursors.
702 * Parameters: HCURSOR hCursor set specified system cursor to this cursor's
703 * contents, then destroy this
704 * DWORD dwCursorID system cursor specified by its identifier
705 * Variables :
706 * Result : If the function succeeds, the return value is TRUE.
707 * If the function fails, the return value is FALSE. To get extended
708 * error information, call GetLastError.
709 * Remark :
710 * Status : UNTESTED STUB
711 *
712 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
713 *****************************************************************************/
714BOOL WIN32API SetSystemCursor(HCURSOR hCursor,
715 DWORD dwCursorId)
716{
717 dprintf(("USER32:SetSystemCursor (%08xh,%08x) not supported.\n",
718 hCursor,
719 dwCursorId));
720
721 return DestroyCursor(hCursor);
722}
723//******************************************************************************
724//******************************************************************************
725int WIN32API ShowCursor( BOOL bShow)
726{
727#ifdef DEBUG
728 WriteLog("USER32: ShowCursor\n");
729#endif
730 return O32_ShowCursor(bShow);
731}
732
733/* Mouse Input Functions */
734
735/*****************************************************************************
736 * Name : BOOL WIN32API DragDetect
737 * Purpose : The DragDetect function captures the mouse and tracks its movement
738 * Parameters: HWND hwnd
739 * POINT pt
740 * Variables :
741 * Result : If the user moved the mouse outside of the drag rectangle while
742 * holding the left button down, the return value is TRUE.
743 * If the user did not move the mouse outside of the drag rectangle
744 * while holding the left button down, the return value is FALSE.
745 * Remark :
746 * Status : UNTESTED STUB
747 *
748 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
749 *****************************************************************************/
750BOOL WIN32API DragDetect(HWND hwnd,
751 POINT pt)
752{
753 dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
754 hwnd));
755
756 return (FALSE);
757}
758//******************************************************************************
759//******************************************************************************
760HWND WIN32API GetCapture(void)
761{
762#ifdef DEBUG
763 WriteLog("USER32: GetCapture\n");
764#endif
765 return Win32Window::OS2ToWin32Handle(O32_GetCapture());
766}
767//******************************************************************************
768//******************************************************************************
769UINT WIN32API GetDoubleClickTime(void)
770{
771#ifdef DEBUG
772 WriteLog("USER32: GetDoubleClickTime\n");
773#endif
774 return O32_GetDoubleClickTime();
775}
776/*****************************************************************************
777 * Name : VOID WIN32API mouse_event
778 * Purpose : The mouse_event function synthesizes mouse motion and button clicks.
779 * Parameters: DWORD dwFlags flags specifying various motion/click variants
780 * DWORD dx horizontal mouse position or position change
781 * DWORD dy vertical mouse position or position change
782 * DWORD cButtons unused, reserved for future use, set to zero
783 * DWORD dwExtraInfo 32 bits of application-defined information
784 * Variables :
785 * Result :
786 * Remark :
787 * Status : UNTESTED STUB
788 *
789 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
790 *****************************************************************************/
791VOID WIN32API mouse_event(DWORD dwFlags,
792 DWORD dx,
793 DWORD dy,
794 DWORD cButtons,
795 DWORD dwExtraInfo)
796{
797 dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
798 dwFlags,
799 dx,
800 dy,
801 cButtons,
802 dwExtraInfo));
803}
804//******************************************************************************
805//******************************************************************************
806BOOL WIN32API ReleaseCapture(void)
807{
808#ifdef DEBUG
809 WriteLog("USER32: ReleaseCapture\n");
810#endif
811 return O32_ReleaseCapture();
812}
813//******************************************************************************
814//******************************************************************************
815HWND WIN32API SetCapture( HWND hwnd)
816{
817#ifdef DEBUG
818 WriteLog("USER32: SetCapture\n");
819#endif
820 hwnd = Win32Window::Win32ToOS2Handle(hwnd);
821 return Win32Window::OS2ToWin32Handle(O32_SetCapture(hwnd));
822}
823//******************************************************************************
824//******************************************************************************
825BOOL WIN32API SetDoubleClickTime( UINT uInterval)
826{
827#ifdef DEBUG
828 WriteLog("USER32: SetDoubleClickTime\n");
829#endif
830 return O32_SetDoubleClickTime(uInterval);
831}
832//******************************************************************************
833//******************************************************************************
834BOOL WIN32API SwapMouseButton( BOOL fSwap)
835{
836#ifdef DEBUG
837 WriteLog("USER32: SwapMouseButton\n");
838#endif
839 return O32_SwapMouseButton(fSwap);
840}
841
842/* Error Functions */
843
844BOOL WIN32API ExitWindowsEx( UINT uFlags, DWORD dwReserved)
845{
846#ifdef DEBUG
847 WriteLog("USER32: ExitWindowsEx\n");
848#endif
849 return O32_ExitWindowsEx(uFlags,dwReserved);
850}
851//******************************************************************************
852//******************************************************************************
853BOOL WIN32API MessageBeep( UINT uType)
854{
855 INT flStyle;
856
857#ifdef DEBUG
858 WriteLog("USER32: MessageBeep\n");
859#endif
860
861 switch (uType)
862 {
863 case 0xFFFFFFFF:
864 OSLibDosBeep(500,50);
865 return TRUE;
866 case MB_ICONASTERISK:
867 flStyle = WAOS_NOTE;
868 break;
869 case MB_ICONEXCLAMATION:
870 flStyle = WAOS_WARNING;
871 break;
872 case MB_ICONHAND:
873 case MB_ICONQUESTION:
874 case MB_OK:
875 flStyle = WAOS_NOTE;
876 break;
877 default:
878 flStyle = WAOS_ERROR; //CB: should be right
879 break;
880 }
881 return OSLibWinAlarm(OSLIB_HWND_DESKTOP,flStyle);
882}
883//******************************************************************************
884//2nd parameter not used according to SDK (yet?)
885//******************************************************************************
886VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
887{
888#ifdef DEBUG
889 WriteLog("USER32: SetLastErrorEx\n");
890#endif
891 SetLastError(dwErrCode);
892}
893
894/* Accessibility Functions */
895
896int WIN32API GetSystemMetrics(int nIndex)
897{
898 int rc = 0;
899
900 switch(nIndex) {
901 case SM_CXICONSPACING: //TODO: size of grid cell for large icons
902 rc = OSLibWinQuerySysValue(OSLIB_HWND_DESKTOP,SVOS_CXICON);
903 //CB: return standard windows icon size?
904 //rc = 32;
905 break;
906 case SM_CYICONSPACING:
907 rc = OSLibWinQuerySysValue(OSLIB_HWND_DESKTOP,SVOS_CYICON);
908 //read SM_CXICONSPACING comment
909 //rc = 32;
910 break;
911 case SM_PENWINDOWS:
912 rc = FALSE;
913 break;
914 case SM_DBCSENABLED:
915 rc = FALSE;
916 break;
917 case SM_CXEDGE: //size of 3D window edge (not supported)
918 rc = 1;
919 break;
920 case SM_CYEDGE:
921 rc = 1;
922 break;
923 case SM_CXMINSPACING: //can be SM_CXMINIMIZED or larger
924 //CB: replace with const
925 rc = O32_GetSystemMetrics(SM_CXMINIMIZED);
926 break;
927 case SM_CYMINSPACING:
928 //CB: replace with const
929 rc = GetSystemMetrics(SM_CYMINIMIZED);
930 break;
931 case SM_CXICON:
932 case SM_CYICON:
933 rc = 32; //CB: Win32: only 32x32, OS/2 32x32/40x40
934 // we must implement 32x32 for all screen resolutions
935 break;
936 case SM_CXSMICON: //recommended size of small icons (TODO: adjust to screen res.)
937 rc = 16;
938 break;
939 case SM_CYSMICON:
940 rc = 16;
941 break;
942 case SM_CYSMCAPTION: //size in pixels of a small caption (TODO: ????)
943 rc = 8;
944 break;
945 case SM_CXSMSIZE: //size of small caption buttons (pixels) (TODO: implement properly)
946 rc = 16;
947 break;
948 case SM_CYSMSIZE:
949 rc = 16;
950 break;
951 case SM_CXMENUSIZE: //TODO: size of menu bar buttons (such as MDI window close)
952 rc = 16;
953 break;
954 case SM_CYMENUSIZE:
955 rc = 16;
956 break;
957 case SM_ARRANGE:
958 rc = ARW_BOTTOMLEFT | ARW_LEFT;
959 break;
960 case SM_CXMINIMIZED:
961 break;
962 case SM_CYMINIMIZED:
963 break;
964 case SM_CXMAXTRACK: //max window size
965 case SM_CXMAXIMIZED: //max toplevel window size
966 rc = OSLibWinQuerySysValue(OSLIB_HWND_DESKTOP,SVOS_CXSCREEN);
967 break;
968 case SM_CYMAXTRACK:
969 case SM_CYMAXIMIZED:
970 rc = OSLibWinQuerySysValue(OSLIB_HWND_DESKTOP,SVOS_CYSCREEN);
971 break;
972 case SM_NETWORK:
973 rc = 0x01; //TODO: default = yes
974 break;
975 case SM_CLEANBOOT:
976 rc = 0; //normal boot
977 break;
978 case SM_CXDRAG: //nr of pixels before drag becomes a real one
979 rc = 2;
980 break;
981 case SM_CYDRAG:
982 rc = 2;
983 break;
984 case SM_SHOWSOUNDS: //show instead of play sound
985 rc = FALSE;
986 break;
987 case SM_CXMENUCHECK:
988 rc = 4; //TODO
989 break;
990 case SM_CYMENUCHECK:
991 rc = OSLibWinQuerySysValue(OSLIB_HWND_DESKTOP,SVOS_CYMENU);
992 break;
993 case SM_SLOWMACHINE:
994 rc = FALSE; //even a slow machine is fast with OS/2 :)
995 break;
996 case SM_MIDEASTENABLED:
997 rc = FALSE;
998 break;
999 case SM_CMETRICS:
1000 //CB: replace with const
1001 rc = O32_GetSystemMetrics(44); //Open32 changed this one
1002 break;
1003 default:
1004 //better than nothing
1005 rc = O32_GetSystemMetrics(nIndex);
1006 break;
1007 }
1008#ifdef DEBUG
1009 WriteLog("USER32: GetSystemMetrics %d returned %d\n", nIndex, rc);
1010#endif
1011 return(rc);
1012}
1013//******************************************************************************
1014/* Not support by Open32 (not included are the new win9x parameters):
1015 case SPI_GETFASTTASKSWITCH:
1016 case SPI_GETGRIDGRANULARITY:
1017 case SPI_GETICONTITLELOGFONT:
1018 case SPI_GETICONTITLEWRAP:
1019 case SPI_GETMENUDROPALIGNMENT:
1020 case SPI_ICONHORIZONTALSPACING:
1021 case SPI_ICONVERTICALSPACING:
1022 case SPI_LANGDRIVER:
1023 case SPI_SETFASTTASKSWITCH:
1024 case SPI_SETGRIDGRANULARITY:
1025 case SPI_SETICONTITLELOGFONT:
1026 case SPI_SETICONTITLEWRAP:
1027 case SPI_SETMENUDROPALIGNMENT:
1028 case SPI_GETSCREENSAVEACTIVE:
1029 case SPI_GETSCREENSAVETIMEOUT:
1030 case SPI_SETDESKPATTERN:
1031 case SPI_SETDESKWALLPAPER:
1032 case SPI_SETSCREENSAVEACTIVE:
1033 case SPI_SETSCREENSAVETIMEOUT:
1034*/
1035//******************************************************************************
1036BOOL WIN32API SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
1037{
1038 BOOL rc = TRUE;
1039 NONCLIENTMETRICSA *cmetric = (NONCLIENTMETRICSA *)pvParam;
1040
1041 switch(uiAction) {
1042 case SPI_SCREENSAVERRUNNING:
1043 *(BOOL *)pvParam = FALSE;
1044 break;
1045 case SPI_GETDRAGFULLWINDOWS:
1046 *(BOOL *)pvParam = FALSE;
1047 break;
1048 case SPI_GETNONCLIENTMETRICS:
1049 memset(cmetric, 0, sizeof(NONCLIENTMETRICSA));
1050 cmetric->cbSize = sizeof(NONCLIENTMETRICSA);
1051
1052 //CB: fonts not handled by Open32, set to WarpSans
1053 lstrcpyA(cmetric->lfCaptionFont.lfFaceName,"WarpSans");
1054 cmetric->lfCaptionFont.lfHeight = 9;
1055
1056 lstrcpyA(cmetric->lfMenuFont.lfFaceName,"WarpSans");
1057 cmetric->lfMenuFont.lfHeight = 9;
1058
1059 lstrcpyA(cmetric->lfStatusFont.lfFaceName,"WarpSans");
1060 cmetric->lfStatusFont.lfHeight = 9;
1061
1062 lstrcpyA(cmetric->lfMessageFont.lfFaceName,"WarpSans");
1063 cmetric->lfMessageFont.lfHeight = 9;
1064
1065 cmetric->iBorderWidth = GetSystemMetrics(SM_CXBORDER);
1066 cmetric->iScrollWidth = GetSystemMetrics(SM_CXHSCROLL);
1067 cmetric->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
1068 cmetric->iCaptionWidth = 32; //TODO
1069 cmetric->iCaptionHeight = 16; //TODO
1070 cmetric->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
1071 cmetric->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
1072 cmetric->iMenuWidth = 32; //TODO
1073 cmetric->iMenuHeight = GetSystemMetrics(SM_CYMENU);
1074 break;
1075 case SPI_GETICONTITLELOGFONT:
1076 {
1077 LPLOGFONTA lpLogFont = (LPLOGFONTA)pvParam;
1078
1079 /* from now on we always have an alias for MS Sans Serif */
1080 strcpy(lpLogFont->lfFaceName, "MS Sans Serif");
1081 lpLogFont->lfHeight = -GetProfileIntA("Desktop","IconTitleSize", 8);
1082 lpLogFont->lfWidth = 0;
1083 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
1084 lpLogFont->lfWeight = FW_NORMAL;
1085 lpLogFont->lfItalic = FALSE;
1086 lpLogFont->lfStrikeOut = FALSE;
1087 lpLogFont->lfUnderline = FALSE;
1088 lpLogFont->lfCharSet = ANSI_CHARSET;
1089 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
1090 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
1091 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
1092 break;
1093 }
1094 case SPI_GETBORDER:
1095 *(INT *)pvParam = GetSystemMetrics( SM_CXFRAME );
1096 break;
1097
1098 case SPI_GETWORKAREA:
1099 SetRect( (RECT *)pvParam, 0, 0,
1100 GetSystemMetrics( SM_CXSCREEN ),
1101 GetSystemMetrics( SM_CYSCREEN )
1102 );
1103 break;
1104
1105 case 104: //TODO: Undocumented
1106 rc = 16;
1107 break;
1108 default:
1109 rc = O32_SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
1110 break;
1111 }
1112#ifdef DEBUG
1113 WriteLog("USER32: SystemParametersInfoA %d, returned %d\n", uiAction, rc);
1114#endif
1115 return(rc);
1116}
1117//******************************************************************************
1118//TODO: Check for more options that have different structs for Unicode!!!!
1119//******************************************************************************
1120BOOL WIN32API SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
1121{
1122 BOOL rc;
1123 NONCLIENTMETRICSW *clientMetricsW = (NONCLIENTMETRICSW *)pvParam;
1124 NONCLIENTMETRICSA clientMetricsA = {0};
1125 PVOID pvParamA;
1126 UINT uiParamA;
1127
1128 switch(uiAction) {
1129 case SPI_SETNONCLIENTMETRICS:
1130 clientMetricsA.cbSize = sizeof(NONCLIENTMETRICSA);
1131 clientMetricsA.iBorderWidth = clientMetricsW->iBorderWidth;
1132 clientMetricsA.iScrollWidth = clientMetricsW->iScrollWidth;
1133 clientMetricsA.iScrollHeight = clientMetricsW->iScrollHeight;
1134 clientMetricsA.iCaptionWidth = clientMetricsW->iCaptionWidth;
1135 clientMetricsA.iCaptionHeight = clientMetricsW->iCaptionHeight;
1136 ConvertFontWA(&clientMetricsW->lfCaptionFont, &clientMetricsA.lfCaptionFont);
1137 clientMetricsA.iSmCaptionWidth = clientMetricsW->iSmCaptionWidth;
1138 clientMetricsA.iSmCaptionHeight = clientMetricsW->iSmCaptionHeight;
1139 ConvertFontWA(&clientMetricsW->lfSmCaptionFont, &clientMetricsA.lfSmCaptionFont);
1140 clientMetricsA.iMenuWidth = clientMetricsW->iMenuWidth;
1141 clientMetricsA.iMenuHeight = clientMetricsW->iMenuHeight;
1142 ConvertFontWA(&clientMetricsW->lfMenuFont, &clientMetricsA.lfMenuFont);
1143 ConvertFontWA(&clientMetricsW->lfStatusFont, &clientMetricsA.lfStatusFont);
1144 ConvertFontWA(&clientMetricsW->lfMessageFont, &clientMetricsA.lfMessageFont);
1145 //no break
1146 case SPI_GETNONCLIENTMETRICS:
1147 uiParamA = sizeof(NONCLIENTMETRICSA);
1148 pvParamA = &clientMetricsA;
1149 break;
1150 case SPI_GETICONTITLELOGFONT:
1151 {
1152 LPLOGFONTW lpLogFont = (LPLOGFONTW)pvParam;
1153
1154 /* from now on we always have an alias for MS Sans Serif */
1155 lstrcpyW(lpLogFont->lfFaceName, (LPCWSTR)L"MS Sans Serif");
1156 lpLogFont->lfHeight = -GetProfileIntA("Desktop","IconTitleSize", 8);
1157 lpLogFont->lfWidth = 0;
1158 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
1159 lpLogFont->lfWeight = FW_NORMAL;
1160 lpLogFont->lfItalic = FALSE;
1161 lpLogFont->lfStrikeOut = FALSE;
1162 lpLogFont->lfUnderline = FALSE;
1163 lpLogFont->lfCharSet = ANSI_CHARSET;
1164 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
1165 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
1166 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
1167 return TRUE;
1168 }
1169 default:
1170 pvParamA = pvParam;
1171 uiParamA = uiParam;
1172 break;
1173 }
1174 rc = SystemParametersInfoA(uiAction, uiParamA, pvParamA, fWinIni);
1175
1176 switch(uiAction) {
1177 case SPI_GETNONCLIENTMETRICS:
1178 clientMetricsW->cbSize = sizeof(*clientMetricsW);
1179 clientMetricsW->iBorderWidth = clientMetricsA.iBorderWidth;
1180 clientMetricsW->iScrollWidth = clientMetricsA.iScrollWidth;
1181 clientMetricsW->iScrollHeight = clientMetricsA.iScrollHeight;
1182 clientMetricsW->iCaptionWidth = clientMetricsA.iCaptionWidth;
1183 clientMetricsW->iCaptionHeight = clientMetricsA.iCaptionHeight;
1184 ConvertFontAW(&clientMetricsA.lfCaptionFont, &clientMetricsW->lfCaptionFont);
1185
1186 clientMetricsW->iSmCaptionWidth = clientMetricsA.iSmCaptionWidth;
1187 clientMetricsW->iSmCaptionHeight = clientMetricsA.iSmCaptionHeight;
1188 ConvertFontAW(&clientMetricsA.lfSmCaptionFont, &clientMetricsW->lfSmCaptionFont);
1189
1190 clientMetricsW->iMenuWidth = clientMetricsA.iMenuWidth;
1191 clientMetricsW->iMenuHeight = clientMetricsA.iMenuHeight;
1192 ConvertFontAW(&clientMetricsA.lfMenuFont, &clientMetricsW->lfMenuFont);
1193 ConvertFontAW(&clientMetricsA.lfStatusFont, &clientMetricsW->lfStatusFont);
1194 ConvertFontAW(&clientMetricsA.lfMessageFont, &clientMetricsW->lfMessageFont);
1195 break;
1196 }
1197#ifdef DEBUG
1198 WriteLog("USER32: SystemParametersInfoW %d, returned %d\n", uiAction, rc);
1199#endif
1200 return(rc);
1201}
1202
1203/* Timer Functions */
1204
1205#if 0
1206BOOL WIN32API KillTimer(HWND hWnd, UINT uIDEvent)
1207{
1208#ifdef DEBUG
1209 WriteLog("USER32: KillTimer\n");
1210#endif
1211 hWnd = Win32Window::Win32ToOS2Handle(hWnd);
1212 //WinStopTimer
1213 //CB: replace
1214 return O32_KillTimer(hWnd,uIDEvent);
1215}
1216//******************************************************************************
1217//******************************************************************************
1218UINT WIN32API SetTimer( HWND hwnd, UINT idTimer, UINT uTimeout, TIMERPROC tmprc)
1219{
1220#ifdef DEBUG
1221 WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
1222#endif
1223 hwnd = Win32Window::Win32ToOS2Handle(hwnd);
1224 //SvL: Write callback handler class for this one
1225 //CB: replace
1226 return O32_SetTimer(hwnd,idTimer,uTimeout,(TIMERPROC_O32)tmprc);
1227}
1228#endif
1229
1230/* Process and Thread Functions */
1231
1232//******************************************************************************
1233//DWORD idAttach; /* thread to attach */
1234//DWORD idAttachTo; /* thread to attach to */
1235//BOOL fAttach; /* attach or detach */
1236//******************************************************************************
1237BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
1238{
1239#ifdef DEBUG
1240 WriteLog("USER32: AttachThreadInput, not implemented\n");
1241#endif
1242 return(TRUE);
1243}
1244//******************************************************************************
1245//TODO:How can we emulate this one in OS/2???
1246//******************************************************************************
1247DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
1248{
1249#ifdef DEBUG
1250 WriteLog("USER32: WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
1251#endif
1252
1253 if(dwTimeOut == INFINITE) return(0);
1254
1255// DosSleep(dwTimeOut/16);
1256 return(0);
1257}
1258
1259/* Help Functions */
1260
1261BOOL WIN32API WinHelpA( HWND hwnd, LPCSTR lpszHelp, UINT uCommand, DWORD dwData)
1262{
1263#ifdef DEBUG
1264 WriteLog("USER32: WinHelp not implemented %s\n", lpszHelp);
1265#endif
1266// hwnd = Win32Window::Win32ToOS2Handle(hwnd);
1267// return O32_WinHelp(arg1, arg2, arg3, arg4);
1268
1269 return(TRUE);
1270}
1271//******************************************************************************
1272//******************************************************************************
1273BOOL WIN32API WinHelpW( HWND arg1, LPCWSTR arg2, UINT arg3, DWORD arg4)
1274{
1275 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1276 BOOL rc;
1277
1278#ifdef DEBUG
1279 WriteLog("USER32: WinHelpW\n");
1280#endif
1281 rc = WinHelpA(arg1, astring, arg3, arg4);
1282 FreeAsciiString(astring);
1283 return rc;
1284}
1285
1286/* Keyboard and Input Functions */
1287
1288BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
1289{
1290#ifdef DEBUG
1291 WriteLog("USER32: ActivateKeyboardLayout, not implemented\n");
1292#endif
1293 return(TRUE);
1294}
1295//******************************************************************************
1296//SvL: 24-6-'97 - Added
1297//TODO: Not implemented
1298//******************************************************************************
1299WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1300{
1301#ifdef DEBUG
1302//// WriteLog("USER32: GetAsyncKeyState Not implemented\n");
1303#endif
1304 return 0;
1305}
1306/*****************************************************************************
1307 * Name : BOOL WIN32API GetKeyboardLayoutNameA
1308 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
1309 * active keyboard layout.
1310 * Parameters: LPTSTR pwszKLID address of buffer for layout name
1311 * Variables :
1312 * Result : If the function succeeds, the return value is TRUE.
1313 * If the function fails, the return value is FALSE. To get extended
1314 * error information, call GetLastError.
1315 * Remark :
1316 * Status : UNTESTED STUB
1317 *
1318 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1319 *****************************************************************************/
1320// @@@PH Win32 BOOL's are casted to INTs
1321INT WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
1322{
1323 dprintf(("USER32:GetKeyboardLayoutNameA (%08x) not implemented.",
1324 pwszKLID));
1325
1326 return(FALSE);
1327}
1328/*****************************************************************************
1329 * Name : BOOL WIN32API GetKeyboardLayoutNameW
1330 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
1331 * active keyboard layout.
1332 * Parameters: LPTSTR pwszKLID address of buffer for layout name
1333 * Variables :
1334 * Result : If the function succeeds, the return value is TRUE.
1335 * If the function fails, the return value is FALSE. To get extended
1336 * error information, call GetLastError.
1337 * Remark :
1338 * Status : UNTESTED STUB
1339 *
1340 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1341 *****************************************************************************/
1342// @@@PH Win32 BOOL's are casted to INTs
1343INT WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
1344{
1345 dprintf(("USER32:GetKeyboardLayoutNameW (%08x) not implemented.",
1346 pwszKLID));
1347
1348 return(FALSE);
1349}
1350//******************************************************************************
1351//******************************************************************************
1352BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
1353{
1354#ifdef DEBUG
1355 WriteLog("USER32: GetKeyboardState, not properly implemented\n");
1356#endif
1357 memset(lpKeyState, 0, 256);
1358 return(TRUE);
1359}
1360//******************************************************************************
1361//******************************************************************************
1362int WIN32API GetKeyNameTextA( LPARAM lParam, LPSTR lpString, int nSize)
1363{
1364#ifdef DEBUG
1365 WriteLog("USER32: GetKeyNameTextA\n");
1366#endif
1367 return O32_GetKeyNameText(lParam,lpString,nSize);
1368}
1369//******************************************************************************
1370//******************************************************************************
1371int WIN32API GetKeyNameTextW( LPARAM lParam, LPWSTR lpString, int nSize)
1372{
1373#ifdef DEBUG
1374 WriteLog("USER32: GetKeyNameTextW DOES NOT WORK\n");
1375#endif
1376 // NOTE: This will not work as is (needs UNICODE support)
1377 return 0;
1378// return O32_GetKeyNameText(arg1, arg2, arg3);
1379}
1380//******************************************************************************
1381//SvL: 24-6-'97 - Added
1382//******************************************************************************
1383SHORT WIN32API GetKeyState( int nVirtKey)
1384{
1385#ifdef DEBUG
1386 WriteLog("USER32: GetKeyState %d\n", nVirtKey);
1387#endif
1388 return O32_GetKeyState(nVirtKey);
1389}
1390/*****************************************************************************
1391 * Name : VOID WIN32API keybd_event
1392 * Purpose : The keybd_event function synthesizes a keystroke. The system
1393 * can use such a synthesized keystroke to generate a WM_KEYUP or
1394 * WM_KEYDOWN message. The keyboard driver's interrupt handler calls
1395 * the keybd_event function.
1396 * Parameters: BYTE bVk virtual-key code
1397
1398 * BYTE bScan hardware scan code
1399 * DWORD dwFlags flags specifying various function options
1400 * DWORD dwExtraInfo additional data associated with keystroke
1401 * Variables :
1402 * Result :
1403 * Remark :
1404 * Status : UNTESTED STUB
1405 *
1406 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1407 *****************************************************************************/
1408VOID WIN32API keybd_event (BYTE bVk,
1409 BYTE bScan,
1410 DWORD dwFlags,
1411 DWORD dwExtraInfo)
1412{
1413 dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
1414 bVk,
1415 bScan,
1416 dwFlags,
1417 dwExtraInfo));
1418}
1419/*****************************************************************************
1420 * Name : HLK WIN32API LoadKeyboardLayoutA
1421 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
1422 * the system. Several keyboard layouts can be loaded at a time, but
1423 * only one per process is active at a time. Loading multiple keyboard
1424 * layouts makes it possible to rapidly switch between layouts.
1425 * Parameters:
1426 * Variables :
1427 * Result : If the function succeeds, the return value is the handle of the
1428 * keyboard layout.
1429 * If the function fails, the return value is NULL. To get extended
1430 * error information, call GetLastError.
1431 * Remark :
1432 * Status : UNTESTED STUB
1433 *
1434 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1435 *****************************************************************************/
1436HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
1437 UINT Flags)
1438{
1439 dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
1440 pwszKLID,
1441 Flags));
1442
1443 return (NULL);
1444}
1445/*****************************************************************************
1446 * Name : HLK WIN32API LoadKeyboardLayoutW
1447 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
1448 * the system. Several keyboard layouts can be loaded at a time, but
1449 * only one per process is active at a time. Loading multiple keyboard
1450 * layouts makes it possible to rapidly switch between layouts.
1451 * Parameters:
1452 * Variables :
1453 * Result : If the function succeeds, the return value is the handle of the
1454 * keyboard layout.
1455 * If the function fails, the return value is NULL. To get extended
1456 * error information, call GetLastError.
1457 * Remark :
1458 * Status : UNTESTED STUB
1459 *
1460 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1461 *****************************************************************************/
1462HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
1463 UINT Flags)
1464{
1465 dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
1466 pwszKLID,
1467 Flags));
1468
1469 return (NULL);
1470}
1471//******************************************************************************
1472//******************************************************************************
1473UINT WIN32API MapVirtualKeyA( UINT uCode, UINT uMapType)
1474{
1475#ifdef DEBUG
1476 WriteLog("USER32: MapVirtualKeyA\n");
1477#endif
1478 return O32_MapVirtualKey(uCode,uMapType);
1479}
1480//******************************************************************************
1481//******************************************************************************
1482UINT WIN32API MapVirtualKeyW( UINT uCode, UINT uMapType)
1483{
1484#ifdef DEBUG
1485 WriteLog("USER32: MapVirtualKeyW\n");
1486#endif
1487 // NOTE: This will not work as is (needs UNICODE support)
1488 return O32_MapVirtualKey(uCode,uMapType);
1489}
1490/*****************************************************************************
1491 * Name : UINT WIN32API MapVirtualKeyExA
1492 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
1493 * code into a scan code or character value, or translates a scan
1494 * code into a virtual-key code. The function translates the codes
1495 * using the input language and physical keyboard layout identified
1496 * by the given keyboard layout handle.
1497 * Parameters:
1498 * Variables :
1499 * Result : The return value is either a scan code, a virtual-key code, or
1500 * a character value, depending on the value of uCode and uMapType.
1501 * If there is no translation, the return value is zero.
1502 * Remark :
1503 * Status : UNTESTED STUB
1504 *
1505 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1506 *****************************************************************************/
1507UINT WIN32API MapVirtualKeyExA(UINT uCode,
1508 UINT uMapType,
1509 HKL dwhkl)
1510{
1511 dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
1512 uCode,
1513 uMapType,
1514 dwhkl));
1515
1516 return (0);
1517}
1518/*****************************************************************************
1519 * Name : UINT WIN32API MapVirtualKeyExW
1520 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
1521 * code into a scan code or character value, or translates a scan
1522 * code into a virtual-key code. The function translates the codes
1523 * using the input language and physical keyboard layout identified
1524 * by the given keyboard layout handle.
1525 * Parameters:
1526 * Variables :
1527 * Result : The return value is either a scan code, a virtual-key code, or
1528 * a character value, depending on the value of uCode and uMapType.
1529 * If there is no translation, the return value is zero.
1530 * Remark :
1531 * Status : UNTESTED STUB
1532
1533 *
1534 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1535 *****************************************************************************/
1536UINT WIN32API MapVirtualKeyExW(UINT uCode,
1537 UINT uMapType,
1538 HKL dwhkl)
1539{
1540 dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
1541 uCode,
1542 uMapType,
1543 dwhkl));
1544
1545 return (0);
1546}
1547/*****************************************************************************
1548 * Name : DWORD WIN32API OemKeyScan
1549 * Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
1550 * into the OEM scan codes and shift states. The function provides
1551 * information that allows a program to send OEM text to another
1552 * program by simulating keyboard input.
1553 * Parameters:
1554 * Variables :
1555 * Result :
1556 * Remark :
1557 * Status : UNTESTED STUB
1558 *
1559 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1560 *****************************************************************************/
1561DWORD WIN32API OemKeyScan(WORD wOemChar)
1562{
1563 dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
1564 wOemChar));
1565
1566 return (wOemChar);
1567}
1568//******************************************************************************
1569//******************************************************************************
1570BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
1571{
1572#ifdef DEBUG
1573 WriteLog("USER32: RegisterHotKey, not implemented\n");
1574#endif
1575 hwnd = Win32Window::Win32ToOS2Handle(hwnd);
1576 return(TRUE);
1577}
1578//******************************************************************************
1579//******************************************************************************
1580BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
1581{
1582#ifdef DEBUG
1583 WriteLog("USER32: SetKeyboardState, not implemented\n");
1584#endif
1585 return(TRUE);
1586}
1587/*****************************************************************************
1588 * Name : int WIN32API ToAscii
1589 * Purpose : The ToAscii function translates the specified virtual-key code
1590 * and keyboard state to the corresponding Windows character or characters.
1591 * Parameters: UINT uVirtKey virtual-key code
1592 * UINT uScanCode scan code
1593 * PBYTE lpbKeyState address of key-state array
1594 * LPWORD lpwTransKey buffer for translated key
1595 * UINT fuState active-menu flag
1596 * Variables :
1597 * Result : 0 The specified virtual key has no translation for the current
1598 * state of the keyboard.
1599 * 1 One Windows character was copied to the buffer.
1600 * 2 Two characters were copied to the buffer. This usually happens
1601 * when a dead-key character (accent or diacritic) stored in the
1602 * keyboard layout cannot be composed with the specified virtual
1603 * key to form a single character.
1604 * Remark :
1605 * Status : UNTESTED STUB
1606 *
1607 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1608 *****************************************************************************/
1609int WIN32API ToAscii(UINT uVirtKey,
1610 UINT uScanCode,
1611 PBYTE lpbKeyState,
1612 LPWORD lpwTransKey,
1613 UINT fuState)
1614{
1615 dprintf(("USER32:ToAscii (%u,%u,%08xh,%08xh,%u) not implemented.\n",
1616 uVirtKey,
1617 uScanCode,
1618 lpbKeyState,
1619 lpwTransKey,
1620 fuState));
1621
1622 return (0);
1623}
1624/*****************************************************************************
1625 * Name : int WIN32API ToAsciiEx
1626 * Purpose : The ToAscii function translates the specified virtual-key code
1627 * and keyboard state to the corresponding Windows character or characters.
1628 * Parameters: UINT uVirtKey virtual-key code
1629 * UINT uScanCode scan code
1630 * PBYTE lpbKeyState address of key-state array
1631 * LPWORD lpwTransKey buffer for translated key
1632 * UINT fuState active-menu flag
1633 * HLK hlk keyboard layout handle
1634 * Variables :
1635 * Result : 0 The specified virtual key has no translation for the current
1636 * state of the keyboard.
1637 * 1 One Windows character was copied to the buffer.
1638 * 2 Two characters were copied to the buffer. This usually happens
1639 * when a dead-key character (accent or diacritic) stored in the
1640 * keyboard layout cannot be composed with the specified virtual
1641 * key to form a single character.
1642 * Remark :
1643 * Status : UNTESTED STUB
1644 *
1645 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1646 *****************************************************************************/
1647int WIN32API ToAsciiEx(UINT uVirtKey,
1648 UINT uScanCode,
1649 PBYTE lpbKeyState,
1650 LPWORD lpwTransKey,
1651 UINT fuState,
1652 HKL hkl)
1653{
1654 dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
1655 uVirtKey,
1656 uScanCode,
1657 lpbKeyState,
1658 lpwTransKey,
1659 fuState,
1660 hkl));
1661
1662 return (0);
1663}
1664/*****************************************************************************
1665 * Name : int WIN32API ToUnicode
1666 * Purpose : The ToUnicode function translates the specified virtual-key code
1667 * and keyboard state to the corresponding Unicode character or characters.
1668 * Parameters: UINT wVirtKey virtual-key code
1669 * UINT wScanCode scan code
1670 * PBYTE lpKeyState address of key-state array
1671 * LPWSTR pwszBuff buffer for translated key
1672 * int cchBuff size of translated key buffer
1673 * UINT wFlags set of function-conditioning flags
1674 * Variables :
1675 * Result : - 1 The specified virtual key is a dead-key character (accent or
1676 * diacritic). This value is returned regardless of the keyboard
1677 * layout, even if several characters have been typed and are
1678 * stored in the keyboard state. If possible, even with Unicode
1679 * keyboard layouts, the function has written a spacing version of
1680 * the dead-key character to the buffer specified by pwszBuffer.
1681 * For example, the function writes the character SPACING ACUTE
1682 * (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
1683 * 0 The specified virtual key has no translation for the current
1684 * state of the keyboard. Nothing was written to the buffer
1685 * specified by pwszBuffer.
1686 * 1 One character was written to the buffer specified by pwszBuffer.
1687 * 2 or more Two or more characters were written to the buffer specified by
1688 * pwszBuff. The most common cause for this is that a dead-key
1689 * character (accent or diacritic) stored in the keyboard layout
1690 * could not be combined with the specified virtual key to form a
1691 * single character.
1692 * Remark :
1693 * Status : UNTESTED STUB
1694 *
1695 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1696 *****************************************************************************/
1697int WIN32API ToUnicode(UINT uVirtKey,
1698 UINT uScanCode,
1699 PBYTE lpKeyState,
1700 LPWSTR pwszBuff,
1701 int cchBuff,
1702 UINT wFlags)
1703{
1704 dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
1705 uVirtKey,
1706 uScanCode,
1707 lpKeyState,
1708 pwszBuff,
1709 cchBuff,
1710 wFlags));
1711
1712 return (0);
1713}
1714/*****************************************************************************
1715 * Name : BOOL WIN32API UnloadKeyboardLayout
1716 * Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
1717 * Parameters: HKL hkl handle of keyboard layout
1718 * Variables :
1719 * Result : If the function succeeds, the return value is the handle of the
1720 * keyboard layout; otherwise, it is NULL. To get extended error
1721 * information, use the GetLastError function.
1722 * Remark :
1723 * Status : UNTESTED STUB
1724 *
1725 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1726 *****************************************************************************/
1727BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
1728{
1729 dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
1730 hkl));
1731
1732 return (0);
1733}
1734//******************************************************************************
1735//******************************************************************************
1736BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
1737{
1738#ifdef DEBUG
1739 WriteLog("USER32: UnregisterHotKey, not implemented\n");
1740#endif
1741 hwnd = Win32Window::Win32ToOS2Handle(hwnd);
1742
1743 return(TRUE);
1744}
1745//******************************************************************************
1746//SvL: 24-6-'97 - Added
1747//******************************************************************************
1748WORD WIN32API VkKeyScanA( char ch)
1749{
1750#ifdef DEBUG
1751 WriteLog("USER32: VkKeyScanA\n");
1752#endif
1753 return O32_VkKeyScan(ch);
1754}
1755
1756
1757//CB: stopped here void aa(){};
1758
1759//******************************************************************************
1760//******************************************************************************
1761DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD arg5)
1762{
1763#ifdef DEBUG
1764 WriteLog("USER32: MsgWaitForMultipleObjects\n");
1765#endif
1766 return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
1767}
1768//******************************************************************************
1769//******************************************************************************
1770BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT arg4)
1771{
1772#ifdef DEBUG
1773 WriteLog("USER32: CheckRadioButton\n");
1774#endif
1775 //CB: check radio buttons in interval
1776 if (arg2 > arg3) return (FALSE);
1777 for (UINT x=arg2;x <= arg3;x++)
1778 {
1779 SendDlgItemMessageA(arg1,x,BM_SETCHECK,(x == arg4) ? BST_CHECKED : BST_UNCHECKED,0);
1780 }
1781 return (TRUE);
1782}
1783//******************************************************************************
1784//******************************************************************************
1785BOOL WIN32API EndDeferWindowPos( HDWP arg1)
1786{
1787#ifdef DEBUG
1788 WriteLog("USER32: EndDeferWindowPos\n");
1789#endif
1790 return O32_EndDeferWindowPos(arg1);
1791}
1792//******************************************************************************
1793//******************************************************************************
1794INT WIN32API ExcludeUpdateRgn( HDC arg1, HWND arg2)
1795{
1796#ifdef DEBUG
1797 WriteLog("USER32: ExcludeUpdateRgn\n");
1798#endif
1799 return O32_ExcludeUpdateRgn(arg1, arg2);
1800}
1801//******************************************************************************
1802//******************************************************************************
1803int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
1804{
1805#ifdef DEBUG
1806 WriteLog("USER32: FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
1807#endif
1808 return O32_FillRect(arg1, arg2, arg3);
1809}
1810//******************************************************************************
1811//******************************************************************************
1812HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
1813{
1814 char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
1815 char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
1816 HWND rc;
1817
1818#ifdef DEBUG
1819 WriteLog("USER32: FindWindowW\n");
1820#endif
1821 rc = O32_FindWindow(astring1, astring2);
1822 FreeAsciiString(astring1);
1823 FreeAsciiString(astring2);
1824 return rc;
1825}
1826//******************************************************************************
1827//******************************************************************************
1828int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH arg3)
1829{
1830#ifdef DEBUG
1831 WriteLog("USER32: FrameRect\n");
1832#endif
1833 return O32_FrameRect(arg1, arg2, arg3);
1834}
1835//******************************************************************************
1836//******************************************************************************
1837HWND WIN32API GetForegroundWindow(void)
1838{
1839#ifdef DEBUG
1840 WriteLog("USER32: GetForegroundWindow\n");
1841#endif
1842 return O32_GetForegroundWindow();
1843}
1844//******************************************************************************
1845//******************************************************************************
1846int WIN32API GetKeyboardType( int arg1)
1847{
1848#ifdef DEBUG
1849 WriteLog("USER32: GetKeyboardType\n");
1850#endif
1851 return O32_GetKeyboardType(arg1);
1852}
1853//******************************************************************************
1854//******************************************************************************
1855HWND WIN32API GetLastActivePopup( HWND arg1)
1856{
1857#ifdef DEBUG
1858 WriteLog("USER32: GetLastActivePopup\n");
1859#endif
1860 return O32_GetLastActivePopup(arg1);
1861}
1862//******************************************************************************
1863//******************************************************************************
1864//******************************************************************************
1865//******************************************************************************
1866DWORD WIN32API GetQueueStatus( UINT arg1)
1867{
1868#ifdef DEBUG
1869 WriteLog("USER32: GetQueueStatus\n");
1870#endif
1871 return O32_GetQueueStatus(arg1);
1872}
1873//******************************************************************************
1874//******************************************************************************
1875DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
1876{
1877#ifdef DEBUG
1878 WriteLog("USER32: GetTabbedTextExtentA\n");
1879#endif
1880 return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
1881}
1882//******************************************************************************
1883//******************************************************************************
1884DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
1885{
1886 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
1887 DWORD rc;
1888
1889#ifdef DEBUG
1890 WriteLog("USER32: GetTabbedTextExtentW\n");
1891#endif
1892 rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
1893 FreeAsciiString(astring);
1894 return rc;
1895}
1896//******************************************************************************
1897//******************************************************************************
1898#if 0
1899int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL arg3)
1900{
1901#ifdef DEBUG
1902 WriteLog("USER32: GetUpdateRgn\n");
1903#endif
1904 return O32_GetUpdateRgn(arg1, arg2, arg3);
1905}
1906#endif
1907//******************************************************************************
1908
1909
1910//******************************************************************************
1911//******************************************************************************
1912//******************************************************************************
1913DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD arg2)
1914{
1915#ifdef DEBUG
1916 WriteLog("USER32: GetWindowThreadProcessId\n");
1917#endif
1918 return O32_GetWindowThreadProcessId(arg1, arg2);
1919}
1920//******************************************************************************
1921//******************************************************************************
1922#if 0
1923BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL arg3)
1924{
1925#ifdef DEBUG
1926 WriteLog("USER32: InvalidateRgn\n");
1927#endif
1928 return O32_InvalidateRgn(arg1, arg2, arg3);
1929}
1930#endif
1931//******************************************************************************
1932//******************************************************************************
1933BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
1934{
1935#ifdef DEBUG
1936 WriteLog("USER32: InvertRect\n");
1937#endif
1938 return O32_InvertRect(arg1, arg2);
1939}
1940//******************************************************************************
1941//******************************************************************************
1942BOOL WIN32API MapDialogRect( HWND arg1, PRECT arg2)
1943{
1944#ifdef DEBUG
1945 WriteLog("USER32: MapDialogRect\n");
1946#endif
1947 return O32_MapDialogRect(arg1, arg2);
1948}
1949//******************************************************************************
1950//******************************************************************************
1951int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
1952{
1953#ifdef DEBUG
1954 WriteLog("USER32: MapWindowPoints\n");
1955#endif
1956 return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
1957}
1958//******************************************************************************
1959//******************************************************************************
1960BOOL WIN32API ScreenToClient (HWND hwnd, LPPOINT pt)
1961{
1962#ifdef DEBUG
1963 WriteLog("USER32: ScreenToClient\n");
1964#endif
1965 Win32BaseWindow *wnd;
1966 PRECT rcl;
1967
1968 if (!hwnd) return (TRUE);
1969 wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
1970 if (!wnd) return (TRUE);
1971
1972 rcl = wnd->getClientRect();
1973 pt->y = ScreenHeight - pt->y;
1974 OSLibWinMapWindowPoints (OSLIB_HWND_DESKTOP, wnd->getOS2WindowHandle(), (OSLIBPOINT *)pt, 1);
1975 pt->y = (rcl->bottom - rcl->top) - pt->y;
1976 return (TRUE);
1977}
1978//******************************************************************************
1979//******************************************************************************
1980#if 0
1981BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT arg7)
1982{
1983#ifdef DEBUG
1984 WriteLog("USER32: ScrollDC\n");
1985#endif
1986 return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1987}
1988#endif
1989//******************************************************************************
1990//******************************************************************************
1991LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int arg8)
1992{
1993#ifdef DEBUG
1994 WriteLog("USER32: TabbedTextOutA\n");
1995#endif
1996 return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1997}
1998//******************************************************************************
1999//******************************************************************************
2000LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int arg8)
2001{
2002 char *astring = UnicodeToAsciiString((LPWSTR)arg4);
2003 LONG rc;
2004
2005#ifdef DEBUG
2006 WriteLog("USER32: TabbedTextOutW\n");
2007#endif
2008 rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
2009 FreeAsciiString(astring);
2010 return rc;
2011}
2012//******************************************************************************
2013//******************************************************************************
2014BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
2015{
2016#ifdef DEBUG
2017 WriteLog("USER32: ValidateRect\n");
2018#endif
2019 return O32_ValidateRect(arg1, arg2);
2020}
2021//******************************************************************************
2022//******************************************************************************
2023BOOL WIN32API ValidateRgn( HWND arg1, HRGN arg2)
2024{
2025#ifdef DEBUG
2026 WriteLog("USER32: ValidateRgn\n");
2027#endif
2028 return O32_ValidateRgn(arg1, arg2);
2029}
2030//******************************************************************************
2031//******************************************************************************
2032WORD WIN32API VkKeyScanW( WCHAR arg1)
2033{
2034#ifdef DEBUG
2035 WriteLog("USER32: VkKeyScanW\n");
2036#endif
2037 // NOTE: This will not work as is (needs UNICODE support)
2038 return O32_VkKeyScan((char)arg1);
2039}
2040//******************************************************************************
2041//TODO: Not complete
2042//******************************************************************************
2043BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
2044 LPARAM lpData, int nCount, int X, int Y, int nWidth,
2045 int nHeight)
2046{
2047 BOOL rc;
2048 COLORREF curclr;
2049
2050#ifdef DEBUG
2051 WriteLog("USER32: GrayStringA, not completely implemented\n");
2052#endif
2053 if(lpOutputFunc == NULL && lpData == NULL) {
2054#ifdef DEBUG
2055 WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
2056#endif
2057 return(FALSE);
2058 }
2059 if(lpOutputFunc) {
2060 return(lpOutputFunc(hdc, lpData, nCount));
2061 }
2062 curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
2063 rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
2064 SetTextColor(hdc, curclr);
2065
2066 return(rc);
2067}
2068//******************************************************************************
2069//******************************************************************************
2070BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
2071 LPARAM lpData, int nCount, int X, int Y, int nWidth,
2072 int nHeight)
2073{
2074 BOOL rc;
2075 char *astring;
2076 COLORREF curclr;
2077
2078#ifdef DEBUG
2079 WriteLog("USER32: GrayStringW, not completely implemented\n");
2080#endif
2081
2082 if(lpOutputFunc == NULL && lpData == NULL) {
2083#ifdef DEBUG
2084 WriteLog("USER32: lpOutputFunc == NULL && lpData == NULL\n");
2085#endif
2086 return(FALSE);
2087 }
2088 if(nCount == 0)
2089 nCount = UniStrlen((UniChar*)lpData);
2090
2091 if(lpOutputFunc) {
2092 return(lpOutputFunc(hdc, lpData, nCount));
2093 }
2094 astring = UnicodeToAsciiString((LPWSTR)lpData);
2095
2096 curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
2097 rc = TextOutA(hdc, X, Y, astring, nCount);
2098 SetTextColor(hdc, curclr);
2099
2100 FreeAsciiString(astring);
2101 return(rc);
2102}
2103//******************************************************************************
2104//TODO:
2105//******************************************************************************
2106HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
2107{
2108#ifdef DEBUG
2109 WriteLog("USER32: CopyImage, not implemented\n");
2110#endif
2111 switch(uType) {
2112 case IMAGE_BITMAP:
2113 case IMAGE_CURSOR:
2114 case IMAGE_ICON:
2115 default:
2116#ifdef DEBUG
2117 WriteLog("USER32: CopyImage, unknown type\n");
2118#endif
2119 return(NULL);
2120 }
2121 return(NULL);
2122}
2123//******************************************************************************
2124//******************************************************************************
2125int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
2126{
2127#ifdef DEBUG
2128 WriteLog("USER32: GetKeyboardLayoutList, not implemented\n");
2129#endif
2130 return(0);
2131}
2132//******************************************************************************
2133//******************************************************************************
2134HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
2135{
2136#ifdef DEBUG
2137 WriteLog("USER32: GetKeyboardLayout, not implemented\n");
2138#endif
2139 return(0);
2140}
2141//******************************************************************************
2142//******************************************************************************
2143int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
2144{
2145#ifdef DEBUG
2146 WriteLog("USER32: LookupIconIdFromDirectory, not implemented\n");
2147#endif
2148 return(0);
2149}
2150//******************************************************************************
2151//******************************************************************************
2152int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL fIcon,
2153 int cxDesired, int cyDesired,
2154 UINT Flags)
2155{
2156#ifdef DEBUG
2157 WriteLog("USER32: LookupIconIdFromDirectoryEx, not implemented\n");
2158#endif
2159 return(0);
2160}
2161//******************************************************************************
2162//******************************************************************************
2163BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
2164{
2165#ifdef DEBUG
2166 WriteLog("USER32: SetWindowContextHelpId, not implemented\n");
2167#endif
2168 return(TRUE);
2169}
2170//******************************************************************************
2171//******************************************************************************
2172DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
2173{
2174#ifdef DEBUG
2175 WriteLog("USER32: GetWindowContextHelpId, not implemented\n");
2176#endif
2177 return(0);
2178}
2179//******************************************************************************
2180//******************************************************************************
2181BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
2182{
2183#ifdef DEBUG
2184 WriteLog("USER32: GetMonitorInfoA not supported!!\n");
2185#endif
2186 return(FALSE);
2187}
2188//******************************************************************************
2189//******************************************************************************
2190BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
2191{
2192#ifdef DEBUG
2193 WriteLog("USER32: GetMonitorInfoW not supported!!\n");
2194#endif
2195 return(FALSE);
2196}
2197//******************************************************************************
2198//******************************************************************************
2199HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
2200{
2201#ifdef DEBUG
2202 WriteLog("USER32: MonitorFromWindow not correctly supported??\n");
2203#endif
2204 return(0);
2205}
2206//******************************************************************************
2207//******************************************************************************
2208HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
2209{
2210#ifdef DEBUG
2211 WriteLog("USER32: MonitorFromRect not correctly supported??\n");
2212#endif
2213 return(0);
2214}
2215//******************************************************************************
2216//******************************************************************************
2217HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
2218{
2219#ifdef DEBUG
2220 WriteLog("USER32: MonitorFromPoint not correctly supported??\n");
2221#endif
2222 return(0);
2223}
2224//******************************************************************************
2225//******************************************************************************
2226BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
2227{
2228#ifdef DEBUG
2229 WriteLog("USER32: EnumDisplayMonitors not supported??\n");
2230#endif
2231 return(FALSE);
2232}
2233//******************************************************************************
2234//******************************************************************************
2235BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
2236 LPDEVMODEA lpDevMode)
2237{
2238#ifdef DEBUG
2239 WriteLog("USER32: EnumDisplaySettingsA FAKED\n");
2240#endif
2241 switch(iModeNum) {
2242 case 0:
2243 lpDevMode->dmBitsPerPel = 16;
2244 lpDevMode->dmPelsWidth = 768;
2245 lpDevMode->dmPelsHeight = 1024;
2246 lpDevMode->dmDisplayFlags = 0;
2247 lpDevMode->dmDisplayFrequency = 70;
2248 break;
2249 case 1:
2250 lpDevMode->dmBitsPerPel = 16;
2251 lpDevMode->dmPelsWidth = 640;
2252 lpDevMode->dmPelsHeight = 480;
2253 lpDevMode->dmDisplayFlags = 0;
2254 lpDevMode->dmDisplayFrequency = 70;
2255 break;
2256 default:
2257 return(FALSE);
2258 }
2259 return(TRUE);
2260}
2261//******************************************************************************
2262//******************************************************************************
2263LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA lpDevMode, DWORD dwFlags)
2264{
2265#ifdef DEBUG
2266 if(lpDevMode) {
2267 WriteLog("USER32: ChangeDisplaySettingsA FAKED %X\n", dwFlags);
2268 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
2269 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsWidth %d\n", lpDevMode->dmPelsWidth);
2270 WriteLog("USER32: ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
2271 }
2272#endif
2273 return(DISP_CHANGE_SUCCESSFUL);
2274}
2275//******************************************************************************
2276//******************************************************************************
2277
2278
2279/*****************************************************************************
2280 * Name : BOOL WIN32API AnyPopup
2281 * Purpose : The AnyPopup function indicates whether an owned, visible,
2282 * top-level pop-up, or overlapped window exists on the screen. The
2283 * function searches the entire Windows screen, not just the calling
2284 * application's client area.
2285 * Parameters: VOID
2286 * Variables :
2287 * Result : If a pop-up window exists, the return value is TRUE even if the
2288 * pop-up window is completely covered by other windows. Otherwise,
2289 * it is FALSE.
2290 * Remark : AnyPopup is a Windows version 1.x function and is retained for
2291 * compatibility purposes. It is generally not useful.
2292 * Status : UNTESTED STUB
2293 *
2294 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2295 *****************************************************************************/
2296
2297BOOL WIN32API AnyPopup(VOID)
2298{
2299 dprintf(("USER32:AnyPopup() not implemented.\n"));
2300
2301 return (FALSE);
2302}
2303
2304
2305
2306/*****************************************************************************
2307 * Name : LONG WIN32API ChangeDisplaySettingsW
2308 * Purpose : The ChangeDisplaySettings function changes the display settings
2309 * to the specified graphics mode.
2310 * Parameters: LPDEVMODEW lpDevModeW
2311 * DWORD dwFlags
2312 * Variables :
2313 * Result : DISP_CHANGE_SUCCESSFUL The settings change was successful.
2314 * DISP_CHANGE_RESTART The computer must be restarted in order for the graphics mode to work.
2315 * DISP_CHANGE_BADFLAGS An invalid set of flags was passed in.
2316 * DISP_CHANGE_FAILED The display driver failed the specified graphics mode.
2317 * DISP_CHANGE_BADMODE The graphics mode is not supported.
2318 * DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
2319 * Remark :
2320 * Status : UNTESTED STUB
2321 *
2322 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2323 *****************************************************************************/
2324
2325LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
2326 DWORD dwFlags)
2327{
2328 dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
2329 lpDevMode,
2330 dwFlags));
2331
2332 return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
2333 dwFlags));
2334}
2335
2336/*****************************************************************************
2337 * Name : BOOL WIN32API CloseDesktop
2338 * Purpose : The CloseDesktop function closes an open handle of a desktop
2339 * object. A desktop is a secure object contained within a window
2340 * station object. A desktop has a logical display surface and
2341 * contains windows, menus and hooks.
2342 * Parameters: HDESK hDesktop
2343 * Variables :
2344 * Result : If the function succeeds, the return value is TRUE.
2345 * If the functions fails, the return value is FALSE. To get
2346 * extended error information, call GetLastError.
2347 * Remark :
2348 * Status : UNTESTED STUB
2349 *
2350 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2351 *****************************************************************************/
2352
2353BOOL WIN32API CloseDesktop(HDESK hDesktop)
2354{
2355 dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
2356 hDesktop));
2357
2358 return (FALSE);
2359}
2360
2361
2362/*****************************************************************************
2363 * Name : BOOL WIN32API CloseWindowStation
2364 * Purpose : The CloseWindowStation function closes an open window station handle.
2365 * Parameters: HWINSTA hWinSta
2366 * Variables :
2367 * Result :
2368 * Remark : If the function succeeds, the return value is TRUE.
2369 * If the functions fails, the return value is FALSE. To get
2370 * extended error information, call GetLastError.
2371 * Status : UNTESTED STUB
2372 *
2373 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2374 *****************************************************************************/
2375
2376BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
2377{
2378 dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
2379 hWinSta));
2380
2381 return (FALSE);
2382}
2383
2384
2385/*****************************************************************************
2386 * Name : HDESK WIN32API CreateDesktopA
2387 * Purpose : The CreateDesktop function creates a new desktop on the window
2388 * station associated with the calling process.
2389 * Parameters: LPCTSTR lpszDesktop name of the new desktop
2390 * LPCTSTR lpszDevice name of display device to assign to the desktop
2391 * LPDEVMODE pDevMode reserved; must be NULL
2392 * DWORD dwFlags flags to control interaction with other applications
2393 * DWORD dwDesiredAccess specifies access of returned handle
2394 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
2395 * Variables :
2396 * Result : If the function succeeds, the return value is a handle of the
2397 * newly created desktop.
2398 * If the function fails, the return value is NULL. To get extended
2399 * error information, call GetLastError.
2400 * Remark :
2401 * Status : UNTESTED STUB
2402 *
2403 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2404 *****************************************************************************/
2405
2406HDESK WIN32API CreateDesktopA(LPCTSTR lpszDesktop,
2407 LPCTSTR lpszDevice,
2408 LPDEVMODEA pDevMode,
2409 DWORD dwFlags,
2410 DWORD dwDesiredAccess,
2411 LPSECURITY_ATTRIBUTES lpsa)
2412{
2413 dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
2414 lpszDesktop,
2415 lpszDevice,
2416 pDevMode,
2417 dwFlags,
2418 dwDesiredAccess,
2419 lpsa));
2420
2421 return (NULL);
2422}
2423
2424
2425/*****************************************************************************
2426 * Name : HDESK WIN32API CreateDesktopW
2427 * Purpose : The CreateDesktop function creates a new desktop on the window
2428 * station associated with the calling process.
2429 * Parameters: LPCTSTR lpszDesktop name of the new desktop
2430 * LPCTSTR lpszDevice name of display device to assign to the desktop
2431 * LPDEVMODE pDevMode reserved; must be NULL
2432 * DWORD dwFlags flags to control interaction with other applications
2433 * DWORD dwDesiredAccess specifies access of returned handle
2434 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
2435 * Variables :
2436 * Result : If the function succeeds, the return value is a handle of the
2437 * newly created desktop.
2438 * If the function fails, the return value is NULL. To get extended
2439 * error information, call GetLastError.
2440 * Remark :
2441 * Status : UNTESTED STUB
2442 *
2443 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2444 *****************************************************************************/
2445
2446HDESK WIN32API CreateDesktopW(LPCTSTR lpszDesktop,
2447 LPCTSTR lpszDevice,
2448 LPDEVMODEW pDevMode,
2449 DWORD dwFlags,
2450 DWORD dwDesiredAccess,
2451 LPSECURITY_ATTRIBUTES lpsa)
2452{
2453 dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
2454 lpszDesktop,
2455 lpszDevice,
2456 pDevMode,
2457 dwFlags,
2458 dwDesiredAccess,
2459 lpsa));
2460
2461 return (NULL);
2462}
2463
2464
2465/*****************************************************************************
2466 * Name : HWINSTA WIN32API CreateWindowStationA
2467 * Purpose : The CreateWindowStation function creates a window station object.
2468 * It returns a handle that can be used to access the window station.
2469 * A window station is a secure object that contains a set of global
2470 * atoms, a clipboard, and a set of desktop objects.
2471 * Parameters: LPTSTR lpwinsta name of the new window station
2472 * DWORD dwReserved reserved; must be NULL
2473 * DWORD dwDesiredAccess specifies access of returned handle
2474 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
2475 * Variables :
2476 * Result : If the function succeeds, the return value is the handle to the
2477 * newly created window station.
2478 * If the function fails, the return value is NULL. To get extended
2479 * error information, call GetLastError.
2480 * Remark :
2481 * Status : UNTESTED STUB
2482 *
2483 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2484 *****************************************************************************/
2485
2486HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
2487 DWORD dwReserved,
2488 DWORD dwDesiredAccess,
2489 LPSECURITY_ATTRIBUTES lpsa)
2490{
2491 dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
2492 lpWinSta,
2493 dwReserved,
2494 dwDesiredAccess,
2495 lpsa));
2496
2497 return (NULL);
2498}
2499
2500
2501/*****************************************************************************
2502 * Name : HWINSTA WIN32API CreateWindowStationW
2503 * Purpose : The CreateWindowStation function creates a window station object.
2504 * It returns a handle that can be used to access the window station.
2505 * A window station is a secure object that contains a set of global
2506 * atoms, a clipboard, and a set of desktop objects.
2507 * Parameters: LPTSTR lpwinsta name of the new window station
2508 * DWORD dwReserved reserved; must be NULL
2509 * DWORD dwDesiredAccess specifies access of returned handle
2510 * LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
2511 * Variables :
2512 * Result : If the function succeeds, the return value is the handle to the
2513 * newly created window station.
2514 * If the function fails, the return value is NULL. To get extended
2515 * error information, call GetLastError.
2516 * Remark :
2517 * Status : UNTESTED STUB
2518 *
2519 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2520 *****************************************************************************/
2521
2522HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
2523 DWORD dwReserved,
2524 DWORD dwDesiredAccess,
2525 LPSECURITY_ATTRIBUTES lpsa)
2526{
2527 dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
2528 lpWinSta,
2529 dwReserved,
2530 dwDesiredAccess,
2531 lpsa));
2532
2533 return (NULL);
2534}
2535
2536/*****************************************************************************
2537 * Name : BOOL WIN32API EnumDesktopWindows
2538 * Purpose : The EnumDesktopWindows function enumerates all windows in a
2539 * desktop by passing the handle of each window, in turn, to an
2540 * application-defined callback function.
2541 * Parameters: HDESK hDesktop handle of desktop to enumerate
2542 * WNDENUMPROC lpfn points to application's callback function
2543 * LPARAM lParam 32-bit value to pass to the callback function
2544 * Variables :
2545 * Result : If the function succeeds, the return value is TRUE.
2546 * If the function fails, the return value is FALSE. To get
2547 * extended error information, call GetLastError.
2548 * Remark :
2549 * Status : UNTESTED STUB
2550 *
2551 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2552 *****************************************************************************/
2553
2554BOOL WIN32API EnumDesktopWindows(HDESK hDesktop,
2555 WNDENUMPROC lpfn,
2556 LPARAM lParam)
2557{
2558 dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
2559 hDesktop,
2560 lpfn,
2561 lParam));
2562
2563 return (FALSE);
2564}
2565
2566
2567/*****************************************************************************
2568 * Name : BOOL WIN32API EnumDesktopsA
2569 * Purpose : The EnumDesktops function enumerates all desktops in the window
2570 * station assigned to the calling process. The function does so by
2571 * passing the name of each desktop, in turn, to an application-
2572 * defined callback function.
2573 * Parameters: HWINSTA hwinsta handle of window station to enumerate
2574 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
2575 * LPARAM lParam 32-bit value to pass to the callback function
2576 * Variables :
2577 * Result : If the function succeeds, the return value is TRUE.
2578 * If the function fails, the return value is FALSE. To get extended
2579 * error information, call GetLastError.
2580 * Remark :
2581 * Status : UNTESTED STUB
2582 *
2583 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2584 *****************************************************************************/
2585
2586BOOL WIN32API EnumDesktopsA(HWINSTA hWinSta,
2587 DESKTOPENUMPROCA lpEnumFunc,
2588 LPARAM lParam)
2589{
2590 dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
2591 hWinSta,
2592 lpEnumFunc,
2593 lParam));
2594
2595 return (FALSE);
2596}
2597
2598
2599/*****************************************************************************
2600 * Name : BOOL WIN32API EnumDesktopsW
2601 * Purpose : The EnumDesktops function enumerates all desktops in the window
2602 * station assigned to the calling process. The function does so by
2603 * passing the name of each desktop, in turn, to an application-
2604 * defined callback function.
2605 * Parameters: HWINSTA hwinsta handle of window station to enumerate
2606 * DESKTOPENUMPROC lpEnumFunc points to application's callback function
2607 * LPARAM lParam 32-bit value to pass to the callback function
2608 * Variables :
2609 * Result : If the function succeeds, the return value is TRUE.
2610 * If the function fails, the return value is FALSE. To get extended
2611 * error information, call GetLastError.
2612 * Remark :
2613 * Status : UNTESTED STUB
2614 *
2615 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2616 *****************************************************************************/
2617
2618BOOL WIN32API EnumDesktopsW(HWINSTA hWinSta,
2619 DESKTOPENUMPROCW lpEnumFunc,
2620 LPARAM lParam)
2621{
2622 dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
2623 hWinSta,
2624 lpEnumFunc,
2625 lParam));
2626
2627 return (FALSE);
2628}
2629
2630
2631
2632/*****************************************************************************
2633 * Name : BOOL WIN32API EnumDisplaySettingsW
2634 * Purpose : The EnumDisplaySettings function obtains information about one
2635 * of a display device's graphics modes. You can obtain information
2636 * for all of a display device's graphics modes by making a series
2637 * of calls to this function.
2638 * Parameters: LPCTSTR lpszDeviceName specifies the display device
2639 * DWORD iModeNum specifies the graphics mode
2640 * LPDEVMODE lpDevMode points to structure to receive settings
2641 * Variables :
2642 * Result : If the function succeeds, the return value is TRUE.
2643 * If the function fails, the return value is FALSE.
2644 * Remark :
2645 * Status : UNTESTED STUB
2646 *
2647 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2648 *****************************************************************************/
2649
2650BOOL WIN32API EnumDisplaySettingsW(LPCSTR lpszDeviceName,
2651 DWORD iModeNum,
2652 LPDEVMODEW lpDevMode)
2653{
2654 dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
2655 lpszDeviceName,
2656 iModeNum,
2657 lpDevMode));
2658
2659 return (EnumDisplaySettingsA(lpszDeviceName,
2660 iModeNum,
2661 (LPDEVMODEA)lpDevMode));
2662}
2663
2664
2665/*****************************************************************************
2666 * Name : BOOL WIN32API EnumWindowStationsA
2667 * Purpose : The EnumWindowStations function enumerates all windowstations
2668 * in the system by passing the name of each window station, in
2669 * turn, to an application-defined callback function.
2670 * Parameters:
2671 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
2672 * LPARAM lParam 32-bit value to pass to the callback function
2673 * Result : If the function succeeds, the return value is TRUE.
2674 * If the function fails the return value is FALSE. To get extended
2675 * error information, call GetLastError.
2676 * Remark :
2677 * Status : UNTESTED STUB
2678 *
2679 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2680 *****************************************************************************/
2681
2682BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
2683 LPARAM lParam)
2684{
2685 dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
2686 lpEnumFunc,
2687 lParam));
2688
2689 return (FALSE);
2690}
2691
2692
2693/*****************************************************************************
2694 * Name : BOOL WIN32API EnumWindowStationsW
2695 * Purpose : The EnumWindowStations function enumerates all windowstations
2696 * in the system by passing the name of each window station, in
2697 * turn, to an application-defined callback function.
2698 * Parameters:
2699 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
2700 * LPARAM lParam 32-bit value to pass to the callback function
2701 * Result : If the function succeeds, the return value is TRUE.
2702 * If the function fails the return value is FALSE. To get extended
2703 * error information, call GetLastError.
2704 * Remark :
2705 * Status : UNTESTED STUB
2706 *
2707 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2708 *****************************************************************************/
2709
2710BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
2711 LPARAM lParam)
2712{
2713 dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
2714 lpEnumFunc,
2715 lParam));
2716
2717 return (FALSE);
2718}
2719
2720
2721
2722/*****************************************************************************
2723 * Name : BOOL WIN32API GetInputState
2724 * Purpose : The GetInputState function determines whether there are
2725 * mouse-button or keyboard messages in the calling thread's message queue.
2726 * Parameters:
2727 * Variables :
2728 * Result : If the queue contains one or more new mouse-button or keyboard
2729 * messages, the return value is TRUE.
2730 * If the function fails, the return value is FALSE.
2731 * Remark :
2732 * Status : UNTESTED STUB
2733 *
2734 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2735 *****************************************************************************/
2736
2737BOOL WIN32API GetInputState(VOID)
2738{
2739 dprintf(("USER32:GetInputState () not implemented.\n"));
2740
2741 return (FALSE);
2742}
2743
2744
2745/*****************************************************************************
2746 * Name : UINT WIN32API GetKBCodePage
2747 * Purpose : The GetKBCodePage function is provided for compatibility with
2748 * earlier versions of Windows. In the Win32 application programming
2749 * interface (API) it just calls the GetOEMCP function.
2750 * Parameters:
2751 * Variables :
2752 * Result : If the function succeeds, the return value is an OEM code-page
2753 * identifier, or it is the default identifier if the registry
2754 * value is not readable. For a list of OEM code-page identifiers,
2755 * see GetOEMCP.
2756 * Remark :
2757 * Status : UNTESTED
2758 *
2759 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2760 *****************************************************************************/
2761
2762UINT WIN32API GetKBCodePage(VOID)
2763{
2764 return (GetOEMCP());
2765}
2766
2767
2768/*****************************************************************************
2769 * Name : HWINSTA WIN32API GetProcessWindowStation
2770 * Purpose : The GetProcessWindowStation function returns a handle of the
2771 * window station associated with the calling process.
2772 * Parameters:
2773 * Variables :
2774 * Result : If the function succeeds, the return value is a handle of the
2775 * window station associated with the calling process.
2776 * If the function fails, the return value is NULL. This can occur
2777 * if the calling process is not an application written for Windows
2778 * NT. To get extended error information, call GetLastError.
2779 * Remark :
2780 * Status : UNTESTED STUB
2781 *
2782 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2783 *****************************************************************************/
2784
2785HWINSTA WIN32API GetProcessWindowStation(VOID)
2786{
2787 dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
2788
2789 return (NULL);
2790}
2791
2792
2793
2794/*****************************************************************************
2795 * Name : HDESK WIN32API GetThreadDesktop
2796 * Purpose : The GetThreadDesktop function returns a handle to the desktop
2797 * associated with a specified thread.
2798 * Parameters: DWORD dwThreadId thread identifier
2799 * Variables :
2800 * Result : If the function succeeds, the return value is the handle of the
2801 * desktop associated with the specified thread.
2802 * Remark :
2803 * Status : UNTESTED STUB
2804 *
2805 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2806 *****************************************************************************/
2807
2808HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
2809{
2810 dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
2811 dwThreadId));
2812
2813 return (NULL);
2814}
2815
2816
2817/*****************************************************************************
2818 * Name : BOOL WIN32API GetUserObjectInformationA
2819 * Purpose : The GetUserObjectInformation function returns information about
2820 * a window station or desktop object.
2821 * Parameters: HANDLE hObj handle of object to get information for
2822 * int nIndex type of information to get
2823 * PVOID pvInfo points to buffer that receives the information
2824 * DWORD nLength size, in bytes, of pvInfo buffer
2825 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
2826 * Variables :
2827 * Result : If the function succeeds, the return value is TRUE.
2828 * If the function fails, the return value is FALSE. To get extended
2829 * error information, call GetLastError.
2830 * Remark :
2831 * Status : UNTESTED STUB
2832 *
2833 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2834 *****************************************************************************/
2835
2836BOOL WIN32API GetUserObjectInformationA(HANDLE hObj,
2837 int nIndex,
2838 PVOID pvInfo,
2839 DWORD nLength,
2840 LPDWORD lpnLengthNeeded)
2841{
2842 dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
2843 hObj,
2844 nIndex,
2845 pvInfo,
2846 nLength,
2847 lpnLengthNeeded));
2848
2849 return (FALSE);
2850}
2851
2852
2853/*****************************************************************************
2854 * Name : BOOL WIN32API GetUserObjectInformationW
2855 * Purpose : The GetUserObjectInformation function returns information about
2856 * a window station or desktop object.
2857 * Parameters: HANDLE hObj handle of object to get information for
2858 * int nIndex type of information to get
2859 * PVOID pvInfo points to buffer that receives the information
2860 * DWORD nLength size, in bytes, of pvInfo buffer
2861 * LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
2862 * Variables :
2863 * Result : If the function succeeds, the return value is TRUE.
2864 * If the function fails, the return value is FALSE. To get extended
2865 * error information, call GetLastError.
2866 * Remark :
2867 * Status : UNTESTED STUB
2868 *
2869 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2870 *****************************************************************************/
2871
2872BOOL WIN32API GetUserObjectInformationW(HANDLE hObj,
2873 int nIndex,
2874 PVOID pvInfo,
2875 DWORD nLength,
2876 LPDWORD lpnLengthNeeded)
2877{
2878 dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
2879 hObj,
2880 nIndex,
2881 pvInfo,
2882 nLength,
2883 lpnLengthNeeded));
2884
2885 return (FALSE);
2886}
2887
2888
2889/*****************************************************************************
2890 * Name : BOOL WIN32API GetUserObjectSecurity
2891 * Purpose : The GetUserObjectSecurity function retrieves security information
2892 * for the specified user object.
2893 * Parameters: HANDLE hObj handle of user object
2894 * SECURITY_INFORMATION * pSIRequested address of requested security information
2895 * LPSECURITY_DESCRIPTOR pSID address of security descriptor
2896 * DWORD nLength size of buffer for security descriptor
2897 * LPDWORD lpnLengthNeeded address of required size of buffer
2898 * Variables :
2899 * Result : If the function succeeds, the return value is TRUE.
2900 * If the function fails, the return value is FALSE. To get extended
2901 * error information, call GetLastError.
2902 * Remark :
2903 * Status : UNTESTED STUB
2904 *
2905 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2906 *****************************************************************************/
2907
2908BOOL WIN32API GetUserObjectSecurity(HANDLE hObj,
2909 SECURITY_INFORMATION * pSIRequested,
2910 LPSECURITY_DESCRIPTOR pSID,
2911 DWORD nLength,
2912 LPDWORD lpnLengthNeeded)
2913{
2914 dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
2915 hObj,
2916 pSIRequested,
2917 pSID,
2918 nLength,
2919 lpnLengthNeeded));
2920
2921 return (FALSE);
2922}
2923
2924
2925
2926/*****************************************************************************
2927 * Name : int WIN32API GetWindowRgn
2928 * Purpose : The GetWindowRgn function obtains a copy of the window region of a window.
2929 * Parameters: HWND hWnd handle to window whose window region is to be obtained
2930 * HRGN hRgn handle to region that receives a copy of the window region
2931 * Variables :
2932 * Result : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
2933 * Remark :
2934 * Status : UNTESTED STUB
2935 *
2936 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2937 *****************************************************************************/
2938
2939int WIN32API GetWindowRgn (HWND hWnd,
2940 HRGN hRgn)
2941{
2942 dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
2943 hWnd,
2944 hRgn));
2945
2946 return (NULLREGION);
2947}
2948
2949
2950
2951/*****************************************************************************
2952 * Name : HDESK WIN32API OpenDesktopA
2953 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
2954 * A desktop is a secure object contained within a window station
2955 * object. A desktop has a logical display surface and contains
2956 * windows, menus and hooks.
2957 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
2958 * DWORD dwFlags flags to control interaction with other applications
2959 * BOOL fInherit specifies whether returned handle is inheritable
2960 * DWORD dwDesiredAccess specifies access of returned handle
2961 * Variables :
2962 * Result : If the function succeeds, the return value is the handle to the
2963 * opened desktop.
2964 * If the function fails, the return value is NULL. To get extended
2965 * error information, call GetLastError.
2966 * Remark :
2967 * Status : UNTESTED STUB
2968 *
2969 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
2970 *****************************************************************************/
2971
2972HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
2973 DWORD dwFlags,
2974 BOOL fInherit,
2975 DWORD dwDesiredAccess)
2976{
2977 dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
2978 lpszDesktopName,
2979 dwFlags,
2980 fInherit,
2981 dwDesiredAccess));
2982
2983 return (NULL);
2984}
2985
2986
2987/*****************************************************************************
2988 * Name : HDESK WIN32API OpenDesktopW
2989 * Purpose : The OpenDesktop function returns a handle to an existing desktop.
2990 * A desktop is a secure object contained within a window station
2991 * object. A desktop has a logical display surface and contains
2992 * windows, menus and hooks.
2993 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
2994 * DWORD dwFlags flags to control interaction with other applications
2995 * BOOL fInherit specifies whether returned handle is inheritable
2996 * DWORD dwDesiredAccess specifies access of returned handle
2997 * Variables :
2998 * Result : If the function succeeds, the return value is the handle to the
2999 * opened desktop.
3000 * If the function fails, the return value is NULL. To get extended
3001 * error information, call GetLastError.
3002 * Remark :
3003 * Status : UNTESTED STUB
3004 *
3005 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3006 *****************************************************************************/
3007
3008HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
3009 DWORD dwFlags,
3010 BOOL fInherit,
3011 DWORD dwDesiredAccess)
3012{
3013 dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
3014 lpszDesktopName,
3015 dwFlags,
3016 fInherit,
3017 dwDesiredAccess));
3018
3019 return (NULL);
3020}
3021
3022
3023/*****************************************************************************
3024 * Name : HDESK WIN32API OpenInputDesktop
3025 * Purpose : The OpenInputDesktop function returns a handle to the desktop
3026 * that receives user input. The input desktop is a desktop on the
3027 * window station associated with the logged-on user.
3028 * Parameters: DWORD dwFlags flags to control interaction with other applications
3029 * BOOL fInherit specifies whether returned handle is inheritable
3030 * DWORD dwDesiredAccess specifies access of returned handle
3031 * Variables :
3032 * Result : If the function succeeds, the return value is a handle of the
3033 * desktop that receives user input.
3034 * If the function fails, the return value is NULL. To get extended
3035 * error information, call GetLastError.
3036 * Remark :
3037 * Status : UNTESTED STUB
3038 *
3039 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3040 *****************************************************************************/
3041
3042HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
3043 BOOL fInherit,
3044 DWORD dwDesiredAccess)
3045{
3046 dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
3047 dwFlags,
3048 fInherit,
3049 dwDesiredAccess));
3050
3051 return (NULL);
3052}
3053
3054
3055/*****************************************************************************
3056 * Name : HWINSTA WIN32API OpenWindowStationA
3057 * Purpose : The OpenWindowStation function returns a handle to an existing
3058 * window station.
3059 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
3060 * BOOL fInherit specifies whether returned handle is inheritable
3061 * DWORD dwDesiredAccess specifies access of returned handle
3062 * Variables :
3063 * Result : If the function succeeds, the return value is the handle to the
3064 * specified window station.
3065 * If the function fails, the return value is NULL. To get extended
3066 * error information, call GetLastError.
3067 * Remark :
3068 * Status : UNTESTED STUB
3069 *
3070 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3071 *****************************************************************************/
3072
3073HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
3074 BOOL fInherit,
3075 DWORD dwDesiredAccess)
3076{
3077 dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
3078 lpszWinStaName,
3079 fInherit,
3080 dwDesiredAccess));
3081
3082 return (NULL);
3083}
3084
3085
3086/*****************************************************************************
3087 * Name : HWINSTA WIN32API OpenWindowStationW
3088 * Purpose : The OpenWindowStation function returns a handle to an existing
3089 * window station.
3090 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
3091 * BOOL fInherit specifies whether returned handle is inheritable
3092 * DWORD dwDesiredAccess specifies access of returned handle
3093 * Variables :
3094 * Result : If the function succeeds, the return value is the handle to the
3095 * specified window station.
3096 * If the function fails, the return value is NULL. To get extended
3097 * error information, call GetLastError.
3098
3099
3100 * Remark :
3101 * Status : UNTESTED STUB
3102 *
3103 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3104 *****************************************************************************/
3105
3106HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
3107 BOOL fInherit,
3108 DWORD dwDesiredAccess)
3109{
3110 dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
3111 lpszWinStaName,
3112 fInherit,
3113 dwDesiredAccess));
3114
3115 return (NULL);
3116}
3117
3118
3119/*****************************************************************************
3120 * Name : BOOL WIN32API PaintDesktop
3121 * Purpose : The PaintDesktop function fills the clipping region in the
3122 * specified device context with the desktop pattern or wallpaper.
3123 * The function is provided primarily for shell desktops.
3124 * Parameters:
3125 * Variables :
3126 * Result : If the function succeeds, the return value is TRUE.
3127 * If the function fails, the return value is FALSE.
3128 * Remark :
3129 * Status : UNTESTED STUB
3130 *
3131 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3132 *****************************************************************************/
3133
3134BOOL WIN32API PaintDesktop(HDC hdc)
3135{
3136 dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
3137 hdc));
3138
3139 return (FALSE);
3140}
3141
3142
3143
3144/*****************************************************************************
3145 * Name : VOID WIN32API SetDebugErrorLevel
3146 * Purpose : The SetDebugErrorLevel function sets the minimum error level at
3147 * which Windows will generate debugging events and pass them to a debugger.
3148 * Parameters: DWORD dwLevel debugging error level
3149 * Variables :
3150 * Result :
3151 * Remark :
3152 * Status : UNTESTED STUB
3153 *
3154 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3155 *****************************************************************************/
3156
3157VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
3158{
3159 dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
3160 dwLevel));
3161}
3162
3163
3164/*****************************************************************************
3165 * Name : BOOL WIN32API SetProcessWindowStation
3166 * Purpose : The SetProcessWindowStation function assigns a window station
3167 * to the calling process. This enables the process to access
3168 * objects in the window station such as desktops, the clipboard,
3169 * and global atoms. All subsequent operations on the window station
3170 * use the access rights granted to hWinSta.
3171 * Parameters:
3172 * Variables :
3173 * Result : If the function succeeds, the return value is TRUE.
3174 * If the function fails, the return value is FALSE. To get extended
3175 * error information, call GetLastError.
3176 * Remark :
3177 * Status : UNTESTED STUB
3178 *
3179 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3180 *****************************************************************************/
3181
3182BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
3183{
3184 dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
3185 hWinSta));
3186
3187 return (FALSE);
3188}
3189
3190
3191/*****************************************************************************
3192 * Name : BOOL WIN32API SetThreadDesktop
3193 * Purpose : The SetThreadDesktop function assigns a desktop to the calling
3194 * thread. All subsequent operations on the desktop use the access
3195 * rights granted to hDesk.
3196 * Parameters: HDESK hDesk handle of the desktop to assign to this thread
3197 * Variables :
3198 * Result : If the function succeeds, the return value is TRUE.
3199 * If the function fails, the return value is FALSE. To get extended
3200 * error information, call GetLastError.
3201 * Remark :
3202 * Status : UNTESTED STUB
3203 *
3204 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3205 *****************************************************************************/
3206
3207BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
3208{
3209 dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
3210 hDesktop));
3211
3212 return (FALSE);
3213}
3214
3215
3216/*****************************************************************************
3217 * Name : BOOL WIN32API SetUserObjectInformationA
3218 * Purpose : The SetUserObjectInformation function sets information about a
3219 * window station or desktop object.
3220 * Parameters: HANDLE hObject handle of the object for which to set information
3221 * int nIndex type of information to set
3222 * PVOID lpvInfo points to a buffer that contains the information
3223 * DWORD cbInfo size, in bytes, of lpvInfo buffer
3224 * Variables :
3225 * Result : If the function succeeds, the return value is TRUE.
3226 * If the function fails the return value is FALSE. To get extended
3227 * error information, call GetLastError.
3228 * Remark :
3229 * Status : UNTESTED STUB
3230 *
3231 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3232 *****************************************************************************/
3233
3234BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
3235 int nIndex,
3236 PVOID lpvInfo,
3237 DWORD cbInfo)
3238{
3239 dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
3240 hObject,
3241 nIndex,
3242 lpvInfo,
3243 cbInfo));
3244
3245 return (FALSE);
3246}
3247
3248
3249/*****************************************************************************
3250 * Name : BOOL WIN32API SetUserObjectInformationW
3251 * Purpose : The SetUserObjectInformation function sets information about a
3252 * window station or desktop object.
3253 * Parameters: HANDLE hObject handle of the object for which to set information
3254 * int nIndex type of information to set
3255 * PVOID lpvInfo points to a buffer that contains the information
3256 * DWORD cbInfo size, in bytes, of lpvInfo buffer
3257 * Variables :
3258 * Result : If the function succeeds, the return value is TRUE.
3259 * If the function fails the return value is FALSE. To get extended
3260 * error information, call GetLastError.
3261 * Remark :
3262 * Status : UNTESTED STUB
3263 *
3264 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3265 *****************************************************************************/
3266
3267BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
3268 int nIndex,
3269 PVOID lpvInfo,
3270 DWORD cbInfo)
3271{
3272 dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
3273 hObject,
3274 nIndex,
3275 lpvInfo,
3276 cbInfo));
3277
3278 return (FALSE);
3279}
3280
3281
3282/*****************************************************************************
3283 * Name : BOOL WIN32API SetUserObjectSecurity
3284 * Purpose : The SetUserObjectSecurity function sets the security of a user
3285 * object. This can be, for example, a window or a DDE conversation
3286 * Parameters: HANDLE hObject handle of user object
3287 * SECURITY_INFORMATION * psi address of security information
3288 * LPSECURITY_DESCRIPTOR psd address of security descriptor
3289 * Variables :
3290 * Result : If the function succeeds, the return value is TRUE.
3291 * If the function fails, the return value is FALSE. To get extended
3292 * error information, call GetLastError.
3293 * Remark :
3294 * Status : UNTESTED STUB
3295 *
3296 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3297 *****************************************************************************/
3298
3299BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
3300 SECURITY_INFORMATION * psi,
3301 LPSECURITY_DESCRIPTOR psd)
3302{
3303 dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
3304 hObject,
3305 psi,
3306 psd));
3307
3308 return (FALSE);
3309}
3310
3311
3312/*****************************************************************************
3313 * Name : int WIN32API SetWindowRgn
3314 * Purpose : The SetWindowRgn function sets the window region of a window. The
3315 * window region determines the area within the window where the
3316 * operating system permits drawing. The operating system does not
3317 * display any portion of a window that lies outside of the window region
3318 * Parameters: HWND hWnd handle to window whose window region is to be set
3319 * HRGN hRgn handle to region
3320 * BOOL bRedraw window redraw flag
3321 * Variables :
3322 * Result : If the function succeeds, the return value is non-zero.
3323 * If the function fails, the return value is zero.
3324 * Remark :
3325 * Status : UNTESTED STUB
3326 *
3327 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3328 *****************************************************************************/
3329
3330int WIN32API SetWindowRgn(HWND hWnd,
3331 HRGN hRgn,
3332 BOOL bRedraw)
3333{
3334 dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
3335 hWnd,
3336 hRgn,
3337 bRedraw));
3338
3339 return (0);
3340}
3341
3342
3343/*****************************************************************************
3344 * Name : BOOL WIN32API SetWindowsHookW
3345 * Purpose : The SetWindowsHook function is not implemented in the Win32 API.
3346 * Win32-based applications should use the SetWindowsHookEx function.
3347 * Parameters:
3348 * Variables :
3349 * Result :
3350 * Remark : ARGH ! MICROSOFT !
3351 * Status : UNTESTED STUB
3352 *
3353 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3354 *****************************************************************************/
3355
3356HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
3357
3358{
3359 return (FALSE);
3360}
3361
3362
3363/*****************************************************************************
3364 * Name : BOOL WIN32API ShowWindowAsync
3365 * Purpose : The ShowWindowAsync function sets the show state of a window
3366 * created by a different thread.
3367 * Parameters: HWND hwnd handle of window
3368 * int nCmdShow show state of window
3369 * Variables :
3370 * Result : If the window was previously visible, the return value is TRUE.
3371 * If the window was previously hidden, the return value is FALSE.
3372 * Remark :
3373 * Status : UNTESTED STUB
3374 *
3375 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3376 *****************************************************************************/
3377
3378BOOL WIN32API ShowWindowAsync (HWND hWnd,
3379 int nCmdShow)
3380{
3381 dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
3382 hWnd,
3383 nCmdShow));
3384
3385 return (FALSE);
3386}
3387
3388
3389/*****************************************************************************
3390 * Name : BOOL WIN32API SwitchDesktop
3391 * Purpose : The SwitchDesktop function makes a desktop visible and activates
3392 * it. This enables the desktop to receive input from the user. The
3393 * calling process must have DESKTOP_SWITCHDESKTOP access to the
3394 * desktop for the SwitchDesktop function to succeed.
3395 * Parameters:
3396 * Variables :
3397 * Result : If the function succeeds, the return value is TRUE.
3398 * If the function fails, the return value is FALSE. To get extended
3399 * error information, call GetLastError.
3400 * Remark :
3401 * Status : UNTESTED STUB
3402 *
3403 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3404 *****************************************************************************/
3405
3406BOOL WIN32API SwitchDesktop(HDESK hDesktop)
3407{
3408 dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
3409 hDesktop));
3410
3411 return (FALSE);
3412}
3413
3414
3415/*****************************************************************************
3416 * Name : WORD WIN32API TileWindows
3417 * Purpose : The TileWindows function tiles the specified windows, or the child
3418 * windows of the specified parent window.
3419 * Parameters: HWND hwndParent handle of parent window
3420 * WORD wFlags types of windows not to arrange
3421 * LPCRECT lpRect rectangle to arrange windows in
3422 * WORD cChildrenb number of windows to arrange
3423 * const HWND *ahwndChildren array of window handles
3424 * Variables :
3425 * Result : If the function succeeds, the return value is the number of
3426 * windows arranged.
3427 * If the function fails, the return value is zero.
3428 * Remark :
3429 * Status : UNTESTED STUB
3430 *
3431 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3432 *****************************************************************************/
3433
3434WORD WIN32API TileWindows(HWND hwndParent,
3435 UINT wFlags,
3436 const LPRECT lpRect,
3437 UINT cChildrenb,
3438 const HWND *ahwndChildren)
3439{
3440 dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
3441 hwndParent,
3442 wFlags,
3443 lpRect,
3444 cChildrenb,
3445 ahwndChildren));
3446
3447 return (0);
3448}
3449
3450
3451/*****************************************************************************
3452 * Name : SHORT WIN32API VkKeyScanExW
3453 * Purpose : The VkKeyScanEx function translates a character to the
3454 * corresponding virtual-key code and shift state. The function
3455 * translates the character using the input language and physical
3456 * keyboard layout identified by the given keyboard layout handle.
3457 * Parameters: UINT uChar character to translate
3458 * HKL hkl keyboard layout handle
3459 * Variables :
3460 * Result : see docs
3461 * Remark :
3462 * Status : UNTESTED STUB
3463 *
3464 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3465 *****************************************************************************/
3466
3467WORD WIN32API VkKeyScanExW(WCHAR uChar,
3468 HKL hkl)
3469{
3470 dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
3471 uChar,
3472 hkl));
3473
3474 return (uChar);
3475}
3476
3477
3478/*****************************************************************************
3479 * Name : SHORT WIN32API VkKeyScanExA
3480 * Purpose : The VkKeyScanEx function translates a character to the
3481 * corresponding virtual-key code and shift state. The function
3482 * translates the character using the input language and physical
3483 * keyboard layout identified by the given keyboard layout handle.
3484 * Parameters: UINT uChar character to translate
3485 * HKL hkl keyboard layout handle
3486 * Variables :
3487 * Result : see docs
3488 * Remark :
3489 * Status : UNTESTED STUB
3490 *
3491 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
3492 *****************************************************************************/
3493
3494WORD WIN32API VkKeyScanExA(CHAR uChar,
3495 HKL hkl)
3496{
3497 dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
3498 uChar,
3499 hkl));
3500
3501 return (uChar);
3502}
3503
3504
3505/*****************************************************************************
3506 * Name : BOOL WIN32API SetShellWindow
3507 * Purpose : Unknown
3508 * Parameters: Unknown
3509 * Variables :
3510 * Result :
3511 * Remark :
3512 * Status : UNTESTED UNKNOWN STUB
3513 *
3514 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3515 *****************************************************************************/
3516
3517BOOL WIN32API SetShellWindow(DWORD x1)
3518{
3519 dprintf(("USER32: SetShellWindow(%08x) not implemented.\n",
3520 x1));
3521
3522 return (FALSE); /* default */
3523}
3524
3525
3526/*****************************************************************************
3527 * Name : BOOL WIN32API PlaySoundEvent
3528 * Purpose : Unknown
3529 * Parameters: Unknown
3530 * Variables :
3531 * Result :
3532 * Remark :
3533 * Status : UNTESTED UNKNOWN STUB
3534 *
3535 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3536 *****************************************************************************/
3537
3538BOOL WIN32API PlaySoundEvent(DWORD x1)
3539{
3540 dprintf(("USER32: PlaySoundEvent(%08x) not implemented.\n",
3541 x1));
3542
3543 return (FALSE); /* default */
3544}
3545
3546
3547/*****************************************************************************
3548 * Name : BOOL WIN32API TileChildWindows
3549 * Purpose : Unknown
3550 * Parameters: Unknown
3551 * Variables :
3552 * Result :
3553 * Remark :
3554 * Status : UNTESTED UNKNOWN STUB
3555 *
3556 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3557 *****************************************************************************/
3558
3559BOOL WIN32API TileChildWindows(DWORD x1,
3560 DWORD x2)
3561{
3562 dprintf(("USER32: TileChildWindows(%08xh,%08xh) not implemented.\n",
3563 x1,
3564 x2));
3565
3566 return (FALSE); /* default */
3567}
3568
3569
3570/*****************************************************************************
3571 * Name : BOOL WIN32API SetSysColorsTemp
3572 * Purpose : Unknown
3573 * Parameters: Unknown
3574 * Variables :
3575 * Result :
3576 * Remark :
3577 * Status : UNTESTED UNKNOWN STUB
3578 *
3579 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3580 *****************************************************************************/
3581
3582BOOL WIN32API SetSysColorsTemp(void)
3583{
3584 dprintf(("USER32: SetSysColorsTemp() not implemented.\n"));
3585
3586 return (FALSE); /* default */
3587}
3588
3589
3590/*****************************************************************************
3591 * Name : BOOL WIN32API RegisterNetworkCapabilities
3592 * Purpose : Unknown
3593 * Parameters: Unknown
3594 * Variables :
3595 * Result :
3596 * Remark :
3597 * Status : UNTESTED UNKNOWN STUB
3598 *
3599 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3600 *****************************************************************************/
3601
3602BOOL WIN32API RegisterNetworkCapabilities(DWORD x1,
3603 DWORD x2)
3604{
3605 dprintf(("USER32: RegisterNetworkCapabilities(%08xh,%08xh) not implemented.\n",
3606 x1,
3607 x2));
3608
3609 return (FALSE); /* default */
3610}
3611
3612
3613/*****************************************************************************
3614 * Name : BOOL WIN32API EndTask
3615 * Purpose : Unknown
3616 * Parameters: Unknown
3617 * Variables :
3618 * Result :
3619 * Remark :
3620 * Status : UNTESTED UNKNOWN STUB
3621 *
3622 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3623 *****************************************************************************/
3624
3625BOOL WIN32API EndTask(DWORD x1,
3626 DWORD x2,
3627 DWORD x3)
3628{
3629 dprintf(("USER32: EndTask(%08xh,%08xh,%08xh) not implemented.\n",
3630 x1,
3631 x2,
3632 x3));
3633
3634 return (FALSE); /* default */
3635}
3636
3637
3638
3639/*****************************************************************************
3640 * Name : BOOL WIN32API GetNextQueueWindow
3641 * Purpose : Unknown
3642 * Parameters: Unknown
3643 * Variables :
3644 * Result :
3645 * Remark :
3646 * Status : UNTESTED UNKNOWN STUB
3647 *
3648 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3649 *****************************************************************************/
3650
3651BOOL WIN32API GetNextQueueWindow(DWORD x1,
3652 DWORD x2)
3653{
3654 dprintf(("USER32: GetNextQueueWindow(%08xh,%08xh) not implemented.\n",
3655 x1,
3656 x2));
3657
3658 return (FALSE); /* default */
3659}
3660
3661
3662/*****************************************************************************
3663 * Name : BOOL WIN32API YieldTask
3664 * Purpose : Unknown
3665 * Parameters: Unknown
3666 * Variables :
3667 * Result :
3668 * Remark :
3669 * Status : UNTESTED UNKNOWN STUB
3670 *
3671 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3672 *****************************************************************************/
3673
3674BOOL WIN32API YieldTask(void)
3675{
3676 dprintf(("USER32: YieldTask() not implemented.\n"));
3677
3678 return (FALSE); /* default */
3679}
3680
3681
3682/*****************************************************************************
3683 * Name : BOOL WIN32API WinOldAppHackoMatic
3684 * Purpose : Unknown
3685 * Parameters: Unknown
3686 * Variables :
3687 * Result :
3688 * Remark :
3689 * Status : UNTESTED UNKNOWN STUB
3690 *
3691 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3692 *****************************************************************************/
3693
3694BOOL WIN32API WinOldAppHackoMatic(DWORD x1)
3695{
3696 dprintf(("USER32: WinOldAppHackoMatic(%08x) not implemented.\n",
3697 x1));
3698
3699 return (FALSE); /* default */
3700}
3701
3702
3703/*****************************************************************************
3704 * Name : BOOL WIN32API DragObject
3705 * Purpose : Unknown
3706 * Parameters: Unknown
3707 * Variables :
3708 * Result :
3709 * Remark :
3710 * Status : UNTESTED UNKNOWN STUB
3711 *
3712 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3713 *****************************************************************************/
3714
3715DWORD WIN32API DragObject(HWND x1,HWND x2,UINT x3,DWORD x4,HCURSOR x5)
3716{
3717 dprintf(("USER32: DragObject(%08x,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3718 x1,
3719 x2,
3720 x3,
3721 x4,
3722 x5));
3723
3724 return (FALSE); /* default */
3725}
3726
3727
3728/*****************************************************************************
3729 * Name : BOOL WIN32API CascadeChildWindows
3730 * Purpose : Unknown
3731 * Parameters: Unknown
3732 * Variables :
3733 * Result :
3734 * Remark :
3735 * Status : UNTESTED UNKNOWN STUB
3736 *
3737 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3738 *****************************************************************************/
3739
3740BOOL WIN32API CascadeChildWindows(DWORD x1,
3741 DWORD x2)
3742{
3743 dprintf(("USER32: CascadeChildWindows(%08xh,%08xh) not implemented.\n",
3744 x1,
3745 x2));
3746
3747 return (FALSE); /* default */
3748}
3749
3750
3751/*****************************************************************************
3752 * Name : BOOL WIN32API RegisterSystemThread
3753 * Purpose : Unknown
3754 * Parameters: Unknown
3755 * Variables :
3756 * Result :
3757 * Remark :
3758 * Status : UNTESTED UNKNOWN STUB
3759 *
3760 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3761 *****************************************************************************/
3762
3763BOOL WIN32API RegisterSystemThread(DWORD x1,
3764 DWORD x2)
3765{
3766 dprintf(("USER32: RegisterSystemThread(%08xh,%08xh) not implemented.\n",
3767 x1,
3768 x2));
3769
3770 return (FALSE); /* default */
3771}
3772
3773
3774/*****************************************************************************
3775 * Name : BOOL WIN32API IsHungThread
3776 * Purpose : Unknown
3777 * Parameters: Unknown
3778 * Variables :
3779 * Result :
3780 * Remark :
3781 * Status : UNTESTED UNKNOWN STUB
3782 *
3783 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3784 *****************************************************************************/
3785
3786BOOL WIN32API IsHungThread(DWORD x1)
3787{
3788 dprintf(("USER32: IsHungThread(%08xh) not implemented.\n",
3789 x1));
3790
3791 return (FALSE); /* default */
3792}
3793
3794
3795
3796/*****************************************************************************
3797 * Name : BOOL WIN32API UserSignalProc
3798 * Purpose : Unknown
3799 * Parameters: Unknown
3800 * Variables :
3801 * Result :
3802 * Remark :
3803 * Status : UNTESTED UNKNOWN STUB
3804 *
3805 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3806 *****************************************************************************/
3807
3808BOOL WIN32API UserSignalProc(DWORD x1,
3809 DWORD x2,
3810 DWORD x3,
3811 DWORD x4)
3812{
3813 dprintf(("USER32: SysErrorBox(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3814 x1,
3815 x2,
3816 x3,
3817 x4));
3818
3819 return (FALSE); /* default */
3820}
3821
3822
3823/*****************************************************************************
3824 * Name : BOOL WIN32API GetShellWindow
3825 * Purpose : Unknown
3826 * Parameters: Unknown
3827 * Variables :
3828 * Result :
3829 * Remark :
3830 * Status : UNTESTED UNKNOWN STUB
3831 *
3832 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
3833 *****************************************************************************/
3834
3835HWND WIN32API GetShellWindow(void)
3836{
3837 dprintf(("USER32: GetShellWindow() not implemented.\n"));
3838
3839 return (0); /* default */
3840}
3841
3842
3843
3844/***********************************************************************
3845 * RegisterTasklist32 [USER32.436]
3846 */
3847DWORD WIN32API RegisterTasklist (DWORD x)
3848{
3849 dprintf(("USER32: RegisterTasklist(%08xh) not implemented.\n",
3850 x));
3851
3852 return TRUE;
3853}
3854
3855
Note: See TracBrowser for help on using the repository browser.