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

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

Combobox fixes + scrollbar position fix
File size: 50.6 KB
Line 
1/* $Id: window.cpp,v 1.22 1999-10-20 22:35:54 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 Win32BaseWindow *window;
718
719 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
720 if(!window) {
721 dprintf(("GetClientRect, window %x not found", hwnd));
722 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
723 return 0;
724 }
725 *pRect = *window->getClientRect();
726 OffsetRect(pRect, -pRect->left, -pRect->top);
727 dprintf(("GetClientRect of %X returned (%d,%d) (%d,%d)\n", hwndWin32, pRect->left, pRect->top, pRect->right, pRect->bottom));
728 return TRUE;
729}
730//******************************************************************************
731//******************************************************************************
732BOOL WIN32API AdjustWindowRect(PRECT rect, DWORD style, BOOL menu)
733{
734 return AdjustWindowRectEx(rect, style, menu, 0);
735}
736//******************************************************************************
737//******************************************************************************
738BOOL WIN32API AdjustWindowRectEx( PRECT rect, DWORD style, BOOL menu, DWORD exStyle)
739{
740 dprintf(("AdjustWindowRectEx %x %x %d (%d,%d)(%d,%d)\n", style, exStyle, menu, rect->right, rect->top, rect->left, rect->bottom));
741
742 /* Correct the window style */
743 if (!(style & (WS_POPUP | WS_CHILD))) /* Overlapped window */
744 style |= WS_CAPTION;
745
746 style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD | WS_VSCROLL | WS_HSCROLL);
747 exStyle &= (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE |
748 WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
749 if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
750
751 Win32BaseWindow::NC_AdjustRectOuter( rect, style, menu, exStyle );
752 Win32BaseWindow::NC_AdjustRectInner( rect, style, exStyle );
753
754 dprintf(("AdjustWindowRectEx returned (%d,%d)(%d,%d)\n", rect->right, rect->top, rect->left, rect->bottom));
755 return TRUE;
756}
757//******************************************************************************
758/* Coordinate Space and Transformation Functions */
759//******************************************************************************
760int WIN32API MapWindowPoints(HWND hwndFrom, HWND hwndTo, LPPOINT lpPoints,
761 UINT cPoints)
762{
763 Win32BaseWindow *wndfrom, *wndto;
764 int retval = 0;
765 OSLIBPOINT point;
766
767 if(lpPoints == NULL || cPoints == 0) {
768 SetLastError(ERROR_INVALID_PARAMETER);
769 return 0;
770 }
771 if(hwndFrom)
772 {
773 wndfrom = Win32BaseWindow::GetWindowFromHandle(hwndFrom);
774 if(!wndfrom) {
775 dprintf(("MapWindowPoints, window %x not found", hwndFrom));
776 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
777 return 0;
778 }
779 }
780 else wndfrom = windowDesktop;
781
782 if(hwndTo)
783 {
784 wndto = Win32BaseWindow::GetWindowFromHandle(hwndTo);
785 if(!wndto) {
786 dprintf(("MapWindowPoints, window %x not found", hwndTo));
787 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
788 return 0;
789 }
790 }
791 else wndto = windowDesktop;
792
793 if(wndto == wndfrom)
794 return 0; //nothing to do
795
796 dprintf(("USER32: MapWindowPoints %x to %x (%d,%d) (%d)", hwndFrom, hwndTo, lpPoints->x, lpPoints->y, cPoints));
797 point.x = lpPoints->x;
798 point.y = wndfrom->getWindowHeight() - lpPoints->y;
799
800 OSLibWinMapWindowPoints(wndfrom->getOS2WindowHandle(), wndto->getOS2WindowHandle(), &point, 1);
801 point.y = wndto->getWindowHeight() - point.y;
802
803 WORD xinc = point.x - lpPoints->x;
804 WORD yinc = point.y - lpPoints->y;
805
806 for(int i=1;i<cPoints;i++)
807 {
808 lpPoints[i].x += xinc;
809 lpPoints[i].y += yinc;
810 }
811 retval = ((DWORD)yinc << 16) | xinc;
812 return retval;
813}
814//******************************************************************************
815//******************************************************************************
816BOOL WIN32API ScreenToClient (HWND hwnd, LPPOINT pt)
817{
818 Win32BaseWindow *wnd;
819 PRECT rcl;
820
821 dprintf(("ScreenToClient %x (%d,%d)\n", hwnd, pt->x, pt->y));
822
823 if (!hwnd) return (TRUE);
824 wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
825 if (!wnd) return (TRUE);
826
827 rcl = wnd->getClientRect();
828 pt->y = ScreenHeight - pt->y;
829 OSLibWinMapWindowPoints (OSLIB_HWND_DESKTOP, wnd->getOS2WindowHandle(), (OSLIBPOINT *)pt, 1);
830 pt->y = (rcl->bottom - rcl->top) - pt->y;
831 dprintf(("ScreenToClient %x returned (%d,%d)\n", hwnd, pt->x, pt->y));
832 return (TRUE);
833}
834//******************************************************************************
835//******************************************************************************
836HWND WIN32API GetDesktopWindow(void)
837{
838 dprintf(("USER32: GetDesktopWindow\n"));
839 return windowDesktop->getWindowHandle();
840}
841//******************************************************************************
842//******************************************************************************
843HWND WIN32API FindWindowA(LPCSTR lpszClass, LPCSTR lpszWindow)
844{
845 if(!lpszClass) {
846 SetLastError(ERROR_INVALID_PARAMETER);
847 return 0;
848 }
849 if(HIWORD(lpszClass)) {
850 dprintf(("USER32: FindWindow %s %s\n", lpszClass, lpszWindow));
851 }
852 else dprintf(("USER32: FindWindow %x %s\n", lpszClass, lpszWindow));
853
854 return Win32BaseWindow::FindWindowEx(OSLIB_HWND_DESKTOP, 0, (LPSTR)lpszClass, (LPSTR)lpszWindow);
855}
856//******************************************************************************
857//******************************************************************************
858HWND WIN32API FindWindowW( LPCWSTR lpClassName, LPCWSTR lpWindowName)
859{
860 char *astring1 = UnicodeToAsciiString((LPWSTR)lpClassName);
861 char *astring2 = UnicodeToAsciiString((LPWSTR)lpWindowName);
862 HWND rc;
863
864 rc = FindWindowA(astring1, astring2);
865 FreeAsciiString(astring1);
866 FreeAsciiString(astring2);
867 return rc;
868}
869//******************************************************************************
870//******************************************************************************
871HWND WIN32API FindWindowExA(HWND hwndParent, HWND hwndChildAfter, LPCSTR lpszClass, LPCSTR lpszWindow)
872{
873 if(!lpszClass) {
874 SetLastError(ERROR_INVALID_PARAMETER);
875 return 0;
876 }
877 if(HIWORD(lpszClass)) {
878 dprintf(("USER32: FindWindowExA (%x,%x) %s %s\n", hwndParent, hwndChildAfter, lpszClass, lpszWindow));
879 }
880 else dprintf(("USER32: FindWindowExA (%x,%x)%x %s\n", hwndParent, hwndChildAfter, lpszClass, lpszWindow));
881
882 return Win32BaseWindow::FindWindowEx(hwndParent, hwndChildAfter, (LPSTR)lpszClass, (LPSTR)lpszWindow);
883}
884/*****************************************************************************
885 * Name : HWND WIN32API FindWindowExW
886 * Purpose : The FindWindowEx function retrieves the handle of a window whose
887 * class name and window name match the specified strings. The
888 * function searches child windows, beginning with the one following
889 * the given child window.
890 * Parameters: HWND hwndParent handle of parent window
891 * HWND hwndChildAfter handle of a child window
892 * LPCTSTR lpszClass address of class name
893 * LPCTSTR lpszWindow address of window name
894 * Variables :
895 * Result : If the function succeeds, the return value is the handle of the
896 * window that has the specified class and window names.
897 * If the function fails, the return value is NULL. To get extended
898 * error information, call GetLastError.
899 * Remark :
900 * Status : UNTESTED STUB
901 *
902 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
903 *****************************************************************************/
904
905HWND WIN32API FindWindowExW(HWND hwndParent,
906 HWND hwndChildAfter,
907 LPCWSTR lpszClass,
908 LPCWSTR lpszWindow)
909{
910 if(!lpszClass) {
911 SetLastError(ERROR_INVALID_PARAMETER);
912 return 0;
913 }
914 dprintf(("USER32: FindWindowExW (%x,%x) %x %s\n", hwndParent, hwndChildAfter, lpszClass, lpszWindow));
915
916 return Win32BaseWindow::FindWindowEx(hwndParent, hwndChildAfter, (LPSTR)lpszClass, (LPSTR)lpszWindow);
917}
918//******************************************************************************
919//******************************************************************************
920BOOL WIN32API FlashWindow(HWND hwnd, BOOL fFlash)
921{
922 dprintf(("FlashWindow %x %d\n", hwnd, fFlash));
923 return OSLibWinFlashWindow(Win32BaseWindow::Win32ToOS2Handle(hwnd), fFlash);
924}
925//******************************************************************************
926//******************************************************************************
927BOOL WIN32API MoveWindow( HWND hwnd, INT x, INT y, INT cx, INT cy,
928 BOOL repaint )
929{
930 int flags = SWP_NOZORDER | SWP_NOACTIVATE;
931
932 if (!repaint) flags |= SWP_NOREDRAW;
933 dprintf(("MoveWindow: %04x %d,%d %dx%d %d\n", hwnd, x, y, cx, cy, repaint ));
934
935 return SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
936}
937//******************************************************************************
938//******************************************************************************
939BOOL WIN32API ClientToScreen (HWND hwnd, PPOINT pt)
940{
941 Win32BaseWindow *wnd;
942 PRECT rcl;
943
944 dprintf(("USER32: ClientToScreen\n"));
945 if (!hwnd) {
946 SetLastError(ERROR_INVALID_PARAMETER);
947 return (FALSE);
948 }
949 wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
950 if (!wnd) {
951 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
952 return (FALSE);
953 }
954
955 rcl = wnd->getClientRect();
956 pt->y = (rcl->bottom - rcl->top) - pt->y;
957 OSLibWinMapWindowPoints (wnd->getOS2WindowHandle(), OSLIB_HWND_DESKTOP, (OSLIBPOINT *)pt, 1);
958 pt->y = ScreenHeight - pt->y;
959 return (TRUE);
960}
961//******************************************************************************
962//******************************************************************************
963HDWP WIN32API BeginDeferWindowPos(int count)
964{
965 HDWP handle;
966 DWP *pDWP;
967
968 dprintf(("USER32: BeginDeferWindowPos\n"));
969 if (count <= 0)
970 {
971 SetLastError(ERROR_INVALID_PARAMETER);
972 return 0;
973 }
974 handle = (HDWP)HeapAlloc(GetProcessHeap(), 0, sizeof(DWP) + (count-1)*sizeof(WINDOWPOS) );
975 if (!handle)
976 return 0;
977
978 pDWP = (DWP *) handle;
979 pDWP->actualCount = 0;
980 pDWP->suggestedCount = count;
981 pDWP->valid = TRUE;
982 pDWP->wMagic = DWP_MAGIC;
983 pDWP->hwndParent = 0;
984 return handle;
985}
986/***********************************************************************
987 * DeferWindowPos (USER32.128)
988 */
989HDWP WIN32API DeferWindowPos( HDWP hdwp, HWND hwnd, HWND hwndAfter,
990 INT x, INT y, INT cx, INT cy,
991 UINT flags )
992{
993 DWP *pDWP;
994 int i;
995 HDWP newhdwp = hdwp,retvalue;
996 Win32BaseWindow *window;
997
998 pDWP = (DWP *)hdwp;
999 if (!pDWP) {
1000 SetLastError(ERROR_INVALID_PARAMETER);
1001 return 0;
1002 }
1003
1004 if (hwnd == GetDesktopWindow())
1005 return 0;
1006
1007 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1008 if(!window) {
1009 dprintf(("DeferWindowPos, window %x not found", hwnd));
1010 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1011 HeapFree(GetProcessHeap(), 0, (LPVOID)hdwp);
1012 return 0;
1013 }
1014
1015
1016/* Numega Bounds Checker Demo dislikes the following code.
1017 In fact, I've not been able to find any "same parent" requirement in any docu
1018 [AM 980509]
1019 */
1020#if 0
1021 /* All the windows of a DeferWindowPos() must have the same parent */
1022 parent = pWnd->parent->hwndSelf;
1023 if (pDWP->actualCount == 0) pDWP->hwndParent = parent;
1024 else if (parent != pDWP->hwndParent)
1025 {
1026 USER_HEAP_FREE( hdwp );
1027 retvalue = 0;
1028 goto END;
1029 }
1030#endif
1031
1032 for (i = 0; i < pDWP->actualCount; i++)
1033 {
1034 if (pDWP->winPos[i].hwnd == hwnd)
1035 {
1036 /* Merge with the other changes */
1037 if (!(flags & SWP_NOZORDER))
1038 {
1039 pDWP->winPos[i].hwndInsertAfter = hwndAfter;
1040 }
1041 if (!(flags & SWP_NOMOVE))
1042 {
1043 pDWP->winPos[i].x = x;
1044 pDWP->winPos[i].y = y;
1045 }
1046 if (!(flags & SWP_NOSIZE))
1047 {
1048 pDWP->winPos[i].cx = cx;
1049 pDWP->winPos[i].cy = cy;
1050 }
1051 pDWP->winPos[i].flags &= flags | ~(SWP_NOSIZE | SWP_NOMOVE |
1052 SWP_NOZORDER | SWP_NOREDRAW |
1053 SWP_NOACTIVATE | SWP_NOCOPYBITS|
1054 SWP_NOOWNERZORDER);
1055 pDWP->winPos[i].flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
1056 SWP_FRAMECHANGED);
1057 retvalue = hdwp;
1058 goto END;
1059 }
1060 }
1061 if (pDWP->actualCount >= pDWP->suggestedCount)
1062 {
1063 newhdwp = (HDWP)HeapReAlloc(GetProcessHeap(), 0, (LPVOID)hdwp,
1064 sizeof(DWP) + pDWP->suggestedCount*sizeof(WINDOWPOS));
1065 if (!newhdwp)
1066 {
1067 retvalue = 0;
1068 goto END;
1069 }
1070 pDWP = (DWP *) newhdwp;
1071 pDWP->suggestedCount++;
1072 }
1073 pDWP->winPos[pDWP->actualCount].hwnd = hwnd;
1074 pDWP->winPos[pDWP->actualCount].hwndInsertAfter = hwndAfter;
1075 pDWP->winPos[pDWP->actualCount].x = x;
1076 pDWP->winPos[pDWP->actualCount].y = y;
1077 pDWP->winPos[pDWP->actualCount].cx = cx;
1078 pDWP->winPos[pDWP->actualCount].cy = cy;
1079 pDWP->winPos[pDWP->actualCount].flags = flags;
1080 pDWP->actualCount++;
1081 retvalue = newhdwp;
1082END:
1083 return retvalue;
1084}
1085//******************************************************************************
1086//******************************************************************************
1087BOOL WIN32API EndDeferWindowPos( HDWP hdwp)
1088{
1089 DWP *pDWP;
1090 WINDOWPOS *winpos;
1091 BOOL res = TRUE;
1092 int i;
1093
1094 pDWP = (DWP *) hdwp;
1095 if (!pDWP) {
1096 dprintf(("**EndDeferWindowPos invalid parameter\n"));
1097 SetLastError(ERROR_INVALID_PARAMETER);
1098 return FALSE;
1099 }
1100 dprintf(("**EndDeferWindowPos for %d windows", pDWP->actualCount));
1101 for (i = 0, winpos = pDWP->winPos; i < pDWP->actualCount; i++, winpos++)
1102 {
1103 dprintf(("**EndDeferWindowPos %x (%d,%d) (%d,%d) %x", winpos->hwnd, winpos->x, winpos->y, winpos->x, winpos->cy, winpos->flags));
1104 if (!(res = SetWindowPos(winpos->hwnd, winpos->hwndInsertAfter,
1105 winpos->x, winpos->y, winpos->cx,
1106 winpos->cy, winpos->flags )))
1107 break;
1108 }
1109 dprintf(("**EndDeferWindowPos DONE"));
1110 HeapFree(GetProcessHeap(), 0, (LPVOID)hdwp);
1111 return res;
1112}
1113//******************************************************************************
1114//******************************************************************************
1115HWND WIN32API ChildWindowFromPoint( HWND hwnd, POINT pt)
1116{
1117 dprintf(("USER32: ChildWindowFromPoint\n"));
1118// return O32_ChildWindowFromPoint(arg1, arg2);
1119 return ChildWindowFromPointEx(hwnd, pt, 0);
1120}
1121//******************************************************************************
1122//******************************************************************************
1123/*****************************************************************************
1124 * Name : HWND WIN32API ChildWindowFromPointEx
1125 * Purpose : The GetWindowRect function retrieves the dimensions of the
1126 * bounding rectangle of the specified window. The dimensions are
1127 * given in screen coordinates that are relative to the upper-left
1128 * corner of the screen.
1129 * Parameters:
1130 * Variables :
1131 * Result : If the function succeeds, the return value is the window handle.
1132 * If the function fails, the return value is zero
1133 * Remark :
1134 * Status : FULLY IMPLEMENTED AND TESTED
1135 *
1136 * Author : Rene Pronk [Sun, 1999/08/08 23:30]
1137 *****************************************************************************/
1138
1139HWND WIN32API ChildWindowFromPointEx (HWND hwndParent, POINT pt, UINT uFlags)
1140{
1141 RECT rect;
1142 HWND hWnd;
1143 POINT absolutePt;
1144
1145 dprintf(("ChildWindowFromPointEx(%08xh,%08xh,%08xh).\n",
1146 hwndParent, pt, uFlags));
1147
1148 if (GetWindowRect (hwndParent, &rect) == 0) {
1149 // oops, invalid handle
1150 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1151 return NULL;
1152 }
1153
1154 // absolutePt has its top in the upper-left corner of the screen
1155 absolutePt = pt;
1156 ClientToScreen (hwndParent, &absolutePt);
1157
1158 // make rect the size of the parent window
1159 GetWindowRect (hwndParent, &rect);
1160 rect.right = rect.right - rect.left;
1161 rect.bottom = rect.bottom - rect.top;
1162 rect.left = 0;
1163 rect.top = 0;
1164
1165 if (PtInRect (&rect, pt) == 0) {
1166 // point is outside window
1167 return NULL;
1168 }
1169
1170 // get first child
1171 hWnd = GetWindow (hwndParent, GW_CHILD);
1172
1173 while (hWnd != NULL) {
1174
1175 // do I need to skip this window?
1176 if (((uFlags & CWP_SKIPINVISIBLE) &&
1177 (IsWindowVisible (hWnd) == FALSE)) ||
1178 ((uFlags & CWP_SKIPDISABLED) &&
1179 (IsWindowEnabled (hWnd) == FALSE)) ||
1180 ((uFlags & CWP_SKIPTRANSPARENT) &&
1181 (GetWindowLongA (hWnd, GWL_EXSTYLE) & WS_EX_TRANSPARENT)))
1182
1183 {
1184 hWnd = GetWindow (hWnd, GW_HWNDNEXT);
1185 continue;
1186 }
1187
1188 // is the point in this window's rect?
1189 GetWindowRect (hWnd, &rect);
1190 if (PtInRect (&rect, absolutePt) == FALSE) {
1191 hWnd = GetWindow (hWnd, GW_HWNDNEXT);
1192 continue;
1193 }
1194
1195 dprintf(("ChildWindowFromPointEx returned %x", hWnd));
1196 // found it!
1197 return hWnd;
1198 }
1199
1200 // the point is in the parentwindow but the parentwindow has no child
1201 // at this coordinate
1202 dprintf(("ChildWindowFromPointEx returned parent %x", hwndParent));
1203 return hwndParent;
1204}
1205//******************************************************************************
1206//******************************************************************************
1207BOOL WIN32API CloseWindow(HWND hwnd)
1208{
1209 Win32BaseWindow *window;
1210
1211 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1212 if(!window) {
1213 dprintf(("CloseWindow, window %x not found", hwnd));
1214 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1215 return 0;
1216 }
1217 dprintf(("CloseWindow %x\n", hwnd));
1218 return window->CloseWindow();
1219}
1220//******************************************************************************
1221//TODO: Does this return handles of hidden or disabled windows?
1222//******************************************************************************
1223HWND WIN32API WindowFromPoint( POINT point)
1224{
1225 HWND hwnd;
1226
1227 dprintf(("WindowFromPoint (%d,%d)\n", point.x, point.y));
1228 hwnd = OSLibWinWindowFromPoint(OSLIB_HWND_DESKTOP, (PVOID)&point);
1229 if(hwnd) {
1230 return Win32BaseWindow::OS2ToWin32Handle(hwnd);
1231 }
1232 return 0;
1233}
1234//******************************************************************************
1235//******************************************************************************
1236BOOL WIN32API IsWindowUnicode(HWND hwnd)
1237{
1238 Win32BaseWindow *window;
1239
1240 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1241 if(!window) {
1242 dprintf(("IsWindowUnicode, window %x not found", hwnd));
1243 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1244 return 0;
1245 }
1246 return window->IsUnicode();
1247}
1248/*****************************************************************************
1249 * Name : WORD WIN32API CascadeWindows
1250 * Purpose : The CascadeWindows function cascades the specified windows or
1251 * the child windows of the specified parent window.
1252 * Parameters: HWND hwndParent handle of parent window
1253 * UINT wHow types of windows not to arrange
1254 * CONST RECT * lpRect rectangle to arrange windows in
1255 * UINT cKids number of windows to arrange
1256 * const HWND FAR * lpKids array of window handles
1257 * Variables :
1258 * Result : If the function succeeds, the return value is the number of windows arranged.
1259 * If the function fails, the return value is zero.
1260 * Remark :
1261 * Status : UNTESTED STUB
1262 *
1263 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1264 *****************************************************************************/
1265
1266WORD WIN32API CascadeWindows(HWND hwndParent,
1267 UINT wHow,
1268 CONST LPRECT lpRect,
1269 UINT cKids,
1270 const HWND *lpKids)
1271{
1272 dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
1273 hwndParent,
1274 wHow,
1275 lpRect,
1276 cKids,
1277 lpKids));
1278
1279 return (0);
1280}
1281/*****************************************************************************
1282 * Name : BOOL WIN32API SwitchToThisWindow
1283 * Purpose : Unknown
1284 * Parameters: Unknown
1285 * Variables :
1286 * Result :
1287 * Remark :
1288 * Status : UNTESTED UNKNOWN STUB
1289 *
1290 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
1291 *****************************************************************************/
1292
1293BOOL WIN32API SwitchToThisWindow(HWND hwnd,
1294 BOOL x2)
1295{
1296 dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
1297 hwnd,
1298 x2));
1299
1300 return (FALSE); /* default */
1301}
1302//******************************************************************************
1303//******************************************************************************
1304BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
1305{
1306 Win32BaseWindow *window;
1307 BOOL rc;
1308 ULONG henum;
1309 HWND hwndNext;
1310 ULONG tid;
1311 ULONG pid, curpid;
1312
1313 dprintf(("EnumThreadWindows\n"));
1314
1315 curpid = GetCurrentProcessId();
1316
1317 henum = OSLibWinBeginEnumWindows(OSLIB_HWND_DESKTOP);
1318 while ((hwndNext = OSLibWinGetNextWindow(henum)) != 0)
1319 {
1320 OSLibWinQueryWindowProcess(hwndNext, &pid, &tid);
1321 if(!(curpid == pid && dwThreadId == tid))
1322 continue;
1323
1324 window = Win32BaseWindow::GetWindowFromOS2Handle(hwndNext);
1325 if(window == NULL) {
1326 window = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndNext);
1327 if(!window) {
1328 //OS/2 window or non-frame window, so skip it
1329 continue;
1330 }
1331 }
1332 if((rc = lpfn(window->getWindowHandle(), lParam)) == FALSE)
1333 break;
1334 }
1335 OSLibWinEndEnumWindows (henum);
1336 return TRUE;
1337}
1338//******************************************************************************
1339//******************************************************************************
1340BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1341{
1342 Win32BaseWindow *window;
1343 BOOL rc = TRUE;
1344 ULONG henum;
1345 HWND hwndNext;
1346
1347 if(lpfn == NULL) {
1348 dprintf(("EnumChildWindows invalid parameter %x %x\n", hwnd, lParam));
1349 SetLastError(ERROR_INVALID_PARAMETER);
1350 return FALSE;
1351 }
1352 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1353 if(!window) {
1354 dprintf(("EnumChildWindows, window %x not found", hwnd));
1355 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1356 return FALSE;
1357 }
1358 return window->EnumChildWindows(lpfn, lParam);
1359}
1360//******************************************************************************
1361//******************************************************************************
1362BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1363{
1364 Win32BaseWindow *window;
1365 BOOL rc;
1366 ULONG henum;
1367 HWND hwndNext, hwndParent = OSLIB_HWND_DESKTOP;
1368
1369 dprintf(("EnumThreadWindows\n"));
1370
1371 do {
1372 henum = OSLibWinBeginEnumWindows(hwndParent);
1373 while ((hwndNext = OSLibWinGetNextWindow(henum)) != 0)
1374 {
1375 window = Win32BaseWindow::GetWindowFromOS2Handle(hwndNext);
1376 if(window == NULL) {
1377 window = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndNext);
1378 if(!window) {
1379 //OS/2 window or non-frame window, so skip it
1380 continue;
1381 }
1382 }
1383 if((rc = lpfn(window->getWindowHandle(), lParam)) == FALSE) {
1384 goto Abort;
1385 }
1386 }
1387 if(hwndParent == OSLIB_HWND_OBJECT)
1388 break;
1389 hwndParent = OSLIB_HWND_OBJECT;
1390 OSLibWinEndEnumWindows(henum);
1391 }
1392 while(TRUE);
1393
1394Abort:
1395 OSLibWinEndEnumWindows(henum);
1396 return TRUE;
1397}
1398//******************************************************************************
1399//******************************************************************************
1400UINT WIN32API ArrangeIconicWindows( HWND arg1)
1401{
1402#ifdef DEBUG
1403 WriteLog("USER32: ArrangeIconicWindows\n");
1404#endif
1405 return O32_ArrangeIconicWindows(arg1);
1406}
1407//******************************************************************************
1408//restores iconized window to previous size/position
1409//******************************************************************************
1410BOOL WIN32API OpenIcon(HWND hwnd)
1411{
1412#ifdef DEBUG
1413 WriteLog("USER32: OpenIcon\n");
1414#endif
1415 if(!IsIconic(hwnd))
1416 return FALSE;
1417 ShowWindow(hwnd, SW_SHOWNORMAL);
1418 return TRUE;
1419}
1420//******************************************************************************
1421//******************************************************************************
1422BOOL WIN32API ShowOwnedPopups( HWND arg1, BOOL arg2)
1423{
1424 dprintf(("USER32: ShowOwnedPopups\n"));
1425 return O32_ShowOwnedPopups(arg1, arg2);
1426}
1427//******************************************************************************
1428//******************************************************************************
1429
Note: See TracBrowser for help on using the repository browser.