Context Navigation

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

Visit:

Last change on this file since 8016 was 8016, checked in by sandervl, 23 years ago
GetWindowThreadProcessId changes
File size: 72.8 KB

Line
1	/* $Id: window.cpp,v 1.121 2002-02-26 11:12:26 sandervl Exp $ */
2	/*
3	* Win32 window apis for OS/2
4	*
5	* Copyright 1999-2001 Sander van Leeuwen (sandervl@xs4all.nl)
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, windows\property.c, windows\winpos.c)
10	*
11	* Copyright 1993, 1994, 1995 Alexandre Julliard
12	* 1995, 1996, 1999 Alex Korobka
13	*
14	* Project Odin Software License can be found in LICENSE.TXT
15	*
16	*
17	* TODO: Decide what to do about commands for OS/2 windows (non-Win32 apps)
18	* TODO: ShowOwnedPopups needs to be tested
19	* GetLastActivePopup needs to be rewritten
20	*
21	*/
22
23	#include <odin.h>
24	#include <odinwrap.h>
25	#include <os2sel.h>
26
27	#include <os2win.h>
28	#include <misc.h>
29	#include <string.h>
30	#include <stdio.h>
31	#include <win32wbase.h>
32	#include <win32wmdiclient.h>
33	#include <win32wdesktop.h>
34	#include "win32dlg.h"
35	#include <oslibwin.h>
36	#include <oslibgdi.h>
37	#include "user32.h"
38	#include "winicon.h"
39	#include "oslibmsg.h"
40	#include <win\winpos.h>
41	#include <win\win.h>
42	#include <heapstring.h>
43	#include <winuser32.h>
44	#include "hook.h"
45
46	#define DBG_LOCALLOG DBG_window
47	#include "dbglocal.h"
48
49	ODINDEBUGCHANNEL(USER32-WINDOW)
50
51
52	//******************************************************************************
53	//******************************************************************************
54	HWND WIN32API CreateWindowExA(DWORD exStyle,
55	LPCSTR className,
56	LPCSTR windowName,
57	DWORD style,
58	INT x,
59	INT y,
60	INT width,
61	INT height,
62	HWND parent,
63	HMENU menu,
64	HINSTANCE instance,
65	LPVOID data )
66	{
67	Win32BaseWindow *window;
68	ATOM classAtom;
69	CREATESTRUCTA cs;
70	char tmpClass[20];
71
72	if(exStyle & WS_EX_MDICHILD)
73	return CreateMDIWindowA(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
74
75	/* Find the class atom */
76	if (!(classAtom = GlobalFindAtomA(className)))
77	{
78	if (!HIWORD(className))
79	dprintf(("CreateWindowEx32A: bad class name %04x\n",LOWORD(className)));
80	else
81	dprintf(("CreateWindowEx32A: bad class name '%s'\n", className));
82
83	SetLastError(ERROR_INVALID_PARAMETER);
84	return 0;
85	}
86
87	if (!HIWORD(className))
88	{
89	sprintf(tmpClass,"#%d", (int) className);
90	className = tmpClass;
91	}
92
93	/* Create the window */
94	cs.lpCreateParams = data;
95	cs.hInstance = instance;
96	cs.hMenu = menu;
97	cs.hwndParent = parent;
98	cs.x = x;
99	cs.y = y;
100	cs.cx = width;
101	cs.cy = height;
102	cs.style = style;
103	cs.lpszName = windowName;
104	cs.lpszClass = className;
105	cs.dwExStyle = exStyle;
106	if(HIWORD(className)) {
107	dprintf(("CreateWindowExA: class %s parent %x (%d,%d) (%d,%d), %x %x menu=%x", className, parent, x, y, width, height, style, exStyle, menu));
108	}
109	else dprintf(("CreateWindowExA: class %d parent %x (%d,%d) (%d,%d), %x %x menu=%x", className, parent, x, y, width, height, style, exStyle, menu));
110
111	if(!strcmpi(className, MDICLIENTCLASSNAMEA)) {
112	window = (Win32BaseWindow *) new Win32MDIClientWindow(&cs, classAtom, FALSE);
113	}
114	else
115	if(!strcmpi((char *) className, DIALOG_CLASS_NAMEA))
116	{
117	DLG_TEMPLATE dlgTemplate = {0};
118	dlgTemplate.style = cs.style;
119	dlgTemplate.exStyle = cs.dwExStyle;
120	dlgTemplate.x = cs.x;
121	dlgTemplate.y = cs.y;
122	dlgTemplate.cx = cs.cx;
123	dlgTemplate.cy = cs.cy;
124	dlgTemplate.className = cs.lpszClass;
125	dlgTemplate.caption = cs.lpszName;
126	window = (Win32BaseWindow *) new Win32Dialog(cs.hInstance,
127	(LPCSTR) &dlgTemplate,
128	cs.hwndParent,
129	NULL,
130	(LPARAM) data,
131	FALSE);
132	}
133	else {
134	window = new Win32BaseWindow( &cs, classAtom, FALSE );
135	}
136	if(window == NULL)
137	{
138	dprintf(("Win32BaseWindow creation failed!!"));
139	return 0;
140	}
141	if(GetLastError() != 0)
142	{
143	dprintf(("Win32BaseWindow error found!!"));
144	RELEASE_WNDOBJ(window);
145	delete window;
146	return 0;
147	}
148	HWND hwnd = window->getWindowHandle();
149
150	// set myself as last active popup / window
151	window->setLastActive( hwnd );
152
153	RELEASE_WNDOBJ(window);
154	return hwnd;
155	}
156	//******************************************************************************
157	//******************************************************************************
158	HWND WIN32API CreateWindowExW(DWORD exStyle,
159	LPCWSTR className,
160	LPCWSTR windowName,
161	DWORD style,
162	INT x,
163	INT y,
164	INT width,
165	INT height,
166	HWND parent,
167	HMENU menu,
168	HINSTANCE instance,
169	LPVOID data )
170	{
171	Win32BaseWindow *window;
172	ATOM classAtom;
173	CREATESTRUCTA cs;
174	WCHAR tmpClassW[20];
175
176	if(exStyle & WS_EX_MDICHILD)
177	return CreateMDIWindowW(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
178
179	/* Find the class atom */
180	if (!(classAtom = GlobalFindAtomW(className)))
181	{
182	if (!HIWORD(className))
183	dprintf(("CreateWindowEx32W: bad class name %04x",LOWORD(className)));
184	else
185	dprintf(("CreateWindowEx32W: bad class name '%ls'", className));
186
187	SetLastError(ERROR_INVALID_PARAMETER);
188	return 0;
189	}
190	#ifdef DEBUG
191	if(HIWORD(className)) {
192	dprintf(("CreateWindowExW: class %ls name %ls parent %x (%d,%d) (%d,%d), %x %x menu=%x", className, HIWORD(windowName) ? windowName : NULL, parent, x, y, width, height, style, exStyle, menu));
193	}
194	else dprintf(("CreateWindowExW: class %d name %ls parent %x (%d,%d) (%d,%d), %x %x menu=%x", className, HIWORD(windowName) ? windowName : NULL, parent, x, y, width, height, style, exStyle, menu));
195	#endif
196	if (!HIWORD(className))
197	{
198	wsprintfW(tmpClassW, (LPCWSTR)L"#%d", (int) className);
199	className = tmpClassW;
200	}
201
202	/* Create the window */
203	cs.lpCreateParams = data;
204	cs.hInstance = instance;
205	cs.hMenu = menu;
206	cs.hwndParent = parent;
207	cs.x = x;
208	cs.y = y;
209	cs.cx = width;
210	cs.cy = height;
211	cs.style = style;
212	cs.lpszName = (LPSTR)windowName;
213	cs.lpszClass = (LPSTR)className;
214	cs.dwExStyle = exStyle;
215
216	if(!lstrcmpiW(className, (LPWSTR)MDICLIENTCLASSNAMEW)) {
217	window = (Win32BaseWindow *) new Win32MDIClientWindow(&cs, classAtom, TRUE);
218	}
219	else
220	if(!lstrcmpiW(className, (LPWSTR)DIALOG_CLASS_NAMEW))
221	{
222	DLG_TEMPLATE dlgTemplate = {0};
223	dlgTemplate.style = cs.style;
224	dlgTemplate.exStyle = cs.dwExStyle;
225	dlgTemplate.x = cs.x;
226	dlgTemplate.y = cs.y;
227	dlgTemplate.cx = cs.cx;
228	dlgTemplate.cy = cs.cy;
229	dlgTemplate.className = cs.lpszClass;
230	dlgTemplate.caption = cs.lpszName;
231	window = (Win32BaseWindow *) new Win32Dialog(cs.hInstance,
232	(LPCSTR) &dlgTemplate,
233	cs.hwndParent,
234	NULL,
235	(LPARAM) data,
236	TRUE);
237	}
238	else {
239	window = new Win32BaseWindow( &cs, classAtom, TRUE );
240	}
241	if(window == NULL)
242	{
243	dprintf(("Win32BaseWindow creation failed!!"));
244	return 0;
245	}
246	if(GetLastError() != 0)
247	{
248	dprintf(("Win32BaseWindow error found!!"));
249	RELEASE_WNDOBJ(window);
250	delete window;
251	return 0;
252	}
253	HWND hwnd = window->getWindowHandle();
254
255	// set myself as last active popup / window
256	window->setLastActive( hwnd );
257
258	RELEASE_WNDOBJ(window);
259	return hwnd;
260	}
261	//******************************************************************************
262	//******************************************************************************
263	HWND WIN32API CreateFakeWindowEx(HWND hwndOS2, ATOM classAtom)
264	{
265	Win32BaseWindow *window;
266
267	window = new Win32BaseWindow(hwndOS2, classAtom);
268	if(window == NULL)
269	{
270	dprintf(("Win32BaseWindow creation failed!!"));
271	return 0;
272	}
273	HWND hwnd = window->getWindowHandle();
274
275	// set myself as last active popup / window
276	window->setLastActive( hwnd );
277
278	RELEASE_WNDOBJ(window);
279	return hwnd;
280	}
281	//******************************************************************************
282	//******************************************************************************
283	BOOL WIN32API DestroyFakeWindow(HWND hwnd)
284	{
285	Win32BaseWindow *window;
286
287	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
288	if(!window) {
289	dprintf(("DestroyFakeWindow, window %x not found", hwnd));
290	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
291	return 0;
292	}
293	delete window;
294	return TRUE;
295	}
296	//******************************************************************************
297	//******************************************************************************
298	BOOL WIN32API DestroyWindow(HWND hwnd)
299	{
300	Win32BaseWindow *window;
301	BOOL ret;
302
303	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
304	if(!window) {
305	dprintf(("DestroyWindow, window %x not found", hwnd));
306	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
307	return 0;
308	}
309	ret = window->DestroyWindow();
310	RELEASE_WNDOBJ(window);
311	return ret;
312	}
313	//******************************************************************************
314	//******************************************************************************
315	HWND WIN32API SetActiveWindow(HWND hwnd)
316	{
317	Win32BaseWindow *window;
318	HWND hwndActive;
319
320	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
321	if(!window) {
322	dprintf(("SetActiveWindow, window %x not found", hwnd));
323	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
324	return 0;
325	}
326	hwndActive = window->SetActiveWindow();
327
328	// check last active popup window
329	if (hwndActive)
330	{
331	// TODO:
332	// set last active popup window to the ancestor window
333	dprintf(("support for last active popup incorrectly implemented"));
334	}
335
336	RELEASE_WNDOBJ(window);
337	return hwndActive;
338	}
339	//******************************************************************************
340	//Note: does not set last error if no parent (verified in NT4, SP6)
341	//******************************************************************************
342	HWND WIN32API GetParent(HWND hwnd)
343	{
344	Win32BaseWindow *window;
345	HWND hwndParent;
346
347	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
348	if(!window) {
349	dprintf(("GetParent, window %x not found", hwnd));
350	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
351	return 0;
352	}
353	dprintf2(("GetParent %x", hwnd));
354	hwndParent = window->GetParent();
355	RELEASE_WNDOBJ(window);
356	return hwndParent;
357	}
358	//******************************************************************************
359	//******************************************************************************
360	HWND WIN32API SetParent(HWND hwndChild, HWND hwndNewParent)
361	{
362	Win32BaseWindow *window;
363	HWND hwndOldParent;
364
365	window = Win32BaseWindow::GetWindowFromHandle(hwndChild);
366	if(!window) {
367	dprintf(("SetParent, window %x not found", hwndChild));
368	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
369	return 0;
370	}
371	if(hwndNewParent == HWND_DESKTOP) {
372	hwndNewParent = GetDesktopWindow();
373	}
374	else {
375	if(!IsWindow(hwndNewParent)) {
376	RELEASE_WNDOBJ(window);
377	dprintf(("SetParent, parent %x not found", hwndNewParent));
378	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
379	return 0;
380	}
381	}
382	dprintf(("SetParent %x %x", hwndChild, hwndNewParent));
383	hwndOldParent = window->SetParent(hwndNewParent);
384	RELEASE_WNDOBJ(window);
385	return hwndOldParent;
386	}
387	//******************************************************************************
388	//******************************************************************************
389	BOOL WIN32API IsChild(HWND hwndParent, HWND hwnd)
390	{
391	Win32BaseWindow *window;
392	BOOL fIsChild;
393
394	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
395	if(!window) {
396	dprintf(("IsChild %x, window %x not found", hwndParent, hwnd));
397	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
398	return 0;
399	}
400	dprintf(("IsChild %x %x", hwndParent, hwnd));
401	fIsChild = window->IsChild(hwndParent);
402	RELEASE_WNDOBJ(window);
403	return fIsChild;
404	}
405	//******************************************************************************
406	//******************************************************************************
407	HWND WIN32API GetTopWindow(HWND hwnd)
408	{
409	Win32BaseWindow *window;
410	HWND hwndTop;
411
412	if(hwnd == HWND_DESKTOP) {
413	windowDesktop->addRef();
414	window = windowDesktop;
415	}
416	else {
417	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
418	if(!window) {
419	dprintf(("GetTopWindow, window %x not found", hwnd));
420	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
421	return 0;
422	}
423	}
424	hwndTop = window->GetTopWindow();
425	dprintf2(("GetTopWindow %x returned %x", hwnd, hwndTop));
426	RELEASE_WNDOBJ(window);
427	return hwndTop;
428	}
429	//******************************************************************************
430	//******************************************************************************
431	BOOL WIN32API IsIconic(HWND hwnd)
432	{
433	Win32BaseWindow *window;
434	BOOL fIsIconic;
435
436	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
437	if(!window) {
438	dprintf(("IsIconic, window %x not found", hwnd));
439	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
440	return FALSE;
441	}
442	fIsIconic = window->IsWindowIconic();
443	dprintf(("IsIconic %x returned %d", hwnd, fIsIconic));
444	RELEASE_WNDOBJ(window);
445	return fIsIconic;
446	}
447	//******************************************************************************
448	//******************************************************************************
449	HWND WIN32API GetWindow(HWND hwnd, UINT uCmd)
450	{
451	Win32BaseWindow *window;
452	HWND hwndRelated;
453
454	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
455	if(!window) {
456	dprintf(("GetWindow, window %x not found", hwnd));
457	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
458	return 0;
459	}
460	hwndRelated = window->GetWindow(uCmd);
461	RELEASE_WNDOBJ(window);
462	return hwndRelated;
463	}
464	//******************************************************************************
465	//******************************************************************************
466	BOOL WIN32API EnableWindow(HWND hwnd, BOOL fEnable)
467	{
468	Win32BaseWindow *window;
469	BOOL fEnabled;
470
471	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
472	if(!window) {
473	dprintf(("EnableWindow, window %x not found", hwnd));
474	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
475	return 0;
476	}
477	dprintf(("EnableWindow %x %d", hwnd, fEnable));
478	fEnabled = window->EnableWindow(fEnable);
479	RELEASE_WNDOBJ(window);
480	return fEnabled;
481	}
482	//******************************************************************************
483	//******************************************************************************
484	BOOL WIN32API BringWindowToTop(HWND hwnd)
485	{
486	dprintf(("BringWindowToTop %x", hwnd));
487	return SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE\|SWP_NOSIZE );
488	}
489	/***********************************************************************
490	* SetInternalWindowPos (USER32.483)
491	*/
492	VOID WIN32API SetInternalWindowPos(HWND hwnd, UINT showCmd, LPRECT lpRect,
493	LPPOINT lpPoint )
494	{
495	if( IsWindow(hwnd) )
496	{
497	WINDOWPLACEMENT wndpl;
498	UINT flags;
499
500	GetWindowPlacement(hwnd, &wndpl);
501	wndpl.length = sizeof(wndpl);
502	wndpl.showCmd = showCmd;
503	wndpl.flags = 0;
504
505	if(lpPoint)
506	{
507	wndpl.flags \|= WPF_SETMINPOSITION;
508	wndpl.ptMinPosition = *lpPoint;
509	}
510	if(lpRect)
511	{
512	wndpl.rcNormalPosition = *lpRect;
513	}
514	SetWindowPlacement(hwnd, &wndpl);
515	}
516
517	}
518	/***********************************************************************
519	* GetInternalWindowPos (USER32.245)
520	*/
521	UINT WIN32API GetInternalWindowPos(HWND hwnd, LPRECT rectWnd, LPPOINT ptIcon )
522	{
523	WINDOWPLACEMENT wndpl;
524
525	if(GetWindowPlacement( hwnd, &wndpl ))
526	{
527	if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
528	if (ptIcon) *ptIcon = wndpl.ptMinPosition;
529	return wndpl.showCmd;
530	}
531	return 0;
532	}
533	//******************************************************************************
534	//******************************************************************************
535	HWND GetActiveWindow()
536	{
537	return Win32BaseWindow::GetActiveWindow();
538	}
539	//******************************************************************************
540	//******************************************************************************
541	BOOL WIN32API ShowWindow(HWND hwnd, INT nCmdShow)
542	{
543	Win32BaseWindow *window;
544	BOOL ret;
545
546	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
547	if(!window) {
548	dprintf(("ShowWindow, window %x not found", hwnd));
549	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
550	return 0;
551	}
552	ret = window->ShowWindow(nCmdShow);
553	RELEASE_WNDOBJ(window);
554	return ret;
555	}
556	/*****************************************************************************
557	* Name : BOOL WIN32API ShowWindowAsync
558	* Purpose : The ShowWindowAsync function sets the show state of a window
559	* created by a different thread.
560	* Parameters: HWND hwnd handle of window
561	* int nCmdShow show state of window
562	* Variables :
563	* Result : If the window was previously visible, the return value is TRUE.
564	* If the window was previously hidden, the return value is FALSE.
565	* Remark :
566	* Status : UNTESTED STUB
567	*
568	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
569	*****************************************************************************/
570	BOOL WIN32API ShowWindowAsync(HWND hwnd, int nCmdShow)
571	{
572	dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not correctly implemented.\n",
573	hwnd, nCmdShow));
574
575	return ShowWindow(hwnd, nCmdShow);
576	}
577	//******************************************************************************
578	//******************************************************************************
579	BOOL WIN32API SetWindowPos(HWND hwnd, HWND hwndInsertAfter, INT x,
580	INT y, INT cx, INT cy, UINT fuFlags)
581	{
582	Win32BaseWindow *window;
583
584	if (!hwnd)
585	{
586	dprintf(("SetWindowPos: Can't move desktop!"));
587	return TRUE;
588	}
589	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
590	if(!window) {
591	dprintf(("SetWindowPos, window %x not found", hwnd));
592	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
593	return FALSE;
594	}
595	dprintf(("SetWindowPos %x %x x=%d y=%d cx=%d cy=%d %x", hwnd, hwndInsertAfter, x, y, cx, cy, fuFlags));
596	BOOL ret = window->SetWindowPos(hwndInsertAfter, x, y, cx, cy, fuFlags);
597	RELEASE_WNDOBJ(window);
598	return ret;
599	}
600	//******************************************************************************
601	//NOTE: length must equal structure size or else api fails (verified in NT4, SP6)
602	//******************************************************************************
603	BOOL WIN32API SetWindowPlacement(HWND hwnd, const WINDOWPLACEMENT *winpos)
604	{
605	Win32BaseWindow *window;
606
607	if(!winpos \|\| winpos->length != sizeof(WINDOWPLACEMENT)) {
608	dprintf(("SetWindowPlacement %x invalid parameter", hwnd));
609	SetLastError(ERROR_INVALID_PARAMETER);
610	return FALSE;
611	}
612	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
613	if(!window) {
614	dprintf(("SetWindowPlacement, window %x not found", hwnd));
615	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
616	return FALSE;
617	}
618	dprintf(("USER32: SetWindowPlacement %x %x", hwnd, winpos));
619	BOOL ret = window->SetWindowPlacement((WINDOWPLACEMENT *)winpos);
620	RELEASE_WNDOBJ(window);
621	return ret;
622	}
623	//******************************************************************************
624	//NOTE: Length does not need to be correct (even though the SDK docs claim otherwise)
625	// (Verified in NT4, SP6)
626	//******************************************************************************
627	BOOL WIN32API GetWindowPlacement(HWND hwnd, LPWINDOWPLACEMENT winpos)
628	{
629	Win32BaseWindow *window;
630
631	if(!winpos) {
632	dprintf(("GetWindowPlacement %x invalid parameter", hwnd));
633	SetLastError(ERROR_INVALID_PARAMETER);
634	return FALSE;
635	}
636	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
637	if(!window) {
638	dprintf(("GetWindowPlacement, window %x not found", hwnd));
639	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
640	return FALSE;
641	}
642	dprintf(("USER32: GetWindowPlacement %x %x", hwnd, winpos));
643	BOOL ret = window->GetWindowPlacement(winpos);
644	RELEASE_WNDOBJ(window);
645	return ret;
646	}
647	//******************************************************************************
648	//******************************************************************************
649	BOOL WIN32API IsWindow(HWND hwnd)
650	{
651	Win32BaseWindow *window;
652
653	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
654	if(!window) {
655	dprintf(("IsWindow, window %x not found", hwnd));
656	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
657	return FALSE;
658	}
659	dprintf2(("IsWindow %x", hwnd));
660	BOOL fIsWindow = window->IsWindow();
661	RELEASE_WNDOBJ(window);
662	return fIsWindow;
663	}
664	//******************************************************************************
665	//******************************************************************************
666	BOOL WIN32API IsWindowEnabled(HWND hwnd)
667	{
668	DWORD dwStyle;
669
670	if(!IsWindow(hwnd)) {
671	dprintf(("IsWindowEnabled, window %x not found", hwnd));
672	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
673	return 0;
674	}
675	dprintf(("IsWindowEnabled %x", hwnd));
676	dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
677	if(dwStyle & WS_DISABLED) {
678	return FALSE;
679	}
680	return TRUE;
681	}
682	//******************************************************************************
683	//******************************************************************************
684	BOOL WIN32API IsWindowVisible(HWND hwnd)
685	{
686	BOOL ret;
687	HWND hwndParent;
688	DWORD dwStyle;
689
690	if(hwnd == HWND_DESKTOP) {//TODO: verify in NT!
691	dprintf(("IsWindowVisible DESKTOP returned TRUE"));
692	return TRUE; //desktop is always visible
693	}
694	if(!IsWindow(hwnd)) {
695	dprintf(("IsWindowVisible, window %x not found", hwnd));
696	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
697	return 0;
698	}
699	//check visibility of this window
700	dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
701	if(!(dwStyle & WS_VISIBLE)) {
702	ret = FALSE;
703	goto end;
704	}
705	ret = TRUE;
706
707	if(dwStyle & WS_CHILD)
708	{
709	//check visibility of parents
710	hwndParent = GetParent(hwnd);
711	while(hwndParent) {
712	dwStyle = GetWindowLongA(hwndParent, GWL_STYLE);
713	if(!(dwStyle & WS_VISIBLE)) {
714	dprintf(("IsWindowVisible %x returned FALSE (parent %x invisible)", hwnd, hwndParent));
715	return FALSE;
716	}
717	if(!(dwStyle & WS_CHILD)) {
718	break; //GetParent can also return the owner
719	}
720	hwndParent = GetParent(hwndParent);
721	}
722	}
723	end:
724	dprintf(("IsWindowVisible %x returned %d", hwnd, ret));
725	return ret;
726	}
727	//******************************************************************************
728	//******************************************************************************
729	HWND WIN32API SetFocus(HWND hwnd)
730	{
731	Win32BaseWindow *window;
732	Win32BaseWindow *oldfocuswnd;
733	HWND lastFocus, lastFocus_W, hwnd_O, hwndTopParent;
734	BOOL activate, ret;
735	TEB *teb;
736
737	teb = GetThreadTEB();
738	if(teb == NULL) {
739	DebugInt3();
740	return 0;
741	}
742
743	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
744	if(!window) {
745	dprintf(("SetFocus, window %x not found", hwnd));
746	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
747	return 0;
748	}
749
750	hwnd_O = window->getOS2WindowHandle();
751	if(teb->o.odin.hwndFocus) {
752	lastFocus = teb->o.odin.hwndFocus;
753	}
754	else lastFocus = OSLibWinQueryFocus (OSLIB_HWND_DESKTOP);
755
756	hwndTopParent = window->GetTopParent();
757	activate = FALSE;
758	lastFocus_W = OS2ToWin32Handle(lastFocus);
759	if(lastFocus_W) {
760	oldfocuswnd = Win32BaseWindow::GetWindowFromHandle(lastFocus_W);
761	if(lastFocus_W != hwnd && hwndTopParent != oldfocuswnd->GetTopParent()) {
762	activate = TRUE;
763	}
764	RELEASE_WNDOBJ(oldfocuswnd);
765	}
766	else activate = TRUE;
767
768	dprintf(("SetFocus %x (%x) -> %x (%x) act %d", lastFocus_W, lastFocus, hwnd, hwnd_O, activate));
769
770	if(HOOK_CallHooksA(WH_CBT, HCBT_SETFOCUS, hwnd, (LPARAM)lastFocus_W)) {
771	dprintf(("hook cancelled SetFocus call!"));
772	RELEASE_WNDOBJ(window);
773	return 0;
774	}
775
776	//PM doesn't allow SetFocus calls during WM_SETFOCUS message processing;
777	//must delay this function call
778	if(teb->o.odin.fWM_SETFOCUS) {
779	dprintf(("USER32: Delay SetFocus call!"));
780	teb->o.odin.hwndFocus = hwnd;
781	//mp1 = win32 window handle
782	//mp2 = top parent if activation required
783	OSLibPostMessageDirect(hwnd_O, WIN32APP_SETFOCUSMSG, hwnd, (activate) ? hwndTopParent : 0);
784	RELEASE_WNDOBJ(window);
785	return lastFocus_W;
786	}
787	teb->o.odin.hwndFocus = 0;
788	if(!IsWindow(hwnd)) return FALSE; //abort if window destroyed
789
790	//NOTE: Don't always activate the window or else the z-order will be changed!!
791	ret = (OSLibWinSetFocus(OSLIB_HWND_DESKTOP, hwnd_O, activate)) ? lastFocus_W : 0;
792	RELEASE_WNDOBJ(window);
793	return ret;
794	}
795	//******************************************************************************
796	//******************************************************************************
797	HWND WIN32API GetFocus()
798	{
799	TEB *teb;
800	HWND hwnd;
801
802	teb = GetThreadTEB();
803	if(teb == NULL) {
804	DebugInt3();
805	return 0;
806	}
807	//PM doesn't allow SetFocus calls during WM_SETFOCUS message processing;
808	//If focus was changed during WM_SETFOCUS, the focus window handle is
809	//stored in teb->o.odin.hwndFocus (set back to 0 when delayed SetFocus
810	//is activated)
811	if(teb->o.odin.hwndFocus) {
812	dprintf(("USER32: GetFocus %x (DURING WM_SETFOCUS PROCESSING)", teb->o.odin.hwndFocus));
813	return teb->o.odin.hwndFocus;
814	}
815
816	hwnd = OSLibWinQueryFocus(OSLIB_HWND_DESKTOP);
817	hwnd = OS2ToWin32Handle(hwnd);
818	dprintf(("USER32: GetFocus %x\n", hwnd));
819	return hwnd;
820	}
821	//******************************************************************************
822	//******************************************************************************
823	BOOL WIN32API IsZoomed(HWND hwnd)
824	{
825	DWORD style;
826
827	style = GetWindowLongA(hwnd, GWL_STYLE);
828	dprintf(("USER32: IsZoomed %x returned %d", hwnd, ((style & WS_MAXIMIZE) != 0)));
829
830	return (style & WS_MAXIMIZE) != 0;
831	}
832	//******************************************************************************
833	//******************************************************************************
834	BOOL WIN32API LockWindowUpdate(HWND hwnd)
835	{
836	return OSLibWinLockWindowUpdate(Win32ToOS2Handle(hwnd));
837	}
838	//******************************************************************************
839	//******************************************************************************
840	BOOL WIN32API GetWindowRect(HWND hwnd, PRECT pRect)
841	{
842	Win32BaseWindow *window;
843
844	if(pRect == NULL) {
845	dprintf(("GetWindowRect %x invalid parameter!", hwnd));
846	SetLastError(ERROR_INVALID_PARAMETER);
847	return FALSE;
848	}
849
850	if(hwnd == HWND_DESKTOP) {
851	windowDesktop->addRef();
852	window = windowDesktop;
853	}
854	else window = Win32BaseWindow::GetWindowFromHandle(hwnd);
855
856	if(!window) {
857	dprintf(("GetWindowRect, window %x not found", hwnd));
858	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
859	return FALSE;
860	}
861	pRect = window->getWindowRect();
862
863	//convert from parent coordinates to screen (if necessary)
864	if(window->getParent()) {
865	MapWindowPoints(window->getParent()->getWindowHandle(), 0, (PPOINT)pRect, 2);
866	}
867	RELEASE_WNDOBJ(window);
868	dprintf(("GetWindowRect %x (%d,%d) (%d,%d)", hwnd, pRect->left, pRect->top, pRect->right, pRect->bottom));
869	return TRUE;
870	}
871	//******************************************************************************
872	//******************************************************************************
873	INT WIN32API GetWindowTextLengthA(HWND hwnd)
874	{
875	Win32BaseWindow *window;
876
877	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
878	if(!window) {
879	dprintf(("GetWindowTextLengthA, window %x not found", hwnd));
880	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
881	return 0;
882	}
883	dprintf(("GetWindowTextLengthA %x", hwnd));
884	int ret = window->GetWindowTextLengthA();
885	RELEASE_WNDOBJ(window);
886	return ret;
887	}
888	//******************************************************************************
889	//******************************************************************************
890	int WIN32API GetWindowTextA( HWND hwnd, LPSTR lpsz, int cch)
891	{
892	Win32BaseWindow *window;
893	int rc;
894
895	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
896	if(!window) {
897	dprintf(("GetWindowTextA, window %x not found", hwnd));
898	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
899	return 0;
900	}
901	rc = window->GetWindowTextA(lpsz, cch);
902	dprintf(("GetWindowTextA %x %s", hwnd, lpsz));
903	RELEASE_WNDOBJ(window);
904	return rc;
905	}
906	//******************************************************************************
907	//******************************************************************************
908	int WIN32API GetWindowTextLengthW( HWND hwnd)
909	{
910	Win32BaseWindow *window;
911
912	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
913	if(!window) {
914	dprintf(("GetWindowTextLengthW, window %x not found", hwnd));
915	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
916	return 0;
917	}
918	dprintf(("GetWindowTextLengthW %x", hwnd));
919	int ret = window->GetWindowTextLengthW();
920	RELEASE_WNDOBJ(window);
921	return ret;
922	}
923	//******************************************************************************
924	//******************************************************************************
925	int WIN32API GetWindowTextW(HWND hwnd, LPWSTR lpsz, int cch)
926	{
927	Win32BaseWindow *window;
928
929	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
930	if(!window) {
931	dprintf(("GetWindowTextW, window %x not found", hwnd));
932	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
933	return 0;
934	}
935	int rc = window->GetWindowTextW(lpsz, cch);
936	RELEASE_WNDOBJ(window);
937	dprintf(("GetWindowTextW %x %ls", hwnd, lpsz));
938	return rc;
939	}
940	//******************************************************************************
941	//******************************************************************************
942	BOOL WIN32API SetWindowTextA(HWND hwnd, LPCSTR lpsz)
943	{
944	Win32BaseWindow *window;
945
946	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
947	if(!window) {
948	dprintf(("SetWindowTextA, window %x not found", hwnd));
949	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
950	return 0;
951	}
952	dprintf(("SetWindowTextA %x %s", hwnd, lpsz));
953	BOOL ret = window->SetWindowTextA((LPSTR)lpsz);
954	RELEASE_WNDOBJ(window);
955	return ret;
956	}
957	//******************************************************************************
958	//******************************************************************************
959	BOOL WIN32API SetWindowTextW( HWND hwnd, LPCWSTR lpsz)
960	{
961	Win32BaseWindow *window;
962
963	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
964	if(!window) {
965	dprintf(("SetWindowTextA, window %x not found", hwnd));
966	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
967	return 0;
968	}
969	dprintf(("SetWindowTextW %x %ls", hwnd, lpsz));
970	BOOL ret = window->SetWindowTextW((LPWSTR)lpsz);
971	RELEASE_WNDOBJ(window);
972	return ret;
973	}
974	/*******************************************************************
975	* InternalGetWindowText (USER32.326)
976	*/
977	int WIN32API InternalGetWindowText(HWND hwnd,
978	LPWSTR lpString,
979	INT nMaxCount )
980	{
981	dprintf(("USER32: InternalGetWindowText(%08xh,%08xh,%08xh) not properly implemented.\n",
982	hwnd, lpString, nMaxCount));
983
984	return GetWindowTextW(hwnd, lpString,nMaxCount);
985	}
986	//******************************************************************************
987	//TODO: Correct?
988	//******************************************************************************
989	BOOL WIN32API SetForegroundWindow(HWND hwnd)
990	{
991	dprintf((" SetForegroundWindow %x", hwnd));
992
993	return SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE \| SWP_NOSIZE);
994	}
995	//******************************************************************************
996	//******************************************************************************
997	BOOL WIN32API GetClientRect( HWND hwnd, PRECT pRect)
998	{
999	HWND hwndWin32 = hwnd;
1000	Win32BaseWindow *window;
1001
1002	if (!pRect)
1003	{
1004	SetLastError(ERROR_INVALID_PARAMETER);
1005	return FALSE;
1006	}
1007	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1008	if(!window) {
1009	dprintf(("GetClientRect, window %x not found", hwnd));
1010	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1011	return FALSE;
1012	}
1013	window->getClientRect(pRect);
1014	dprintf(("GetClientRect of %X returned (%d,%d) (%d,%d)\n", hwndWin32, pRect->left, pRect->top, pRect->right, pRect->bottom));
1015	RELEASE_WNDOBJ(window);
1016	return TRUE;
1017	}
1018	//******************************************************************************
1019	//******************************************************************************
1020	BOOL WIN32API AdjustWindowRect(PRECT rect, DWORD style, BOOL menu)
1021	{
1022	return AdjustWindowRectEx(rect, style, menu, 0);
1023	}
1024	//******************************************************************************
1025	//Calculate window rectangle based on given client rectangle, style, menu and extended style
1026	//******************************************************************************
1027	BOOL WIN32API AdjustWindowRectEx( PRECT rect, DWORD style, BOOL menu, DWORD exStyle)
1028	{
1029	if(style == 0 && menu == FALSE && exStyle == 0) {
1030	dprintf(("AdjustWindowRectEx %x %x %d (%d,%d)(%d,%d) -> no change required", style, exStyle, menu, rect->left, rect->top, rect->right, rect->bottom));
1031	return TRUE; //nothing needs to be changed (VERIFIED in NT 4)
1032	}
1033	dprintf(("AdjustWindowRectEx %x %x %d (%d,%d)(%d,%d)\n", style, exStyle, menu, rect->left, rect->top, rect->right, rect->bottom));
1034	/* Correct the window style */
1035	if (!(style & (WS_POPUP \| WS_CHILD))) /* Overlapped window */
1036	style \|= WS_CAPTION;
1037
1038	//SvL: Include WS_POPUP -> otherwise HAS_THINFRAME is true for popup windows
1039	// Also include WS_CHILD -> otherwise HAS_THICKFRAME doesn't work correctly
1040	style &= (WS_DLGFRAME \| WS_BORDER \| WS_THICKFRAME \| WS_CHILD \| WS_VSCROLL \| WS_HSCROLL \| WS_POPUP);
1041	exStyle &= (WS_EX_DLGMODALFRAME \| WS_EX_CLIENTEDGE \| WS_EX_STATICEDGE \| WS_EX_TOOLWINDOW);
1042	if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
1043
1044	//Adjust rect outer (Win32BaseWindow::AdjustRectOuter)
1045	if (HAS_THICKFRAME(style,exStyle))
1046	InflateRect( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
1047	else
1048	if (HAS_DLGFRAME(style,exStyle))
1049	InflateRect(rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
1050	else
1051	if (HAS_THINFRAME(style))
1052	InflateRect( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
1053
1054	if ((style & WS_CAPTION) == WS_CAPTION)
1055	{
1056	if (exStyle & WS_EX_TOOLWINDOW)
1057	rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
1058	else
1059	rect->top -= GetSystemMetrics(SM_CYCAPTION);
1060	}
1061
1062	if (menu)
1063	rect->top -= GetSystemMetrics(SM_CYMENU);
1064
1065	//Adjust rect inner (Win32BaseWindow::AdjustRectInner)
1066	if(!(style & WS_ICONIC)) {
1067	if (exStyle & WS_EX_CLIENTEDGE)
1068	InflateRect (rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
1069
1070	if (exStyle & WS_EX_STATICEDGE)
1071	InflateRect (rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
1072
1073	//SvL: scrollbars aren't checked UNLESS the style includes a border (any border)
1074	// --> VERIFIED IN NT4, SP6 (fixes MFC apps with scrollbars + bar controls)
1075	if(style & (WS_THICKFRAME\|WS_BORDER\|WS_DLGFRAME)) {
1076	if (style & WS_VSCROLL) rect->right += GetSystemMetrics(SM_CXVSCROLL);
1077	if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
1078	}
1079	}
1080
1081	dprintf(("AdjustWindowRectEx returned (%d,%d)(%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom));
1082
1083	return TRUE;
1084	}
1085	//******************************************************************************
1086	/* Coordinate Space and Transformation Functions */
1087	//******************************************************************************
1088	/*******************************************************************
1089	* WINPOS_GetWinOffset
1090	*
1091	* Calculate the offset between the origin of the two windows. Used
1092	* to implement MapWindowPoints.
1093	*/
1094	static void WINPOS_GetWinOffset( Win32BaseWindow wndFrom, Win32BaseWindow wndTo,
1095	POINT *offset )
1096	{
1097	Win32BaseWindow *window;
1098
1099	offset->x = offset->y = 0;
1100
1101	/* Translate source window origin to screen coords */
1102	if(wndFrom != windowDesktop)
1103	{
1104	window = wndFrom;
1105	while(window)
1106	{
1107	offset->x += window->getClientRectPtr()->left + window->getWindowRect()->left;
1108	offset->y += window->getClientRectPtr()->top + window->getWindowRect()->top;
1109	window = window->getParent();
1110	}
1111	}
1112
1113	/* Translate origin to destination window coords */
1114	if(wndTo != windowDesktop)
1115	{
1116	window = wndTo;
1117	while(window)
1118	{
1119	offset->x -= window->getClientRectPtr()->left + window->getWindowRect()->left;
1120	offset->y -= window->getClientRectPtr()->top + window->getWindowRect()->top;
1121	window = window->getParent();
1122	}
1123	}
1124	}
1125	//******************************************************************************
1126	//******************************************************************************
1127	int WIN32API MapWindowPoints(HWND hwndFrom, HWND hwndTo, LPPOINT lpPoints,
1128	UINT cPoints)
1129	{
1130	Win32BaseWindow wndfrom, wndto;
1131	int retval = 0;
1132	POINT offset;
1133
1134	SetLastError(0);
1135	if(lpPoints == NULL \|\| cPoints == 0) {
1136	SetLastError(ERROR_INVALID_PARAMETER);
1137	return 0;
1138	}
1139	if(hwndTo == hwndFrom)
1140	return 0; //nothing to do
1141
1142	if(hwndFrom == HWND_DESKTOP)
1143	{
1144	windowDesktop->addRef();
1145	wndfrom = windowDesktop;
1146	}
1147	else {
1148	wndfrom = Win32BaseWindow::GetWindowFromHandle(hwndFrom);
1149	if(!wndfrom) {
1150	dprintf(("MapWindowPoints, window %x not found", hwndFrom));
1151	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1152	return 0;
1153	}
1154	}
1155
1156	if(hwndTo == HWND_DESKTOP)
1157	{
1158	windowDesktop->addRef();
1159	wndto = windowDesktop;
1160	}
1161	else {
1162	wndto = Win32BaseWindow::GetWindowFromHandle(hwndTo);
1163	if(!wndto) {
1164	dprintf(("MapWindowPoints, window %x not found", hwndTo));
1165	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1166	return 0;
1167	}
1168	}
1169
1170	dprintf2(("USER32: MapWindowPoints %x to %x (%d,%d) (%d)", hwndFrom, hwndTo, lpPoints->x, lpPoints->y, cPoints));
1171	WINPOS_GetWinOffset(wndfrom, wndto, &offset);
1172
1173	RELEASE_WNDOBJ(wndto);
1174	RELEASE_WNDOBJ(wndfrom);
1175	for(int i=0;i<cPoints;i++)
1176	{
1177	lpPoints[i].x += offset.x;
1178	lpPoints[i].y += offset.y;
1179	}
1180	retval = ((LONG)offset.y << 16) \| offset.x;
1181	return retval;
1182	}
1183	//******************************************************************************
1184	//******************************************************************************
1185	BOOL WIN32API ScreenToClient(HWND hwnd, LPPOINT pt)
1186	{
1187	PRECT rcl;
1188	BOOL rc;
1189
1190	if(hwnd == HWND_DESKTOP) {
1191	return (TRUE); //nothing to do
1192	}
1193	if (!IsWindow(hwnd)) {
1194	dprintf(("warning: ScreenToClient: window %x not found!", hwnd));
1195	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1196	return FALSE;
1197	}
1198	SetLastError(0);
1199	#ifdef DEBUG
1200	POINT tmp = *pt;
1201	#endif
1202	MapWindowPoints(0, hwnd, pt, 1);
1203	dprintf2(("ScreenToClient %x (%d,%d) -> (%d,%d)", hwnd, tmp.x, tmp.y, pt->x, pt->y));
1204	return TRUE;
1205	}
1206	//******************************************************************************
1207	//******************************************************************************
1208	HWND WIN32API GetDesktopWindow(void)
1209	{
1210	HWND hDesktopWindow = windowDesktop->getWindowHandle();
1211	dprintf2(("USER32: GetDesktopWindow, returned %x\n", hDesktopWindow));
1212	return hDesktopWindow;
1213	}
1214	//******************************************************************************
1215	//******************************************************************************
1216	HWND WIN32API FindWindowA(LPCSTR lpszClass, LPCSTR lpszWindow)
1217	{
1218	return FindWindowExA( NULL, NULL, lpszClass, lpszWindow );
1219	}
1220	//******************************************************************************
1221	//******************************************************************************
1222	HWND WIN32API FindWindowW( LPCWSTR lpClassName, LPCWSTR lpWindowName)
1223	{
1224	return FindWindowExW( NULL, NULL, lpClassName, lpWindowName );
1225	}
1226	//******************************************************************************
1227	//******************************************************************************
1228	HWND WIN32API FindWindowExA(HWND hwndParent, HWND hwndChildAfter, LPCSTR lpszClass, LPCSTR lpszWindow)
1229	{
1230	ATOM atom = 0;
1231
1232	if (lpszClass)
1233	{
1234	/* If the atom doesn't exist, then no class */
1235	/* with this name exists either. */
1236	if (!(atom = GlobalFindAtomA( lpszClass )))
1237	{
1238	SetLastError(ERROR_CANNOT_FIND_WND_CLASS);
1239	return 0;
1240	}
1241	}
1242	return Win32BaseWindow::FindWindowEx(hwndParent, hwndChildAfter, atom, (LPSTR)lpszWindow);
1243	}
1244	/*****************************************************************************
1245	* Name : HWND WIN32API FindWindowExW
1246	* Purpose : The FindWindowEx function retrieves the handle of a window whose
1247	* class name and window name match the specified strings. The
1248	* function searches child windows, beginning with the one following
1249	* the given child window.
1250	* Parameters: HWND hwndParent handle of parent window
1251	* HWND hwndChildAfter handle of a child window
1252	* LPCTSTR lpszClass address of class name
1253	* LPCTSTR lpszWindow address of window name
1254	* Variables :
1255	* Result : If the function succeeds, the return value is the handle of the
1256	* window that has the specified class and window names.
1257	* If the function fails, the return value is NULL. To get extended
1258	* error information, call GetLastError.
1259	* Remark :
1260	*
1261	*****************************************************************************/
1262
1263	HWND WIN32API FindWindowExW(HWND hwndParent,
1264	HWND hwndChildAfter,
1265	LPCWSTR lpszClass,
1266	LPCWSTR lpszWindow)
1267	{
1268	ATOM atom = 0;
1269	char *buffer;
1270	HWND hwnd;
1271
1272	if (lpszClass)
1273	{
1274	/* If the atom doesn't exist, then no class */
1275	/* with this name exists either. */
1276	if (!(atom = GlobalFindAtomW( lpszClass )))
1277	{
1278	SetLastError(ERROR_CANNOT_FIND_WND_CLASS);
1279	return 0;
1280	}
1281	}
1282	buffer = HEAP_strdupWtoA( GetProcessHeap(), 0, lpszWindow );
1283	hwnd = Win32BaseWindow::FindWindowEx(hwndParent, hwndChildAfter, atom, buffer);
1284	HeapFree( GetProcessHeap(), 0, buffer );
1285	return hwnd;
1286	}
1287	//******************************************************************************
1288	//******************************************************************************
1289	BOOL WIN32API FlashWindow(HWND hwnd, BOOL fFlash)
1290	{
1291	dprintf(("FlashWindow %x %d\n", hwnd, fFlash));
1292	// return OSLibWinFlashWindow(Win32ToOS2Handle(hwnd), fFlash);
1293	return 1;
1294	}
1295	//******************************************************************************
1296	//******************************************************************************
1297	BOOL WIN32API MoveWindow( HWND hwnd, INT x, INT y, INT cx, INT cy,
1298	BOOL repaint )
1299	{
1300	int flags = SWP_NOZORDER \| SWP_NOACTIVATE;
1301
1302	if (!repaint) flags \|= SWP_NOREDRAW;
1303	dprintf(("MoveWindow: %x %d,%d %dx%d %d\n", hwnd, x, y, cx, cy, repaint ));
1304
1305	return SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
1306	}
1307	//******************************************************************************
1308	//******************************************************************************
1309	BOOL WIN32API ClientToScreen (HWND hwnd, PPOINT pt)
1310	{
1311	PRECT rcl;
1312
1313	if(hwnd == HWND_DESKTOP) {
1314	return(TRUE); //nothing to do
1315	}
1316	if(!IsWindow(hwnd)) {
1317	dprintf(("warning: ClientToScreen window %x not found!", hwnd));
1318	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1319	return (FALSE);
1320	}
1321	#ifdef DEBUG
1322	POINT tmp = *pt;
1323	#endif
1324	MapWindowPoints(hwnd, 0, pt, 1);
1325	dprintf2(("ClientToScreen %x (%d,%d) -> (%d,%d)", hwnd, tmp.x, tmp.y, pt->x, pt->y));
1326
1327	return TRUE;
1328	}
1329	//******************************************************************************
1330	//Note: count 0 is a legal parameter (verified in NT4)
1331	//******************************************************************************
1332	HDWP WIN32API BeginDeferWindowPos(int count)
1333	{
1334	HDWP handle;
1335	DWP *pDWP;
1336
1337	if (count < 0)
1338	{
1339	dprintf(("USER32: BeginDeferWindowPos invalid param %d", count));
1340	SetLastError(ERROR_INVALID_PARAMETER);
1341	return 0;
1342	}
1343	dprintf(("USER32: BeginDeferWindowPos %d", count));
1344	if(count == 0)
1345	count = 8; // change to any non-zero value
1346
1347	handle = (HDWP)HeapAlloc(GetProcessHeap(), 0, sizeof(DWP) + (count-1)*sizeof(WINDOWPOS));
1348	if (!handle)
1349	return 0;
1350
1351	pDWP = (DWP *) handle;
1352	pDWP->actualCount = 0;
1353	pDWP->suggestedCount = count;
1354	pDWP->valid = TRUE;
1355	pDWP->wMagic = DWP_MAGIC;
1356	pDWP->hwndParent = 0;
1357	return handle;
1358	}
1359	/***********************************************************************
1360	* DeferWindowPos (USER32.128)
1361	*
1362	* TODO: SvL: Does this need to be thread safe?
1363	*
1364	*/
1365	HDWP WIN32API DeferWindowPos( HDWP hdwp, HWND hwnd, HWND hwndAfter,
1366	INT x, INT y, INT cx, INT cy,
1367	UINT flags )
1368	{
1369	DWP *pDWP;
1370	int i;
1371	HDWP newhdwp = hdwp,retvalue;
1372
1373	pDWP = (DWP *)hdwp;
1374	if (!pDWP) {
1375	SetLastError(ERROR_INVALID_PARAMETER);
1376	return 0;
1377	}
1378
1379	if (hwnd == GetDesktopWindow())
1380	return 0;
1381
1382	if(!IsWindow(hwnd)) {
1383	dprintf(("DeferWindowPos, window %x not found", hwnd));
1384	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1385	HeapFree(GetProcessHeap(), 0, (LPVOID)hdwp);
1386	return 0;
1387	}
1388
1389	dprintf(("USER32: DeferWindowPos hdwp %x hwnd %x hwndAfter %x (%d,%d)(%d,%d) %x", hdwp, hwnd, hwndAfter,
1390	x, y, cx, cy, flags));
1391
1392	/* Numega Bounds Checker Demo dislikes the following code.
1393	In fact, I've not been able to find any "same parent" requirement in any docu
1394	[AM 980509]
1395	*/
1396	#if 0
1397	/* All the windows of a DeferWindowPos() must have the same parent */
1398	parent = pWnd->parent->hwndSelf;
1399	if (pDWP->actualCount == 0) pDWP->hwndParent = parent;
1400	else if (parent != pDWP->hwndParent)
1401	{
1402	USER_HEAP_FREE( hdwp );
1403	retvalue = 0;
1404	goto END;
1405	}
1406	#endif
1407
1408	for (i = 0; i < pDWP->actualCount; i++)
1409	{
1410	if (pDWP->winPos[i].hwnd == hwnd)
1411	{
1412	/* Merge with the other changes */
1413	if (!(flags & SWP_NOZORDER))
1414	{
1415	pDWP->winPos[i].hwndInsertAfter = hwndAfter;
1416	}
1417	if (!(flags & SWP_NOMOVE))
1418	{
1419	pDWP->winPos[i].x = x;
1420	pDWP->winPos[i].y = y;
1421	}
1422	if (!(flags & SWP_NOSIZE))
1423	{
1424	pDWP->winPos[i].cx = cx;
1425	pDWP->winPos[i].cy = cy;
1426	}
1427	pDWP->winPos[i].flags &= flags \| ~(SWP_NOSIZE \| SWP_NOMOVE \|
1428	SWP_NOZORDER \| SWP_NOREDRAW \|
1429	SWP_NOACTIVATE \| SWP_NOCOPYBITS\|
1430	SWP_NOOWNERZORDER);
1431	pDWP->winPos[i].flags \|= flags & (SWP_SHOWWINDOW \| SWP_HIDEWINDOW \|
1432	SWP_FRAMECHANGED);
1433	retvalue = hdwp;
1434	goto END;
1435	}
1436	}
1437	if (pDWP->actualCount >= pDWP->suggestedCount)
1438	{
1439	//DWP structure already contains WINDOWPOS, allocated with (count-1)
1440	//in BeginDeferWindowPos; pDWP->suggestedCount alloc increases it by one
1441	newhdwp = (HDWP)HeapReAlloc(GetProcessHeap(), 0, (LPVOID)hdwp,
1442	sizeof(DWP) + pDWP->suggestedCount*sizeof(WINDOWPOS));
1443	if (!newhdwp)
1444	{
1445	retvalue = 0;
1446	goto END;
1447	}
1448	pDWP = (DWP *) newhdwp;
1449	pDWP->suggestedCount++;
1450	}
1451	pDWP->winPos[pDWP->actualCount].hwnd = hwnd;
1452	pDWP->winPos[pDWP->actualCount].hwndInsertAfter = hwndAfter;
1453	pDWP->winPos[pDWP->actualCount].x = x;
1454	pDWP->winPos[pDWP->actualCount].y = y;
1455	pDWP->winPos[pDWP->actualCount].cx = cx;
1456	pDWP->winPos[pDWP->actualCount].cy = cy;
1457	pDWP->winPos[pDWP->actualCount].flags = flags;
1458	pDWP->actualCount++;
1459	retvalue = newhdwp;
1460	END:
1461	return retvalue;
1462	}
1463	//******************************************************************************
1464	//******************************************************************************
1465	BOOL WIN32API EndDeferWindowPos( HDWP hdwp)
1466	{
1467	DWP *pDWP;
1468	WINDOWPOS *winpos;
1469	BOOL res = TRUE;
1470	int i;
1471
1472	pDWP = (DWP *) hdwp;
1473	if (!pDWP) {
1474	dprintf(("**EndDeferWindowPos invalid parameter\n"));
1475	SetLastError(ERROR_INVALID_PARAMETER);
1476	return FALSE;
1477	}
1478	dprintf(("**EndDeferWindowPos for %d windows", pDWP->actualCount));
1479	for (i = 0, winpos = pDWP->winPos; i < pDWP->actualCount; i++, winpos++)
1480	{
1481	dprintf(("**EndDeferWindowPos %x (%d,%d) (%d,%d) %x", winpos->hwnd, winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags));
1482	if (!(res = SetWindowPos(winpos->hwnd, winpos->hwndInsertAfter,
1483	winpos->x, winpos->y, winpos->cx,
1484	winpos->cy, winpos->flags )))
1485	break;
1486	}
1487	dprintf(("**EndDeferWindowPos DONE"));
1488	HeapFree(GetProcessHeap(), 0, (LPVOID)hdwp);
1489	return res;
1490	}
1491	//******************************************************************************
1492	//******************************************************************************
1493	HWND WIN32API ChildWindowFromPoint( HWND hwnd, POINT pt)
1494	{
1495	dprintf(("USER32: ChildWindowFromPoint\n"));
1496	return ChildWindowFromPointEx(hwnd, pt, 0);
1497	}
1498	/*****************************************************************************
1499	* Name : HWND WIN32API ChildWindowFromPointEx
1500	* Purpose : pt: client coordinates
1501	* Parameters:
1502	* Variables :
1503	* Result : If the function succeeds, the return value is the window handle.
1504	* If the function fails, the return value is zero
1505	* Remark :
1506	* Status : COMPLETELY IMPLEMENTED AND TESTED
1507	*
1508	* Author : Rene Pronk [Sun, 1999/08/08 23:30]
1509	*****************************************************************************/
1510	HWND WIN32API ChildWindowFromPointEx (HWND hwndParent, POINT pt, UINT uFlags)
1511	{
1512	RECT rect;
1513	HWND hWnd;
1514
1515	dprintf(("ChildWindowFromPointEx(%08xh,%08xh,%08xh).\n",
1516	hwndParent, pt, uFlags));
1517
1518	if (GetWindowRect (hwndParent, &rect) == 0) {
1519	// oops, invalid handle
1520	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1521	return NULL;
1522	}
1523
1524	ClientToScreen(hwndParent, &pt);
1525	if (PtInRect (&rect, pt) == 0) {
1526	// point is outside window
1527	return NULL;
1528	}
1529
1530	// get first child
1531	hWnd = GetWindow (hwndParent, GW_CHILD);
1532
1533	while (hWnd != NULL)
1534	{
1535	// do I need to skip this window?
1536	if (((uFlags & CWP_SKIPINVISIBLE) &&
1537	(IsWindowVisible (hWnd) == FALSE)) \|\|
1538	((uFlags & CWP_SKIPDISABLED) &&
1539	(IsWindowEnabled (hWnd) == FALSE)) \|\|
1540	((uFlags & CWP_SKIPTRANSPARENT) &&
1541	(GetWindowLongA (hWnd, GWL_EXSTYLE) & WS_EX_TRANSPARENT)))
1542	{
1543	hWnd = GetWindow (hWnd, GW_HWNDNEXT);
1544	continue;
1545	}
1546
1547	// is the point in this window's rect?
1548	GetWindowRect (hWnd, &rect);
1549	if (PtInRect (&rect,pt) == FALSE) {
1550	hWnd = GetWindow (hWnd, GW_HWNDNEXT);
1551	continue;
1552	}
1553
1554	dprintf(("ChildWindowFromPointEx returned %x", hWnd));
1555	// found it!
1556	return hWnd;
1557	}
1558	// the point is in the parentwindow but the parentwindow has no child
1559	// at this coordinate
1560	dprintf(("ChildWindowFromPointEx returned parent %x", hwndParent));
1561	return hwndParent;
1562	}
1563	//******************************************************************************
1564	//******************************************************************************
1565	BOOL WIN32API CloseWindow(HWND hwnd)
1566	{
1567	Win32BaseWindow *window;
1568
1569	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1570	if(!window) {
1571	dprintf(("CloseWindow, window %x not found", hwnd));
1572	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1573	return 0;
1574	}
1575	dprintf(("CloseWindow %x\n", hwnd));
1576	BOOL ret = window->CloseWindow();
1577	RELEASE_WNDOBJ(window);
1578	return ret;
1579	}
1580	//******************************************************************************
1581	//******************************************************************************
1582	static BOOL IsPointInWindow(HWND hwnd, POINT point)
1583	{
1584	RECT rectWindow;
1585	DWORD hittest, dwStyle, dwExStyle;
1586
1587	dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
1588	dwExStyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
1589
1590	GetWindowRect(hwnd, &rectWindow);
1591
1592	/* If point is in window, and window is visible, and it */
1593	/* is enabled (or it's a top-level window), then explore */
1594	/* its children. Otherwise, go to the next window. */
1595
1596	if( (dwStyle & WS_VISIBLE) &&
1597	((dwExStyle & (WS_EX_LAYERED \| WS_EX_TRANSPARENT)) != (WS_EX_LAYERED \| WS_EX_TRANSPARENT)) &&
1598	(!(dwStyle & WS_DISABLED) \|\| ((dwStyle & (WS_POPUP \| WS_CHILD)) != WS_CHILD)) &&
1599	((point.x >= rectWindow.left) && (point.x < rectWindow.right) &&
1600	(point.y >= rectWindow.top) && (point.y < rectWindow.bottom))
1601	#if 1
1602	)
1603	#else
1604	&&
1605	(wndPtr->hrgnWnd ? PtInRegion(wndPtr->hrgnWnd, 1))
1606	#endif
1607	{
1608	hittest = SendMessageA(hwnd, WM_NCHITTEST, 0, MAKELONG(point.x, point.y));
1609	if(hittest != HTTRANSPARENT) {
1610	return TRUE;
1611	}
1612	}
1613	return FALSE;
1614	}
1615	//******************************************************************************
1616	//TODO: Does this return handles of hidden or disabled windows?
1617	//******************************************************************************
1618	HWND WIN32API WindowFromPoint( POINT point)
1619	{
1620	HWND hwndOS2, hwnd;
1621	POINT wPoint;
1622
1623	wPoint.x = point.x;
1624	wPoint.y = mapScreenY(point.y);
1625
1626	hwndOS2 = OSLibWinWindowFromPoint(OSLIB_HWND_DESKTOP, (PVOID)&wPoint);
1627	if(hwndOS2)
1628	{
1629	hwnd = OS2ToWin32Handle(hwndOS2);
1630	while(hwnd)
1631	{
1632	if(IsPointInWindow(hwnd, point)) {
1633	dprintf(("WindowFromPoint (%d,%d) %x->%x\n", point.x, point.y, hwndOS2, hwnd));
1634	return hwnd;
1635	}
1636	hwnd = GetWindow(hwnd, GW_HWNDNEXT);
1637	#if 0
1638	//try siblings
1639	HWND hwndSibling;
1640	HWND hwndParent = GetParent(hwnd);
1641
1642	if(hwndParent) {
1643	hwndSibling = GetWindow(hwndParent, GW_CHILD);
1644	while(hwndSibling) {
1645	if(hwndSibling != hwnd) {
1646	if(IsPointInWindow(hwndSibling, point)) {
1647	dprintf(("WindowFromPoint (%d,%d) %x->%x\n", point.x, point.y, hwndOS2, hwndSibling));
1648	return hwndSibling;
1649	}
1650	}
1651	hwndSibling = GetWindow(hwndSibling, GW_HWNDNEXT);
1652	}
1653	}
1654	hwnd = hwndParent;
1655	#endif
1656	}
1657	}
1658	dprintf(("WindowFromPoint (%d,%d) %x->1\n", point.x, point.y, hwndOS2));
1659	return windowDesktop->getWindowHandle();
1660	}
1661	//******************************************************************************
1662	//******************************************************************************
1663	BOOL WIN32API IsWindowUnicode(HWND hwnd)
1664	{
1665	Win32BaseWindow *window;
1666
1667	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1668	if(!window) {
1669	dprintf(("IsWindowUnicode, window %x not found", hwnd));
1670	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1671	return 0;
1672	}
1673	BOOL ret = window->IsWindowUnicode();
1674	RELEASE_WNDOBJ(window);
1675	return ret;
1676	}
1677	/***********************************************************************
1678	* SwitchToThisWindow (USER32.539)
1679	*/
1680	DWORD WINAPI SwitchToThisWindow( HWND hwnd, BOOL restore )
1681	{
1682	return ShowWindow( hwnd, restore ? SW_RESTORE : SW_SHOWMINIMIZED );
1683	}
1684	//******************************************************************************
1685	//******************************************************************************
1686	BOOL WIN32API EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
1687	{
1688	return windowDesktop->EnumThreadWindows(dwThreadId, lpfn, lParam);
1689	}
1690	//******************************************************************************
1691	//******************************************************************************
1692	BOOL WIN32API EnumChildWindows(HWND hwnd, WNDENUMPROC lpfn, LPARAM lParam)
1693	{
1694	Win32BaseWindow *window;
1695	BOOL ret = TRUE;
1696	ULONG henum;
1697	HWND hwndNext;
1698
1699	if(lpfn == NULL) {
1700	dprintf(("EnumChildWindows invalid parameter %x %x\n", hwnd, lParam));
1701	SetLastError(ERROR_INVALID_PARAMETER);
1702	return FALSE;
1703	}
1704	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1705	if(!window) {
1706	dprintf(("EnumChildWindows, window %x not found", hwnd));
1707	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1708	return FALSE;
1709	}
1710	ret = window->EnumChildWindows(lpfn, lParam);
1711	RELEASE_WNDOBJ(window);
1712	return ret;
1713	}
1714	//******************************************************************************
1715	//******************************************************************************
1716	BOOL WIN32API EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
1717	{
1718	return windowDesktop->EnumWindows(lpfn, lParam);
1719	}
1720	//******************************************************************************
1721	//******************************************************************************
1722	UINT WIN32API ArrangeIconicWindows( HWND parent)
1723	{
1724	RECT rectParent;
1725	HWND hwndChild;
1726	INT x, y, xspacing, yspacing;
1727
1728	dprintf(("USER32: ArrangeIconicWindows %x", parent));
1729	dprintf(("USER32: TODO: icon title!!"));
1730
1731	GetClientRect(parent, &rectParent);
1732	x = rectParent.left;
1733	y = rectParent.bottom;
1734	xspacing = GetSystemMetrics(SM_CXICONSPACING);
1735	yspacing = GetSystemMetrics(SM_CYICONSPACING);
1736
1737	hwndChild = GetWindow( parent, GW_CHILD );
1738	while (hwndChild)
1739	{
1740	if( IsIconic( hwndChild ) )
1741	{
1742	// WND *wndPtr = WIN_FindWndPtr(hwndChild);
1743
1744	// WINPOS_ShowIconTitle( wndPtr, FALSE );
1745
1746	SetWindowPos( hwndChild, 0, x + (xspacing - GetSystemMetrics(SM_CXICON)) / 2,
1747	y - yspacing - GetSystemMetrics(SM_CYICON)/2, 0, 0,
1748	SWP_NOSIZE \| SWP_NOZORDER \| SWP_NOACTIVATE );
1749	// if( IsWindow(hwndChild) )
1750	// WINPOS_ShowIconTitle(wndPtr , TRUE );
1751	// WIN_ReleaseWndPtr(wndPtr);
1752
1753	if (x <= rectParent.right - xspacing) x += xspacing;
1754	else
1755	{
1756	x = rectParent.left;
1757	y -= yspacing;
1758	}
1759	}
1760	hwndChild = GetWindow( hwndChild, GW_HWNDNEXT );
1761	}
1762	return yspacing;
1763	}
1764	//******************************************************************************
1765	//restores iconized window to previous size/position
1766	//******************************************************************************
1767	BOOL WIN32API OpenIcon(HWND hwnd)
1768	{
1769	dprintf(("USER32: OpenIcon %x", hwnd));
1770
1771	if(!IsIconic(hwnd))
1772	return FALSE;
1773	ShowWindow(hwnd, SW_SHOWNORMAL);
1774	return TRUE;
1775	}
1776	//******************************************************************************
1777	//SDK: Windows can only be shown with ShowOwnedPopups if they were previously
1778	// hidden with the same api
1779	//TODO: -> needs testing
1780	//******************************************************************************
1781	BOOL WIN32API ShowOwnedPopups(HWND hwndOwner, BOOL fShow)
1782	{
1783	Win32BaseWindow window, owner;
1784	HWND hwnd;
1785
1786	owner = Win32BaseWindow::GetWindowFromHandle(hwndOwner);
1787	if(!owner) {
1788	dprintf(("ShowOwnedPopups, window %x not found", hwndOwner));
1789	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1790	return FALSE;
1791	}
1792	dprintf(("USER32: ShowOwnedPopups %x %d", hwndOwner, fShow));
1793
1794	hwnd = GetWindow(GetDesktopWindow(), GW_CHILD);
1795	while(hwnd) {
1796	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1797	if(window) {
1798	if(window == owner && (window->getStyle() & WS_POPUP))
1799	{
1800	if(fShow) {
1801	if(window->getFlags() & WIN_NEEDS_SHOW_OWNEDPOPUP)
1802	{
1803	/*
1804	* In Windows, ShowOwnedPopups(TRUE) generates WM_SHOWWINDOW messages with SW_PARENTOPENING,
1805	* regardless of the state of the owner
1806	*/
1807	SendMessageA(hwnd, WM_SHOWWINDOW, SW_SHOW, SW_PARENTOPENING);
1808	window->setFlags(window->getFlags() & ~WIN_NEEDS_SHOW_OWNEDPOPUP);
1809	}
1810	}
1811	else
1812	{
1813	if(IsWindowVisible(hwnd))
1814	{
1815	/*
1816	* In Windows, ShowOwnedPopups(FALSE) generates WM_SHOWWINDOW messages with SW_PARENTCLOSING,
1817	* regardless of the state of the owner
1818	*/
1819	SendMessageA(hwnd, WM_SHOWWINDOW, SW_HIDE, SW_PARENTCLOSING);
1820	window->setFlags(window->getFlags() \| WIN_NEEDS_SHOW_OWNEDPOPUP);
1821	}
1822	}
1823	}
1824	RELEASE_WNDOBJ(window);
1825	}
1826	else dprintf(("WARNING: window %x is not valid", hwnd));
1827
1828	hwnd = GetWindow(hwnd, GW_HWNDNEXT);
1829	}
1830	RELEASE_WNDOBJ(owner);
1831	return TRUE;
1832	}
1833	//******************************************************************************
1834	//******************************************************************************
1835	HWND WIN32API GetForegroundWindow()
1836	{
1837	HWND hwnd;
1838
1839	hwnd = OS2ToWin32Handle(OSLibWinQueryActiveWindow());
1840	return hwnd;
1841	}
1842	//******************************************************************************
1843
1844	/******************************************************************************
1845	* The return value identifies the most recently active pop-up window.
1846	* The return value is the same as the hWnd parameter, if any of the
1847	* following conditions are met:
1848	*
1849	* - The window identified by hWnd was most recently active.
1850	* - The window identified by hWnd does not own any pop-up windows.
1851	* - The window identified by hWnd is not a top-level window or it is
1852	* owned by another window.
1853	*/
1854	HWND WIN32API GetLastActivePopup(HWND hWnd)
1855	{
1856	Win32BaseWindow *owner;
1857
1858	owner = Win32BaseWindow::GetWindowFromHandle(hWnd);
1859	if(!owner)
1860	{
1861	dprintf(("GetLastActivePopup, window %x not found", hWnd));
1862	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1863	return hWnd;
1864	}
1865
1866	HWND hwndRetVal = owner->getLastActive();
1867	if (!IsWindow( hwndRetVal ))
1868	hwndRetVal = owner->getWindowHandle();
1869
1870	RELEASE_WNDOBJ(owner);
1871
1872	return hwndRetVal;
1873	}
1874	//******************************************************************************
1875	//******************************************************************************
1876	DWORD WIN32API GetWindowThreadProcessId(HWND hwnd, PDWORD lpdwProcessId)
1877	{
1878	Win32BaseWindow *window;
1879	DWORD dwThreadId;
1880
1881	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1882	if(!window) {
1883	dprintf(("GetWindowThreadProcessId, window %x not found", hwnd));
1884	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1885	return 0;
1886	}
1887	dwThreadId = window->getThreadId();
1888	if(lpdwProcessId) {
1889	*lpdwProcessId = window->getProcessId();
1890	}
1891	RELEASE_WNDOBJ(window);
1892
1893	return dwThreadId;
1894	}
1895	//******************************************************************************
1896	//******************************************************************************
1897	DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
1898	{
1899	Win32BaseWindow *window;
1900
1901	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1902	if(!window) {
1903	dprintf(("GetWindowContextHelpId, window %x not found", hwnd));
1904	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1905	return 0;
1906	}
1907	dprintf(("GetWindowContextHelpId %x", hwnd));
1908	DWORD ret = window->getWindowContextHelpId();
1909	RELEASE_WNDOBJ(window);
1910	return ret;
1911	}
1912	//******************************************************************************
1913	//******************************************************************************
1914	BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
1915	{
1916	Win32BaseWindow *window;
1917
1918	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1919	if(!window) {
1920	dprintf(("SetWindowContextHelpId, window %x not found", hwnd));
1921	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1922	return 0;
1923	}
1924	dprintf(("SetWindowContextHelpId %x %d", hwnd, dwContextHelpId));
1925	window->setWindowContextHelpId(dwContextHelpId);
1926	RELEASE_WNDOBJ(window);
1927	return(TRUE);
1928	}
1929	//******************************************************************************
1930	//******************************************************************************
1931	HANDLE WIN32API GetPropA(HWND hwnd, LPCSTR str )
1932	{
1933	Win32BaseWindow *window;
1934
1935	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1936	if(!window) {
1937	dprintf(("GetPropA, window %x not found", hwnd));
1938	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1939	return 0;
1940	}
1941	HANDLE ret = window->getProp(str);
1942	RELEASE_WNDOBJ(window);
1943	return ret;
1944	}
1945	//******************************************************************************
1946	//******************************************************************************
1947	HANDLE WIN32API GetPropW(HWND hwnd, LPCWSTR str)
1948	{
1949	Win32BaseWindow *window;
1950	LPSTR strA;
1951	HANDLE ret;
1952
1953	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1954	if(!window) {
1955	dprintf(("GetPropW, window %x not found", hwnd));
1956	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1957	return 0;
1958	}
1959
1960	if(HIWORD(str)) {
1961	strA = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
1962	}
1963	else strA = (LPSTR)str;
1964
1965	ret = window->getProp(strA);
1966
1967	RELEASE_WNDOBJ(window);
1968	if(HIWORD(str)) HeapFree( GetProcessHeap(), 0, strA );
1969	return ret;
1970	}
1971	//******************************************************************************
1972	//******************************************************************************
1973	BOOL WIN32API SetPropA(HWND hwnd, LPCSTR str, HANDLE handle )
1974	{
1975	Win32BaseWindow *window;
1976
1977	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1978	if(!window) {
1979	dprintf(("SetPropA, window %x not found", hwnd));
1980	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1981	return FALSE;
1982	}
1983	BOOL ret = window->setProp(str, handle);
1984	RELEASE_WNDOBJ(window);
1985	return ret;
1986	}
1987	//******************************************************************************
1988	//******************************************************************************
1989	BOOL SetPropW(HWND hwnd, LPCWSTR str, HANDLE handle )
1990	{
1991	BOOL ret;
1992	LPSTR strA;
1993
1994	if (!HIWORD(str))
1995	return SetPropA( hwnd, (LPCSTR)(UINT)LOWORD(str), handle );
1996	strA = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
1997	ret = SetPropA( hwnd, strA, handle );
1998	HeapFree( GetProcessHeap(), 0, strA );
1999	return ret;
2000	}
2001	//******************************************************************************
2002	//******************************************************************************
2003	HANDLE WIN32API RemovePropA(HWND hwnd, LPCSTR str)
2004	{
2005	Win32BaseWindow *window;
2006
2007	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
2008	if(!window) {
2009	dprintf(("RemovePropA, window %x not found", hwnd));
2010	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
2011	return 0;
2012	}
2013	HANDLE ret = window->removeProp(str);
2014	RELEASE_WNDOBJ(window);
2015	return ret;
2016	}
2017	//******************************************************************************
2018	//******************************************************************************
2019	HANDLE WIN32API RemovePropW(HWND hwnd, LPCWSTR str)
2020	{
2021	LPSTR strA;
2022	HANDLE ret;
2023
2024	if (!HIWORD(str))
2025	return RemovePropA( hwnd, (LPCSTR)(UINT)LOWORD(str) );
2026	strA = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
2027	ret = RemovePropA( hwnd, strA );
2028	HeapFree( GetProcessHeap(), 0, strA );
2029	return ret;
2030	}
2031	//******************************************************************************
2032	//******************************************************************************
2033	INT WIN32API EnumPropsA(HWND hwnd, PROPENUMPROCA func )
2034	{
2035	return EnumPropsExA( hwnd, (PROPENUMPROCEXA)func, 0 );
2036	}
2037	//******************************************************************************
2038	//******************************************************************************
2039	INT WIN32API EnumPropsW(HWND hwnd, PROPENUMPROCW func )
2040	{
2041	return EnumPropsExW( hwnd, (PROPENUMPROCEXW)func, 0 );
2042	}
2043	//******************************************************************************
2044	//******************************************************************************
2045	INT WIN32API EnumPropsExA(HWND hwnd, PROPENUMPROCEXA func, LPARAM lParam)
2046	{
2047	Win32BaseWindow *window;
2048
2049	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
2050	if(!window) {
2051	dprintf(("EnumPropsExA, window %x not found", hwnd));
2052	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
2053	return -1;
2054	}
2055	INT ret = window->enumPropsExA(func, lParam);
2056	RELEASE_WNDOBJ(window);
2057	return ret;
2058	}
2059	//******************************************************************************
2060	//******************************************************************************
2061	INT WIN32API EnumPropsExW(HWND hwnd, PROPENUMPROCEXW func, LPARAM lParam)
2062	{
2063	Win32BaseWindow *window;
2064
2065	window = Win32BaseWindow::GetWindowFromHandle(hwnd);
2066	if(!window) {
2067	dprintf(("EnumPropsExA, window %x not found", hwnd));
2068	SetLastError(ERROR_INVALID_WINDOW_HANDLE);
2069	return -1;
2070	}
2071	INT ret = window->enumPropsExW(func, lParam);
2072	RELEASE_WNDOBJ(window);
2073	return ret;
2074	}
2075	//******************************************************************************
2076	//******************************************************************************
2077
2078
2079	/*****************************************************************************
2080	* Name : BOOL WIN32API AnyPopup
2081	* Purpose : The AnyPopup function indicates whether an owned, visible,
2082	* top-level pop-up, or overlapped window exists on the screen. The
2083	* function searches the entire Windows screen, not just the calling
2084	* application's client area.
2085	* Parameters: VOID
2086	* Variables :
2087	* Result : If a pop-up window exists, the return value is TRUE even if the
2088	* pop-up window is completely covered by other windows. Otherwise,
2089	* it is FALSE.
2090	* Remark : AnyPopup is a Windows version 1.x function and is retained for
2091	* compatibility purposes. It is generally not useful.
2092	* Status : UNTESTED STUB
2093	*
2094	* Author : Patrick Haller [Thu, 1998/02/26 11:55]
2095	*****************************************************************************/
2096	BOOL WIN32API AnyPopup()
2097	{
2098	dprintf(("USER32:AnyPopup() not implemented.\n"));
2099
2100	return (FALSE);
2101	}

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

Download in other formats: