Context Navigation

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

Visit:

Last change on this file since 3482 was 3482, checked in by sandervl, 25 years ago
RDW_FRAME support for GetDCEx; added wine dialog change; added extra logging
File size: 52.5 KB

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

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

Download in other formats: