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

Last change on this file since 314 was 314, checked in by sandervl, 26 years ago

Misc window class changes/bugfixes
File size: 24.6 KB
Line 
1/* $Id: window.cpp,v 1.3 1999-07-16 11:32:09 sandervl Exp $ */
2/*
3 * Win32 window apis for OS/2
4 *
5 * Copyright 1999 Sander van Leeuwen
6 *
7 * Parts based on Wine Windows code (windows\win.c)
8 *
9 * Copyright 1993, 1994 Alexandre Julliard
10 *
11 * Project Odin Software License can be found in LICENSE.TXT
12 *
13 */
14
15#include <os2win.h>
16#include <misc.h>
17#include <win32wnd.h>
18
19//******************************************************************************
20//******************************************************************************
21HWND WIN32API CreateWindowExA(DWORD exStyle, LPCSTR className,
22 LPCSTR windowName, DWORD style, INT x,
23 INT y, INT width, INT height,
24 HWND parent, HMENU menu,
25 HINSTANCE instance, LPVOID data )
26{
27 Win32Window *window;
28 ATOM classAtom;
29 CREATESTRUCTA cs;
30
31 if(exStyle & WS_EX_MDICHILD)
32 return CreateMDIWindowA(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
33
34 /* Find the class atom */
35 if (!(classAtom = GlobalFindAtomA(className)))
36 {
37 dprintf(("CreateWindowEx32A: bad class name "));
38 if (!HIWORD(className)) {
39 dprintf(("CreateWindowEx32A: bad class name %04x\n", LOWORD(className)));
40 }
41 else dprintf(("CreateWindowEx32A: bad class name '%s'\n", className ));
42 SetLastError(ERROR_INVALID_PARAMETER);
43 return 0;
44 }
45
46 /* Create the window */
47 cs.lpCreateParams = data;
48 cs.hInstance = instance;
49 cs.hMenu = menu;
50 cs.hwndParent = parent;
51 cs.x = x;
52 cs.y = y;
53 cs.cx = width;
54 cs.cy = height;
55 cs.style = style;
56 cs.lpszName = windowName;
57 cs.lpszClass = className;
58 cs.dwExStyle = exStyle;
59 window = new Win32Window( &cs, classAtom, FALSE );
60 if(window == NULL)
61 {
62 dprintf(("Win32Window creation failed!!"));
63 return 0;
64 }
65 if(GetLastError() != 0)
66 {
67 dprintf(("Win32Window error found!!"));
68 delete window;
69 return 0;
70 }
71 return window->getWindowHandle();
72}
73//******************************************************************************
74//******************************************************************************
75HWND WIN32API CreateMDIWindowA(LPCSTR arg1, LPCSTR arg2, DWORD arg3,
76 int arg4, int arg5, int arg6, int arg7,
77 HWND arg8, HINSTANCE arg9, LPARAM arg10)
78{
79 HWND hwnd;
80
81 dprintf(("USER32: CreateMDIWindowA\n"));
82
83 hwnd = O32_CreateMDIWindow((LPSTR)arg1, (LPSTR)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
84
85 dprintf(("USER32: CreateMDIWindowA returned %X\n", hwnd));
86 return hwnd;
87}
88//******************************************************************************
89//******************************************************************************
90HWND WIN32API CreateMDIWindowW(LPCWSTR arg1, LPCWSTR arg2, DWORD arg3, int arg4,
91 int arg5, int arg6, int arg7, HWND arg8, HINSTANCE arg9,
92 LPARAM arg10)
93{
94 HWND hwnd;
95 char *astring1 = NULL, *astring2 = NULL;
96
97 if((int)arg1 >> 16 != 0) {
98 astring1 = UnicodeToAsciiString((LPWSTR)arg1);
99 }
100 else astring1 = (char *)arg2;
101
102 astring2 = UnicodeToAsciiString((LPWSTR)arg2);
103
104 hwnd = O32_CreateMDIWindow(astring1, astring2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
105
106 if(astring1) FreeAsciiString(astring1);
107 FreeAsciiString(astring2);
108 dprintf(("USER32: CreateMDIWindowW hwnd = %X\n", hwnd));
109 return(hwnd);
110}
111//******************************************************************************
112//******************************************************************************
113HWND WIN32API CreateWindowExW(DWORD arg1,
114 LPCWSTR arg2,
115 LPCWSTR arg3,
116 DWORD dwStyle,
117 int arg5,
118 int arg6,
119 int arg7,
120 int arg8,
121 HWND arg9,
122 HMENU arg10,
123 HINSTANCE arg11,
124 PVOID arg12)
125{
126 HWND hwnd;
127 char *astring1 = NULL,
128 *astring2 = NULL;
129
130 /* @@@PH 98/06/21 changed to call OS2CreateWindowExA */
131 if(HIWORD(arg2) != 0)
132 astring1 = UnicodeToAsciiString((LPWSTR)arg2);
133 else
134 astring1 = (char *)arg2;
135
136 astring2 = UnicodeToAsciiString((LPWSTR)arg3);
137
138#ifdef DEBUG
139 WriteLog("USER32: CreateWindowExW: dwExStyle = %X\n", arg1);
140 if((int)arg2 >> 16 != 0)
141 WriteLog("USER32: CreateWindow: classname = %s\n", astring1);
142 else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
143 WriteLog("USER32: CreateWindow: windowname= %s\n", astring2);
144 WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
145 WriteLog("USER32: CreateWindow: x = %d\n", arg5);
146 WriteLog("USER32: CreateWindow: y = %d\n", arg6);
147 WriteLog("USER32: CreateWindow: nWidth = %d\n", arg7);
148 WriteLog("USER32: CreateWindow: nHeight = %d\n", arg8);
149 WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
150 WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
151 WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
152 WriteLog("USER32: CreateWindow: param = %X\n", arg12);
153 #endif
154
155 hwnd = CreateWindowExA(arg1,
156 astring1,
157 astring2,
158 dwStyle,
159 arg5,
160 arg6,
161 arg7,
162 arg8,
163 arg9,
164 arg10,
165 arg11,
166 arg12);
167
168 if(HIWORD(arg1) != 0)
169 FreeAsciiString(astring1);
170
171 FreeAsciiString(astring2);
172
173#ifdef DEBUG
174 WriteLog("USER32: ************CreateWindowExW hwnd = %X (%X)\n", hwnd, GetLastError());
175#endif
176 return(hwnd);
177}
178//******************************************************************************
179//******************************************************************************
180BOOL WIN32API DestroyWindow(HWND hwnd)
181{
182 Win32Window *window;
183
184 window = Win32Window::GetWindowFromHandle(hwnd);
185 if(!window) {
186 dprintf(("SendMessageA, window %x not found", hwnd));
187 return 0;
188 }
189 return window->DestroyWindow();
190}
191//******************************************************************************
192//******************************************************************************
193HWND WIN32API SetActiveWindow( HWND hwnd)
194{
195 Win32Window *window;
196
197 window = Win32Window::GetWindowFromHandle(hwnd);
198 if(!window) {
199 dprintf(("SendMessageA, window %x not found", hwnd));
200 return 0;
201 }
202 return window->SetActiveWindow();
203}
204//******************************************************************************
205//******************************************************************************
206HWND WIN32API GetParent( HWND hwnd)
207{
208 Win32Window *window;
209
210 window = Win32Window::GetWindowFromHandle(hwnd);
211 if(!window) {
212 dprintf(("SendMessageA, window %x not found", hwnd));
213 return 0;
214 }
215 return window->GetParent();
216}
217//******************************************************************************
218//******************************************************************************
219HWND WIN32API SetParent( HWND hwndChild, HWND hwndNewParent)
220{
221 Win32Window *window;
222
223 window = Win32Window::GetWindowFromHandle(hwndChild);
224 if(!window) {
225 dprintf(("SendMessageA, window %x not found", hwndChild));
226 return 0;
227 }
228 return window->SetParent(hwndNewParent);
229}
230//******************************************************************************
231//******************************************************************************
232BOOL WIN32API IsChild( HWND hwndParent, HWND hwnd)
233{
234 Win32Window *window;
235
236 window = Win32Window::GetWindowFromHandle(hwnd);
237 if(!window) {
238 dprintf(("SendMessageA, window %x not found", hwnd));
239 return 0;
240 }
241 return window->IsChild(hwndParent);
242}
243//******************************************************************************
244//******************************************************************************
245HWND WIN32API GetTopWindow( HWND hwnd)
246{
247 Win32Window *window;
248
249 window = Win32Window::GetWindowFromHandle(hwnd);
250 if(!window) {
251 dprintf(("SendMessageA, window %x not found", hwnd));
252 return 0;
253 }
254 return window->GetTopWindow();
255}
256//******************************************************************************
257//******************************************************************************
258BOOL WIN32API UpdateWindow(HWND hwnd)
259{
260 Win32Window *window;
261
262 window = Win32Window::GetWindowFromHandle(hwnd);
263 if(!window) {
264 dprintf(("SendMessageA, window %x not found", hwnd));
265 return 0;
266 }
267 return window->UpdateWindow();
268}
269//******************************************************************************
270//******************************************************************************
271BOOL WIN32API IsIconic( HWND hwnd)
272{
273 Win32Window *window;
274
275 window = Win32Window::GetWindowFromHandle(hwnd);
276 if(!window) {
277 dprintf(("SendMessageA, window %x not found", hwnd));
278 return 0;
279 }
280 return window->IsIconic();
281}
282//******************************************************************************
283//******************************************************************************
284HWND WIN32API GetWindow(HWND arg1, UINT arg2)
285{
286 HWND rc;
287
288 rc = O32_GetWindow(arg1, arg2);
289#ifdef DEBUG
290 WriteLog("USER32: GetWindow %X %d returned %d\n", arg1, arg2, rc);
291#endif
292 return(rc);
293}
294//******************************************************************************
295//******************************************************************************
296HDC WIN32API GetWindowDC(HWND arg1)
297{
298#ifdef DEBUG
299 WriteLog("USER32: GetWindowDC\n");
300#endif
301 return O32_GetWindowDC(arg1);
302}
303//******************************************************************************
304//******************************************************************************
305BOOL WIN32API EnableWindow( HWND arg1, BOOL arg2)
306{
307#ifdef DEBUG
308 WriteLog("USER32: EnableWindow\n");
309#endif
310 return O32_EnableWindow(arg1, arg2);
311}
312//******************************************************************************
313//******************************************************************************
314BOOL WIN32API BringWindowToTop( HWND arg1)
315{
316#ifdef DEBUG
317 WriteLog("USER32: BringWindowToTop\n");
318#endif
319 return O32_BringWindowToTop(arg1);
320}
321//******************************************************************************
322//******************************************************************************
323HWND WIN32API GetActiveWindow()
324{
325 return(O32_GetActiveWindow());
326}
327//******************************************************************************
328//******************************************************************************
329BOOL WIN32API ShowWindow(HWND arg1, int arg2)
330{
331#ifdef DEBUG
332 WriteLog("USER32: ShowWindow %X %d\n", arg1, arg2);
333#endif
334 return O32_ShowWindow(arg1, arg2);
335}
336//******************************************************************************
337//******************************************************************************
338BOOL WIN32API SetWindowPos( HWND arg1, HWND arg2, int arg3, int arg4, int arg5, int arg6, UINT arg7)
339{
340#ifdef DEBUG
341 WriteLog("USER32: SetWindowPos\n");
342#endif
343 return O32_SetWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
344}
345/***********************************************************************
346 * GetInternalWindowPos (USER32.245)
347 */
348UINT WIN32API GetInternalWindowPos(HWND hwnd,
349 LPRECT rectWnd,
350 LPPOINT ptIcon )
351{
352 WINDOWPLACEMENT wndpl;
353
354 dprintf(("USER32: GetInternalWindowPos(%08xh,%08xh,%08xh)\n",
355 hwnd,
356 rectWnd,
357 ptIcon));
358
359 if (O32_GetWindowPlacement( hwnd, &wndpl ))
360 {
361 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
362 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
363 return wndpl.showCmd;
364 }
365 return 0;
366}
367//******************************************************************************
368//******************************************************************************
369BOOL WIN32API IsWindow( HWND arg1)
370{
371#ifdef DEBUG
372 WriteLog("USER32: IsWindow\n");
373#endif
374 return O32_IsWindow(arg1);
375}
376//******************************************************************************
377//******************************************************************************
378BOOL WIN32API IsWindowEnabled( HWND arg1)
379{
380#ifdef DEBUG
381 WriteLog("USER32: IsWindowEnabled\n");
382#endif
383 return O32_IsWindowEnabled(arg1);
384}
385//******************************************************************************
386//******************************************************************************
387BOOL WIN32API IsWindowVisible( HWND arg1)
388{
389#ifdef DEBUG
390 WriteLog("USER32: IsWindowVisible\n");
391#endif
392 return O32_IsWindowVisible(arg1);
393}
394//******************************************************************************
395//******************************************************************************
396BOOL WIN32API IsZoomed( HWND arg1)
397{
398#ifdef DEBUG
399 WriteLog("USER32: IsZoomed\n");
400#endif
401 return O32_IsZoomed(arg1);
402}
403//******************************************************************************
404//******************************************************************************
405BOOL WIN32API LockWindowUpdate( HWND arg1)
406{
407#ifdef DEBUG
408 WriteLog("USER32: LockWindowUpdate\n");
409#endif
410 return O32_LockWindowUpdate(arg1);
411}
412//******************************************************************************
413//******************************************************************************
414BOOL WIN32API RedrawWindow( HWND arg1, const RECT * arg2, HRGN arg3, UINT arg4)
415{
416 BOOL rc;
417
418 rc = O32_RedrawWindow(arg1, arg2, arg3, arg4);
419#ifdef DEBUG
420 WriteLog("USER32: RedrawWindow %X , %X, %X, %X returned %d\n", arg1, arg2, arg3, arg4, rc);
421#endif
422 InvalidateRect(arg1, arg2, TRUE);
423 UpdateWindow(arg1);
424 SendMessageA(arg1, WM_PAINT, 0, 0);
425 return(rc);
426}
427//******************************************************************************
428//******************************************************************************
429BOOL WIN32API GetWindowRect( HWND arg1, PRECT arg2)
430{
431 BOOL rc;
432
433 rc = O32_GetWindowRect(arg1, arg2);
434 dprintf(("USER32: GetWindowRect %X returned %d\n", arg1, rc));
435 return(rc);
436}
437//******************************************************************************
438//******************************************************************************
439BOOL WIN32API SetWindowTextA(HWND arg1, LPCSTR arg2)
440{
441#ifdef DEBUG
442 WriteLog("USER32: SetWindowText %s\n", arg2);
443#endif
444 return O32_SetWindowText(arg1, arg2);
445}
446//******************************************************************************
447//******************************************************************************
448BOOL WIN32API SetWindowTextW( HWND arg1, LPCWSTR arg2)
449{
450 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
451 BOOL rc;
452
453 rc = SetWindowTextA(arg1, (LPCSTR)astring);
454 dprintf(("USER32: SetWindowTextW %X %s returned %d\n", arg1, astring, rc));
455 FreeAsciiString(astring);
456 return(rc);
457}
458//******************************************************************************
459//******************************************************************************
460BOOL WIN32API SetForegroundWindow(HWND arg1)
461{
462#ifdef DEBUG
463 WriteLog("USER32: SetForegroundWindow\n");
464#endif
465 return O32_SetForegroundWindow(arg1);
466}
467//******************************************************************************
468//******************************************************************************
469BOOL WIN32API GetClientRect( HWND arg1, PRECT arg2)
470{
471#ifdef DEBUG
472 WriteLog("USER32: GetClientRect of %X\n", arg1);
473#endif
474
475 return O32_GetClientRect(arg1, arg2);
476}
477//******************************************************************************
478//******************************************************************************
479HWND WIN32API FindWindowA(LPCSTR arg1, LPCSTR arg2)
480{
481#ifdef DEBUG
482 WriteLog("USER32: FindWindow\n");
483#endif
484 return O32_FindWindow(arg1, arg2);
485}
486//******************************************************************************
487//******************************************************************************
488HWND WIN32API FindWindowExA(HWND arg1, HWND arg2, LPCSTR arg3, LPCSTR arg4)
489{
490#ifdef DEBUG
491 WriteLog("USER32: FindWindowExA, not completely implemented\n");
492#endif
493 return O32_FindWindow(arg3, arg4);
494}
495//******************************************************************************
496//******************************************************************************
497BOOL WIN32API FlashWindow( HWND arg1, BOOL arg2)
498{
499#ifdef DEBUG
500 WriteLog("USER32: FlashWindow\n");
501#endif
502 return O32_FlashWindow(arg1, arg2);
503}
504//******************************************************************************
505//******************************************************************************
506BOOL WIN32API MoveWindow(HWND arg1, int arg2, int arg3, int arg4, int arg5, BOOL arg6)
507{
508 BOOL rc;
509
510 rc = O32_MoveWindow(arg1, arg2, arg3, arg4, arg5, arg6);
511 dprintf(("USER32: MoveWindow %X to (%d,%d) size (%d,%d), repaint = %d returned %d\n", arg1, arg2, arg3, arg4, arg5, arg6, rc));
512 return(rc);
513}
514//******************************************************************************
515//******************************************************************************
516BOOL WIN32API AdjustWindowRect( PRECT arg1, DWORD arg2, BOOL arg3)
517{
518#ifdef DEBUG
519 WriteLog("USER32: AdjustWindowRect\n");
520#endif
521 return O32_AdjustWindowRect(arg1, arg2, arg3);
522}
523//******************************************************************************
524//******************************************************************************
525BOOL WIN32API AdjustWindowRectEx( PRECT arg1, DWORD arg2, BOOL arg3, DWORD arg4)
526{
527#ifdef DEBUG
528 WriteLog("USER32: AdjustWindowRectEx\n");
529#endif
530 return O32_AdjustWindowRectEx(arg1, arg2, arg3, arg4);
531}
532//******************************************************************************
533//******************************************************************************
534BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
535{
536#ifdef DEBUG
537//// WriteLog("USER32: ClientToScreen\n");
538#endif
539 return O32_ClientToScreen(arg1, arg2);
540}
541//******************************************************************************
542//******************************************************************************
543HDWP WIN32API BeginDeferWindowPos( int arg1)
544{
545#ifdef DEBUG
546 WriteLog("USER32: BeginDeferWindowPos\n");
547#endif
548 return O32_BeginDeferWindowPos(arg1);
549}
550//******************************************************************************
551//******************************************************************************
552HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
553{
554#ifdef DEBUG
555 WriteLog("USER32: DeferWindowPos\n");
556#endif
557 return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
558}
559//******************************************************************************
560//******************************************************************************
561HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
562{
563#ifdef DEBUG
564 WriteLog("USER32: ChildWindowFromPoint\n");
565#endif
566 return O32_ChildWindowFromPoint(arg1, arg2);
567}
568//******************************************************************************
569//******************************************************************************
570HWND WIN32API ChildWindowFromPointEx(HWND arg1, POINT arg2, UINT uFlags)
571{
572#ifdef DEBUG
573 WriteLog("USER32: ChildWindowFromPointEx, not completely supported!\n");
574#endif
575 return O32_ChildWindowFromPoint(arg1, arg2);
576}
577//******************************************************************************
578//******************************************************************************
579BOOL WIN32API CloseWindow( HWND arg1)
580{
581#ifdef DEBUG
582 WriteLog("USER32: CloseWindow\n");
583#endif
584 return O32_CloseWindow(arg1);
585}
586//******************************************************************************
587//******************************************************************************
588HWND WIN32API WindowFromDC( HDC arg1)
589{
590#ifdef DEBUG
591 WriteLog("USER32: WindowFromDC\n");
592#endif
593 return O32_WindowFromDC(arg1);
594}
595//******************************************************************************
596//******************************************************************************
597HWND WIN32API WindowFromPoint( POINT arg1)
598{
599#ifdef DEBUG
600 WriteLog("USER32: WindowFromPoint\n");
601#endif
602 return O32_WindowFromPoint(arg1);
603}
604//******************************************************************************
605//******************************************************************************
606BOOL WIN32API IsWindowUnicode(HWND hwnd)
607{
608#ifdef DEBUG
609 WriteLog("USER32: IsWindowUnicode, not implemented\n");
610#endif
611 return(FALSE);
612}
613/*****************************************************************************
614 * Name : WORD WIN32API CascadeWindows
615 * Purpose : The CascadeWindows function cascades the specified windows or
616 * the child windows of the specified parent window.
617 * Parameters: HWND hwndParent handle of parent window
618 * UINT wHow types of windows not to arrange
619 * CONST RECT * lpRect rectangle to arrange windows in
620 * UINT cKids number of windows to arrange
621 * const HWND FAR * lpKids array of window handles
622 * Variables :
623 * Result : If the function succeeds, the return value is the number of windows arranged.
624 * If the function fails, the return value is zero.
625 * Remark :
626 * Status : UNTESTED STUB
627 *
628 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
629 *****************************************************************************/
630
631WORD WIN32API CascadeWindows(HWND hwndParent,
632 UINT wHow,
633 CONST LPRECT lpRect,
634 UINT cKids,
635 const HWND *lpKids)
636{
637 dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
638 hwndParent,
639 wHow,
640 lpRect,
641 cKids,
642 lpKids));
643
644 return (0);
645}
646/*****************************************************************************
647 * Name : HWND WIN32API FindWindowExW
648 * Purpose : The FindWindowEx function retrieves the handle of a window whose
649 * class name and window name match the specified strings. The
650 * function searches child windows, beginning with the one following
651 * the given child window.
652 * Parameters: HWND hwndParent handle of parent window
653 * HWND hwndChildAfter handle of a child window
654 * LPCTSTR lpszClass address of class name
655 * LPCTSTR lpszWindow address of window name
656 * Variables :
657 * Result : If the function succeeds, the return value is the handle of the
658 * window that has the specified class and window names.
659 * If the function fails, the return value is NULL. To get extended
660 * error information, call GetLastError.
661 * Remark :
662 * Status : UNTESTED STUB
663 *
664 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
665 *****************************************************************************/
666
667HWND WIN32API FindWindowExW(HWND hwndParent,
668 HWND hwndChildAfter,
669 LPCWSTR lpszClass,
670 LPCWSTR lpszWindow)
671{
672 dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
673 hwndParent,
674 hwndChildAfter,
675 lpszClass,
676 lpszWindow));
677
678 return (NULL);
679}
680/*****************************************************************************
681 * Name : BOOL WIN32API SwitchToThisWindow
682 * Purpose : Unknown
683 * Parameters: Unknown
684 * Variables :
685 * Result :
686 * Remark :
687 * Status : UNTESTED UNKNOWN STUB
688 *
689 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
690 *****************************************************************************/
691
692BOOL WIN32API SwitchToThisWindow(HWND hwnd,
693 BOOL x2)
694{
695 dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
696 hwnd,
697 x2));
698
699 return (FALSE); /* default */
700}
701//******************************************************************************
702//******************************************************************************
Note: See TracBrowser for help on using the repository browser.