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

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

* empty log message *
File size: 32.4 KB
Line 
1/* $Id: window.cpp,v 1.9 1999-07-24 14:01:45 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//******************************************************************************
301HDC WIN32API GetWindowDC(HWND arg1)
302{
303#ifdef DEBUG
304 WriteLog("USER32: GetWindowDC\n");
305#endif
306 return O32_GetWindowDC(arg1);
307}
308//******************************************************************************
309//******************************************************************************
310BOOL WIN32API EnableWindow( HWND hwnd, BOOL fEnable)
311{
312 Win32Window *window;
313
314 window = Win32Window::GetWindowFromHandle(hwnd);
315 if(!window) {
316 dprintf(("EnableWindow, window %x not found", hwnd));
317 return 0;
318 }
319 dprintf(("EnableWindow %x %d", hwnd, fEnable));
320 return window->EnableWindow(fEnable);
321}
322//******************************************************************************
323//******************************************************************************
324BOOL WIN32API BringWindowToTop(HWND hwnd)
325{
326 Win32Window *window;
327
328 window = Win32Window::GetWindowFromHandle(hwnd);
329 if(!window) {
330 dprintf(("BringWindowToTop, window %x not found", hwnd));
331 return 0;
332 }
333 dprintf(("BringWindowToTop %x", hwnd));
334 return window->BringWindowToTop();
335}
336//******************************************************************************
337//******************************************************************************
338HWND WIN32API GetActiveWindow()
339{
340 return Win32Window::GetActiveWindow();
341}
342//******************************************************************************
343//******************************************************************************
344BOOL WIN32API ShowWindow(HWND hwnd, int nCmdShow)
345{
346 Win32Window *window;
347
348 window = Win32Window::GetWindowFromHandle(hwnd);
349 if(!window) {
350 dprintf(("ShowWindow, window %x not found", hwnd));
351 return 0;
352 }
353 dprintf(("ShowWindow %x", hwnd));
354 return window->ShowWindow(nCmdShow);
355}
356//******************************************************************************
357//******************************************************************************
358BOOL WIN32API SetWindowPos(HWND hwnd, HWND hwndInsertAfter, int x, int y, int cx, int cy, UINT fuFlags)
359{
360 Win32Window *window;
361
362 window = Win32Window::GetWindowFromHandle(hwnd);
363 if(!window) {
364 dprintf(("SetWindowPos, window %x not found", hwnd));
365 return 0;
366 }
367 dprintf(("SetWindowPos %x %x x=%d y=%d cx=%d cy=%d %x", hwnd, hwndInsertAfter, x, y, cx, cy, fuFlags));
368 return window->SetWindowPos(hwndInsertAfter, x, y, cx, cy, fuFlags);
369}
370//******************************************************************************
371//******************************************************************************
372BOOL WIN32API SetWindowPlacement( HWND arg1, const WINDOWPLACEMENT * arg2)
373{
374 dprintf(("USER32: SetWindowPlacement\n"));
375 return O32_SetWindowPlacement(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 (O32_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//******************************************************************************
542BOOL WIN32API SetWindowTextA(HWND hwnd, LPCSTR lpsz)
543{
544 Win32Window *window;
545
546 window = Win32Window::GetWindowFromHandle(hwnd);
547 if(!window) {
548 dprintf(("SetWindowTextA, window %x not found", hwnd));
549 return 0;
550 }
551 dprintf(("SetWindowTextA %x %s", hwnd, lpsz));
552 return window->SetWindowTextA(lpsz);
553}
554//******************************************************************************
555//******************************************************************************
556BOOL WIN32API SetWindowTextW( HWND arg1, LPCWSTR arg2)
557{
558 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
559 BOOL rc;
560
561 rc = SetWindowTextA(arg1, (LPCSTR)astring);
562 dprintf(("USER32: SetWindowTextW %X %s returned %d\n", arg1, astring, rc));
563 FreeAsciiString(astring);
564 return(rc);
565}
566/*******************************************************************
567 * InternalGetWindowText (USER32.326)
568 */
569int WIN32API InternalGetWindowText(HWND hwnd,
570 LPWSTR lpString,
571 INT nMaxCount )
572{
573 dprintf(("USER32: InternalGetWindowText(%08xh,%08xh,%08xh) not properly implemented.\n",
574 hwnd,
575 lpString,
576 nMaxCount));
577
578 return GetWindowTextW(hwnd,lpString,nMaxCount);
579}
580//******************************************************************************
581//******************************************************************************
582BOOL WIN32API SetForegroundWindow(HWND arg1)
583{
584#ifdef DEBUG
585 WriteLog("USER32: SetForegroundWindow\n");
586#endif
587 return O32_SetForegroundWindow(arg1);
588}
589//******************************************************************************
590//******************************************************************************
591BOOL WIN32API GetClientRect( HWND hwnd, PRECT pRect)
592{
593#ifdef DEBUG
594 WriteLog("USER32: GetClientRect of %X\n", hwnd);
595#endif
596 hwnd = Win32Window::Win32ToOS2Handle(hwnd);
597 return OSLibWinQueryWindowRect(hwnd, pRect);
598// return O32_GetClientRect(hwnd, arg2);
599}
600//******************************************************************************
601//******************************************************************************
602HWND WIN32API GetDesktopWindow(void)
603{
604 dprintf(("USER32: GetDesktopWindow\n"));
605 return OSLIB_HWND_DESKTOP;
606}
607//******************************************************************************
608//******************************************************************************
609HWND WIN32API FindWindowA(LPCSTR arg1, LPCSTR arg2)
610{
611#ifdef DEBUG
612 WriteLog("USER32: FindWindow\n");
613#endif
614 return O32_FindWindow(arg1, arg2);
615}
616//******************************************************************************
617//******************************************************************************
618HWND WIN32API FindWindowExA(HWND arg1, HWND arg2, LPCSTR arg3, LPCSTR arg4)
619{
620#ifdef DEBUG
621 WriteLog("USER32: FindWindowExA, not completely implemented\n");
622#endif
623 return O32_FindWindow(arg3, arg4);
624}
625//******************************************************************************
626//******************************************************************************
627BOOL WIN32API FlashWindow(HWND hwnd, BOOL fFlash)
628{
629 dprintf(("FlashWindow %x %d\n", hwnd, fFlash));
630 return OSLibWinFlashWindow(Win32Window::Win32ToOS2Handle(hwnd), fFlash);
631}
632//******************************************************************************
633//******************************************************************************
634BOOL WIN32API MoveWindow(HWND arg1, int arg2, int arg3, int arg4, int arg5, BOOL arg6)
635{
636 BOOL rc;
637
638 rc = O32_MoveWindow(arg1, arg2, arg3, arg4, arg5, arg6);
639 dprintf(("USER32: MoveWindow %X to (%d,%d) size (%d,%d), repaint = %d returned %d\n", arg1, arg2, arg3, arg4, arg5, arg6, rc));
640 return(rc);
641}
642//******************************************************************************
643//******************************************************************************
644BOOL WIN32API AdjustWindowRect( PRECT arg1, DWORD arg2, BOOL arg3)
645{
646#ifdef DEBUG
647 WriteLog("USER32: AdjustWindowRect\n");
648#endif
649 return O32_AdjustWindowRect(arg1, arg2, arg3);
650}
651//******************************************************************************
652//******************************************************************************
653BOOL WIN32API AdjustWindowRectEx( PRECT arg1, DWORD arg2, BOOL arg3, DWORD arg4)
654{
655#ifdef DEBUG
656 WriteLog("USER32: AdjustWindowRectEx\n");
657#endif
658 return O32_AdjustWindowRectEx(arg1, arg2, arg3, arg4);
659}
660//******************************************************************************
661//******************************************************************************
662BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
663{
664#ifdef DEBUG
665//// WriteLog("USER32: ClientToScreen\n");
666#endif
667 return O32_ClientToScreen(arg1, arg2);
668}
669//******************************************************************************
670//******************************************************************************
671HDWP WIN32API BeginDeferWindowPos( int arg1)
672{
673#ifdef DEBUG
674 WriteLog("USER32: BeginDeferWindowPos\n");
675#endif
676 return O32_BeginDeferWindowPos(arg1);
677}
678//******************************************************************************
679//******************************************************************************
680HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
681{
682#ifdef DEBUG
683 WriteLog("USER32: DeferWindowPos\n");
684#endif
685 return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
686}
687//******************************************************************************
688//******************************************************************************
689HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
690{
691#ifdef DEBUG
692 WriteLog("USER32: ChildWindowFromPoint\n");
693#endif
694 return O32_ChildWindowFromPoint(arg1, arg2);
695}
696//******************************************************************************
697//******************************************************************************
698HWND WIN32API ChildWindowFromPointEx(HWND arg1, POINT arg2, UINT uFlags)
699{
700#ifdef DEBUG
701 WriteLog("USER32: ChildWindowFromPointEx, not completely supported!\n");
702#endif
703 return O32_ChildWindowFromPoint(arg1, arg2);
704}
705//******************************************************************************
706//******************************************************************************
707BOOL WIN32API CloseWindow(HWND hwnd)
708{
709 Win32Window *window;
710
711 window = Win32Window::GetWindowFromHandle(hwnd);
712 if(!window) {
713 dprintf(("CloseWindow, window %x not found", hwnd));
714 return 0;
715 }
716 dprintf(("CloseWindow %x\n", hwnd));
717 return window->CloseWindow();
718}
719//******************************************************************************
720//******************************************************************************
721HWND WIN32API WindowFromDC(HDC hdc)
722{
723#ifdef DEBUG
724 WriteLog("USER32: WindowFromDC\n");
725#endif
726 return O32_WindowFromDC(hdc);
727}
728//******************************************************************************
729//TODO: Does this return handles of hidden or disabled windows?
730//******************************************************************************
731HWND WIN32API WindowFromPoint( POINT point)
732{
733 HWND hwnd;
734
735 dprintf(("WindowFromPoint (%d,%d)\n", point.x, point.y));
736 hwnd = OSLibWinWindowFromPoint(OSLIB_HWND_DESKTOP, (PVOID)&point);
737 if(hwnd) {
738 return Win32Window::OS2ToWin32Handle(hwnd);
739 }
740 return 0;
741}
742//******************************************************************************
743//******************************************************************************
744BOOL WIN32API IsWindowUnicode(HWND hwnd)
745{
746 Win32Window *window;
747
748 window = Win32Window::GetWindowFromHandle(hwnd);
749 if(!window) {
750 dprintf(("IsWindowUnicode, window %x not found", hwnd));
751 return 0;
752 }
753 return window->IsUnicode();
754}
755/*****************************************************************************
756 * Name : WORD WIN32API CascadeWindows
757 * Purpose : The CascadeWindows function cascades the specified windows or
758 * the child windows of the specified parent window.
759 * Parameters: HWND hwndParent handle of parent window
760 * UINT wHow types of windows not to arrange
761 * CONST RECT * lpRect rectangle to arrange windows in
762 * UINT cKids number of windows to arrange
763 * const HWND FAR * lpKids array of window handles
764 * Variables :
765 * Result : If the function succeeds, the return value is the number of windows arranged.
766 * If the function fails, the return value is zero.
767 * Remark :
768 * Status : UNTESTED STUB
769 *
770 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
771 *****************************************************************************/
772
773WORD WIN32API CascadeWindows(HWND hwndParent,
774 UINT wHow,
775 CONST LPRECT lpRect,
776 UINT cKids,
777 const HWND *lpKids)
778{
779 dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
780 hwndParent,
781 wHow,
782 lpRect,
783 cKids,
784 lpKids));
785
786 return (0);
787}
788/*****************************************************************************
789 * Name : HWND WIN32API FindWindowExW
790 * Purpose : The FindWindowEx function retrieves the handle of a window whose
791 * class name and window name match the specified strings. The
792 * function searches child windows, beginning with the one following
793 * the given child window.
794 * Parameters: HWND hwndParent handle of parent window
795 * HWND hwndChildAfter handle of a child window
796 * LPCTSTR lpszClass address of class name
797 * LPCTSTR lpszWindow address of window name
798 * Variables :
799 * Result : If the function succeeds, the return value is the handle of the
800 * window that has the specified class and window names.
801 * If the function fails, the return value is NULL. To get extended
802 * error information, call GetLastError.
803 * Remark :
804 * Status : UNTESTED STUB
805 *
806 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
807 *****************************************************************************/
808
809HWND WIN32API FindWindowExW(HWND hwndParent,
810 HWND hwndChildAfter,
811 LPCWSTR lpszClass,
812 LPCWSTR lpszWindow)
813{
814 dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
815 hwndParent,
816 hwndChildAfter,
817 lpszClass,
818 lpszWindow));
819
820 return (NULL);
821}
822/*****************************************************************************
823 * Name : BOOL WIN32API SwitchToThisWindow
824 * Purpose : Unknown
825 * Parameters: Unknown
826 * Variables :
827 * Result :
828 * Remark :
829 * Status : UNTESTED UNKNOWN STUB
830 *
831 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
832 *****************************************************************************/
833
834BOOL WIN32API SwitchToThisWindow(HWND hwnd,
835 BOOL x2)
836{
837 dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
838 hwnd,
839 x2));
840
841 return (FALSE); /* default */
842}
843//******************************************************************************
844//******************************************************************************
845BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
846{
847 BOOL rc;
848 EnumWindowCallback *callback = new EnumWindowCallback(lpfn, lParam);
849
850 dprintf(("USER32: EnumThreadWindows\n"));
851 //CB: replace
852 rc = O32_EnumThreadWindows(dwThreadId, callback->GetOS2Callback(), (LPARAM)callback);
853 if(callback)
854 delete callback;
855 return(rc);
856}
857//******************************************************************************
858//******************************************************************************
859BOOL WIN32API GetUpdateRect( HWND hwnd, PRECT lpRect, BOOL bErase)
860{
861 dprintf(("GetUpdateRect %x %d\n", hwnd, bErase));
862 if (!lpRect) return FALSE;
863
864 return OSLibWinQueryUpdateRect(Win32Window::Win32ToOS2Handle(hwnd), lpRect);
865}
866//******************************************************************************
867//******************************************************************************
868BOOL WIN32API InvalidateRect(HWND hWnd, const RECT *lpRect, BOOL bErase)
869{
870#ifdef DEBUG
871 if(lpRect)
872 WriteLog("USER32: InvalidateRect for window %X (%d,%d)(%d,%d) %d\n", hWnd, lpRect->left, lpRect->top, lpRect->right, lpRect->bottom, bErase);
873 else WriteLog("USER32: InvalidateRect for window %X NULL, %d\n", hWnd, bErase);
874#endif
875
876 //CB: bErase no quite the same
877 hWnd = Win32Window::Win32ToOS2Handle(hWnd);
878 if (lpRect)
879 {
880 return OSLibWinInvalidateRect(hWnd, (PRECT)lpRect, bErase);
881 }
882 else return OSLibWinInvalidateRect(hWnd,NULL,bErase);
883}
884//******************************************************************************
885//******************************************************************************
886UINT WIN32API ArrangeIconicWindows( HWND arg1)
887{
888#ifdef DEBUG
889 WriteLog("USER32: ArrangeIconicWindows\n");
890#endif
891 return O32_ArrangeIconicWindows(arg1);
892}
893//******************************************************************************
894//restores iconized window to previous size/position
895//******************************************************************************
896BOOL WIN32API OpenIcon(HWND hwnd)
897{
898#ifdef DEBUG
899 WriteLog("USER32: OpenIcon\n");
900#endif
901 if(!IsIconic(hwnd))
902 return FALSE;
903 ShowWindow(hwnd, SW_SHOWNORMAL);
904 return TRUE;
905}
906//******************************************************************************
907//******************************************************************************
908BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
909{
910 dprintf(("USER32: ShowOwnedPopups\n"));
911 return O32_ShowOwnedPopups(arg1, arg2);
912}
913//******************************************************************************
914//******************************************************************************
Note: See TracBrowser for help on using the repository browser.