Context Navigation

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

Visit:

Last change on this file since 2004 was 1971, checked in by sandervl, 26 years ago
Rewrote some message apis + WM_WINDOWPOSCHANGED fix
File size: 52.1 KB

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

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

Download in other formats: