source: trunk/src/user32/window.cpp@ 2956

Last change on this file since 2956 was 2956, checked in by sandervl, 25 years ago

focus fixes + changes for dinput
File size: 52.3 KB
Line 
1/* $Id: window.cpp,v 1.58 2000-03-01 13:30:07 sandervl Exp $ */
2/*
3 * Win32 window apis for OS/2
4 *
5 * Copyright 1999 Sander van Leeuwen
6 * Copyright 1999 Daniela Engert (dani@ngrt.de)
7 * Copyright 2000 Christoph Bratschi (cbratschi@datacomm.ch)
8 *
9 * Parts based on Wine Windows code (windows\win.c)
10 *
11 * Copyright 1993, 1994 Alexandre Julliard
12 *
13 * Project Odin Software License can be found in LICENSE.TXT
14 *
15 *
16 * TODO: Decide what to do about commands for OS/2 windows (non-Win32 apps)
17 *
18 */
19
20#include <os2win.h>
21#include <misc.h>
22#include <string.h>
23#include <stdio.h>
24#include <win32wbase.h>
25#include <win32wmdiclient.h>
26#include <win32wdesktop.h>
27#include "win32dlg.h"
28#include <oslibwin.h>
29#include <oslibgdi.h>
30#include "user32.h"
31#include "winicon.h"
32#include <win\winpos.h>
33#include <heapstring.h>
34
35#define DBG_LOCALLOG DBG_window
36#include "dbglocal.h"
37
38//******************************************************************************
39//******************************************************************************
40HWND WIN32API CreateWindowExA(DWORD exStyle, LPCSTR className,
41 LPCSTR windowName, DWORD style, INT x,
42 INT y, INT width, INT height,
43 HWND parent, HMENU menu,
44 HINSTANCE instance, LPVOID data )
45{
46 Win32BaseWindow *window;
47 ATOM classAtom;
48 CREATESTRUCTA cs;
49 char tmpClass[20];
50
51 if(exStyle & WS_EX_MDICHILD)
52 return CreateMDIWindowA(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
53
54#if 1
55 /* Find the class atom */
56 if (!(classAtom = GlobalFindAtomA(className)))
57 {
58 if (!HIWORD(className))
59 dprintf(("CreateWindowEx32A: bad class name %04x\n",LOWORD(className)));
60 else
61 dprintf(("CreateWindowEx32A: bad class name '%s'\n", className));
62
63 SetLastError(ERROR_INVALID_PARAMETER);
64 return 0;
65 }
66
67 if (!HIWORD(className))
68 {
69 sprintf(tmpClass,"#%d", (int) className);
70 className = tmpClass;
71 }
72#else
73 /* Find the class atom */
74 if (!HIWORD(className) || !(classAtom = GlobalFindAtomA(className)))
75 {
76 if (!HIWORD(className))
77 {
78 sprintf(tmpClass,"#%d", (int) className);
79 classAtom = GlobalFindAtomA(tmpClass);
80 className = tmpClass;
81 }
82 if (!classAtom)
83 {
84 if (!HIWORD(className)) {
85 dprintf(("CreateWindowEx32A: bad class name %04x\n", LOWORD(className)));
86 }
87 else dprintf(("CreateWindowEx32A: bad class name '%s'\n", className ));
88
89 SetLastError(ERROR_INVALID_PARAMETER);
90 return 0;
91 }
92 }
93#endif
94
95 /* Create the window */
96 cs.lpCreateParams = data;
97 cs.hInstance = instance;
98 cs.hMenu = menu;
99 cs.hwndParent = parent;
100 cs.x = x;
101 cs.y = y;
102 cs.cx = width;
103 cs.cy = height;
104 cs.style = style;
105 cs.lpszName = windowName;
106 cs.lpszClass = className;
107 cs.dwExStyle = exStyle;
108 if(HIWORD(className)) {
109 dprintf(("CreateWindowExA: class %s parent %x (%d,%d) (%d,%d), %x %x", className, parent, x, y, width, height, style, exStyle));
110 }
111 else dprintf(("CreateWindowExA: class %d parent %x (%d,%d) (%d,%d), %x %x", className, parent, x, y, width, height, style, exStyle));
112
113 if(!strcmpi(className, MDICLIENTCLASSNAMEA)) {
114 window = (Win32BaseWindow *) new Win32MDIClientWindow(&cs, classAtom, FALSE);
115 }
116 else
117 if(!strcmpi((char *) className, DIALOG_CLASS_NAMEA))
118 {
119 DLG_TEMPLATE dlgTemplate = {0};
120 dlgTemplate.style = cs.style;
121 dlgTemplate.exStyle = cs.dwExStyle;
122 dlgTemplate.x = cs.x;
123 dlgTemplate.y = cs.y;
124 dlgTemplate.cx = cs.cx;
125 dlgTemplate.cy = cs.cy;
126 dlgTemplate.className = cs.lpszClass;
127 dlgTemplate.caption = cs.lpszName;
128 window = (Win32BaseWindow *) new Win32Dialog(cs.hInstance,
129 (LPCSTR) &dlgTemplate,
130 cs.hwndParent,
131 NULL,
132 (LPARAM) data,
133 FALSE);
134 }
135 else {
136 window = new Win32BaseWindow( &cs, classAtom, FALSE );
137 }
138 if(window == NULL)
139 {
140 dprintf(("Win32BaseWindow creation failed!!"));
141 return 0;
142 }
143 if(GetLastError() != 0)
144 {
145 dprintf(("Win32BaseWindow error found!!"));
146 delete window;
147 return 0;
148 }
149 return window->getWindowHandle();
150}
151//******************************************************************************
152//******************************************************************************
153HWND WIN32API CreateWindowExW(DWORD exStyle, LPCWSTR className,
154 LPCWSTR windowName, DWORD style, INT x,
155 INT y, INT width, INT height,
156 HWND parent, HMENU menu,
157 HINSTANCE instance, LPVOID data )
158{
159 Win32BaseWindow *window;
160 ATOM classAtom;
161 CREATESTRUCTA cs;
162 char tmpClassA[20];
163 WCHAR tmpClassW[20];
164
165 if(exStyle & WS_EX_MDICHILD)
166 return CreateMDIWindowW(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
167
168 /* Find the class atom */
169 if (!HIWORD(className) || !(classAtom = GlobalFindAtomW(className)))
170 {
171 if (!HIWORD(className))
172 {
173 sprintf(tmpClassA,"#%d", (int) className);
174 AsciiToUnicode(tmpClassA, tmpClassW);
175 classAtom = GlobalFindAtomW(tmpClassW);
176 className = (LPCWSTR)tmpClassW;
177 }
178 if (!classAtom)
179 {
180 if (!HIWORD(className)) {
181 dprintf(("CreateWindowEx32W: bad class name %04x\n", LOWORD(className)));
182 }
183 else dprintf(("CreateWindowEx32W: bad class name "));
184
185 SetLastError(ERROR_INVALID_PARAMETER);
186 return 0;
187 }
188 }
189 if(HIWORD(className)) {
190 dprintf(("CreateWindowExW: class %ls parent %x (%d,%d) (%d,%d), %x %x", className, parent, x, y, width, height, style, exStyle));
191 }
192 else dprintf(("CreateWindowExW: class %d parent %x (%d,%d) (%d,%d), %x %x", className, parent, x, y, width, height, style, exStyle));
193
194 /* Create the window */
195 cs.lpCreateParams = data;
196 cs.hInstance = instance;
197 cs.hMenu = menu;
198 cs.hwndParent = parent;
199 cs.x = x;
200 cs.y = y;
201 cs.cx = width;
202 cs.cy = height;
203 cs.style = style;
204 cs.lpszName = (LPSTR)windowName;
205 cs.lpszClass = (LPSTR)className;
206 cs.dwExStyle = exStyle;
207
208 if(!lstrcmpiW(className, (LPWSTR)MDICLIENTCLASSNAMEW)) {
209 window = (Win32BaseWindow *) new Win32MDIClientWindow(&cs, classAtom, TRUE);
210 }
211 else
212 if(!lstrcmpiW(className, (LPWSTR)DIALOG_CLASS_NAMEW))
213 {
214 DLG_TEMPLATE dlgTemplate = {0};
215 dlgTemplate.style = cs.style;
216 dlgTemplate.exStyle = cs.dwExStyle;
217 dlgTemplate.x = cs.x;
218 dlgTemplate.y = cs.y;
219 dlgTemplate.cx = cs.cx;
220 dlgTemplate.cy = cs.cy;
221 dlgTemplate.className = cs.lpszClass;
222 dlgTemplate.caption = cs.lpszName;
223 window = (Win32BaseWindow *) new Win32Dialog(cs.hInstance,
224 (LPCSTR) &dlgTemplate,
225 cs.hwndParent,
226 NULL,
227 (LPARAM) data,
228 TRUE);
229 }
230 else {
231 window = new Win32BaseWindow( &cs, classAtom, TRUE );
232 }
233 if(window == NULL)
234 {
235 dprintf(("Win32BaseWindow creation failed!!"));
236 return 0;
237 }
238 if(GetLastError() != 0)
239 {
240 dprintf(("Win32BaseWindow error found!!"));
241 delete window;
242 return 0;
243 }
244 return window->getWindowHandle();
245}
246//******************************************************************************
247//******************************************************************************
248HWND WIN32API CreateMDIWindowA(LPCSTR lpszClassName, LPCSTR lpszWindowName,
249 DWORD dwStyle, int x, int y, int nWidth,
250 int nHeight, HWND hwndParent,
251 HINSTANCE hInstance, LPARAM lParam )
252{
253 HWND hwnd;
254 MDICREATESTRUCTA cs;
255 Win32BaseWindow *window;
256
257 window = Win32BaseWindow::GetWindowFromHandle(hwndParent);
258 if(!window) {
259 dprintf(("CreateMDIWindowA, window %x not found", hwndParent));
260 return 0;
261 }
262
263 dprintf(("USER32: CreateMDIWindowA\n"));
264 cs.szClass = lpszClassName;
265 cs.szTitle = lpszWindowName;
266 cs.hOwner = hInstance;
267 cs.x = x;
268 cs.y = y;
269 cs.cx = nHeight;
270 cs.cy = nWidth;
271 cs.style = dwStyle;
272 cs.lParam = lParam;
273
274 return window->SendMessageA(WM_MDICREATE, 0, (LPARAM)&cs);
275}
276//******************************************************************************
277//******************************************************************************
278HWND WIN32API CreateMDIWindowW(LPCWSTR lpszClassName, LPCWSTR lpszWindowName,
279 DWORD dwStyle, int x, int y, int nWidth,
280 int nHeight, HWND hwndParent,
281 HINSTANCE hInstance, LPARAM lParam )
282{
283 HWND hwnd;
284 MDICREATESTRUCTW cs;
285 Win32BaseWindow *window;
286
287 window = Win32BaseWindow::GetWindowFromHandle(hwndParent);
288 if(!window) {
289 dprintf(("CreateMDIWindowW, window %x not found", hwndParent));
290 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
291 return 0;
292 }
293
294 dprintf(("USER32: CreateMDIWindowW\n"));
295 cs.szClass = lpszClassName;
296 cs.szTitle = lpszWindowName;
297 cs.hOwner = hInstance;
298 cs.x = x;
299 cs.y = y;
300 cs.cx = nHeight;
301 cs.cy = nWidth;
302 cs.style = dwStyle;
303 cs.lParam = lParam;
304
305 return window->SendMessageW(WM_MDICREATE, 0, (LPARAM)&cs);
306}
307//******************************************************************************
308//******************************************************************************
309BOOL WIN32API DestroyWindow(HWND hwnd)
310{
311 Win32BaseWindow *window;
312
313 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
314 if(!window) {
315 dprintf(("DestroyWindow, window %x not found", hwnd));
316 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
317 return 0;
318 }
319 dprintf(("DestroyWindow %x", hwnd));
320 return window->DestroyWindow();
321}
322//******************************************************************************
323//******************************************************************************
324HWND WIN32API SetActiveWindow( HWND hwnd)
325{
326 Win32BaseWindow *window;
327
328 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
329 if(!window) {
330 dprintf(("SetActiveWindow, window %x not found", hwnd));
331 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
332 return 0;
333 }
334 return window->SetActiveWindow();
335}
336//******************************************************************************
337//******************************************************************************
338HWND WIN32API GetParent( HWND hwnd)
339{
340 Win32BaseWindow *window;
341
342 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
343 if(!window) {
344 dprintf(("GetParent, window %x not found", hwnd));
345 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
346 return 0;
347 }
348// dprintf(("GetParent %x", hwnd));
349 return window->GetParent();
350}
351//******************************************************************************
352//******************************************************************************
353HWND WIN32API SetParent( HWND hwndChild, HWND hwndNewParent)
354{
355 Win32BaseWindow *window;
356
357 window = Win32BaseWindow::GetWindowFromHandle(hwndChild);
358 if(!window) {
359 dprintf(("SetParent, window %x not found", hwndChild));
360 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
361 return 0;
362 }
363 dprintf(("SetParent %x %x", hwndChild, hwndNewParent));
364 return window->SetParent(hwndNewParent);
365}
366//******************************************************************************
367//******************************************************************************
368BOOL WIN32API IsChild( HWND hwndParent, HWND hwnd)
369{
370 Win32BaseWindow *window;
371
372 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
373 if(!window) {
374 dprintf(("IsChild, window %x not found", hwnd));
375 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
376 return 0;
377 }
378 dprintf(("IsChild %x %x", hwndParent, hwnd));
379 return window->IsChild(hwndParent);
380}
381//******************************************************************************
382//******************************************************************************
383HWND WIN32API GetTopWindow( HWND hwnd)
384{
385 Win32BaseWindow *window;
386
387 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
388 if(!window) {
389 dprintf(("GetTopWindow, window %x not found", hwnd));
390 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
391 return 0;
392 }
393 return window->GetTopWindow();
394}
395//******************************************************************************
396//******************************************************************************
397BOOL WIN32API IsIconic( HWND hwnd)
398{
399 Win32BaseWindow *window;
400 BOOL rc;
401
402 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
403 if(!window) {
404 dprintf(("IsIconic, window %x not found", hwnd));
405 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
406 return FALSE;
407 }
408 rc = window->IsWindowIconic();
409 dprintf(("IsIconic %x returned %d", hwnd, rc));
410 return rc;
411}
412//******************************************************************************
413//******************************************************************************
414HWND WIN32API GetWindow(HWND hwnd, UINT uCmd)
415{
416 Win32BaseWindow *window;
417 HWND rc;
418
419 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
420 if(!window) {
421 dprintf(("GetWindow, window %x not found", hwnd));
422 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
423 return 0;
424 }
425 rc = window->GetWindow(uCmd);
426 return rc;
427}
428//******************************************************************************
429//******************************************************************************
430BOOL WIN32API EnableWindow( HWND hwnd, BOOL fEnable)
431{
432 Win32BaseWindow *window;
433
434 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
435 if(!window) {
436 dprintf(("EnableWindow, window %x not found", hwnd));
437 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
438 return 0;
439 }
440 dprintf(("EnableWindow %x %d", hwnd, fEnable));
441 return window->EnableWindow(fEnable);
442}
443//******************************************************************************
444//******************************************************************************
445BOOL WIN32API BringWindowToTop(HWND hwnd)
446{
447 return SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE );
448}
449//******************************************************************************
450//******************************************************************************
451HWND WIN32API GetActiveWindow()
452{
453 return Win32BaseWindow::GetActiveWindow();
454}
455//******************************************************************************
456//******************************************************************************
457BOOL WIN32API ShowWindow(HWND hwnd, int nCmdShow)
458{
459 Win32BaseWindow *window;
460
461 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
462 if(!window) {
463 dprintf(("ShowWindow, window %x not found", hwnd));
464 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
465 return 0;
466 }
467 dprintf(("ShowWindow %x", hwnd));
468 return window->ShowWindow(nCmdShow);
469}
470/*****************************************************************************
471 * Name : BOOL WIN32API ShowWindowAsync
472 * Purpose : The ShowWindowAsync function sets the show state of a window
473 * created by a different thread.
474 * Parameters: HWND hwnd handle of window
475 * int nCmdShow show state of window
476 * Variables :
477 * Result : If the window was previously visible, the return value is TRUE.
478 * If the window was previously hidden, the return value is FALSE.
479 * Remark :
480 * Status : UNTESTED STUB
481 *
482 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
483 *****************************************************************************/
484BOOL WIN32API ShowWindowAsync (HWND hwnd,
485 int nCmdShow)
486{
487 dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not correctly implemented.\n",
488 hwnd,
489 nCmdShow));
490
491 return ShowWindow(hwnd, nCmdShow);
492}
493//******************************************************************************
494//******************************************************************************
495BOOL WIN32API SetWindowPos(HWND hwnd, HWND hwndInsertAfter, int x, int y, int cx, int cy, UINT fuFlags)
496{
497 Win32BaseWindow *window;
498
499 if (!hwnd)
500 {
501 dprintf(("SetWindowPos: Can't move desktop!"));
502 return TRUE;
503 }
504 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
505 if(!window) {
506 dprintf(("SetWindowPos, window %x not found", hwnd));
507 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
508 return FALSE;
509 }
510 dprintf(("SetWindowPos %x %x x=%d y=%d cx=%d cy=%d %x", hwnd, hwndInsertAfter, x, y, cx, cy, fuFlags));
511 return window->SetWindowPos(hwndInsertAfter, x, y, cx, cy, fuFlags);
512}
513//******************************************************************************
514//******************************************************************************
515BOOL WIN32API SetWindowPlacement(HWND hwnd, const WINDOWPLACEMENT *winpos)
516{
517 Win32BaseWindow *window;
518
519 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
520 if(!window) {
521 dprintf(("SetWindowPlacement, window %x not found", hwnd));
522 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
523 return 0;
524 }
525 return window->SetWindowPlacement((WINDOWPLACEMENT *)winpos);
526}
527//******************************************************************************
528//******************************************************************************
529BOOL WIN32API GetWindowPlacement(HWND hwnd, LPWINDOWPLACEMENT arg2)
530{
531 dprintf(("USER32: GetWindowPlacement\n"));
532 return O32_GetWindowPlacement(Win32BaseWindow::Win32ToOS2FrameHandle(hwnd), arg2);
533}
534//******************************************************************************
535//******************************************************************************
536BOOL WIN32API IsWindow( HWND hwnd)
537{
538 Win32BaseWindow *window;
539
540 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
541 if(!window) {
542 dprintf(("IsWindow, window %x not found", hwnd));
543 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
544 return FALSE;
545 }
546 dprintf(("IsWindow %x", hwnd));
547 return window->IsWindow();
548}
549//******************************************************************************
550//******************************************************************************
551BOOL WIN32API IsWindowEnabled( HWND hwnd)
552{
553 Win32BaseWindow *window;
554
555 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
556 if(!window) {
557 dprintf(("IsWindowEnabled, window %x not found", hwnd));
558 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
559 return 0;
560 }
561 dprintf(("IsWindowEnabled %x", hwnd));
562 return window->IsWindowEnabled();
563}
564//******************************************************************************
565//******************************************************************************
566BOOL WIN32API IsWindowVisible( HWND hwnd)
567{
568 Win32BaseWindow *window;
569 BOOL rc;
570
571 if (hwnd)
572 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
573 else
574 window = windowDesktop;
575 if(!window) {
576 dprintf(("IsWindowVisible, window %x not found", hwnd));
577 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
578 return 0;
579 }
580 rc = window->IsWindowVisible();
581 dprintf(("IsWindowVisible %x returned %d", hwnd, rc));
582 return rc;
583}
584//******************************************************************************
585//******************************************************************************
586HWND WIN32API SetFocus (HWND hwnd)
587{
588 HWND lastFocus, lastFocus_W, hwnd_O;
589 BOOL activate;
590
591 hwnd_O = Win32BaseWindow::Win32ToOS2Handle (hwnd);
592 lastFocus = OSLibWinQueryFocus (OSLIB_HWND_DESKTOP);
593 activate = ((hwnd_O == lastFocus) || OSLibWinIsChild (lastFocus, hwnd_O));
594 lastFocus_W = Win32BaseWindow::OS2ToWin32Handle (lastFocus);
595
596 dprintf(("SetFocus %x (%x) -> %x (%x)\n", lastFocus_W, lastFocus, hwnd, hwnd_O));
597
598 return (OSLibWinSetFocus (OSLIB_HWND_DESKTOP, hwnd_O, activate)) ? lastFocus_W : 0;
599}
600//******************************************************************************
601//******************************************************************************
602HWND WIN32API GetFocus(void)
603{
604 HWND hwnd;
605
606 hwnd = OSLibWinQueryFocus(OSLIB_HWND_DESKTOP);
607 dprintf(("USER32: GetFocus %x\n", hwnd));
608 hwnd = Win32BaseWindow::OS2ToWin32Handle(hwnd);
609 return hwnd;
610}
611//******************************************************************************
612//******************************************************************************
613/***********************************************************************
614 * GetInternalWindowPos (USER32.245)
615 */
616UINT WIN32API GetInternalWindowPos(HWND hwnd,
617 LPRECT rectWnd,
618 LPPOINT ptIcon )
619{
620 WINDOWPLACEMENT wndpl;
621
622 dprintf(("USER32: GetInternalWindowPos(%08xh,%08xh,%08xh)\n",
623 hwnd,
624 rectWnd,
625 ptIcon));
626
627 if (GetWindowPlacement( hwnd, &wndpl ))
628 {
629 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
630 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
631 return wndpl.showCmd;
632 }
633 return 0;
634}
635//******************************************************************************
636//******************************************************************************
637BOOL WIN32API IsZoomed(HWND hwnd)
638{
639 dprintf(("USER32: IsZoomed\n"));
640 return O32_IsZoomed(Win32BaseWindow::Win32ToOS2FrameHandle(hwnd));
641}
642//******************************************************************************
643//******************************************************************************
644BOOL WIN32API LockWindowUpdate(HWND hwnd)
645{
646 dprintf(("USER32: LockWindowUpdate\n"));
647 return O32_LockWindowUpdate(Win32BaseWindow::Win32ToOS2FrameHandle(hwnd));
648}
649//******************************************************************************
650//******************************************************************************
651BOOL WIN32API GetWindowRect( HWND hwnd, PRECT pRect)
652{
653 Win32BaseWindow *window;
654
655 if (hwnd)
656 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
657 else
658 window = windowDesktop;
659
660
661 if(!window) {
662 dprintf(("GetWindowRect, window %x not found", hwnd));
663 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
664 return FALSE;
665 }
666 if(pRect == NULL) {
667 SetLastError(ERROR_INVALID_PARAMETER);
668 return FALSE;
669 }
670 *pRect = *window->getWindowRect(); //always in screen coordinates
671
672 if(hwnd == 0x68000034) {
673 window = 0;
674 }
675 dprintf(("GetWindowRect %x (%d,%d) (%d,%d)", hwnd, pRect->left, pRect->top, pRect->right, pRect->bottom));
676 return TRUE;
677}
678//******************************************************************************
679//******************************************************************************
680int WIN32API GetWindowTextLengthA( HWND hwnd)
681{
682 Win32BaseWindow *window;
683
684 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
685 if(!window) {
686 dprintf(("GetWindowTextLength, window %x not found", hwnd));
687 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
688 return 0;
689 }
690 dprintf(("GetWindowTextLength %x", hwnd));
691 return window->GetWindowTextLength();
692}
693//******************************************************************************
694//******************************************************************************
695int WIN32API GetWindowTextA( HWND hwnd, LPSTR lpsz, int cch)
696{
697 Win32BaseWindow *window;
698 int rc;
699
700 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
701 if(!window) {
702 dprintf(("GetWindowTextA, window %x not found", hwnd));
703 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
704 return 0;
705 }
706 rc = window->GetWindowTextA(lpsz, cch);
707 dprintf(("GetWindowTextA %x %s", hwnd, lpsz));
708 return rc;
709}
710//******************************************************************************
711//******************************************************************************
712int WIN32API GetWindowTextLengthW( HWND hwnd)
713{
714 dprintf(("USER32: GetWindowTextLengthW\n"));
715 return GetWindowTextLengthA(hwnd);
716}
717//******************************************************************************
718//******************************************************************************
719int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
720{
721 Win32BaseWindow *window;
722
723 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
724 if(!window) {
725 dprintf(("GetWindowTextW, window %x not found", hwnd));
726 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
727 return 0;
728 }
729 dprintf(("GetWindowTextW %x", hwnd));
730 return window->GetWindowTextW(lpsz, cch);
731}
732//******************************************************************************
733//******************************************************************************
734BOOL WIN32API SetWindowTextA(HWND hwnd, LPCSTR lpsz)
735{
736 Win32BaseWindow *window;
737
738 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
739 if(!window) {
740 dprintf(("SetWindowTextA, window %x not found", hwnd));
741 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
742 return 0;
743 }
744 dprintf(("SetWindowTextA %x %s", hwnd, lpsz));
745 return window->SetWindowTextA((LPSTR)lpsz);
746}
747//******************************************************************************
748//******************************************************************************
749BOOL WIN32API SetWindowTextW( HWND hwnd, LPCWSTR lpsz)
750{
751 Win32BaseWindow *window;
752
753 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
754 if(!window) {
755 dprintf(("SetWindowTextA, window %x not found", hwnd));
756 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
757 return 0;
758 }
759 dprintf(("SetWindowTextW %x", hwnd));
760 return window->SetWindowTextW((LPWSTR)lpsz);
761}
762/*******************************************************************
763 * InternalGetWindowText (USER32.326)
764 */
765int WIN32API InternalGetWindowText(HWND hwnd,
766 LPWSTR lpString,
767 INT nMaxCount )
768{
769 dprintf(("USER32: InternalGetWindowText(%08xh,%08xh,%08xh) not properly implemented.\n",
770 hwnd,
771 lpString,
772 nMaxCount));
773
774 return GetWindowTextW(hwnd,lpString,nMaxCount);
775}
776//******************************************************************************
777//TODO: Correct?
778//******************************************************************************
779BOOL WIN32API SetForegroundWindow(HWND hwnd)
780{
781 dprintf((" SetForegroundWindow %x", hwnd));
782
783 return SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER );
784}
785//******************************************************************************
786//******************************************************************************
787BOOL WIN32API GetClientRect( HWND hwnd, PRECT pRect)
788{
789 HWND hwndWin32 = hwnd;
790 Win32BaseWindow *window;
791
792 if (!pRect)
793 {
794 SetLastError(ERROR_INVALID_PARAMETER);
795 return FALSE;
796 }
797 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
798 if(!window) {
799 dprintf(("GetClientRect, window %x not found", hwnd));
800 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
801 return FALSE;
802 }
803 window->getClientRect(pRect);
804 dprintf(("GetClientRect of %X returned (%d,%d) (%d,%d)\n", hwndWin32, pRect->left, pRect->top, pRect->right, pRect->bottom));
805 return TRUE;
806}
807//******************************************************************************
808//******************************************************************************
809BOOL WIN32API AdjustWindowRect(PRECT rect, DWORD style, BOOL menu)
810{
811 return AdjustWindowRectEx(rect, style, menu, 0);
812}
813//******************************************************************************
814//******************************************************************************
815BOOL WIN32API AdjustWindowRectEx( PRECT rect, DWORD style, BOOL menu, DWORD exStyle)
816{
817 dprintf(("AdjustWindowRectEx %x %x %d (%d,%d)(%d,%d)\n", style, exStyle, menu, rect->left, rect->top, rect->right, rect->bottom));
818
819 /* Correct the window style */
820 if (!(style & (WS_POPUP | WS_CHILD))) /* Overlapped window */
821 style |= WS_CAPTION;
822
823 style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD | WS_VSCROLL | WS_HSCROLL);
824 exStyle &= (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE |
825 WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
826 if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
827
828 //Adjust rect outer (Win32BaseWindow::AdjustRectOuter)
829 if (HAS_THICKFRAME(style,exStyle))
830 InflateRect( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
831 else
832 if (HAS_DLGFRAME(style,exStyle))
833 InflateRect(rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
834 else
835 if (HAS_THINFRAME(style))
836 InflateRect( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
837
838 if ((style & WS_CAPTION) == WS_CAPTION)
839 {
840 if (exStyle & WS_EX_TOOLWINDOW)
841 rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
842 else
843 rect->top -= GetSystemMetrics(SM_CYCAPTION);
844 }
845
846 if (menu)
847 rect->top -= GetSystemMetrics(SM_CYMENU);
848
849 //Adjust rect inner (Win32BaseWindow::AdjustRectInner)
850 if (exStyle & WS_EX_CLIENTEDGE)
851 InflateRect (rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
852
853 if (exStyle & WS_EX_STATICEDGE)
854 InflateRect (rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
855
856 if (style & WS_VSCROLL) rect->right += GetSystemMetrics(SM_CXVSCROLL);
857 if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
858
859 dprintf(("AdjustWindowRectEx returned (%d,%d)(%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom));
860
861 return TRUE;
862}
863//******************************************************************************
864/* Coordinate Space and Transformation Functions */
865//******************************************************************************
866int WIN32API MapWindowPoints(HWND hwndFrom, HWND hwndTo, LPPOINT lpPoints,
867 UINT cPoints)
868{
869 Win32BaseWindow *wndfrom, *wndto;
870 int retval = 0;
871 OSLIBPOINT point;
872
873 if(lpPoints == NULL || cPoints == 0) {
874 SetLastError(ERROR_INVALID_PARAMETER);
875 return 0;
876 }
877 if(hwndFrom)
878 {
879 wndfrom = Win32BaseWindow::GetWindowFromHandle(hwndFrom);
880 if(!wndfrom) {
881 dprintf(("MapWindowPoints, window %x not found", hwndFrom));
882 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
883 return 0;
884 }
885 }
886 else wndfrom = windowDesktop;
887
888 if(hwndTo)
889 {
890 wndto = Win32BaseWindow::GetWindowFromHandle(hwndTo);
891 if(!wndto) {
892 dprintf(("MapWindowPoints, window %x not found", hwndTo));
893 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
894 return 0;
895 }
896 }
897 else wndto = windowDesktop;
898
899 if(wndto == wndfrom)
900 return 0; //nothing to do
901
902 dprintf(("USER32: MapWindowPoints %x to %x (%d,%d) (%d)", hwndFrom, hwndTo, lpPoints->x, lpPoints->y, cPoints));
903 point.x = lpPoints->x;
904 point.y = lpPoints->y;
905 if (!mapWin32Point(wndfrom,wndto,&point))
906 {
907 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
908 return 0;
909 }
910
911 short int xinc = point.x - lpPoints->x;
912 short int yinc = point.y - lpPoints->y;
913
914 for(int i=0;i<cPoints;i++)
915 {
916 lpPoints[i].x += xinc;
917 lpPoints[i].y += yinc;
918 }
919 retval = ((LONG)yinc << 16) | xinc;
920 return retval;
921}
922//******************************************************************************
923//******************************************************************************
924BOOL WIN32API ScreenToClient (HWND hwnd, LPPOINT pt)
925{
926 Win32BaseWindow *wnd;
927 PRECT rcl;
928 BOOL rc;
929
930 if (!hwnd) return (TRUE);
931 wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
932 if (!wnd) {
933 dprintf(("warning: ScreenToClient: window %x not found!", hwnd));
934 return (TRUE);
935 }
936#ifdef DEBUG
937 POINT tmp = *pt;
938#endif
939 rc = mapWin32Point(OSLIB_HWND_DESKTOP, wnd->getOS2WindowHandle(), (OSLIBPOINT*)pt);
940 dprintf(("ScreenToClient %x (%d,%d) -> (%d,%d)", hwnd, tmp.x, tmp.y, pt->x, pt->y));
941 return rc;
942}
943//******************************************************************************
944//******************************************************************************
945HWND WIN32API GetDesktopWindow(void)
946{
947 HWND DesktopWindow = windowDesktop->getWindowHandle();
948 dprintf2(("USER32: GetDesktopWindow, returned %d\n", DesktopWindow));
949 return DesktopWindow;
950}
951//******************************************************************************
952//******************************************************************************
953HWND WIN32API FindWindowA(LPCSTR lpszClass, LPCSTR lpszWindow)
954{
955 return FindWindowExA( NULL, NULL, lpszClass, lpszWindow );
956}
957//******************************************************************************
958//******************************************************************************
959HWND WIN32API FindWindowW( LPCWSTR lpClassName, LPCWSTR lpWindowName)
960{
961 return FindWindowExW( NULL, NULL, lpClassName, lpWindowName );
962}
963//******************************************************************************
964//******************************************************************************
965HWND WIN32API FindWindowExA(HWND hwndParent, HWND hwndChildAfter, LPCSTR lpszClass, LPCSTR lpszWindow)
966{
967 ATOM atom = 0;
968
969 if (lpszClass)
970 {
971 /* If the atom doesn't exist, then no class */
972 /* with this name exists either. */
973 if (!(atom = GlobalFindAtomA( lpszClass )))
974 {
975 SetLastError(ERROR_CANNOT_FIND_WND_CLASS);
976 return 0;
977 }
978 }
979 return Win32BaseWindow::FindWindowEx(hwndParent, hwndChildAfter, atom, (LPSTR)lpszWindow);
980}
981/*****************************************************************************
982 * Name : HWND WIN32API FindWindowExW
983 * Purpose : The FindWindowEx function retrieves the handle of a window whose
984 * class name and window name match the specified strings. The
985 * function searches child windows, beginning with the one following
986 * the given child window.
987 * Parameters: HWND hwndParent handle of parent window
988 * HWND hwndChildAfter handle of a child window
989 * LPCTSTR lpszClass address of class name
990 * LPCTSTR lpszWindow address of window name
991 * Variables :
992 * Result : If the function succeeds, the return value is the handle of the
993 * window that has the specified class and window names.
994 * If the function fails, the return value is NULL. To get extended
995 * error information, call GetLastError.
996 * Remark :
997 *
998 *****************************************************************************/
999
1000HWND WIN32API FindWindowExW(HWND hwndParent,
1001 HWND hwndChildAfter,
1002 LPCWSTR lpszClass,
1003 LPCWSTR lpszWindow)
1004{
1005 ATOM atom = 0;
1006 char *buffer;
1007 HWND hwnd;
1008
1009 if (lpszClass)
1010 {
1011 /* If the atom doesn't exist, then no class */
1012 /* with this name exists either. */
1013 if (!(atom = GlobalFindAtomW( lpszClass )))
1014 {
1015 SetLastError(ERROR_CANNOT_FIND_WND_CLASS);
1016 return 0;
1017 }
1018 }
1019 buffer = HEAP_strdupWtoA( GetProcessHeap(), 0, lpszWindow );
1020 hwnd = Win32BaseWindow::FindWindowEx(hwndParent, hwndChildAfter, atom, buffer);
1021 HeapFree( GetProcessHeap(), 0, buffer );
1022 return hwnd;
1023}
1024//******************************************************************************
1025//******************************************************************************
1026BOOL WIN32API FlashWindow(HWND hwnd, BOOL fFlash)
1027{
1028 dprintf(("FlashWindow %x %d\n", hwnd, fFlash));
1029 return OSLibWinFlashWindow(Win32BaseWindow::Win32ToOS2Handle(hwnd), fFlash);
1030}
1031//******************************************************************************
1032//******************************************************************************
1033BOOL WIN32API MoveWindow( HWND hwnd, INT x, INT y, INT cx, INT cy,
1034 BOOL repaint )
1035{
1036 int flags = SWP_NOZORDER | SWP_NOACTIVATE;
1037
1038 if (!repaint) flags |= SWP_NOREDRAW;
1039 dprintf(("MoveWindow: %x %d,%d %dx%d %d\n", hwnd, x, y, cx, cy, repaint ));
1040
1041 return SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
1042}
1043//******************************************************************************
1044//******************************************************************************
1045BOOL WIN32API ClientToScreen (HWND hwnd, PPOINT pt)
1046{
1047 Win32BaseWindow *wnd;
1048 PRECT rcl;
1049 BOOL rc;
1050
1051 if (!hwnd) {
1052 SetLastError(ERROR_INVALID_PARAMETER);
1053 return (FALSE);
1054 }
1055 wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
1056 if (!wnd) {
1057 dprintf(("warning: ClientToScreen window %x not found!", hwnd));
1058 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1059 return (FALSE);
1060 }
1061#ifdef DEBUG
1062 POINT tmp = *pt;
1063#endif
1064 rc = mapWin32Point(wnd->getOS2WindowHandle(),OSLIB_HWND_DESKTOP,(OSLIBPOINT*)pt);
1065 dprintf(("ClientToScreen %x (%d,%d) -> (%d,%d)", hwnd, tmp.x, tmp.y, pt->x, pt->y));
1066
1067 return rc;
1068}
1069//******************************************************************************
1070//******************************************************************************
1071HDWP WIN32API BeginDeferWindowPos(int count)
1072{
1073 HDWP handle;
1074 DWP *pDWP;
1075
1076 if (count <= 0)
1077 {
1078 dprintf(("USER32: BeginDeferWindowPos invalid param %d", count));
1079 SetLastError(ERROR_INVALID_PARAMETER);
1080 return 0;
1081 }
1082 dprintf(("USER32: BeginDeferWindowPos %d", count));
1083 handle = (HDWP)HeapAlloc(GetProcessHeap(), 0, sizeof(DWP) + (count-1)*sizeof(WINDOWPOS) );
1084 if (!handle)
1085 return 0;
1086
1087 pDWP = (DWP *) handle;
1088 pDWP->actualCount = 0;
1089 pDWP->suggestedCount = count;
1090 pDWP->valid = TRUE;
1091 pDWP->wMagic = DWP_MAGIC;
1092 pDWP->hwndParent = 0;
1093 return handle;
1094}
1095/***********************************************************************
1096 * DeferWindowPos (USER32.128)
1097 */
1098HDWP WIN32API DeferWindowPos( HDWP hdwp, HWND hwnd, HWND hwndAfter,
1099 INT x, INT y, INT cx, INT cy,
1100 UINT flags )
1101{
1102 DWP *pDWP;
1103 int i;
1104 HDWP newhdwp = hdwp,retvalue;
1105 Win32BaseWindow *window;
1106
1107 pDWP = (DWP *)hdwp;
1108 if (!pDWP) {
1109 SetLastError(ERROR_INVALID_PARAMETER);
1110 return 0;
1111 }
1112
1113 if (hwnd == GetDesktopWindow())
1114 return 0;
1115
1116 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1117 if(!window) {
1118 dprintf(("DeferWindowPos, window %x not found", hwnd));
1119 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1120 HeapFree(GetProcessHeap(), 0, (LPVOID)hdwp);
1121 return 0;
1122 }
1123
1124 dprintf(("USER32: DeferWindowPos hdwp %x hwnd %x hwndAfter %x (%d,%d)(%d,%d) %x", hdwp, hwnd, hwndAfter,
1125 x, y, cx, cy, flags));
1126
1127/* Numega Bounds Checker Demo dislikes the following code.
1128 In fact, I've not been able to find any "same parent" requirement in any docu
1129 [AM 980509]
1130 */
1131#if 0
1132 /* All the windows of a DeferWindowPos() must have the same parent */
1133 parent = pWnd->parent->hwndSelf;
1134 if (pDWP->actualCount == 0) pDWP->hwndParent = parent;
1135 else if (parent != pDWP->hwndParent)
1136 {
1137 USER_HEAP_FREE( hdwp );
1138 retvalue = 0;
1139 goto END;
1140 }
1141#endif
1142
1143 for (i = 0; i < pDWP->actualCount; i++)
1144 {
1145 if (pDWP->winPos[i].hwnd == hwnd)
1146 {
1147 /* Merge with the other changes */
1148 if (!(flags & SWP_NOZORDER))
1149 {
1150 pDWP->winPos[i].hwndInsertAfter = hwndAfter;
1151 }
1152 if (!(flags & SWP_NOMOVE))
1153 {
1154 pDWP->winPos[i].x = x;
1155 pDWP->winPos[i].y = y;
1156 }
1157 if (!(flags & SWP_NOSIZE))
1158 {
1159 pDWP->winPos[i].cx = cx;
1160 pDWP->winPos[i].cy = cy;
1161 }
1162 pDWP->winPos[i].flags &= flags | ~(SWP_NOSIZE | SWP_NOMOVE |
1163 SWP_NOZORDER | SWP_NOREDRAW |
1164 SWP_NOACTIVATE | SWP_NOCOPYBITS|
1165 SWP_NOOWNERZORDER);
1166 pDWP->winPos[i].flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
1167 SWP_FRAMECHANGED);
1168 retvalue = hdwp;
1169 goto END;
1170 }
1171 }
1172 if (pDWP->actualCount >= pDWP->suggestedCount)
1173 {
1174 newhdwp = (HDWP)HeapReAlloc(GetProcessHeap(), 0, (LPVOID)hdwp,
1175 sizeof(DWP) + pDWP->suggestedCount*sizeof(WINDOWPOS));
1176 if (!newhdwp)
1177 {
1178 retvalue = 0;
1179 goto END;
1180 }
1181 pDWP = (DWP *) newhdwp;
1182 pDWP->suggestedCount++;
1183 }
1184 pDWP->winPos[pDWP->actualCount].hwnd = hwnd;
1185 pDWP->winPos[pDWP->actualCount].hwndInsertAfter = hwndAfter;
1186 pDWP->winPos[pDWP->actualCount].x = x;
1187 pDWP->winPos[pDWP->actualCount].y = y;
1188 pDWP->winPos[pDWP->actualCount].cx = cx;
1189 pDWP->winPos[pDWP->actualCount].cy = cy;
1190 pDWP->winPos[pDWP->actualCount].flags = flags;
1191 pDWP->actualCount++;
1192 retvalue = newhdwp;
1193END:
1194 return retvalue;
1195}
1196//******************************************************************************
1197//******************************************************************************
1198BOOL WIN32API EndDeferWindowPos( HDWP hdwp)
1199{
1200 DWP *pDWP;
1201 WINDOWPOS *winpos;
1202 BOOL res = TRUE;
1203 int i;
1204
1205 pDWP = (DWP *) hdwp;
1206 if (!pDWP) {
1207 dprintf(("**EndDeferWindowPos invalid parameter\n"));
1208 SetLastError(ERROR_INVALID_PARAMETER);
1209 return FALSE;
1210 }
1211 dprintf(("**EndDeferWindowPos for %d windows", pDWP->actualCount));
1212 for (i = 0, winpos = pDWP->winPos; i < pDWP->actualCount; i++, winpos++)
1213 {
1214 dprintf(("**EndDeferWindowPos %x (%d,%d) (%d,%d) %x", winpos->hwnd, winpos->x, winpos->y, winpos->x, winpos->cy, winpos->flags));
1215 if (!(res = SetWindowPos(winpos->hwnd, winpos->hwndInsertAfter,
1216 winpos->x, winpos->y, winpos->cx,
1217 winpos->cy, winpos->flags )))
1218 break;
1219 }
1220 dprintf(("**EndDeferWindowPos DONE"));
1221 HeapFree(GetProcessHeap(), 0, (LPVOID)hdwp);
1222 return res;
1223}
1224//******************************************************************************
1225//******************************************************************************
1226HWND WIN32API ChildWindowFromPoint( HWND hwnd, POINT pt)
1227{
1228 dprintf(("USER32: ChildWindowFromPoint\n"));
1229 return ChildWindowFromPointEx(hwnd, pt, 0);
1230}
1231/*****************************************************************************
1232 * Name : HWND WIN32API ChildWindowFromPointEx
1233 * Purpose : pt: client coordinates
1234 * Parameters:
1235 * Variables :
1236 * Result : If the function succeeds, the return value is the window handle.
1237 * If the function fails, the return value is zero
1238 * Remark :
1239 * Status : FULLY IMPLEMENTED AND TESTED
1240 *
1241 * Author : Rene Pronk [Sun, 1999/08/08 23:30]
1242 *****************************************************************************/
1243HWND WIN32API ChildWindowFromPointEx (HWND hwndParent, POINT pt, UINT uFlags)
1244{
1245 RECT rect;
1246 HWND hWnd;
1247
1248 dprintf(("ChildWindowFromPointEx(%08xh,%08xh,%08xh).\n",
1249 hwndParent, pt, uFlags));
1250
1251 if (GetWindowRect (hwndParent, &rect) == 0) {
1252 // oops, invalid handle
1253 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1254 return NULL;
1255 }
1256
1257 ClientToScreen(hwndParent, &pt);
1258 if (PtInRect (&rect, pt) == 0) {
1259 // point is outside window
1260 return NULL;
1261 }
1262
1263
1264 // get first child
1265 hWnd = GetWindow (hwndParent, GW_CHILD);
1266
1267 while (hWnd != NULL) {
1268
1269 // do I need to skip this window?
1270 if (((uFlags & CWP_SKIPINVISIBLE) &&
1271 (IsWindowVisible (hWnd) == FALSE)) ||
1272 ((uFlags & CWP_SKIPDISABLED) &&
1273 (IsWindowEnabled (hWnd) == FALSE)) ||
1274 ((uFlags & CWP_SKIPTRANSPARENT) &&
1275 (GetWindowLongA (hWnd, GWL_EXSTYLE) & WS_EX_TRANSPARENT)))
1276
1277 {
1278 hWnd = GetWindow (hWnd, GW_HWNDNEXT);
1279 continue;
1280 }
1281
1282 // is the point in this window's rect?
1283 GetWindowRect (hWnd, &rect);
1284 if (PtInRect (&rect,pt) == FALSE) {
1285 hWnd = GetWindow (hWnd, GW_HWNDNEXT);
1286 continue;
1287 }
1288
1289 dprintf(("ChildWindowFromPointEx returned %x", hWnd));
1290 // found it!
1291 return hWnd;
1292 }
1293
1294 // the point is in the parentwindow but the parentwindow has no child
1295 // at this coordinate
1296 dprintf(("ChildWindowFromPointEx returned parent %x", hwndParent));
1297 return hwndParent;
1298}
1299//******************************************************************************
1300//******************************************************************************
1301BOOL WIN32API CloseWindow(HWND hwnd)
1302{
1303 Win32BaseWindow *window;
1304
1305 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1306 if(!window) {
1307 dprintf(("CloseWindow, window %x not found", hwnd));
1308 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1309 return 0;
1310 }
1311 dprintf(("CloseWindow %x\n", hwnd));
1312 return window->CloseWindow();
1313}
1314//******************************************************************************
1315//TODO: Does this return handles of hidden or disabled windows?
1316//******************************************************************************
1317HWND WIN32API WindowFromPoint( POINT point)
1318{
1319 HWND hwndOS2, hwnd;
1320 POINT wPoint;
1321
1322 wPoint.x = point.x;
1323 wPoint.y = mapScreenY(point.y);
1324
1325 hwndOS2 = OSLibWinWindowFromPoint(OSLIB_HWND_DESKTOP, (PVOID)&wPoint);
1326 if(hwndOS2)
1327 {
1328 hwnd = Win32BaseWindow::OS2ToWin32Handle(hwndOS2);
1329 if(hwnd) {
1330 dprintf(("WindowFromPoint (%d,%d) %x->%x\n", point.x, point.y, hwndOS2, hwnd));
1331 return hwnd;
1332 }
1333 }
1334 dprintf(("WindowFromPoint (%d,%d) %x->1\n", point.x, point.y, hwndOS2));
1335 return windowDesktop->getWindowHandle();
1336}
1337//******************************************************************************
1338//******************************************************************************
1339BOOL WIN32API IsWindowUnicode(HWND hwnd)
1340{
1341 Win32BaseWindow *window;
1342
1343 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1344 if(!window) {
1345 dprintf(("IsWindowUnicode, window %x not found", hwnd));
1346 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1347 return 0;
1348 }
1349 return window->IsWindowUnicode();
1350}
1351/***********************************************************************
1352 * SwitchToThisWindow (USER32.539)
1353 */
1354DWORD WINAPI SwitchToThisWindow( HWND hwnd, BOOL restore )
1355{
1356 return ShowWindow( hwnd, restore ? SW_RESTORE : SW_SHOWMINIMIZED );
1357}
1358//******************************************************************************
1359//******************************************************************************
1360BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
1361{
1362 return windowDesktop->EnumThreadWindows(dwThreadId, lpfn, lParam);
1363}
1364//******************************************************************************
1365//******************************************************************************
1366BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1367{
1368 Win32BaseWindow *window;
1369 BOOL rc = TRUE;
1370 ULONG henum;
1371 HWND hwndNext;
1372
1373 if(lpfn == NULL) {
1374 dprintf(("EnumChildWindows invalid parameter %x %x\n", hwnd, lParam));
1375 SetLastError(ERROR_INVALID_PARAMETER);
1376 return FALSE;
1377 }
1378 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1379 if(!window) {
1380 dprintf(("EnumChildWindows, window %x not found", hwnd));
1381 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1382 return FALSE;
1383 }
1384 return window->EnumChildWindows(lpfn, lParam);
1385}
1386//******************************************************************************
1387//******************************************************************************
1388BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1389{
1390 return windowDesktop->EnumWindows(lpfn, lParam);
1391}
1392//******************************************************************************
1393//******************************************************************************
1394UINT WIN32API ArrangeIconicWindows( HWND hwnd)
1395{
1396 dprintf(("USER32: ArrangeIconicWindows %x", hwnd));
1397 return O32_ArrangeIconicWindows(Win32BaseWindow::Win32ToOS2FrameHandle(hwnd));
1398}
1399//******************************************************************************
1400//restores iconized window to previous size/position
1401//******************************************************************************
1402BOOL WIN32API OpenIcon(HWND hwnd)
1403{
1404 dprintf(("USER32: OpenIcon"));
1405
1406 if(!IsIconic(hwnd))
1407 return FALSE;
1408 ShowWindow(hwnd, SW_SHOWNORMAL);
1409 return TRUE;
1410}
1411//******************************************************************************
1412//******************************************************************************
1413BOOL WIN32API ShowOwnedPopups( HWND hwnd, BOOL arg2)
1414{
1415 dprintf(("USER32: ShowOwnedPopups %x", hwnd));
1416 return O32_ShowOwnedPopups(Win32BaseWindow::Win32ToOS2FrameHandle(hwnd), arg2);
1417}
1418//******************************************************************************
1419//******************************************************************************
1420HWND WIN32API GetForegroundWindow(void)
1421{
1422 dprintf(("USER32: GetForegroundWindow"));
1423 return Win32BaseWindow::OS2ToWin32Handle(O32_GetForegroundWindow());
1424}
1425//******************************************************************************
1426//******************************************************************************
1427HWND WIN32API GetLastActivePopup( HWND hWnd)
1428{
1429 HWND hwnd;
1430
1431 hWnd = Win32BaseWindow::Win32ToOS2Handle(hWnd);
1432
1433 hwnd = Win32BaseWindow::OS2ToWin32Handle(O32_GetLastActivePopup(hWnd));
1434
1435 dprintf(("GetLastActivePopup %x returned %x", hWnd, hwnd));
1436 return hwnd;
1437}
1438//******************************************************************************
1439//******************************************************************************
1440DWORD WIN32API GetWindowThreadProcessId(HWND hWnd, PDWORD lpdwProcessId)
1441{
1442 dprintf2(("USER32: GetWindowThreadProcessId"));
1443 hWnd = Win32BaseWindow::Win32ToOS2Handle(hWnd);
1444
1445 return O32_GetWindowThreadProcessId(hWnd,lpdwProcessId);
1446}
1447//******************************************************************************
1448//******************************************************************************
1449DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
1450{
1451 Win32BaseWindow *window;
1452
1453 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1454 if(!window) {
1455 dprintf(("GetWindowContextHelpId, window %x not found", hwnd));
1456 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1457 return 0;
1458 }
1459 dprintf(("GetWindowContextHelpId %x", hwnd));
1460 return window->getWindowContextHelpId();
1461}
1462//******************************************************************************
1463//******************************************************************************
1464BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
1465{
1466 Win32BaseWindow *window;
1467
1468 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1469 if(!window) {
1470 dprintf(("SetWindowContextHelpId, window %x not found", hwnd));
1471 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1472 return 0;
1473 }
1474 dprintf(("SetWindowContextHelpId %x %d", hwnd, dwContextHelpId));
1475 window->setWindowContextHelpId(dwContextHelpId);
1476 return(TRUE);
1477}
1478//******************************************************************************
1479//******************************************************************************
Note: See TracBrowser for help on using the repository browser.