Context Navigation

source: trunk/src/user32/new/window.cpp@ 2400

Visit:

Last change on this file since 2400 was 2400, checked in by sandervl, 26 years ago
get/peekmessage fixes, timer fix, (user/new) replaced wm_hittest code; added wm_ncactivate, changed system menu
File size: 50.9 KB

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

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

Download in other formats: