Context Navigation

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

Visit:

Last change on this file since 2552 was 2552, checked in by sandervl, 26 years ago
Don't call default frame handler for WM_ADJUSTWINDOWPOS
File size: 52.2 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: