source: trunk/src/user32/new/window.cpp@ 397

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

* empty log message *
File size: 32.3 KB
Line 
1/* $Id: window.cpp,v 1.13 1999-07-26 09:01:34 sandervl Exp $ */
2/*
3 * Win32 window apis for OS/2
4 *
5 * Copyright 1999 Sander van Leeuwen
6 *
7 * Parts based on Wine Windows code (windows\win.c)
8 *
9 * Copyright 1993, 1994 Alexandre Julliard
10 *
11 * Project Odin Software License can be found in LICENSE.TXT
12 *
13 *
14 * TODO: Decide what to do about commands for OS/2 windows (non-Win32 apps)
15 *
16 */
17
18#include <os2win.h>
19#include <misc.h>
20#include <win32wnd.h>
21#include <oslibwin.h>
22#include <oslibgdi.h>
23#include "user32.h"
24#include "icon.h"
25#include "usrcall.h"
26
27//******************************************************************************
28//******************************************************************************
29HWND WIN32API CreateWindowExA(DWORD exStyle, LPCSTR className,
30 LPCSTR windowName, DWORD style, INT x,
31 INT y, INT width, INT height,
32 HWND parent, HMENU menu,
33 HINSTANCE instance, LPVOID data )
34{
35 Win32Window *window;
36 ATOM classAtom;
37 CREATESTRUCTA cs;
38
39 if(exStyle & WS_EX_MDICHILD)
40 return CreateMDIWindowA(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
41
42 /* Find the class atom */
43 if (!(classAtom = GlobalFindAtomA(className)))
44 {
45 dprintf(("CreateWindowEx32A: bad class name "));
46 if (!HIWORD(className)) {
47 dprintf(("CreateWindowEx32A: bad class name %04x\n", LOWORD(className)));
48 }
49 else dprintf(("CreateWindowEx32A: bad class name '%s'\n", className ));
50 SetLastError(ERROR_INVALID_PARAMETER);
51 return 0;
52 }
53
54 /* Create the window */
55 cs.lpCreateParams = data;
56 cs.hInstance = instance;
57 cs.hMenu = menu;
58 cs.hwndParent = parent;
59 cs.x = x;
60 cs.y = y;
61 cs.cx = width;
62 cs.cy = height;
63 cs.style = style;
64 cs.lpszName = windowName;
65 cs.lpszClass = className;
66 cs.dwExStyle = exStyle;
67 dprintf(("CreateWindowExA: (%d,%d) (%d,%d), %x %x", x, y, width, height, style, exStyle));
68 window = new Win32Window( &cs, classAtom, FALSE );
69 if(window == NULL)
70 {
71 dprintf(("Win32Window creation failed!!"));
72 return 0;
73 }
74 if(GetLastError() != 0)
75 {
76 dprintf(("Win32Window error found!!"));
77 delete window;
78 return 0;
79 }
80 return window->getWindowHandle();
81}
82//******************************************************************************
83//******************************************************************************
84HWND WIN32API CreateMDIWindowA(LPCSTR arg1, LPCSTR arg2, DWORD arg3,
85 int arg4, int arg5, int arg6, int arg7,
86 HWND arg8, HINSTANCE arg9, LPARAM arg10)
87{
88 HWND hwnd;
89
90 dprintf(("USER32: CreateMDIWindowA\n"));
91
92 hwnd = O32_CreateMDIWindow((LPSTR)arg1, (LPSTR)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
93
94 dprintf(("USER32: CreateMDIWindowA returned %X\n", hwnd));
95 return hwnd;
96}
97//******************************************************************************
98//******************************************************************************
99HWND WIN32API CreateMDIWindowW(LPCWSTR arg1, LPCWSTR arg2, DWORD arg3, int arg4,
100 int arg5, int arg6, int arg7, HWND arg8, HINSTANCE arg9,
101 LPARAM arg10)
102{
103 HWND hwnd;
104 char *astring1 = NULL, *astring2 = NULL;
105
106 if((int)arg1 >> 16 != 0) {
107 astring1 = UnicodeToAsciiString((LPWSTR)arg1);
108 }
109 else astring1 = (char *)arg2;
110
111 astring2 = UnicodeToAsciiString((LPWSTR)arg2);
112
113 hwnd = O32_CreateMDIWindow(astring1, astring2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
114
115 if(astring1) FreeAsciiString(astring1);
116 FreeAsciiString(astring2);
117 dprintf(("USER32: CreateMDIWindowW hwnd = %X\n", hwnd));
118 return(hwnd);
119}
120//******************************************************************************
121//******************************************************************************
122HWND WIN32API CreateWindowExW(DWORD exStyle, LPCWSTR className,
123 LPCWSTR windowName, DWORD style, INT x,
124 INT y, INT width, INT height,
125 HWND parent, HMENU menu,
126 HINSTANCE instance, LPVOID data )
127{
128 Win32Window *window;
129 ATOM classAtom;
130 CREATESTRUCTA cs;
131
132 if(exStyle & WS_EX_MDICHILD)
133 return CreateMDIWindowW(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
134
135 /* Find the class atom */
136 if (!(classAtom = GlobalFindAtomW(className)))
137 {
138 dprintf(("CreateWindowEx32A: bad class name "));
139 if (!HIWORD(className)) {
140 dprintf(("CreateWindowEx32A: bad class name %04x\n", LOWORD(className)));
141 }
142// else dprintf(("CreateWindowEx32A: bad class name '%s'\n", className ));
143 SetLastError(ERROR_INVALID_PARAMETER);
144 return 0;
145 }
146
147 /* Create the window */
148 cs.lpCreateParams = data;
149 cs.hInstance = instance;
150 cs.hMenu = menu;
151 cs.hwndParent = parent;
152 cs.x = x;
153 cs.y = y;
154 cs.cx = width;
155 cs.cy = height;
156 cs.style = style;
157 cs.lpszName = (LPSTR)windowName;
158 cs.lpszClass = (LPSTR)className;
159 cs.dwExStyle = exStyle;
160 window = new Win32Window( &cs, classAtom, TRUE );
161 if(window == NULL)
162 {
163 dprintf(("Win32Window creation failed!!"));
164 return 0;
165 }
166 if(GetLastError() != 0)
167 {
168 dprintf(("Win32Window error found!!"));
169 delete window;
170 return 0;
171 }
172 return window->getWindowHandle();
173}
174//******************************************************************************
175//******************************************************************************
176BOOL WIN32API DestroyWindow(HWND hwnd)
177{
178 Win32Window *window;
179
180 window = Win32Window::GetWindowFromHandle(hwnd);
181 if(!window) {
182 dprintf(("DestroyWindow, window %x not found", hwnd));
183 return 0;
184 }
185 dprintf(("DestroyWindow %x", hwnd));
186 return window->DestroyWindow();
187}
188//******************************************************************************
189//******************************************************************************
190HWND WIN32API SetActiveWindow( HWND hwnd)
191{
192 Win32Window *window;
193
194 window = Win32Window::GetWindowFromHandle(hwnd);
195 if(!window) {
196 dprintf(("SetActiveWindow, window %x not found", hwnd));
197 return 0;
198 }
199 dprintf(("SetActiveWindow %x", hwnd));
200 return window->SetActiveWindow();
201}
202//******************************************************************************
203//******************************************************************************
204HWND WIN32API GetParent( HWND hwnd)
205{
206 Win32Window *window;
207
208 window = Win32Window::GetWindowFromHandle(hwnd);
209 if(!window) {
210 dprintf(("GetParent, window %x not found", hwnd));
211 return 0;
212 }
213 dprintf(("GetParent %x", hwnd));
214 return window->GetParent();
215}
216//******************************************************************************
217//******************************************************************************
218HWND WIN32API SetParent( HWND hwndChild, HWND hwndNewParent)
219{
220 Win32Window *window;
221
222 window = Win32Window::GetWindowFromHandle(hwndChild);
223 if(!window) {
224 dprintf(("SetParent, window %x not found", hwndChild));
225 return 0;
226 }
227 dprintf(("SetParent %x %x", hwndChild, hwndNewParent));
228 return window->SetParent(hwndNewParent);
229}
230//******************************************************************************
231//******************************************************************************
232BOOL WIN32API IsChild( HWND hwndParent, HWND hwnd)
233{
234 Win32Window *window;
235
236 window = Win32Window::GetWindowFromHandle(hwnd);
237 if(!window) {
238 dprintf(("IsChild, window %x not found", hwnd));
239 return 0;
240 }
241 dprintf(("IsChild %x %x", hwndParent, hwnd));
242 return window->IsChild(hwndParent);
243}
244//******************************************************************************
245//******************************************************************************
246HWND WIN32API GetTopWindow( HWND hwnd)
247{
248 Win32Window *window;
249
250 window = Win32Window::GetWindowFromHandle(hwnd);
251 if(!window) {
252 dprintf(("GetTopWindow, window %x not found", hwnd));
253 return 0;
254 }
255 dprintf(("GetTopWindow %x", hwnd));
256 return window->GetTopWindow();
257}
258//******************************************************************************
259//******************************************************************************
260BOOL WIN32API UpdateWindow(HWND hwnd)
261{
262 Win32Window *window;
263
264 window = Win32Window::GetWindowFromHandle(hwnd);
265 if(!window) {
266 dprintf(("UpdateWindow, window %x not found", hwnd));
267 return 0;
268 }
269 dprintf(("UpdateWindow %x", hwnd));
270 return window->UpdateWindow();
271}
272//******************************************************************************
273//******************************************************************************
274BOOL WIN32API IsIconic( HWND hwnd)
275{
276 Win32Window *window;
277
278 window = Win32Window::GetWindowFromHandle(hwnd);
279 if(!window) {
280 dprintf(("IsIconic, window %x not found", hwnd));
281 return 0;
282 }
283 dprintf(("IsIconic %x", hwnd));
284 return window->IsIconic();
285}
286//******************************************************************************
287//******************************************************************************
288HWND WIN32API GetWindow(HWND hwnd, UINT uCmd)
289{
290 Win32Window *window;
291
292 window = Win32Window::GetWindowFromHandle(hwnd);
293 if(!window) {
294 dprintf(("GetWindow, window %x not found", hwnd));
295 return 0;
296 }
297 dprintf(("GetWindow %x %d", hwnd, uCmd));
298 return window->GetWindow(uCmd);
299}
300//******************************************************************************
301//******************************************************************************
302BOOL WIN32API EnableWindow( HWND hwnd, BOOL fEnable)
303{
304 Win32Window *window;
305
306 window = Win32Window::GetWindowFromHandle(hwnd);
307 if(!window) {
308 dprintf(("EnableWindow, window %x not found", hwnd));
309 return 0;
310 }
311 dprintf(("EnableWindow %x %d", hwnd, fEnable));
312 return window->EnableWindow(fEnable);
313}
314//******************************************************************************
315//******************************************************************************
316BOOL WIN32API BringWindowToTop(HWND hwnd)
317{
318 Win32Window *window;
319
320 window = Win32Window::GetWindowFromHandle(hwnd);
321 if(!window) {
322 dprintf(("BringWindowToTop, window %x not found", hwnd));
323 return 0;
324 }
325 dprintf(("BringWindowToTop %x", hwnd));
326 return window->BringWindowToTop();
327}
328//******************************************************************************
329//******************************************************************************
330HWND WIN32API GetActiveWindow()
331{
332 return Win32Window::GetActiveWindow();
333}
334//******************************************************************************
335//******************************************************************************
336BOOL WIN32API ShowWindow(HWND hwnd, int nCmdShow)
337{
338 Win32Window *window;
339
340 window = Win32Window::GetWindowFromHandle(hwnd);
341 if(!window) {
342 dprintf(("ShowWindow, window %x not found", hwnd));
343 return 0;
344 }
345 dprintf(("ShowWindow %x", hwnd));
346 return window->ShowWindow(nCmdShow);
347}
348//******************************************************************************
349//******************************************************************************
350BOOL WIN32API SetWindowPos(HWND hwnd, HWND hwndInsertAfter, int x, int y, int cx, int cy, UINT fuFlags)
351{
352 Win32Window *window;
353
354 window = Win32Window::GetWindowFromHandle(hwnd);
355 if(!window) {
356 dprintf(("SetWindowPos, window %x not found", hwnd));
357 return 0;
358 }
359 dprintf(("SetWindowPos %x %x x=%d y=%d cx=%d cy=%d %x", hwnd, hwndInsertAfter, x, y, cx, cy, fuFlags));
360 return window->SetWindowPos(hwndInsertAfter, x, y, cx, cy, fuFlags);
361}
362//******************************************************************************
363//******************************************************************************
364BOOL WIN32API SetWindowPlacement( HWND arg1, const WINDOWPLACEMENT * arg2)
365{
366 dprintf(("USER32: SetWindowPlacement\n"));
367 return O32_SetWindowPlacement(arg1, arg2);
368}
369//******************************************************************************
370//******************************************************************************
371BOOL WIN32API GetWindowPlacement( HWND arg1, LPWINDOWPLACEMENT arg2)
372{
373#ifdef DEBUG
374 WriteLog("USER32: GetWindowPlacement\n");
375#endif
376 return O32_GetWindowPlacement(arg1, arg2);
377}
378//******************************************************************************
379//******************************************************************************
380BOOL WIN32API IsWindow( HWND hwnd)
381{
382 Win32Window *window;
383
384 window = Win32Window::GetWindowFromHandle(hwnd);
385 if(!window) {
386 dprintf(("IsWindow, window %x not found", hwnd));
387 return FALSE;
388 }
389 dprintf(("IsWindow %x", hwnd));
390 return window->IsWindow();
391}
392//******************************************************************************
393//******************************************************************************
394BOOL WIN32API IsWindowEnabled( HWND hwnd)
395{
396 Win32Window *window;
397
398 window = Win32Window::GetWindowFromHandle(hwnd);
399 if(!window) {
400 dprintf(("IsWindowEnabled, window %x not found", hwnd));
401 return 0;
402 }
403 dprintf(("IsWindowEnabled %x", hwnd));
404 return window->IsWindowEnabled();
405}
406//******************************************************************************
407//******************************************************************************
408BOOL WIN32API IsWindowVisible( HWND hwnd)
409{
410 Win32Window *window;
411
412 window = Win32Window::GetWindowFromHandle(hwnd);
413 if(!window) {
414 dprintf(("IsWindowVisible, window %x not found", hwnd));
415 return 0;
416 }
417 dprintf(("IsWindowVisible %x", hwnd));
418 return window->IsWindowVisible();
419}
420//******************************************************************************
421//******************************************************************************
422HWND WIN32API SetFocus( HWND hwnd)
423{
424 HWND lastFocus;
425
426 dprintf(("USER32: SetFocus\n"));
427
428 lastFocus = GetFocus();
429 hwnd = Win32Window::Win32ToOS2Handle(hwnd);
430 return (OSLibWinSetFocus(OSLIB_HWND_DESKTOP,hwnd)) ? lastFocus:0;
431}
432//******************************************************************************
433//******************************************************************************
434HWND WIN32API GetFocus(void)
435{
436 HWND hwnd;
437// dprintf(("USER32: GetFocus\n"));
438
439 hwnd = OSLibWinQueryFocus(OSLIB_HWND_DESKTOP);
440 return Win32Window::OS2ToWin32Handle(hwnd);
441}
442//******************************************************************************
443//******************************************************************************
444/***********************************************************************
445 * GetInternalWindowPos (USER32.245)
446 */
447UINT WIN32API GetInternalWindowPos(HWND hwnd,
448 LPRECT rectWnd,
449 LPPOINT ptIcon )
450{
451 WINDOWPLACEMENT wndpl;
452
453 dprintf(("USER32: GetInternalWindowPos(%08xh,%08xh,%08xh)\n",
454 hwnd,
455 rectWnd,
456 ptIcon));
457
458 if (GetWindowPlacement( hwnd, &wndpl ))
459 {
460 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
461 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
462 return wndpl.showCmd;
463 }
464 return 0;
465}
466//******************************************************************************
467//******************************************************************************
468BOOL WIN32API IsZoomed( HWND arg1)
469{
470#ifdef DEBUG
471 WriteLog("USER32: IsZoomed\n");
472#endif
473 return O32_IsZoomed(arg1);
474}
475//******************************************************************************
476//******************************************************************************
477BOOL WIN32API LockWindowUpdate( HWND arg1)
478{
479#ifdef DEBUG
480 WriteLog("USER32: LockWindowUpdate\n");
481#endif
482 return O32_LockWindowUpdate(arg1);
483}
484//******************************************************************************
485//******************************************************************************
486BOOL WIN32API RedrawWindow( HWND arg1, const RECT * arg2, HRGN arg3, UINT arg4)
487{
488 BOOL rc;
489
490 rc = O32_RedrawWindow(arg1, arg2, arg3, arg4);
491#ifdef DEBUG
492 WriteLog("USER32: RedrawWindow %X , %X, %X, %X returned %d\n", arg1, arg2, arg3, arg4, rc);
493#endif
494 InvalidateRect(arg1, arg2, TRUE);
495 UpdateWindow(arg1);
496 SendMessageA(arg1, WM_PAINT, 0, 0);
497 return(rc);
498}
499//******************************************************************************
500//******************************************************************************
501BOOL WIN32API GetWindowRect( HWND hwnd, PRECT pRect)
502{
503 Win32Window *window;
504
505 window = Win32Window::GetWindowFromHandle(hwnd);
506 if(!window) {
507 dprintf(("GetWindowRect, window %x not found", hwnd));
508 return 0;
509 }
510 dprintf(("GetWindowRect %x", hwnd));
511 return window->GetWindowRect(pRect);
512}
513//******************************************************************************
514//******************************************************************************
515int WIN32API GetWindowTextLengthA( HWND hwnd)
516{
517 Win32Window *window;
518
519 window = Win32Window::GetWindowFromHandle(hwnd);
520 if(!window) {
521 dprintf(("GetWindowTextLength, window %x not found", hwnd));
522 return 0;
523 }
524 dprintf(("GetWindowTextLength %x", hwnd));
525 return window->GetWindowTextLengthA();
526}
527//******************************************************************************
528//******************************************************************************
529int WIN32API GetWindowTextA( HWND hwnd, LPSTR lpsz, int cch)
530{
531 Win32Window *window;
532
533 window = Win32Window::GetWindowFromHandle(hwnd);
534 if(!window) {
535 dprintf(("GetWindowTextA, window %x not found", hwnd));
536 return 0;
537 }
538 dprintf(("GetWindowTextA %x", hwnd));
539 return window->GetWindowTextA(lpsz, cch);
540}
541//******************************************************************************
542//******************************************************************************
543int WIN32API GetWindowTextLengthW( HWND hwnd)
544{
545 dprintf(("USER32: GetWindowTextLengthW\n"));
546 return GetWindowTextLengthA(hwnd);
547}
548//******************************************************************************
549//******************************************************************************
550int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
551{
552 char title[128];
553 int rc;
554
555 rc = O32_GetWindowText(hwnd, title, sizeof(title));
556#ifdef DEBUG
557 WriteLog("USER32: GetWindowTextW returned %s\n", title);
558#endif
559 if(rc > cch) {
560 title[cch-1] = 0;
561 rc = cch;
562 }
563 AsciiToUnicode(title, lpsz);
564 return(rc);
565}
566//******************************************************************************
567//******************************************************************************
568BOOL WIN32API SetWindowTextA(HWND hwnd, LPCSTR lpsz)
569{
570 Win32Window *window;
571
572 window = Win32Window::GetWindowFromHandle(hwnd);
573 if(!window) {
574 dprintf(("SetWindowTextA, window %x not found", hwnd));
575 return 0;
576 }
577 dprintf(("SetWindowTextA %x %s", hwnd, lpsz));
578 return window->SetWindowTextA(lpsz);
579}
580//******************************************************************************
581//******************************************************************************
582BOOL WIN32API SetWindowTextW( HWND arg1, LPCWSTR arg2)
583{
584 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
585 BOOL rc;
586
587 rc = SetWindowTextA(arg1, (LPCSTR)astring);
588 dprintf(("USER32: SetWindowTextW %X %s returned %d\n", arg1, astring, rc));
589 FreeAsciiString(astring);
590 return(rc);
591}
592/*******************************************************************
593 * InternalGetWindowText (USER32.326)
594 */
595int WIN32API InternalGetWindowText(HWND hwnd,
596 LPWSTR lpString,
597 INT nMaxCount )
598{
599 dprintf(("USER32: InternalGetWindowText(%08xh,%08xh,%08xh) not properly implemented.\n",
600 hwnd,
601 lpString,
602 nMaxCount));
603
604 return GetWindowTextW(hwnd,lpString,nMaxCount);
605}
606//******************************************************************************
607//******************************************************************************
608BOOL WIN32API SetForegroundWindow(HWND arg1)
609{
610#ifdef DEBUG
611 WriteLog("USER32: SetForegroundWindow\n");
612#endif
613 return O32_SetForegroundWindow(arg1);
614}
615//******************************************************************************
616//******************************************************************************
617BOOL WIN32API GetClientRect( HWND hwnd, PRECT pRect)
618{
619 BOOL rc;
620
621 hwnd = Win32Window::Win32ToOS2Handle(hwnd);
622 rc = OSLibWinQueryWindowRect(hwnd, pRect);
623 dprintf(("USER32: GetClientRect of %X returned (%d,%d) (%d,%d)\n", hwnd, pRect->left, pRect->top, pRect->right, pRect->bottom));
624 return rc;
625}
626//******************************************************************************
627//******************************************************************************
628HWND WIN32API GetDesktopWindow(void)
629{
630 dprintf(("USER32: GetDesktopWindow\n"));
631 return OSLIB_HWND_DESKTOP;
632}
633//******************************************************************************
634//******************************************************************************
635HWND WIN32API FindWindowA(LPCSTR arg1, LPCSTR arg2)
636{
637#ifdef DEBUG
638 WriteLog("USER32: FindWindow\n");
639#endif
640 return O32_FindWindow(arg1, arg2);
641}
642//******************************************************************************
643//******************************************************************************
644HWND WIN32API FindWindowExA(HWND arg1, HWND arg2, LPCSTR arg3, LPCSTR arg4)
645{
646#ifdef DEBUG
647 WriteLog("USER32: FindWindowExA, not completely implemented\n");
648#endif
649 return O32_FindWindow(arg3, arg4);
650}
651/*****************************************************************************
652 * Name : HWND WIN32API FindWindowExW
653 * Purpose : The FindWindowEx function retrieves the handle of a window whose
654 * class name and window name match the specified strings. The
655 * function searches child windows, beginning with the one following
656 * the given child window.
657 * Parameters: HWND hwndParent handle of parent window
658 * HWND hwndChildAfter handle of a child window
659 * LPCTSTR lpszClass address of class name
660 * LPCTSTR lpszWindow address of window name
661 * Variables :
662 * Result : If the function succeeds, the return value is the handle of the
663 * window that has the specified class and window names.
664 * If the function fails, the return value is NULL. To get extended
665 * error information, call GetLastError.
666 * Remark :
667 * Status : UNTESTED STUB
668 *
669 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
670 *****************************************************************************/
671
672HWND WIN32API FindWindowExW(HWND hwndParent,
673 HWND hwndChildAfter,
674 LPCWSTR lpszClass,
675 LPCWSTR lpszWindow)
676{
677 dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
678 hwndParent,
679 hwndChildAfter,
680 lpszClass,
681 lpszWindow));
682
683 return (NULL);
684}
685//******************************************************************************
686//******************************************************************************
687BOOL WIN32API FlashWindow(HWND hwnd, BOOL fFlash)
688{
689 dprintf(("FlashWindow %x %d\n", hwnd, fFlash));
690 return OSLibWinFlashWindow(Win32Window::Win32ToOS2Handle(hwnd), fFlash);
691}
692//******************************************************************************
693//******************************************************************************
694BOOL WIN32API MoveWindow(HWND arg1, int arg2, int arg3, int arg4, int arg5, BOOL arg6)
695{
696 BOOL rc;
697
698 rc = O32_MoveWindow(arg1, arg2, arg3, arg4, arg5, arg6);
699 dprintf(("USER32: MoveWindow %X to (%d,%d) size (%d,%d), repaint = %d returned %d\n", arg1, arg2, arg3, arg4, arg5, arg6, rc));
700 return(rc);
701}
702//******************************************************************************
703//******************************************************************************
704BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
705{
706#ifdef DEBUG
707//// WriteLog("USER32: ClientToScreen\n");
708#endif
709 return O32_ClientToScreen(arg1, arg2);
710}
711//******************************************************************************
712//******************************************************************************
713HDWP WIN32API BeginDeferWindowPos( int arg1)
714{
715#ifdef DEBUG
716 WriteLog("USER32: BeginDeferWindowPos\n");
717#endif
718 return O32_BeginDeferWindowPos(arg1);
719}
720//******************************************************************************
721//******************************************************************************
722HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
723{
724#ifdef DEBUG
725 WriteLog("USER32: DeferWindowPos\n");
726#endif
727 return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
728}
729//******************************************************************************
730//******************************************************************************
731HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
732{
733#ifdef DEBUG
734 WriteLog("USER32: ChildWindowFromPoint\n");
735#endif
736 return O32_ChildWindowFromPoint(arg1, arg2);
737}
738//******************************************************************************
739//******************************************************************************
740HWND WIN32API ChildWindowFromPointEx(HWND arg1, POINT arg2, UINT uFlags)
741{
742#ifdef DEBUG
743 WriteLog("USER32: ChildWindowFromPointEx, not completely supported!\n");
744#endif
745 return O32_ChildWindowFromPoint(arg1, arg2);
746}
747//******************************************************************************
748//******************************************************************************
749BOOL WIN32API CloseWindow(HWND hwnd)
750{
751 Win32Window *window;
752
753 window = Win32Window::GetWindowFromHandle(hwnd);
754 if(!window) {
755 dprintf(("CloseWindow, window %x not found", hwnd));
756 return 0;
757 }
758 dprintf(("CloseWindow %x\n", hwnd));
759 return window->CloseWindow();
760}
761//******************************************************************************
762//TODO: Does this return handles of hidden or disabled windows?
763//******************************************************************************
764HWND WIN32API WindowFromPoint( POINT point)
765{
766 HWND hwnd;
767
768 dprintf(("WindowFromPoint (%d,%d)\n", point.x, point.y));
769 hwnd = OSLibWinWindowFromPoint(OSLIB_HWND_DESKTOP, (PVOID)&point);
770 if(hwnd) {
771 return Win32Window::OS2ToWin32Handle(hwnd);
772 }
773 return 0;
774}
775//******************************************************************************
776//******************************************************************************
777BOOL WIN32API IsWindowUnicode(HWND hwnd)
778{
779 Win32Window *window;
780
781 window = Win32Window::GetWindowFromHandle(hwnd);
782 if(!window) {
783 dprintf(("IsWindowUnicode, window %x not found", hwnd));
784 return 0;
785 }
786 return window->IsUnicode();
787}
788/*****************************************************************************
789 * Name : WORD WIN32API CascadeWindows
790 * Purpose : The CascadeWindows function cascades the specified windows or
791 * the child windows of the specified parent window.
792 * Parameters: HWND hwndParent handle of parent window
793 * UINT wHow types of windows not to arrange
794 * CONST RECT * lpRect rectangle to arrange windows in
795 * UINT cKids number of windows to arrange
796 * const HWND FAR * lpKids array of window handles
797 * Variables :
798 * Result : If the function succeeds, the return value is the number of windows arranged.
799 * If the function fails, the return value is zero.
800 * Remark :
801 * Status : UNTESTED STUB
802 *
803 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
804 *****************************************************************************/
805
806WORD WIN32API CascadeWindows(HWND hwndParent,
807 UINT wHow,
808 CONST LPRECT lpRect,
809 UINT cKids,
810 const HWND *lpKids)
811{
812 dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
813 hwndParent,
814 wHow,
815 lpRect,
816 cKids,
817 lpKids));
818
819 return (0);
820}
821/*****************************************************************************
822 * Name : BOOL WIN32API SwitchToThisWindow
823 * Purpose : Unknown
824 * Parameters: Unknown
825 * Variables :
826 * Result :
827 * Remark :
828 * Status : UNTESTED UNKNOWN STUB
829 *
830 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
831 *****************************************************************************/
832
833BOOL WIN32API SwitchToThisWindow(HWND hwnd,
834 BOOL x2)
835{
836 dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
837 hwnd,
838 x2));
839
840 return (FALSE); /* default */
841}
842//******************************************************************************
843//******************************************************************************
844BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
845{
846 BOOL rc;
847 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
848
849 dprintf(("USER32: EnumThreadWindows\n"));
850 //CB: replace
851 rc = O32_EnumThreadWindows(dwThreadId, callback->GetOS2Callback(), (LPARAM)callback);
852 if(callback)
853 delete callback;
854 return(rc);
855}
856//******************************************************************************
857//******************************************************************************
858BOOL WIN32API GetUpdateRect( HWND hwnd, PRECT lpRect, BOOL bErase)
859{
860 dprintf(("GetUpdateRect %x %d\n", hwnd, bErase));
861 if (!lpRect) return FALSE;
862
863 return OSLibWinQueryUpdateRect(Win32Window::Win32ToOS2Handle(hwnd), lpRect);
864}
865//******************************************************************************
866//******************************************************************************
867BOOL WIN32API InvalidateRect(HWND hWnd, const RECT *lpRect, BOOL bErase)
868{
869#ifdef DEBUG
870 if(lpRect)
871 WriteLog("USER32: InvalidateRect for window %X (%d,%d)(%d,%d) %d\n", hWnd, lpRect->left, lpRect->top, lpRect->right, lpRect->bottom, bErase);
872 else WriteLog("USER32: InvalidateRect for window %X NULL, %d\n", hWnd, bErase);
873#endif
874
875 //CB: bErase no quite the same
876 hWnd = Win32Window::Win32ToOS2Handle(hWnd);
877 if (lpRect)
878 {
879 return OSLibWinInvalidateRect(hWnd, (PRECT)lpRect, bErase);
880 }
881 else return OSLibWinInvalidateRect(hWnd,NULL,bErase);
882}
883//******************************************************************************
884//******************************************************************************
885UINT WIN32API ArrangeIconicWindows( HWND arg1)
886{
887#ifdef DEBUG
888 WriteLog("USER32: ArrangeIconicWindows\n");
889#endif
890 return O32_ArrangeIconicWindows(arg1);
891}
892//******************************************************************************
893//restores iconized window to previous size/position
894//******************************************************************************
895BOOL WIN32API OpenIcon(HWND hwnd)
896{
897#ifdef DEBUG
898 WriteLog("USER32: OpenIcon\n");
899#endif
900 if(!IsIconic(hwnd))
901 return FALSE;
902 ShowWindow(hwnd, SW_SHOWNORMAL);
903 return TRUE;
904}
905//******************************************************************************
906//******************************************************************************
907BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
908{
909 dprintf(("USER32: ShowOwnedPopups\n"));
910 return O32_ShowOwnedPopups(arg1, arg2);
911}
912//******************************************************************************
913//******************************************************************************
Note: See TracBrowser for help on using the repository browser.