Context Navigation

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

Visit:

Last change on this file since 2521 was 2521, checked in by cbratschi, 26 years ago
refixed WM_WINDOWPOS*
File size: 52.3 KB

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

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

Download in other formats: