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

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

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