Context Navigation

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

Visit:

Last change on this file since 2529 was 2529, checked in by cbratschi, 26 years ago
WINE code clean-up
File size: 52.0 KB

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

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

Download in other formats: