Context Navigation

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

Visit:

Last change on this file since 4509 was 2426, checked in by sandervl, 26 years ago
wm_activate fixes, scrollbar fix, drawframe fix
File size: 52.1 KB

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

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

Download in other formats: