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

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

Bugfixes for enum* apis & findwindowex
File size: 48.6 KB
Line 
1/* $Id: window.cpp,v 1.19 1999-10-17 16: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
510 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
511 if(!window) {
512 dprintf(("IsWindowVisible, window %x not found", hwnd));
513 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
514 return 0;
515 }
516 dprintf(("IsWindowVisible %x", hwnd));
517 return window->IsWindowVisible();
518}
519//******************************************************************************
520//******************************************************************************
521HWND WIN32API SetFocus (HWND hwnd)
522{
523 HWND lastFocus, lastFocus_W, hwnd_O;
524 BOOL activate;
525
526 hwnd_O = Win32BaseWindow::Win32ToOS2Handle (hwnd);
527 lastFocus = OSLibWinQueryFocus (OSLIB_HWND_DESKTOP);
528 activate = ((hwnd_O == lastFocus) || OSLibWinIsChild (lastFocus, hwnd_O));
529 lastFocus_W = Win32BaseWindow::OS2ToWin32Handle (lastFocus);
530
531 dprintf(("SetFocus %x (%x) -> %x (%x)\n", lastFocus_W, lastFocus, hwnd, hwnd_O));
532
533 return (OSLibWinSetFocus (OSLIB_HWND_DESKTOP, hwnd_O, activate)) ? lastFocus_W : 0;
534}
535//******************************************************************************
536//******************************************************************************
537HWND WIN32API GetFocus(void)
538{
539 HWND hwnd;
540
541 hwnd = OSLibWinQueryFocus(OSLIB_HWND_DESKTOP);
542 dprintf(("USER32: GetFocus %x\n", hwnd));
543 hwnd = Win32BaseWindow::OS2ToWin32Handle(hwnd);
544 return hwnd;
545}
546//******************************************************************************
547//******************************************************************************
548/***********************************************************************
549 * GetInternalWindowPos (USER32.245)
550 */
551UINT WIN32API GetInternalWindowPos(HWND hwnd,
552 LPRECT rectWnd,
553 LPPOINT ptIcon )
554{
555 WINDOWPLACEMENT wndpl;
556
557 dprintf(("USER32: GetInternalWindowPos(%08xh,%08xh,%08xh)\n",
558 hwnd,
559 rectWnd,
560 ptIcon));
561
562 if (GetWindowPlacement( hwnd, &wndpl ))
563 {
564 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
565 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
566 return wndpl.showCmd;
567 }
568 return 0;
569}
570//******************************************************************************
571//******************************************************************************
572BOOL WIN32API IsZoomed(HWND hwnd)
573{
574 dprintf(("USER32: IsZoomed\n"));
575 return O32_IsZoomed(Win32BaseWindow::Win32ToOS2FrameHandle(hwnd));
576}
577//******************************************************************************
578//******************************************************************************
579BOOL WIN32API LockWindowUpdate(HWND hwnd)
580{
581 dprintf(("USER32: LockWindowUpdate\n"));
582 return O32_LockWindowUpdate(Win32BaseWindow::Win32ToOS2FrameHandle(hwnd));
583}
584//******************************************************************************
585//******************************************************************************
586BOOL WIN32API GetWindowRect( HWND hwnd, PRECT pRect)
587{
588 Win32BaseWindow *window;
589 BOOL rc;
590
591 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
592 if(!window) {
593 dprintf(("GetWindowRect, window %x not found", hwnd));
594 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
595 return 0;
596 }
597 rc = window->GetWindowRect(pRect);
598 dprintf(("GetWindowRect %x (%d,%d) (%d,%d)", hwnd, pRect->left, pRect->top, pRect->right, pRect->bottom));
599 return rc;
600}
601//******************************************************************************
602//******************************************************************************
603int WIN32API GetWindowTextLengthA( HWND hwnd)
604{
605 Win32BaseWindow *window;
606
607 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
608 if(!window) {
609 dprintf(("GetWindowTextLength, window %x not found", hwnd));
610 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
611 return 0;
612 }
613 dprintf(("GetWindowTextLength %x", hwnd));
614 return window->GetWindowTextLength();
615}
616//******************************************************************************
617//******************************************************************************
618int WIN32API GetWindowTextA( HWND hwnd, LPSTR lpsz, int cch)
619{
620 Win32BaseWindow *window;
621 int rc;
622
623 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
624 if(!window) {
625 dprintf(("GetWindowTextA, window %x not found", hwnd));
626 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
627 return 0;
628 }
629 rc = window->GetWindowTextA(lpsz, cch);
630 dprintf(("GetWindowTextA %x %s", hwnd, lpsz));
631 return rc;
632}
633//******************************************************************************
634//******************************************************************************
635int WIN32API GetWindowTextLengthW( HWND hwnd)
636{
637 dprintf(("USER32: GetWindowTextLengthW\n"));
638 return GetWindowTextLengthA(hwnd);
639}
640//******************************************************************************
641//******************************************************************************
642int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
643{
644 Win32BaseWindow *window;
645
646 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
647 if(!window) {
648 dprintf(("GetWindowTextW, window %x not found", hwnd));
649 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
650 return 0;
651 }
652 dprintf(("GetWindowTextW %x", hwnd));
653 return window->GetWindowTextW(lpsz, cch);
654}
655//******************************************************************************
656//******************************************************************************
657BOOL WIN32API SetWindowTextA(HWND hwnd, LPCSTR lpsz)
658{
659 Win32BaseWindow *window;
660
661 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
662 if(!window) {
663 dprintf(("SetWindowTextA, window %x not found", hwnd));
664 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
665 return 0;
666 }
667 dprintf(("SetWindowTextA %x %s", hwnd, lpsz));
668 return window->SetWindowTextA((LPSTR)lpsz);
669}
670//******************************************************************************
671//******************************************************************************
672BOOL WIN32API SetWindowTextW( HWND hwnd, LPCWSTR lpsz)
673{
674 Win32BaseWindow *window;
675
676 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
677 if(!window) {
678 dprintf(("SetWindowTextA, window %x not found", hwnd));
679 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
680 return 0;
681 }
682 dprintf(("SetWindowTextW %x", hwnd));
683 return window->SetWindowTextW((LPWSTR)lpsz);
684}
685/*******************************************************************
686 * InternalGetWindowText (USER32.326)
687 */
688int WIN32API InternalGetWindowText(HWND hwnd,
689 LPWSTR lpString,
690 INT nMaxCount )
691{
692 dprintf(("USER32: InternalGetWindowText(%08xh,%08xh,%08xh) not properly implemented.\n",
693 hwnd,
694 lpString,
695 nMaxCount));
696
697 return GetWindowTextW(hwnd,lpString,nMaxCount);
698}
699//******************************************************************************
700//TODO: Correct?
701//******************************************************************************
702BOOL WIN32API SetForegroundWindow(HWND hwnd)
703{
704 dprintf((" SetForegroundWindow %x", hwnd));
705
706 return SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER );
707}
708//******************************************************************************
709//******************************************************************************
710BOOL WIN32API GetClientRect( HWND hwnd, PRECT pRect)
711{
712 BOOL rc;
713 HWND hwndWin32 = hwnd;
714
715#if 1
716 Win32BaseWindow *window;
717
718 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
719 if(!window) {
720 dprintf(("GetClientRect, window %x not found", hwnd));
721 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
722 return 0;
723 }
724 *pRect = *window->getClientRect();
725 OffsetRect(pRect, -pRect->left, -pRect->top);
726 dprintf(("GetClientRect of %X returned (%d,%d) (%d,%d)\n", hwndWin32, pRect->left, pRect->top, pRect->right, pRect->bottom));
727 return TRUE;
728#else
729 hwnd = Win32BaseWindow::Win32ToOS2Handle(hwnd);
730 rc = OSLibWinQueryWindowRect(hwnd, pRect);
731 dprintf(("GetClientRect of %X returned (%d,%d) (%d,%d)\n", hwndWin32, pRect->left, pRect->top, pRect->right, pRect->bottom));
732 return rc;
733#endif
734}
735//******************************************************************************
736//******************************************************************************
737BOOL WIN32API AdjustWindowRect(PRECT rect, DWORD style, BOOL menu)
738{
739 return AdjustWindowRectEx(rect, style, menu, 0);
740}
741//******************************************************************************
742//******************************************************************************
743BOOL WIN32API AdjustWindowRectEx( PRECT rect, DWORD style, BOOL menu, DWORD exStyle)
744{
745 dprintf(("AdjustWindowRectEx %x %x %d (%d,%d)(%d,%d)\n", style, exStyle, menu, rect->right, rect->top, rect->left, rect->bottom));
746
747#if 0
748 O32_AdjustWindowRectEx(rect, style, menu, exStyle);
749#else
750 /* Correct the window style */
751 if (!(style & (WS_POPUP | WS_CHILD))) /* Overlapped window */
752 style |= WS_CAPTION;
753
754 style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD | WS_VSCROLL | WS_HSCROLL);
755 exStyle &= (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE |
756 WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
757 if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
758
759 Win32BaseWindow::NC_AdjustRectOuter( rect, style, menu, exStyle );
760 Win32BaseWindow::NC_AdjustRectInner( rect, style, exStyle );
761#endif
762
763 dprintf(("AdjustWindowRectEx returned (%d,%d)(%d,%d)\n", rect->right, rect->top, rect->left, rect->bottom));
764 return TRUE;
765}
766//******************************************************************************
767//******************************************************************************
768HWND WIN32API GetDesktopWindow(void)
769{
770 dprintf(("USER32: GetDesktopWindow\n"));
771 return windowDesktop->getWindowHandle();
772}
773//******************************************************************************
774//******************************************************************************
775HWND WIN32API FindWindowA(LPCSTR lpszClass, LPCSTR lpszWindow)
776{
777 if(!lpszClass) {
778 SetLastError(ERROR_INVALID_PARAMETER);
779 return 0;
780 }
781 if(HIWORD(lpszClass)) {
782 dprintf(("USER32: FindWindow %s %s\n", lpszClass, lpszWindow));
783 }
784 else dprintf(("USER32: FindWindow %x %s\n", lpszClass, lpszWindow));
785
786 return Win32BaseWindow::FindWindowEx(OSLIB_HWND_DESKTOP, 0, (LPSTR)lpszClass, (LPSTR)lpszWindow);
787}
788//******************************************************************************
789//******************************************************************************
790HWND WIN32API FindWindowW( LPCWSTR lpClassName, LPCWSTR lpWindowName)
791{
792 char *astring1 = UnicodeToAsciiString((LPWSTR)lpClassName);
793 char *astring2 = UnicodeToAsciiString((LPWSTR)lpWindowName);
794 HWND rc;
795
796 rc = FindWindowA(astring1, astring2);
797 FreeAsciiString(astring1);
798 FreeAsciiString(astring2);
799 return rc;
800}
801//******************************************************************************
802//******************************************************************************
803HWND WIN32API FindWindowExA(HWND hwndParent, HWND hwndChildAfter, LPCSTR lpszClass, LPCSTR lpszWindow)
804{
805 if(!lpszClass) {
806 SetLastError(ERROR_INVALID_PARAMETER);
807 return 0;
808 }
809 if(HIWORD(lpszClass)) {
810 dprintf(("USER32: FindWindowExA (%x,%x) %s %s\n", hwndParent, hwndChildAfter, lpszClass, lpszWindow));
811 }
812 else dprintf(("USER32: FindWindowExA (%x,%x)%x %s\n", hwndParent, hwndChildAfter, lpszClass, lpszWindow));
813
814 return Win32BaseWindow::FindWindowEx(hwndParent, hwndChildAfter, (LPSTR)lpszClass, (LPSTR)lpszWindow);
815}
816/*****************************************************************************
817 * Name : HWND WIN32API FindWindowExW
818 * Purpose : The FindWindowEx function retrieves the handle of a window whose
819 * class name and window name match the specified strings. The
820 * function searches child windows, beginning with the one following
821 * the given child window.
822 * Parameters: HWND hwndParent handle of parent window
823 * HWND hwndChildAfter handle of a child window
824 * LPCTSTR lpszClass address of class name
825 * LPCTSTR lpszWindow address of window name
826 * Variables :
827 * Result : If the function succeeds, the return value is the handle of the
828 * window that has the specified class and window names.
829 * If the function fails, the return value is NULL. To get extended
830 * error information, call GetLastError.
831 * Remark :
832 * Status : UNTESTED STUB
833 *
834 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
835 *****************************************************************************/
836
837HWND WIN32API FindWindowExW(HWND hwndParent,
838 HWND hwndChildAfter,
839 LPCWSTR lpszClass,
840 LPCWSTR lpszWindow)
841{
842 if(!lpszClass) {
843 SetLastError(ERROR_INVALID_PARAMETER);
844 return 0;
845 }
846 dprintf(("USER32: FindWindowExW (%x,%x) %x %s\n", hwndParent, hwndChildAfter, lpszClass, lpszWindow));
847
848 return Win32BaseWindow::FindWindowEx(hwndParent, hwndChildAfter, (LPSTR)lpszClass, (LPSTR)lpszWindow);
849}
850//******************************************************************************
851//******************************************************************************
852BOOL WIN32API FlashWindow(HWND hwnd, BOOL fFlash)
853{
854 dprintf(("FlashWindow %x %d\n", hwnd, fFlash));
855 return OSLibWinFlashWindow(Win32BaseWindow::Win32ToOS2Handle(hwnd), fFlash);
856}
857//******************************************************************************
858//******************************************************************************
859BOOL WIN32API MoveWindow( HWND hwnd, INT x, INT y, INT cx, INT cy,
860 BOOL repaint )
861{
862 int flags = SWP_NOZORDER | SWP_NOACTIVATE;
863
864 if (!repaint) flags |= SWP_NOREDRAW;
865 dprintf(("MoveWindow: %04x %d,%d %dx%d %d\n", hwnd, x, y, cx, cy, repaint ));
866
867 return SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
868}
869//******************************************************************************
870//******************************************************************************
871BOOL WIN32API ClientToScreen (HWND hwnd, PPOINT pt)
872{
873 Win32BaseWindow *wnd;
874 PRECT rcl;
875
876 dprintf(("USER32: ClientToScreen\n"));
877 if (!hwnd) {
878 SetLastError(ERROR_INVALID_PARAMETER);
879 return (FALSE);
880 }
881 wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
882 if (!wnd) {
883 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
884 return (FALSE);
885 }
886
887 rcl = wnd->getClientRect();
888 pt->y = (rcl->bottom - rcl->top) - pt->y;
889 OSLibWinMapWindowPoints (wnd->getOS2WindowHandle(), OSLIB_HWND_DESKTOP, (OSLIBPOINT *)pt, 1);
890 pt->y = ScreenHeight - pt->y;
891 return (TRUE);
892}
893//******************************************************************************
894//******************************************************************************
895HDWP WIN32API BeginDeferWindowPos(int count)
896{
897 HDWP handle;
898 DWP *pDWP;
899
900 dprintf(("USER32: BeginDeferWindowPos\n"));
901 if (count <= 0)
902 {
903 SetLastError(ERROR_INVALID_PARAMETER);
904 return 0;
905 }
906 handle = (HDWP)HeapAlloc(GetProcessHeap(), 0, sizeof(DWP) + (count-1)*sizeof(WINDOWPOS) );
907 if (!handle)
908 return 0;
909
910 pDWP = (DWP *) handle;
911 pDWP->actualCount = 0;
912 pDWP->suggestedCount = count;
913 pDWP->valid = TRUE;
914 pDWP->wMagic = DWP_MAGIC;
915 pDWP->hwndParent = 0;
916 return handle;
917}
918/***********************************************************************
919 * DeferWindowPos (USER32.128)
920 */
921HDWP WIN32API DeferWindowPos( HDWP hdwp, HWND hwnd, HWND hwndAfter,
922 INT x, INT y, INT cx, INT cy,
923 UINT flags )
924{
925 DWP *pDWP;
926 int i;
927 HDWP newhdwp = hdwp,retvalue;
928 Win32BaseWindow *window;
929
930 pDWP = (DWP *)hdwp;
931 if (!pDWP) {
932 SetLastError(ERROR_INVALID_PARAMETER);
933 return 0;
934 }
935
936 if (hwnd == GetDesktopWindow())
937 return 0;
938
939 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
940 if(!window) {
941 dprintf(("DeferWindowPos, window %x not found", hwnd));
942 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
943 HeapFree(GetProcessHeap(), 0, (LPVOID)hdwp);
944 return 0;
945 }
946
947
948/* Numega Bounds Checker Demo dislikes the following code.
949 In fact, I've not been able to find any "same parent" requirement in any docu
950 [AM 980509]
951 */
952#if 0
953 /* All the windows of a DeferWindowPos() must have the same parent */
954 parent = pWnd->parent->hwndSelf;
955 if (pDWP->actualCount == 0) pDWP->hwndParent = parent;
956 else if (parent != pDWP->hwndParent)
957 {
958 USER_HEAP_FREE( hdwp );
959 retvalue = 0;
960 goto END;
961 }
962#endif
963
964 for (i = 0; i < pDWP->actualCount; i++)
965 {
966 if (pDWP->winPos[i].hwnd == hwnd)
967 {
968 /* Merge with the other changes */
969 if (!(flags & SWP_NOZORDER))
970 {
971 pDWP->winPos[i].hwndInsertAfter = hwndAfter;
972 }
973 if (!(flags & SWP_NOMOVE))
974 {
975 pDWP->winPos[i].x = x;
976 pDWP->winPos[i].y = y;
977 }
978 if (!(flags & SWP_NOSIZE))
979 {
980 pDWP->winPos[i].cx = cx;
981 pDWP->winPos[i].cy = cy;
982 }
983 pDWP->winPos[i].flags &= flags | ~(SWP_NOSIZE | SWP_NOMOVE |
984 SWP_NOZORDER | SWP_NOREDRAW |
985 SWP_NOACTIVATE | SWP_NOCOPYBITS|
986 SWP_NOOWNERZORDER);
987 pDWP->winPos[i].flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
988 SWP_FRAMECHANGED);
989 retvalue = hdwp;
990 goto END;
991 }
992 }
993 if (pDWP->actualCount >= pDWP->suggestedCount)
994 {
995 newhdwp = (HDWP)HeapReAlloc(GetProcessHeap(), 0, (LPVOID)hdwp,
996 sizeof(DWP) + pDWP->suggestedCount*sizeof(WINDOWPOS));
997 if (!newhdwp)
998 {
999 retvalue = 0;
1000 goto END;
1001 }
1002 pDWP = (DWP *) newhdwp;
1003 pDWP->suggestedCount++;
1004 }
1005 pDWP->winPos[pDWP->actualCount].hwnd = hwnd;
1006 pDWP->winPos[pDWP->actualCount].hwndInsertAfter = hwndAfter;
1007 pDWP->winPos[pDWP->actualCount].x = x;
1008 pDWP->winPos[pDWP->actualCount].y = y;
1009 pDWP->winPos[pDWP->actualCount].cx = cx;
1010 pDWP->winPos[pDWP->actualCount].cy = cy;
1011 pDWP->winPos[pDWP->actualCount].flags = flags;
1012 pDWP->actualCount++;
1013 retvalue = newhdwp;
1014END:
1015 return retvalue;
1016}
1017//******************************************************************************
1018//******************************************************************************
1019BOOL WIN32API EndDeferWindowPos( HDWP hdwp)
1020{
1021 DWP *pDWP;
1022 WINDOWPOS *winpos;
1023 BOOL res = TRUE;
1024 int i;
1025
1026 dprintf(("EndDeferWindowPos\n"));
1027 pDWP = (DWP *) hdwp;
1028 if (!pDWP) {
1029 SetLastError(ERROR_INVALID_PARAMETER);
1030 return FALSE;
1031 }
1032 for (i = 0, winpos = pDWP->winPos; i < pDWP->actualCount; i++, winpos++)
1033 {
1034 if (!(res = SetWindowPos(winpos->hwnd, winpos->hwndInsertAfter,
1035 winpos->x, winpos->y, winpos->cx,
1036 winpos->cy, winpos->flags )))
1037 break;
1038 }
1039 HeapFree(GetProcessHeap(), 0, (LPVOID)hdwp);
1040 return res;
1041}
1042//******************************************************************************
1043//******************************************************************************
1044HWND WIN32API ChildWindowFromPoint( HWND hwnd, POINT pt)
1045{
1046 dprintf(("USER32: ChildWindowFromPoint\n"));
1047// return O32_ChildWindowFromPoint(arg1, arg2);
1048 return ChildWindowFromPointEx(hwnd, pt, 0);
1049}
1050//******************************************************************************
1051//******************************************************************************
1052/*****************************************************************************
1053 * Name : HWND WIN32API ChildWindowFromPointEx
1054 * Purpose : The GetWindowRect function retrieves the dimensions of the
1055 * bounding rectangle of the specified window. The dimensions are
1056 * given in screen coordinates that are relative to the upper-left
1057 * corner of the screen.
1058 * Parameters:
1059 * Variables :
1060 * Result : If the function succeeds, the return value is the window handle.
1061 * If the function fails, the return value is zero
1062 * Remark :
1063 * Status : FULLY IMPLEMENTED AND TESTED
1064 *
1065 * Author : Rene Pronk [Sun, 1999/08/08 23:30]
1066 *****************************************************************************/
1067
1068HWND WIN32API ChildWindowFromPointEx (HWND hwndParent, POINT pt, UINT uFlags)
1069{
1070 RECT rect;
1071 HWND hWnd;
1072 POINT absolutePt;
1073
1074 dprintf(("ChildWindowFromPointEx(%08xh,%08xh,%08xh).\n",
1075 hwndParent, pt, uFlags));
1076
1077 if (GetWindowRect (hwndParent, &rect) == 0) {
1078 // oops, invalid handle
1079 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1080 return NULL;
1081 }
1082
1083 // absolutePt has its top in the upper-left corner of the screen
1084 absolutePt = pt;
1085 ClientToScreen (hwndParent, &absolutePt);
1086
1087 // make rect the size of the parent window
1088 GetWindowRect (hwndParent, &rect);
1089 rect.right = rect.right - rect.left;
1090 rect.bottom = rect.bottom - rect.top;
1091 rect.left = 0;
1092 rect.top = 0;
1093
1094 if (PtInRect (&rect, pt) == 0) {
1095 // point is outside window
1096 return NULL;
1097 }
1098
1099 // get first child
1100 hWnd = GetWindow (hwndParent, GW_CHILD);
1101
1102 while (hWnd != NULL) {
1103
1104 // do I need to skip this window?
1105 if (((uFlags & CWP_SKIPINVISIBLE) &&
1106 (IsWindowVisible (hWnd) == FALSE)) ||
1107 ((uFlags & CWP_SKIPDISABLED) &&
1108 (IsWindowEnabled (hWnd) == FALSE)) ||
1109 ((uFlags & CWP_SKIPTRANSPARENT) &&
1110 (GetWindowLongA (hWnd, GWL_EXSTYLE) & WS_EX_TRANSPARENT)))
1111
1112 {
1113 hWnd = GetWindow (hWnd, GW_HWNDNEXT);
1114 continue;
1115 }
1116
1117 // is the point in this window's rect?
1118 GetWindowRect (hWnd, &rect);
1119 if (PtInRect (&rect, absolutePt) == FALSE) {
1120 hWnd = GetWindow (hWnd, GW_HWNDNEXT);
1121 continue;
1122 }
1123
1124 dprintf(("ChildWindowFromPointEx returned %x", hWnd));
1125 // found it!
1126 return hWnd;
1127 }
1128
1129 // the point is in the parentwindow but the parentwindow has no child
1130 // at this coordinate
1131 dprintf(("ChildWindowFromPointEx returned parent %x", hwndParent));
1132 return hwndParent;
1133}
1134//******************************************************************************
1135//******************************************************************************
1136BOOL WIN32API CloseWindow(HWND hwnd)
1137{
1138 Win32BaseWindow *window;
1139
1140 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1141 if(!window) {
1142 dprintf(("CloseWindow, window %x not found", hwnd));
1143 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1144 return 0;
1145 }
1146 dprintf(("CloseWindow %x\n", hwnd));
1147 return window->CloseWindow();
1148}
1149//******************************************************************************
1150//TODO: Does this return handles of hidden or disabled windows?
1151//******************************************************************************
1152HWND WIN32API WindowFromPoint( POINT point)
1153{
1154 HWND hwnd;
1155
1156 dprintf(("WindowFromPoint (%d,%d)\n", point.x, point.y));
1157 hwnd = OSLibWinWindowFromPoint(OSLIB_HWND_DESKTOP, (PVOID)&point);
1158 if(hwnd) {
1159 return Win32BaseWindow::OS2ToWin32Handle(hwnd);
1160 }
1161 return 0;
1162}
1163//******************************************************************************
1164//******************************************************************************
1165BOOL WIN32API IsWindowUnicode(HWND hwnd)
1166{
1167 Win32BaseWindow *window;
1168
1169 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1170 if(!window) {
1171 dprintf(("IsWindowUnicode, window %x not found", hwnd));
1172 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1173 return 0;
1174 }
1175 return window->IsUnicode();
1176}
1177/*****************************************************************************
1178 * Name : WORD WIN32API CascadeWindows
1179 * Purpose : The CascadeWindows function cascades the specified windows or
1180 * the child windows of the specified parent window.
1181 * Parameters: HWND hwndParent handle of parent window
1182 * UINT wHow types of windows not to arrange
1183 * CONST RECT * lpRect rectangle to arrange windows in
1184 * UINT cKids number of windows to arrange
1185 * const HWND FAR * lpKids array of window handles
1186 * Variables :
1187 * Result : If the function succeeds, the return value is the number of windows arranged.
1188 * If the function fails, the return value is zero.
1189 * Remark :
1190 * Status : UNTESTED STUB
1191 *
1192 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1193 *****************************************************************************/
1194
1195WORD WIN32API CascadeWindows(HWND hwndParent,
1196 UINT wHow,
1197 CONST LPRECT lpRect,
1198 UINT cKids,
1199 const HWND *lpKids)
1200{
1201 dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
1202 hwndParent,
1203 wHow,
1204 lpRect,
1205 cKids,
1206 lpKids));
1207
1208 return (0);
1209}
1210/*****************************************************************************
1211 * Name : BOOL WIN32API SwitchToThisWindow
1212 * Purpose : Unknown
1213 * Parameters: Unknown
1214 * Variables :
1215 * Result :
1216 * Remark :
1217 * Status : UNTESTED UNKNOWN STUB
1218 *
1219 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
1220 *****************************************************************************/
1221
1222BOOL WIN32API SwitchToThisWindow(HWND hwnd,
1223 BOOL x2)
1224{
1225 dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
1226 hwnd,
1227 x2));
1228
1229 return (FALSE); /* default */
1230}
1231//******************************************************************************
1232//******************************************************************************
1233BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
1234{
1235 Win32BaseWindow *window;
1236 BOOL rc;
1237 ULONG henum;
1238 HWND hwndNext;
1239 ULONG tid;
1240 ULONG pid, curpid;
1241
1242 dprintf(("EnumThreadWindows\n"));
1243
1244 curpid = GetCurrentProcessId();
1245
1246 henum = OSLibWinBeginEnumWindows(OSLIB_HWND_DESKTOP);
1247 while ((hwndNext = OSLibWinGetNextWindow(henum)) != 0)
1248 {
1249 OSLibWinQueryWindowProcess(hwndNext, &pid, &tid);
1250 if(!(curpid == pid && dwThreadId == tid))
1251 continue;
1252
1253 window = Win32BaseWindow::GetWindowFromOS2Handle(hwndNext);
1254 if(window == NULL) {
1255 window = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndNext);
1256 if(!window) {
1257 //OS/2 window or non-frame window, so skip it
1258 continue;
1259 }
1260 }
1261 if((rc = lpfn(window->getWindowHandle(), lParam)) == FALSE)
1262 break;
1263 }
1264 OSLibWinEndEnumWindows (henum);
1265 return TRUE;
1266}
1267//******************************************************************************
1268//******************************************************************************
1269BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1270{
1271 Win32BaseWindow *window, *parentwindow;
1272 BOOL rc = TRUE;
1273 ULONG henum;
1274 HWND hwndNext;
1275
1276 dprintf(("EnumChildWindows %x %x\n", hwnd, lParam));
1277
1278 parentwindow = Win32BaseWindow::GetWindowFromHandle(hwnd);
1279 if(!parentwindow) {
1280 dprintf(("EnumChildWindows, window %x not found", hwnd));
1281 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1282 return FALSE;
1283 }
1284
1285 henum = OSLibWinBeginEnumWindows(OSLIB_HWND_DESKTOP);
1286 while ((hwndNext = OSLibWinGetNextWindow(henum)) != 0)
1287 {
1288 window = Win32BaseWindow::GetWindowFromOS2Handle(hwndNext);
1289 if(window == NULL) {
1290 window = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndNext);
1291 if(!window) {
1292 //OS/2 window or non-frame window, so skip it
1293 continue;
1294 }
1295 }
1296 if((rc = lpfn(window->getWindowHandle(), lParam)) == FALSE)
1297 {
1298 rc = FALSE;
1299 break;
1300 }
1301 }
1302 OSLibWinEndEnumWindows(henum);
1303 return rc;
1304}
1305//******************************************************************************
1306//******************************************************************************
1307BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1308{
1309 Win32BaseWindow *window;
1310 BOOL rc;
1311 ULONG henum;
1312 HWND hwndNext, hwndParent = OSLIB_HWND_DESKTOP;
1313
1314 dprintf(("EnumThreadWindows\n"));
1315
1316 do {
1317 henum = OSLibWinBeginEnumWindows(hwndParent);
1318 while ((hwndNext = OSLibWinGetNextWindow(henum)) != 0)
1319 {
1320 window = Win32BaseWindow::GetWindowFromOS2Handle(hwndNext);
1321 if(window == NULL) {
1322 window = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndNext);
1323 if(!window) {
1324 //OS/2 window or non-frame window, so skip it
1325 continue;
1326 }
1327 }
1328 if((rc = lpfn(window->getWindowHandle(), lParam)) == FALSE) {
1329 goto Abort;
1330 }
1331 }
1332 if(hwndParent == OSLIB_HWND_OBJECT)
1333 break;
1334 hwndParent = OSLIB_HWND_OBJECT;
1335 OSLibWinEndEnumWindows(henum);
1336 }
1337 while(TRUE);
1338
1339Abort:
1340 OSLibWinEndEnumWindows(henum);
1341 return TRUE;
1342}
1343//******************************************************************************
1344//******************************************************************************
1345UINT WIN32API ArrangeIconicWindows( HWND arg1)
1346{
1347#ifdef DEBUG
1348 WriteLog("USER32: ArrangeIconicWindows\n");
1349#endif
1350 return O32_ArrangeIconicWindows(arg1);
1351}
1352//******************************************************************************
1353//restores iconized window to previous size/position
1354//******************************************************************************
1355BOOL WIN32API OpenIcon(HWND hwnd)
1356{
1357#ifdef DEBUG
1358 WriteLog("USER32: OpenIcon\n");
1359#endif
1360 if(!IsIconic(hwnd))
1361 return FALSE;
1362 ShowWindow(hwnd, SW_SHOWNORMAL);
1363 return TRUE;
1364}
1365//******************************************************************************
1366//******************************************************************************
1367BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
1368{
1369 dprintf(("USER32: ShowOwnedPopups\n"));
1370 return O32_ShowOwnedPopups(arg1, arg2);
1371}
1372//******************************************************************************
1373//******************************************************************************
1374
Note: See TracBrowser for help on using the repository browser.