Context Navigation

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

Visit:

Last change on this file since 3419 was 3419, checked in by sandervl, 25 years ago
misc updates
File size: 52.4 KB

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

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

Download in other formats: