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

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

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