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

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

* empty log message *
File size: 32.2 KB
Line 
1/* $Id: window.cpp,v 1.12 1999-07-25 17:47:25 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}
624//******************************************************************************
625//******************************************************************************
626HWND WIN32API GetDesktopWindow(void)
627{
628 dprintf(("USER32: GetDesktopWindow\n"));
629 return OSLIB_HWND_DESKTOP;
630}
631//******************************************************************************
632//******************************************************************************
633HWND WIN32API FindWindowA(LPCSTR arg1, LPCSTR arg2)
634{
635#ifdef DEBUG
636 WriteLog("USER32: FindWindow\n");
637#endif
638 return O32_FindWindow(arg1, arg2);
639}
640//******************************************************************************
641//******************************************************************************
642HWND WIN32API FindWindowExA(HWND arg1, HWND arg2, LPCSTR arg3, LPCSTR arg4)
643{
644#ifdef DEBUG
645 WriteLog("USER32: FindWindowExA, not completely implemented\n");
646#endif
647 return O32_FindWindow(arg3, arg4);
648}
649/*****************************************************************************
650 * Name : HWND WIN32API FindWindowExW
651 * Purpose : The FindWindowEx function retrieves the handle of a window whose
652 * class name and window name match the specified strings. The
653 * function searches child windows, beginning with the one following
654 * the given child window.
655 * Parameters: HWND hwndParent handle of parent window
656 * HWND hwndChildAfter handle of a child window
657 * LPCTSTR lpszClass address of class name
658 * LPCTSTR lpszWindow address of window name
659 * Variables :
660 * Result : If the function succeeds, the return value is the handle of the
661 * window that has the specified class and window names.
662 * If the function fails, the return value is NULL. To get extended
663 * error information, call GetLastError.
664 * Remark :
665 * Status : UNTESTED STUB
666 *
667 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
668 *****************************************************************************/
669
670HWND WIN32API FindWindowExW(HWND hwndParent,
671 HWND hwndChildAfter,
672 LPCWSTR lpszClass,
673 LPCWSTR lpszWindow)
674{
675 dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
676 hwndParent,
677 hwndChildAfter,
678 lpszClass,
679 lpszWindow));
680
681 return (NULL);
682}
683//******************************************************************************
684//******************************************************************************
685BOOL WIN32API FlashWindow(HWND hwnd, BOOL fFlash)
686{
687 dprintf(("FlashWindow %x %d\n", hwnd, fFlash));
688 return OSLibWinFlashWindow(Win32Window::Win32ToOS2Handle(hwnd), fFlash);
689}
690//******************************************************************************
691//******************************************************************************
692BOOL WIN32API MoveWindow(HWND arg1, int arg2, int arg3, int arg4, int arg5, BOOL arg6)
693{
694 BOOL rc;
695
696 rc = O32_MoveWindow(arg1, arg2, arg3, arg4, arg5, arg6);
697 dprintf(("USER32: MoveWindow %X to (%d,%d) size (%d,%d), repaint = %d returned %d\n", arg1, arg2, arg3, arg4, arg5, arg6, rc));
698 return(rc);
699}
700//******************************************************************************
701//******************************************************************************
702BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
703{
704#ifdef DEBUG
705//// WriteLog("USER32: ClientToScreen\n");
706#endif
707 return O32_ClientToScreen(arg1, arg2);
708}
709//******************************************************************************
710//******************************************************************************
711HDWP WIN32API BeginDeferWindowPos( int arg1)
712{
713#ifdef DEBUG
714 WriteLog("USER32: BeginDeferWindowPos\n");
715#endif
716 return O32_BeginDeferWindowPos(arg1);
717}
718//******************************************************************************
719//******************************************************************************
720HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
721{
722#ifdef DEBUG
723 WriteLog("USER32: DeferWindowPos\n");
724#endif
725 return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
726}
727//******************************************************************************
728//******************************************************************************
729HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
730{
731#ifdef DEBUG
732 WriteLog("USER32: ChildWindowFromPoint\n");
733#endif
734 return O32_ChildWindowFromPoint(arg1, arg2);
735}
736//******************************************************************************
737//******************************************************************************
738HWND WIN32API ChildWindowFromPointEx(HWND arg1, POINT arg2, UINT uFlags)
739{
740#ifdef DEBUG
741 WriteLog("USER32: ChildWindowFromPointEx, not completely supported!\n");
742#endif
743 return O32_ChildWindowFromPoint(arg1, arg2);
744}
745//******************************************************************************
746//******************************************************************************
747BOOL WIN32API CloseWindow(HWND hwnd)
748{
749 Win32Window *window;
750
751 window = Win32Window::GetWindowFromHandle(hwnd);
752 if(!window) {
753 dprintf(("CloseWindow, window %x not found", hwnd));
754 return 0;
755 }
756 dprintf(("CloseWindow %x\n", hwnd));
757 return window->CloseWindow();
758}
759//******************************************************************************
760//TODO: Does this return handles of hidden or disabled windows?
761//******************************************************************************
762HWND WIN32API WindowFromPoint( POINT point)
763{
764 HWND hwnd;
765
766 dprintf(("WindowFromPoint (%d,%d)\n", point.x, point.y));
767 hwnd = OSLibWinWindowFromPoint(OSLIB_HWND_DESKTOP, (PVOID)&point);
768 if(hwnd) {
769 return Win32Window::OS2ToWin32Handle(hwnd);
770 }
771 return 0;
772}
773//******************************************************************************
774//******************************************************************************
775BOOL WIN32API IsWindowUnicode(HWND hwnd)
776{
777 Win32Window *window;
778
779 window = Win32Window::GetWindowFromHandle(hwnd);
780 if(!window) {
781 dprintf(("IsWindowUnicode, window %x not found", hwnd));
782 return 0;
783 }
784 return window->IsUnicode();
785}
786/*****************************************************************************
787 * Name : WORD WIN32API CascadeWindows
788 * Purpose : The CascadeWindows function cascades the specified windows or
789 * the child windows of the specified parent window.
790 * Parameters: HWND hwndParent handle of parent window
791 * UINT wHow types of windows not to arrange
792 * CONST RECT * lpRect rectangle to arrange windows in
793 * UINT cKids number of windows to arrange
794 * const HWND FAR * lpKids array of window handles
795 * Variables :
796 * Result : If the function succeeds, the return value is the number of windows arranged.
797 * If the function fails, the return value is zero.
798 * Remark :
799 * Status : UNTESTED STUB
800 *
801 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
802 *****************************************************************************/
803
804WORD WIN32API CascadeWindows(HWND hwndParent,
805 UINT wHow,
806 CONST LPRECT lpRect,
807 UINT cKids,
808 const HWND *lpKids)
809{
810 dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
811 hwndParent,
812 wHow,
813 lpRect,
814 cKids,
815 lpKids));
816
817 return (0);
818}
819/*****************************************************************************
820 * Name : BOOL WIN32API SwitchToThisWindow
821 * Purpose : Unknown
822 * Parameters: Unknown
823 * Variables :
824 * Result :
825 * Remark :
826 * Status : UNTESTED UNKNOWN STUB
827 *
828 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
829 *****************************************************************************/
830
831BOOL WIN32API SwitchToThisWindow(HWND hwnd,
832 BOOL x2)
833{
834 dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
835 hwnd,
836 x2));
837
838 return (FALSE); /* default */
839}
840//******************************************************************************
841//******************************************************************************
842BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
843{
844 BOOL rc;
845 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
846
847 dprintf(("USER32: EnumThreadWindows\n"));
848 //CB: replace
849 rc = O32_EnumThreadWindows(dwThreadId, callback->GetOS2Callback(), (LPARAM)callback);
850 if(callback)
851 delete callback;
852 return(rc);
853}
854//******************************************************************************
855//******************************************************************************
856BOOL WIN32API GetUpdateRect( HWND hwnd, PRECT lpRect, BOOL bErase)
857{
858 dprintf(("GetUpdateRect %x %d\n", hwnd, bErase));
859 if (!lpRect) return FALSE;
860
861 return OSLibWinQueryUpdateRect(Win32Window::Win32ToOS2Handle(hwnd), lpRect);
862}
863//******************************************************************************
864//******************************************************************************
865BOOL WIN32API InvalidateRect(HWND hWnd, const RECT *lpRect, BOOL bErase)
866{
867#ifdef DEBUG
868 if(lpRect)
869 WriteLog("USER32: InvalidateRect for window %X (%d,%d)(%d,%d) %d\n", hWnd, lpRect->left, lpRect->top, lpRect->right, lpRect->bottom, bErase);
870 else WriteLog("USER32: InvalidateRect for window %X NULL, %d\n", hWnd, bErase);
871#endif
872
873 //CB: bErase no quite the same
874 hWnd = Win32Window::Win32ToOS2Handle(hWnd);
875 if (lpRect)
876 {
877 return OSLibWinInvalidateRect(hWnd, (PRECT)lpRect, bErase);
878 }
879 else return OSLibWinInvalidateRect(hWnd,NULL,bErase);
880}
881//******************************************************************************
882//******************************************************************************
883UINT WIN32API ArrangeIconicWindows( HWND arg1)
884{
885#ifdef DEBUG
886 WriteLog("USER32: ArrangeIconicWindows\n");
887#endif
888 return O32_ArrangeIconicWindows(arg1);
889}
890//******************************************************************************
891//restores iconized window to previous size/position
892//******************************************************************************
893BOOL WIN32API OpenIcon(HWND hwnd)
894{
895#ifdef DEBUG
896 WriteLog("USER32: OpenIcon\n");
897#endif
898 if(!IsIconic(hwnd))
899 return FALSE;
900 ShowWindow(hwnd, SW_SHOWNORMAL);
901 return TRUE;
902}
903//******************************************************************************
904//******************************************************************************
905BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
906{
907 dprintf(("USER32: ShowOwnedPopups\n"));
908 return O32_ShowOwnedPopups(arg1, arg2);
909}
910//******************************************************************************
911//******************************************************************************
Note: See TracBrowser for help on using the repository browser.