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

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

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