Context Navigation

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

Visit:

Last change on this file since 2383 was 2383, checked in by sandervl, 26 years ago
Several updates/bug fixes
File size: 50.8 KB

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

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

Download in other formats: