source: trunk/src/user32/win32wbase.cpp@ 9635

Last change on this file since 9635 was 9635, checked in by sandervl, 23 years ago

Invalidate window when it's resized and SWP_NOCOPYBITS is specified (update).
File size: 144.1 KB
Line 
1/* $Id: win32wbase.cpp,v 1.352 2003-01-06 15:38:17 sandervl Exp $ */
2/*
3 * Win32 Window Base Class for OS/2
4 *
5 * Copyright 1998-2002 Sander van Leeuwen (sandervl@xs4all.nl)
6 * Copyright 1999 Daniela Engert (dani@ngrt.de)
7 * Copyright 1999-2000 Christoph Bratschi (cbratschi@datacomm.ch)
8 *
9 * Parts based on Wine Windows code (windows\win.c)
10 * Corel version: corel20000212
11 *
12 * Copyright 1993, 1994, 1996 Alexandre Julliard
13 * 1995 Alex Korobka
14 *
15 * TODO: Not thread/process safe
16 *
17 * NOTE: To access a window object, you must call GetWindowFromOS2Handle or
18 * GetWindowFromHandle. Both these methods increase the reference count
19 * of the object. When you're done with the object, you MUST call
20 * the release method!
21 * This mechanism prevents premature destruction of objects when there
22 * are still clients using it.
23 *
24 * NOTE: Client rectangle always relative to frame window
25 * Window rectangle in parent coordinates (relative to parent's client window)
26 * (screen coord. if no parent)
27 *
28 * NOTE: Status of window:
29 * Before a window has processed WM_NCCREATE:
30 * - GetTopWindow can't return that window handle
31 * - GetWindow(parent, GW_CHILD) can't return that window handle
32 * - IsChild works
33 * TODO: Does this affect more functions?? (other GetWindow ops)
34 * (verified in NT4, SP6)
35 *
36 * Project Odin Software License can be found in LICENSE.TXT
37 *
38 */
39#include <os2win.h>
40#include <win.h>
41#include <stdlib.h>
42#include <string.h>
43#include <stdarg.h>
44#include <assert.h>
45#include <misc.h>
46#include <heapstring.h>
47#include <winuser32.h>
48#include <custombuild.h>
49#include "win32wbase.h"
50#include "wndmsg.h"
51#include "oslibwin.h"
52#include "oslibmsg.h"
53#include "oslibutil.h"
54#include "oslibgdi.h"
55#include "oslibres.h"
56#include "oslibdos.h"
57#include "syscolor.h"
58#include "win32wndhandle.h"
59#include "dc.h"
60#include "win32wdesktop.h"
61#include "pmwindow.h"
62#include "controls.h"
63#include <wprocess.h>
64#include <win\hook.h>
65#include <menu.h>
66#define INCL_TIMERWIN32
67#include "timer.h"
68#include "user32api.h"
69
70#define DBG_LOCALLOG DBG_win32wbase
71#include "dbglocal.h"
72
73/* bits in the dwKeyData */
74#define KEYDATA_ALT 0x2000
75#define KEYDATA_PREVSTATE 0x4000
76
77void PrintWindowStyle(DWORD dwStyle, DWORD dwExStyle);
78
79static fDestroyAll = FALSE;
80//For quick lookup of current process id
81static ULONG currentProcessId = -1;
82static int iF10Key = 0;
83static int iMenuSysKey = 0;
84
85//******************************************************************************
86//******************************************************************************
87Win32BaseWindow::Win32BaseWindow()
88 : GenericObject(&windows, &critsect), ChildWindow(&critsect)
89{
90 Init();
91}
92//******************************************************************************
93//******************************************************************************
94Win32BaseWindow::Win32BaseWindow(HWND hwndOS2, ATOM classAtom)
95 : GenericObject(&windows, &critsect), ChildWindow(&critsect)
96{
97 Init();
98 OS2Hwnd = OS2HwndFrame = hwndOS2;
99
100 /* Find the window class */
101 windowClass = Win32WndClass::FindClass(NULL, (LPSTR)classAtom);
102 if (!windowClass)
103 {
104 char buffer[32];
105 GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) );
106 dprintf(("Bad class '%s'", buffer ));
107 DebugInt3();
108 }
109
110 //Allocate window words
111 nrUserWindowBytes = windowClass->getExtraWndBytes();
112 if(nrUserWindowBytes) {
113 userWindowBytes = (char *)_smalloc(nrUserWindowBytes);
114 memset(userWindowBytes, 0, nrUserWindowBytes);
115 }
116
117 WINPROC_SetProc((HWINDOWPROC *)&win32wndproc, windowClass->getWindowProc((isUnicode) ? WNDPROC_UNICODE : WNDPROC_ASCII), WINPROC_GetProcType(windowClass->getWindowProc((isUnicode) ? WNDPROC_UNICODE : WNDPROC_ASCII)), WIN_PROC_WINDOW);
118 hInstance = NULL;
119 dwStyle = WS_VISIBLE;
120 dwOldStyle = dwStyle;
121 dwExStyle = 0;
122
123 //We pretend this window has no parent and won't change size
124 //(dangerous assumption!!)
125 OSLibWinQueryWindowClientRect(OS2Hwnd, &rectClient);
126 OSLibQueryWindowRectAbsolute (OS2Hwnd, &rectWindow);
127
128 fFakeWindow = TRUE;
129}
130//******************************************************************************
131//******************************************************************************
132Win32BaseWindow::Win32BaseWindow(CREATESTRUCTA *lpCreateStructA, ATOM classAtom, BOOL isUnicode)
133 : GenericObject(&windows, &critsect), ChildWindow(&critsect)
134{
135 Init();
136 this->isUnicode = isUnicode;
137 // call member function
138 CreateWindowExA(lpCreateStructA, classAtom);
139}
140//******************************************************************************
141//******************************************************************************
142void Win32BaseWindow::Init()
143{
144 isUnicode = FALSE;
145 fFirstShow = TRUE;
146 fIsDialog = FALSE;
147 fIsModalDialogOwner = FALSE;
148 OS2HwndModalDialog = 0;
149 fParentChange = FALSE;
150 fDestroyWindowCalled = FALSE;
151 fChildDestructionInProgress = FALSE;
152 fTaskList = FALSE;
153 fParentDC = FALSE;
154 fComingToTop = FALSE;
155 fMinMaxChange = FALSE;
156 fVisibleRegionChanged = FALSE;
157 fEraseBkgndFlag = TRUE;
158 fFakeWindow = FALSE;
159 fIsDragDropActive= FALSE;
160
161 state = STATE_INIT;
162 windowNameA = NULL;
163 windowNameW = NULL;
164 windowNameLength = 0;
165
166 userWindowBytes = NULL;;
167 nrUserWindowBytes= 0;
168
169 OS2Hwnd = 0;
170 OS2HwndFrame = 0;
171 hSysMenu = 0;
172 Win32Hwnd = 0;
173
174 // allocate a Win32 HWND, return it in Win32Hwnd and associate object
175 // pointer with it
176 if(HwAllocateWindowHandle(&Win32Hwnd, (ULONG)this) == FALSE)
177 {
178 dprintf(("Win32BaseWindow::Init HwAllocateWindowHandle failed!!"));
179 DebugInt3();
180 }
181
182 posx = posy = 0;
183 width = height = 0;
184
185 dwExStyle = 0;
186 dwStyle = 0;
187 dwOldStyle = 0;
188 win32wndproc = 0;
189 hInstance = 0;
190 dwIDMenu = 0; //0xFFFFFFFF; //default -1
191 userData = 0;
192 contextHelpId = 0;
193 hotkey = 0;
194
195 hwndLinkAfter = HWND_BOTTOM;
196 flags = 0;
197 lastHitTestVal = HTCLIENT;
198 owner = NULL;
199 windowClass = 0;
200
201 hIcon = 0;
202 hIconSm = 0;
203
204 horzScrollInfo = NULL;
205 vertScrollInfo = NULL;
206
207 propertyList = NULL;
208
209 cbExtra = 0;
210 pExtra = NULL;
211
212 ownDC = 0;
213 hWindowRegion = 0;
214 hClipRegion = 0;
215
216 hTaskList = 0;
217
218 if(currentProcessId == -1)
219 {
220 currentProcessId = GetCurrentProcessId();
221 }
222 dwThreadId = GetCurrentThreadId();
223 dwProcessId = currentProcessId;
224
225 memset(&windowpos, 0, sizeof(windowpos));
226 //min and max position are initially -1 (verified in NT4, SP6)
227 windowpos.ptMinPosition.x = -1;
228 windowpos.ptMinPosition.y = -1;
229 windowpos.ptMaxPosition.x = -1;
230 windowpos.ptMaxPosition.y = -1;
231
232 lpVisRgnNotifyProc = NULL;
233 dwVisRgnNotifyParam = NULL;
234}
235//******************************************************************************
236//todo get rid of resources (menu, icon etc)
237//******************************************************************************
238Win32BaseWindow::~Win32BaseWindow()
239{
240 if(getRefCount() < 0) {
241 DebugInt3();
242 }
243
244 if(hTaskList) {
245 OSLibWinRemoveFromTasklist(hTaskList);
246 }
247
248 OSLibWinSetVisibleRegionNotify(OS2Hwnd, FALSE);
249 OSLibWinSetWindowULong(OS2Hwnd, OFFSET_WIN32WNDPTR, 0);
250 OSLibWinSetWindowULong(OS2Hwnd, OFFSET_WIN32PM_MAGIC, 0);
251
252 if(fDestroyAll) {
253 dprintf(("Destroying window %x %s", getWindowHandle(), windowNameA));
254 setParent(NULL); //or else we'll crash in the dtor of the ChildWindow class
255 }
256 else
257 if(getParent() && getParent()->getFirstChild() == this && getNextChild() == NULL)
258 {
259 //if we're the last child that's being destroyed and our
260 //parent window was also destroyed, then we
261 if(getParent()->IsWindowDestroyed())
262 {
263 Win32BaseWindow *wndparent = (Win32BaseWindow *)ChildWindow::getParentOfChild();
264 RELEASE_WNDOBJ(wndparent);
265 setParent(NULL); //or else we'll crash in the dtor of the ChildWindow class
266 }
267 }
268 else
269 {
270 Win32BaseWindow *wndparent = (Win32BaseWindow *)ChildWindow::getParentOfChild();
271 if(wndparent && !fDestroyAll) {
272 RELEASE_WNDOBJ(wndparent);
273 }
274 }
275 if(owner && !fDestroyAll) {
276 RELEASE_WNDOBJ(owner);
277 }
278
279 /* Decrement class window counter */
280 if(windowClass) {
281 RELEASE_CLASSOBJ(windowClass);
282 }
283
284 if(isOwnDC())
285 releaseOwnDC(ownDC);
286
287 if(Win32Hwnd)
288 HwFreeWindowHandle(Win32Hwnd);
289
290 if(userWindowBytes)
291 free(userWindowBytes);
292
293 if(windowNameA) {
294 free(windowNameA);
295 windowNameA = NULL;
296 }
297 if(windowNameW) {
298 free(windowNameW);
299 windowNameW = NULL;
300 }
301 if(vertScrollInfo) {
302 free(vertScrollInfo);
303 vertScrollInfo = NULL;
304 }
305 if(horzScrollInfo) {
306 free(horzScrollInfo);
307 horzScrollInfo = NULL;
308 }
309 if(propertyList) {
310 removeWindowProps();
311 }
312}
313//******************************************************************************
314//******************************************************************************
315void Win32BaseWindow::DestroyAll()
316{
317 fDestroyAll = TRUE;
318 GenericObject::DestroyAll(windows);
319}
320//******************************************************************************
321//******************************************************************************
322BOOL Win32BaseWindow::isChild()
323{
324 return ((dwStyle & WS_CHILD) != 0);
325}
326//******************************************************************************
327//******************************************************************************
328BOOL Win32BaseWindow::IsWindowUnicode()
329{
330 dprintf2(("IsWindowUnicode %x %d", getWindowHandle(), WINPROC_GetProcType(getWindowProc()) == WIN_PROC_32W));
331 return (WINPROC_GetProcType(getWindowProc()) == WIN_PROC_32W);
332}
333//******************************************************************************
334//******************************************************************************
335BOOL Win32BaseWindow::CreateWindowExA(CREATESTRUCTA *cs, ATOM classAtom)
336{
337 char buffer[256];
338
339#ifdef DEBUG
340 PrintWindowStyle(cs->style, cs->dwExStyle);
341#endif
342
343 //If window has no owner/parent window, then it will be added to the tasklist
344 //(depending on visibility state)
345 if (!cs->hwndParent) fTaskList = TRUE;
346
347 sw = SW_SHOW;
348 SetLastError(0);
349
350 /* Find the parent window */
351 if (cs->hwndParent)
352 {
353 Win32BaseWindow *window = GetWindowFromHandle(cs->hwndParent);
354 if(!window) {
355 dprintf(("Bad parent %04x\n", cs->hwndParent ));
356 SetLastError(ERROR_INVALID_PARAMETER);
357 return FALSE;
358 }
359 /* Make sure parent is valid */
360 if (!window->IsWindow() )
361 {
362 RELEASE_WNDOBJ(window);
363 dprintf(("Bad parent %04x\n", cs->hwndParent ));
364 SetLastError(ERROR_INVALID_PARAMETER);
365 return FALSE;
366 }
367 if (window->getExStyle() & WS_EX_TOPMOST)
368 cs->dwExStyle |= WS_EX_TOPMOST;
369
370 RELEASE_WNDOBJ(window);
371 /* Windows does this for overlapped windows
372 * (I don't know about other styles.) */
373 if (cs->hwndParent == GetDesktopWindow() && (!(cs->style & WS_CHILD) || (cs->style & WS_POPUP)))
374 {
375 cs->hwndParent = 0;
376 }
377 }
378 else
379 if ((cs->style & WS_CHILD) && !(cs->style & WS_POPUP)) {
380 dprintf(("No parent for child window" ));
381 SetLastError(ERROR_INVALID_PARAMETER);
382 return FALSE; /* WS_CHILD needs a parent, but WS_POPUP doesn't */
383 }
384
385 /* Find the window class */
386 windowClass = Win32WndClass::FindClass(cs->hInstance, (LPSTR)classAtom);
387 if (!windowClass)
388 {
389 GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) );
390 dprintf(("Bad class '%s'", buffer ));
391 SetLastError(ERROR_INVALID_PARAMETER);
392 return 0;
393 }
394
395#ifdef DEBUG
396 if(HIWORD(cs->lpszClass))
397 {
398 if(isUnicode) dprintf(("Window class %ls", cs->lpszClass));
399 else dprintf(("Window class %s", cs->lpszClass));
400 }
401 else dprintf(("Window class %x", cs->lpszClass));
402#endif
403
404 /* Fix the lpszClass field: from existing programs, it seems ok to call a CreateWindowXXX
405 * with an atom as the class name, put some programs expect to have a *REAL* string in
406 * lpszClass when the CREATESTRUCT is sent with WM_CREATE
407 */
408 if (!HIWORD(cs->lpszClass) ) {
409 if (isUnicode) {
410 GlobalGetAtomNameW( classAtom, (LPWSTR)buffer, sizeof(buffer) );
411 }
412 else {
413 GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) );
414 }
415 cs->lpszClass = buffer;
416 }
417
418 /* Fix the coordinates */
419 fXDefault = FALSE;
420 fCXDefault = FALSE;
421 if ((cs->x == CW_USEDEFAULT) || (cs->x == CW_USEDEFAULT16))
422 {
423 /* Never believe Microsoft's documentation... CreateWindowEx doc says
424 * that if an overlapped window is created with WS_VISIBLE style bit
425 * set and the x parameter is set to CW_USEDEFAULT, the system ignores
426 * the y parameter. However, looking at NT reveals that
427 *
428 * 1) not only if checks for CW_USEDEFAULT but also for CW_USEDEFAULT16
429 * 2) it does not ignore the y parameter as the docs claim; instead, it
430 * uses it as second parameter to ShowWindow() unless y is either
431 * CW_USEDEFAULT or CW_USEDEFAULT16.
432 *
433 * The fact that we didn't do 2) caused bogus windows pop up when wine
434 * was running apps that were using this obscure feature. Example -
435 * calc.exe that comes with Win98 (only Win98, it's different from
436 * the one that comes with Win95 and NT)
437 */
438 if ((cs->y != CW_USEDEFAULT) && (cs->y != CW_USEDEFAULT16)) sw = cs->y;
439
440 /* We have saved cs->y, now we can trash it */
441 cs->x = 0;
442 cs->y = 0;
443 fXDefault = TRUE;
444 }
445 if ((cs->cx == CW_USEDEFAULT) || (cs->cx == CW_USEDEFAULT16))
446 {
447 cs->cx = 600; /* FIXME */
448 cs->cy = 400;
449 fCXDefault = TRUE;
450 }
451 if (cs->style & (WS_POPUP | WS_CHILD))
452 {
453 fXDefault = FALSE;
454 if (fCXDefault)
455 {
456 fCXDefault = FALSE;
457 cs->cx = cs->cy = 0;
458 }
459 }
460 if (fXDefault && !fCXDefault) fXDefault = FALSE; //CB: only x positioning doesn't work (calc.exe,cdrlabel.exe)
461
462
463 /* Correct the window style - stage 1
464 *
465 * These are patches that appear to affect both the style loaded into the
466 * WIN structure and passed in the CreateStruct to the WM_CREATE etc.
467 *
468 * WS_EX_WINDOWEDGE appears to be enforced based on the other styles, so
469 * why does the user get to set it?
470 */
471
472 /* This has been tested for WS_CHILD | WS_VISIBLE. It has not been
473 * tested for WS_POPUP
474 */
475 if ((cs->dwExStyle & WS_EX_DLGMODALFRAME) ||
476 ((!(cs->dwExStyle & WS_EX_STATICEDGE)) &&
477 (cs->style & (WS_DLGFRAME | WS_THICKFRAME))))
478 cs->dwExStyle |= WS_EX_WINDOWEDGE;
479 else
480 cs->dwExStyle &= ~WS_EX_WINDOWEDGE;
481
482 //Allocate window words
483 nrUserWindowBytes = windowClass->getExtraWndBytes();
484 if(nrUserWindowBytes) {
485 userWindowBytes = (char *)_smalloc(nrUserWindowBytes);
486 memset(userWindowBytes, 0, nrUserWindowBytes);
487 }
488
489 // check if it's the standard child window case
490 if ((cs->style & WS_CHILD) && cs->hwndParent)
491 {
492 SetParent(cs->hwndParent);
493 owner = NULL;
494 //SvL: Shell positioning shouldn't be done for child windows! (breaks Notes)
495 fXDefault = fCXDefault = FALSE;
496 }
497 else
498 {
499 // either no child window or a popup window
500
501 SetParent(0);
502 if (!cs->hwndParent || (cs->hwndParent == windowDesktop->getWindowHandle())) {
503 owner = NULL;
504 }
505 else
506 {
507 // we're a popup window
508
509 Win32BaseWindow *wndparent = GetWindowFromHandle(cs->hwndParent);
510 if(wndparent) {
511 owner = GetWindowFromHandle(wndparent->GetTopParent());
512 RELEASE_WNDOBJ(wndparent);
513 }
514 else owner = NULL;
515
516 if(owner == NULL)
517 {
518 dprintf(("HwGetWindowHandleData couldn't find owner window %x!!!", cs->hwndParent));
519 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
520 return FALSE;
521 }
522 }
523 }
524
525 WINPROC_SetProc((HWINDOWPROC *)&win32wndproc, windowClass->getWindowProc((isUnicode) ? WNDPROC_UNICODE : WNDPROC_ASCII), WINPROC_GetProcType(windowClass->getWindowProc((isUnicode) ? WNDPROC_UNICODE : WNDPROC_ASCII)), WIN_PROC_WINDOW);
526 hInstance = cs->hInstance;
527 dwStyle = cs->style & ~WS_VISIBLE;
528 dwOldStyle = dwStyle;
529 dwExStyle = cs->dwExStyle;
530
531 hwndLinkAfter = ((cs->style & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD) ? HWND_BOTTOM : HWND_TOP;
532
533 /* Correct the window style phase 2 */
534 if (!(cs->style & WS_CHILD))
535 {
536 dwStyle |= WS_CLIPSIBLINGS;
537 if (!(cs->style & WS_POPUP))
538 {
539 dwStyle |= WS_CAPTION;
540 flags |= WIN_NEED_SIZE;
541 }
542 }
543 if (cs->dwExStyle & WS_EX_DLGMODALFRAME) dwStyle &= ~WS_THICKFRAME;
544
545 //WinZip 8.0 crashes when a dialog created after opening a zipfile receives
546 //the WM_SIZE message (before WM_INITDIALOG)
547 //Opera doesn't like this either.
548 if(IsDialog()) {
549 flags |= WIN_NEED_SIZE;
550 }
551
552 //copy pointer of CREATESTRUCT for usage in MsgCreate method
553 tmpcs = cs;
554
555 //Store our window object pointer in thread local memory, so PMWINDOW.CPP can retrieve it
556 TEB *teb = GetThreadTEB();
557 if(teb == NULL) {
558 dprintf(("Window creation failed - teb == NULL")); //this is VERY bad
559 ExitProcess(666);
560 return FALSE;
561 }
562 teb->o.odin.newWindow = (ULONG)this;
563
564 DWORD dwOSWinStyle, dwOSFrameStyle;
565 OSLibWinConvertStyle(dwStyle,dwExStyle,&dwOSWinStyle, &dwOSFrameStyle);
566
567 // create PM windows - frame and client window
568 HWND hwndOS2Frame = (getParent()) ? getParent()->getOS2WindowHandle() : OSLIB_HWND_DESKTOP;
569 OS2Hwnd = OSLibWinCreateWindow(hwndOS2Frame,
570 dwOSWinStyle,
571 dwOSFrameStyle,
572 (char *)windowNameA,
573 (owner) ? owner->getOS2WindowHandle() : hwndOS2Frame,
574 (hwndLinkAfter == HWND_BOTTOM) ? TRUE : FALSE,
575 0,
576 fTaskList,
577 fXDefault | fCXDefault,
578 windowClass->getStyle(),
579 &OS2HwndFrame);
580 if(OS2Hwnd == 0) {
581 dprintf(("Window creation failed!! OS LastError %0x", OSLibWinGetLastError()));
582 SetLastError(ERROR_OUTOFMEMORY); //TODO: Better error
583 return FALSE;
584 }
585 OSLibWinSetVisibleRegionNotify(OS2Hwnd, TRUE);
586 state = STATE_CREATED;
587 SetLastError(0);
588 return TRUE;
589}
590//******************************************************************************
591//******************************************************************************
592BOOL Win32BaseWindow::MsgCreate(HWND hwndOS2)
593{
594 CREATESTRUCTA *cs = tmpcs; //pointer to CREATESTRUCT used in CreateWindowExA method
595 POINT maxSize, maxPos, minTrack, maxTrack;
596 HWND hwnd = getWindowHandle();
597 LRESULT (* CALLBACK localSend32)(HWND, UINT, WPARAM, LPARAM);
598
599 OS2Hwnd = hwndOS2;
600
601 if(OSLibWinSetWindowULong(OS2Hwnd, OFFSET_WIN32WNDPTR, getWindowHandle()) == FALSE) {
602 dprintf(("WM_CREATE: WinSetWindowULong %X failed!!", OS2Hwnd));
603 SetLastError(ERROR_OUTOFMEMORY); //TODO: Better error
604 return FALSE;
605 }
606 if(OSLibWinSetWindowULong(OS2Hwnd, OFFSET_WIN32PM_MAGIC, WIN32PM_MAGIC) == FALSE) {
607 dprintf(("WM_CREATE: WinSetWindowULong2 %X failed!!", OS2Hwnd));
608 SetLastError(ERROR_OUTOFMEMORY); //TODO: Better error
609 return FALSE;
610 }
611 if(OSLibWinSetWindowULong(OS2Hwnd, OFFSET_WIN32FLAGS, 0) == FALSE) {
612 dprintf(("WM_CREATE: WinSetWindowULong2 %X failed!!", OS2Hwnd));
613 SetLastError(ERROR_OUTOFMEMORY); //TODO: Better error
614 return FALSE;
615 }
616
617 if (HOOK_IsHooked( WH_CBT ))
618 {
619 CBT_CREATEWNDA cbtc;
620 LRESULT ret;
621
622 cbtc.lpcs = cs;
623 cbtc.hwndInsertAfter = hwndLinkAfter;
624 ret = (isUnicode) ? HOOK_CallHooksW(WH_CBT, HCBT_CREATEWND, getWindowHandle(), (LPARAM)&cbtc)
625 : HOOK_CallHooksA(WH_CBT, HCBT_CREATEWND, getWindowHandle(), (LPARAM)&cbtc);
626 if(ret)
627 {
628 dprintf(("CBT-hook returned non-0 !!"));
629 SetLastError(ERROR_CAN_NOT_COMPLETE); //todo: wrong error
630 return FALSE;
631 }
632 //todo: if hook changes parent, we need to do so too!!!!!!!!!!
633 }
634
635 if (cs->style & WS_HSCROLL)
636 {
637 horzScrollInfo = (SCROLLBAR_INFO*)malloc(sizeof(SCROLLBAR_INFO));
638 horzScrollInfo->MinVal = horzScrollInfo->CurVal = horzScrollInfo->Page = 0;
639 horzScrollInfo->MaxVal = 100;
640 horzScrollInfo->flags = ESB_ENABLE_BOTH;
641 }
642
643 if (cs->style & WS_VSCROLL)
644 {
645 vertScrollInfo = (SCROLLBAR_INFO*)malloc(sizeof(SCROLLBAR_INFO));
646 vertScrollInfo->MinVal = vertScrollInfo->CurVal = vertScrollInfo->Page = 0;
647 vertScrollInfo->MaxVal = 100;
648 vertScrollInfo->flags = ESB_ENABLE_BOTH;
649 }
650
651 // initially allocate the window name fields
652 if(HIWORD(cs->lpszName))
653 {
654 if (!isUnicode)
655 {
656 windowNameLength = strlen(cs->lpszName);
657 windowNameA = (LPSTR)_smalloc(windowNameLength+1);
658 memcpy(windowNameA,cs->lpszName,windowNameLength+1);
659 windowNameW = (LPWSTR)_smalloc((windowNameLength+1)*sizeof(WCHAR));
660 lstrcpynAtoW(windowNameW,windowNameA,windowNameLength+1);
661 windowNameA[windowNameLength] = 0;
662 windowNameW[windowNameLength] = 0;
663 }
664 else
665 {
666 // Wide
667 windowNameLength = lstrlenW((LPWSTR)cs->lpszName);
668 windowNameW = (LPWSTR)_smalloc( (windowNameLength+1)*sizeof(WCHAR) );
669 memcpy(windowNameW,(LPWSTR)cs->lpszName, (windowNameLength+1)*sizeof(WCHAR) );
670
671 // windowNameW[lstrlenW((LPWSTR)cs->lpszName)] = 0; // need ?
672
673 // Ascii
674 windowNameA = (LPSTR)_smalloc(windowNameLength+1);
675 WideCharToMultiByte(CP_ACP,
676 0,
677 windowNameW,
678 windowNameLength,
679 windowNameA,
680 windowNameLength + 1,
681 0,
682 NULL);
683 windowNameA[windowNameLength] = 0;
684 }
685
686 if(fOS2Look) {
687 OSLibWinSetTitleBarText(OS2HwndFrame, windowNameA);
688 }
689 }
690
691//SvL: This completely messes up MS Word 97 (no button bar, no menu)
692#if 0
693 //adjust CW_USEDEFAULT position
694 if (fXDefault | fCXDefault)
695 {
696 RECT rect;
697
698 //SvL: Returns invalid rectangle (not the expected shell default size)
699 OSLibWinQueryWindowRect(OS2Hwnd,&rect,RELATIVE_TO_SCREEN);
700 if (getParent()) mapWin32Rect(OSLIB_HWND_DESKTOP,getParent()->getOS2WindowHandle(),&rect);
701 if (fXDefault)
702 {
703 cs->x = rect.left;
704 cs->y = rect.top;
705 if (!fCXDefault)
706 {
707 //CB: todo: adjust pos to screen rect
708 }
709 }
710 if (fCXDefault)
711 {
712 cs->cx = rect.right-rect.left;
713 cs->cy = rect.bottom-rect.top;
714 }
715 }
716#endif
717
718 //Set icon from window or class
719 if (hIcon)
720 OSLibWinSetIcon(OS2HwndFrame,hIcon);
721 else
722 if (windowClass->getIcon())
723 OSLibWinSetIcon(OS2HwndFrame,windowClass->getIcon());
724
725 /* Get class or window DC if needed */
726 if(windowClass->getStyle() & CS_OWNDC) {
727 dprintf(("Class with CS_OWNDC style"));
728 ownDC = GetDCEx(getWindowHandle(), NULL, DCX_USESTYLE);
729 }
730 else
731 if (windowClass->getStyle() & CS_PARENTDC) {
732 fParentDC = TRUE;
733 ownDC = 0;
734 }
735 else
736 if (windowClass->getStyle() & CS_CLASSDC) {
737 dprintf(("WARNING: Class with CS_CLASSDC style!"));
738 //not a good solution, but it's a bit difficult to share a single
739 //DC among different windows... DevOpenDC apparently can't be used
740 //for window DCs and WinOpenWindowDC must be associated with a window
741 ownDC = GetDCEx(getWindowHandle(), NULL, DCX_USESTYLE);
742 }
743 /* Set the window menu */
744 if ((dwStyle & (WS_CAPTION | WS_CHILD)) == WS_CAPTION )
745 {
746 if (cs->hMenu) {
747 ::SetMenu(getWindowHandle(), cs->hMenu);
748 }
749 else {
750 if (windowClass->getMenuNameA()) {
751 cs->hMenu = LoadMenuA(windowClass->getInstance(),windowClass->getMenuNameA());
752#if 0 //CB: hack for treeview test cases bug
753if (!cs->hMenu) cs->hMenu = LoadMenuA(windowClass->getInstance(),"MYAPP");
754#endif
755 if (cs->hMenu) ::SetMenu(getWindowHandle(), cs->hMenu );
756 }
757 }
758 }
759 else
760 {
761 setWindowId((DWORD)cs->hMenu);
762 }
763 hSysMenu = (dwStyle & WS_SYSMENU) ? MENU_GetSysMenu(Win32Hwnd,0):0;
764
765 /* Send the WM_GETMINMAXINFO message and fix the size if needed */
766 if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD)))
767 {
768 GetMinMaxInfo(&maxSize, &maxPos, &minTrack, &maxTrack);
769 if (maxSize.x < cs->cx) cs->cx = maxSize.x;
770 if (maxSize.y < cs->cy) cs->cy = maxSize.y;
771 if (cs->cx < minTrack.x) cs->cx = minTrack.x;
772 if (cs->cy < minTrack.y) cs->cy = minTrack.y;
773 if (cs->cx < 0) cs->cx = 0;
774 if (cs->cy < 0) cs->cy = 0;
775 }
776
777 //set client & window rectangles from CreateWindowEx CREATESTRUCT
778 rectWindow.left = cs->x;
779 rectWindow.right = cs->x+cs->cx;
780 rectWindow.top = cs->y;
781 rectWindow.bottom = cs->y+cs->cy;
782 rectClient = rectWindow;
783 OffsetRect(&rectClient, -rectClient.left, -rectClient.top);
784
785 /* Send the WM_CREATE message
786 * Perhaps we shouldn't allow width/height changes as well.
787 * See p327 in "Internals".
788 */
789 maxPos.x = rectWindow.left; maxPos.y = rectWindow.top;
790
791 if(fTaskList) {
792 hTaskList = OSLibWinAddToTaskList(OS2HwndFrame, windowNameA, (cs->style & WS_VISIBLE) ? 1 : 0);
793 }
794
795 localSend32 = (isUnicode) ? ::SendMessageW : ::SendMessageA;
796
797 state = STATE_PRE_WMNCCREATE;
798 if(localSend32(getWindowHandle(), WM_NCCREATE,0,(LPARAM)cs))
799 {
800 RECT tmpRect;
801
802 //CB: recheck flags
803 if (cs->style & (WS_POPUP | WS_CHILD))
804 {
805 fXDefault = FALSE;
806 if (fCXDefault)
807 {
808 fCXDefault = FALSE;
809 cs->cx = cs->cy = 0;
810 rectWindow.right = rectWindow.left;
811 rectWindow.bottom = rectWindow.top;
812 }
813 }
814 tmpRect = rectWindow;
815 state = STATE_POST_WMNCCREATE;
816
817 //set the window size and update the client
818 //@@PF Popup children of inactive windows can thus bring inactive window
819 //on top, this is not correct, popup windows can be on top only if their owner
820 //is in foreground, otherwise they are linked after owner.
821 if (((dwStyle & (WS_CHILD|WS_POPUP)) == WS_POPUP) && getOwner() && (getOwner()->getWindowHandle() != GetForegroundWindow()))
822 {
823 hwndLinkAfter = getOwner()->getWindowHandle();
824 }
825 SetWindowPos(hwndLinkAfter, tmpRect.left, tmpRect.top, tmpRect.right-tmpRect.left, tmpRect.bottom-tmpRect.top,SWP_NOACTIVATE | SWP_NOREDRAW | SWP_FRAMECHANGED);
826
827 state = STATE_PRE_WMCREATE;
828 if (cs->style & WS_VISIBLE) dwStyle |= WS_VISIBLE; //program could change position in WM_CREATE
829 if( (localSend32(getWindowHandle(), WM_CREATE, 0, (LPARAM)cs )) != -1 )
830 {
831 state = STATE_POST_WMCREATE;
832
833 if(!(flags & WIN_NEED_SIZE))
834 {
835 SendMessageA(getWindowHandle(), WM_SIZE, SIZE_RESTORED,
836 MAKELONG(rectClient.right-rectClient.left,
837 rectClient.bottom-rectClient.top));
838
839 if(!::IsWindow(hwnd))
840 {
841 dprintf(("Createwindow: WM_SIZE destroyed window"));
842 goto end;
843 }
844 SendMessageA(getWindowHandle(), WM_MOVE,0,MAKELONG(rectClient.left,rectClient.top));
845 if(!::IsWindow(hwnd))
846 {
847 dprintf(("Createwindow: WM_MOVE destroyed window"));
848 goto end;
849 }
850 }
851
852 if (getStyle() & (WS_MINIMIZE | WS_MAXIMIZE))
853 {
854 RECT newPos;
855 UINT swFlag = (getStyle() & WS_MINIMIZE) ? SW_MINIMIZE : SW_MAXIMIZE;
856 setStyle(getStyle() & ~(WS_MAXIMIZE | WS_MINIMIZE));
857 MinMaximize(swFlag, &newPos);
858 swFlag = ((getStyle() & WS_CHILD) || GetActiveWindow()) ? SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED
859 : SWP_NOZORDER | SWP_FRAMECHANGED;
860 SetWindowPos(0, newPos.left, newPos.top, newPos.right, newPos.bottom, swFlag);
861 if(!::IsWindow(hwnd))
862 {
863 dprintf(("Createwindow: min/max destroyed window"));
864 goto end;
865 }
866 }
867
868 if( (getStyle() & WS_CHILD) && !(getExStyle() & WS_EX_NOPARENTNOTIFY) )
869 {
870 /* Notify the parent window only */
871 if(getParent() && getParent()->IsWindowDestroyed() == FALSE)
872 {
873 SendMessageA(getParent()->getWindowHandle(), WM_PARENTNOTIFY, MAKEWPARAM(WM_CREATE, getWindowId()), (LPARAM)getWindowHandle());
874 }
875 if(!::IsWindow(hwnd))
876 {
877 dprintf(("Createwindow: WM_PARENTNOTIFY destroyed window"));
878 goto end;
879 }
880 }
881
882 if(cs->style & WS_VISIBLE) {
883 dwStyle &= ~WS_VISIBLE;
884 ShowWindow(sw);
885 }
886
887 /* Call WH_SHELL hook */
888 if (!(getStyle() & WS_CHILD) && !owner)
889 HOOK_CallHooksA(WH_SHELL, HSHELL_WINDOWCREATED, getWindowHandle(), 0);
890
891 //Call custom Odin hook for window creation (for all windows)
892 HOOK_CallOdinHookA(HODIN_WINDOWCREATED, hwnd, 0);
893
894 SetLastError(0);
895 return TRUE;
896 }
897 }
898 dprintf(("Window creation FAILED (NCCREATE cancelled creation)"));
899 SetLastError(ERROR_OUTOFMEMORY); //TODO: Better error
900end:
901 return FALSE;
902}
903//******************************************************************************
904//******************************************************************************
905ULONG Win32BaseWindow::MsgQuit()
906{
907 return SendMessageA(getWindowHandle(), WM_QUIT, 0, 0);
908}
909//******************************************************************************
910//******************************************************************************
911ULONG Win32BaseWindow::MsgClose()
912{
913 return SendMessageA(getWindowHandle(), WM_CLOSE,0,0);
914}
915//******************************************************************************
916//******************************************************************************
917ULONG Win32BaseWindow::MsgDestroy()
918{
919 ULONG rc;
920 Win32BaseWindow *child;
921 HWND hwnd = getWindowHandle();
922
923 state = STATE_DESTROYED;
924
925 if(fDestroyWindowCalled == FALSE)
926 {//this window was destroyed because DestroyWindow was called for its parent
927 //so: send a WM_PARENTNOTIFY now as that hasn't happened yet
928 if((getStyle() & WS_CHILD) && !(getExStyle() & WS_EX_NOPARENTNOTIFY))
929 {
930 if(getParent() && getParent()->IsWindowDestroyed() == FALSE)
931 {
932 /* Notify the parent window only */
933 SendMessageA(getParent()->getWindowHandle(), WM_PARENTNOTIFY, MAKEWPARAM(WM_DESTROY, getWindowId()), (LPARAM)getWindowHandle());
934 }
935//// else DebugInt3();
936 }
937 }
938 SendMessageA(getWindowHandle(),WM_DESTROY, 0, 0);
939 if(::IsWindow(hwnd) == FALSE) {
940 //object already destroyed, so return immediately
941 return 1;
942 }
943 SendMessageA(getWindowHandle(),WM_NCDESTROY, 0, 0);
944
945 TIMER_KillTimerFromWindow(getWindowHandle());
946
947 if(getRefCount() == 0 && getFirstChild() == NULL && state == STATE_CREATED) {
948 delete this;
949 }
950 else {
951 //make sure no message can ever arrive for this window again (PM or from other win32 windows)
952 dprintf(("Mark window %x (%x) as deleted; refcount %d", getWindowHandle(), this, getRefCount()));
953 markDeleted();
954 OSLibWinSetWindowULong(OS2Hwnd, OFFSET_WIN32WNDPTR, 0);
955 OSLibWinSetWindowULong(OS2Hwnd, OFFSET_WIN32PM_MAGIC, 0);
956 if(Win32Hwnd) {
957 HwFreeWindowHandle(Win32Hwnd);
958 Win32Hwnd = 0;
959 }
960 }
961 return 1;
962}
963//******************************************************************************
964//******************************************************************************
965ULONG Win32BaseWindow::MsgEnable(BOOL fEnable)
966{
967 if(fEnable) {
968 dwStyle &= ~WS_DISABLED;
969 }
970 else dwStyle |= WS_DISABLED;
971
972 return SendMessageA(getWindowHandle(),WM_ENABLE, fEnable, 0);
973}
974//******************************************************************************
975//TODO: SW_PARENTCLOSING/OPENING flag (lParam)
976//******************************************************************************
977ULONG Win32BaseWindow::MsgShow(BOOL fShow)
978{
979 if(!CanReceiveSizeMsgs() || fDestroyWindowCalled) {
980 return 1;
981 }
982
983 if(fShow) {
984 setStyle(getStyle() | WS_VISIBLE);
985 if(getStyle() & WS_MINIMIZE) {
986 return ShowWindow(SW_RESTORE);
987 }
988 }
989 else setStyle(getStyle() & ~WS_VISIBLE);
990
991 //already sent from ShowWindow
992//// return SendMessageA(getWindowHandle(),WM_SHOWWINDOW, fShow, 0);
993 return 0;
994}
995//******************************************************************************
996//******************************************************************************
997ULONG Win32BaseWindow::MsgPosChanging(LPARAM lp)
998{
999 //SvL: Notes crashes when switching views (calls DestroyWindow -> PM sends
1000 // a WM_WINDOWPOSCHANGED msg -> crash)
1001 if(!CanReceiveSizeMsgs() || fDestroyWindowCalled)
1002 return 0;
1003
1004 return SendMessageA(getWindowHandle(),WM_WINDOWPOSCHANGING, 0, lp);
1005}
1006//******************************************************************************
1007//******************************************************************************
1008ULONG Win32BaseWindow::MsgPosChanged(LPARAM lp)
1009{
1010 //SvL: Notes crashes when switching views (calls DestroyWindow -> PM sends
1011 // a WM_WINDOWPOSCHANGED msg -> crash)
1012 if(!CanReceiveSizeMsgs() || fDestroyWindowCalled)
1013 return 1;
1014
1015 return SendMessageA(getWindowHandle(),WM_WINDOWPOSCHANGED, 0, lp);
1016}
1017//******************************************************************************
1018//******************************************************************************
1019ULONG Win32BaseWindow::MsgScroll(ULONG msg, ULONG scrollCode, ULONG scrollPos)
1020{
1021 //According to the SDK docs, the scrollbar handle (lParam) is 0 when the standard
1022 //window scrollbars send these messages
1023 return SendMessageA(getWindowHandle(),msg, MAKELONG(scrollCode, scrollPos), 0);
1024}
1025//******************************************************************************
1026//******************************************************************************
1027ULONG Win32BaseWindow::MsgActivate(BOOL fActivate, BOOL fMinimized, HWND hwnd, HWND hwndOS2Win)
1028{
1029 ULONG rc, procidhwnd = -1, threadidhwnd = 0;
1030
1031 //SvL: Don't send WM_(NC)ACTIVATE messages when the window is being destroyed
1032 if(fDestroyWindowCalled) {
1033 return 0;
1034 }
1035
1036 //According to SDK docs, if app returns FALSE & window is being deactivated,
1037 //default processing is cancelled
1038 //TODO: According to Wine we should proceed anyway if window is sysmodal
1039 if(SendMessageA(getWindowHandle(),WM_NCACTIVATE, fActivate, 0) == FALSE && !fActivate)
1040 {
1041 dprintf(("WARNING: WM_NCACTIVATE return code = FALSE -> cancel processing"));
1042 return 0;
1043 }
1044 /* child windows get a WM_CHILDACTIVATE message */
1045 if((getStyle() & (WS_CHILD | WS_POPUP)) == WS_CHILD )
1046 {
1047 if(fActivate) {//WM_CHILDACTIVE is for activation only
1048 SendMessageA(getWindowHandle(),WM_CHILDACTIVATE, 0, 0L);
1049 }
1050 return 0;
1051 }
1052
1053 return SendMessageA(getWindowHandle(),WM_ACTIVATE, MAKELONG((fActivate) ? WA_ACTIVE : WA_INACTIVE, fMinimized), hwnd);
1054}
1055//******************************************************************************
1056//******************************************************************************
1057ULONG Win32BaseWindow::MsgChildActivate(BOOL fActivate)
1058{
1059 //SvL: Don't send WM_(NC)ACTIVATE messages when the window is being destroyed
1060 if(fDestroyWindowCalled) {
1061 return 0;
1062 }
1063
1064 //According to SDK docs, if app returns FALSE & window is being deactivated,
1065 //default processing is cancelled
1066 //TODO: According to Wine we should proceed anyway if window is sysmodal
1067 if(SendMessageA(getWindowHandle(),WM_NCACTIVATE, fActivate, 0) == FALSE && !fActivate)
1068 {
1069 dprintf(("WARNING: WM_NCACTIVATE return code = FALSE -> cancel processing"));
1070 return 0;
1071 }
1072 /* child windows get a WM_CHILDACTIVATE message */
1073 if((getStyle() & (WS_CHILD | WS_POPUP)) == WS_CHILD )
1074 {
1075 if(fActivate) {//WM_CHILDACTIVE is for activation only
1076 SendMessageA(getWindowHandle(),WM_CHILDACTIVATE, 0, 0L);
1077 }
1078 return 0;
1079 }
1080 DebugInt3();
1081 return 0;
1082}
1083//******************************************************************************
1084//******************************************************************************
1085ULONG Win32BaseWindow::DispatchMsgA(MSG *msg)
1086{
1087 return SendMessageA(getWindowHandle(),msg->message, msg->wParam, msg->lParam);
1088}
1089//******************************************************************************
1090//******************************************************************************
1091ULONG Win32BaseWindow::DispatchMsgW(MSG *msg)
1092{
1093 return SendMessageW(getWindowHandle(), msg->message, msg->wParam, msg->lParam);
1094}
1095//******************************************************************************
1096//******************************************************************************
1097ULONG Win32BaseWindow::MsgSetFocus(HWND hwnd)
1098{
1099 //SvL: Don't send WM_(NC)ACTIVATE messages when the window is being destroyed
1100 if(fDestroyWindowCalled) {
1101 return 0;
1102 }
1103
1104 return SendMessageA(getWindowHandle(),WM_SETFOCUS, hwnd, 0);
1105}
1106//******************************************************************************
1107//******************************************************************************
1108ULONG Win32BaseWindow::MsgKillFocus(HWND hwnd)
1109{
1110 //SvL: Don't send WM_(NC)ACTIVATE messages when the window is being destroyed
1111 if(fDestroyWindowCalled) {
1112 return 0;
1113 }
1114 return SendMessageA(getWindowHandle(),WM_KILLFOCUS, hwnd, 0);
1115}
1116//******************************************************************************
1117//******************************************************************************
1118ULONG Win32BaseWindow::MsgButton(MSG *msg)
1119{
1120 BOOL fClick = FALSE;
1121
1122 dprintf(("MsgButton %d at (%d,%d)", msg->message, msg->pt.x, msg->pt.y));
1123 switch(msg->message)
1124 {
1125 case WM_LBUTTONDBLCLK:
1126 case WM_RBUTTONDBLCLK:
1127 case WM_MBUTTONDBLCLK:
1128 if (!(windowClass && windowClass->getClassLongA(GCL_STYLE) & CS_DBLCLKS))
1129 {
1130 msg->message = msg->message - (WM_LBUTTONDBLCLK - WM_LBUTTONDOWN); //dblclick -> down
1131 return MsgButton(msg);
1132 }
1133 break;
1134 case WM_NCLBUTTONDBLCLK:
1135 case WM_NCRBUTTONDBLCLK:
1136 case WM_NCMBUTTONDBLCLK:
1137 //Docs say CS_DBLCLKS style doesn't matter for non-client double clicks
1138 fClick = TRUE;
1139 break;
1140
1141 case WM_LBUTTONDOWN:
1142 case WM_RBUTTONDOWN:
1143 case WM_MBUTTONDOWN:
1144 case WM_NCLBUTTONDOWN:
1145 case WM_NCRBUTTONDOWN:
1146 case WM_NCMBUTTONDOWN:
1147 fClick = TRUE;
1148 break;
1149 }
1150
1151 if(fClick)
1152 {
1153 HWND hwndTop;
1154
1155 /* Activate the window if needed */
1156 hwndTop = GetTopParent();
1157
1158 HWND hwndActive = GetActiveWindow();
1159 if (hwndTop && (getWindowHandle() != hwndActive))
1160 {
1161 LONG ret = SendMessageA(getWindowHandle(),WM_MOUSEACTIVATE, hwndTop,
1162 MAKELONG( lastHitTestVal, msg->message) );
1163
1164 dprintf2(("WM_MOUSEACTIVATE returned %d", ret));
1165#if 0
1166 if ((ret == MA_ACTIVATEANDEAT) || (ret == MA_NOACTIVATEANDEAT))
1167 eatMsg = TRUE;
1168#endif
1169 //SvL: 0 is not documented, but experiments in NT4 show that
1170 // the window will get activated when it returns this.
1171 // (FreeCell is an example)
1172 if(((ret == MA_ACTIVATE) || (ret == MA_ACTIVATEANDEAT) || (ret == 0))
1173 && (hwndTop != GetForegroundWindow()) )
1174 {
1175 Win32BaseWindow *win32top = Win32BaseWindow::GetWindowFromHandle(hwndTop);
1176
1177 //SvL: Calling OSLibSetActiveWindow(hwndTop); causes focus problems
1178 if (win32top) {
1179 OSLibWinSetFocus(win32top->getOS2FrameWindowHandle());
1180 RELEASE_WNDOBJ(win32top);
1181 }
1182 }
1183 }
1184 }
1185
1186 SendMessageA(getWindowHandle(),WM_SETCURSOR, getWindowHandle(), MAKELONG(lastHitTestVal, msg->message));
1187
1188 switch(msg->message)
1189 {
1190 case WM_LBUTTONDOWN:
1191 case WM_MBUTTONDOWN:
1192 case WM_RBUTTONDOWN:
1193 {
1194 if (getParent())
1195 {
1196 POINTS pt = MAKEPOINTS(msg->lParam);
1197 POINT point;
1198
1199 point.x = pt.x;
1200 point.y = pt.y;
1201 MapWindowPoints(getWindowHandle(), getParent()->getWindowHandle(), &point, 1);
1202 NotifyParent(msg->message, msg->wParam, MAKELPARAM(point.x,point.y));
1203 }
1204 break;
1205 }
1206 }
1207 return SendMessageA(getWindowHandle(),msg->message, msg->wParam, msg->lParam);
1208}
1209//******************************************************************************
1210//******************************************************************************
1211ULONG Win32BaseWindow::MsgPaint(ULONG tmp, ULONG select)
1212{
1213 if (select && IsWindowIconic())
1214 return SendMessageA(getWindowHandle(),WM_PAINTICON, 1, 0);
1215 else
1216 return SendMessageA(getWindowHandle(),WM_PAINT, 0, 0);
1217}
1218//******************************************************************************
1219//TODO: Is the clipper region of the window DC equal to the invalidated rectangle?
1220// (or are we simply erasing too much here)
1221//******************************************************************************
1222ULONG Win32BaseWindow::MsgEraseBackGround(HDC hdc)
1223{
1224 ULONG rc;
1225 HDC hdcErase = hdc;
1226
1227 if (hdcErase == 0)
1228 hdcErase = GetDC(getWindowHandle());
1229
1230 if(IsWindowIconic())
1231 rc = SendMessageA(getWindowHandle(),WM_ICONERASEBKGND, hdcErase, 0);
1232 else
1233 rc = SendMessageA(getWindowHandle(),WM_ERASEBKGND, hdcErase, 0);
1234 if (hdc == 0)
1235 ReleaseDC(getWindowHandle(), hdcErase);
1236 return (rc);
1237}
1238//******************************************************************************
1239//******************************************************************************
1240ULONG Win32BaseWindow::MsgMouseMove(MSG *msg)
1241{
1242 //TODO: hiword should be 0 if window enters menu mode (SDK docs)
1243 //SDK: WM_SETCURSOR is not sent if the mouse is captured
1244 if(GetCapture() == 0) {
1245 SendMessageA(getWindowHandle(),WM_SETCURSOR, Win32Hwnd, MAKELONG(lastHitTestVal, msg->message));
1246 }
1247
1248 //translated message == WM_(NC)MOUSEMOVE
1249 return SendMessageA(getWindowHandle(),msg->message, msg->wParam, msg->lParam);
1250}
1251//******************************************************************************
1252//******************************************************************************
1253ULONG Win32BaseWindow::MsgChar(MSG *msg)
1254{
1255 return DispatchMsgA(msg);
1256}
1257//******************************************************************************
1258//TODO: Should use update region, not rectangle
1259//******************************************************************************
1260ULONG Win32BaseWindow::MsgNCPaint(PRECT pUpdateRect)
1261{
1262 HRGN hrgn;
1263 ULONG rc;
1264 RECT client = rectClient;
1265
1266 if ((pUpdateRect->left >= client.left) && (pUpdateRect->left < client.right) &&
1267 (pUpdateRect->right >= client.left) && (pUpdateRect->right < client.right) &&
1268 (pUpdateRect->top >= client.top) && (pUpdateRect->top < client.bottom) &&
1269 (pUpdateRect->bottom >= client.top) && (pUpdateRect->bottom < client.bottom)
1270 && (!(getStyle() & WS_MINIMIZE)))
1271 {
1272 return 0;
1273 }
1274
1275 dprintf(("MsgNCPaint (%d,%d)(%d,%d)", pUpdateRect->left, pUpdateRect->top, pUpdateRect->right, pUpdateRect->bottom));
1276 hrgn = CreateRectRgnIndirect(pUpdateRect);
1277
1278 rc = SendMessageA(getWindowHandle(),WM_NCPAINT, hrgn, 0);
1279 //Send WM_PAINTICON here if minimized, because client window will
1280 //not receive a (valid) WM_PAINT message
1281 if (getStyle() & WS_MINIMIZE)
1282 {
1283 rc = SendMessageA(getWindowHandle(),WM_PAINTICON, 1, 0);
1284 }
1285
1286 DeleteObject(hrgn);
1287
1288 return rc;
1289}
1290//******************************************************************************
1291//Called when either the frame's size or position has changed (lpWndPos != NULL)
1292//or when the frame layout has changed (i.e. scrollbars added/removed) (lpWndPos == NULL)
1293//******************************************************************************
1294ULONG Win32BaseWindow::MsgFormatFrame(WINDOWPOS *lpWndPos)
1295{
1296 RECT oldWindowRect = rectWindow, client = rectClient, newWindowRect;
1297 RECT newClientRect;
1298 WINDOWPOS wndPos;
1299 ULONG rc;
1300
1301 if(lpWndPos)
1302 {
1303 //set new window rectangle
1304 setWindowRect(lpWndPos->x, lpWndPos->y, lpWndPos->x+lpWndPos->cx,
1305 lpWndPos->y+lpWndPos->cy);
1306 newWindowRect = rectWindow;
1307 }
1308 else {
1309 wndPos.hwnd = getWindowHandle();
1310 wndPos.hwndInsertAfter = 0;
1311 newWindowRect= rectWindow;
1312 wndPos.x = newWindowRect.left;
1313 wndPos.y = newWindowRect.top;
1314 wndPos.cx = newWindowRect.right - newWindowRect.left;
1315 wndPos.cy = newWindowRect.bottom - newWindowRect.top;
1316 wndPos.flags = SWP_FRAMECHANGED;
1317 lpWndPos = &wndPos;
1318 }
1319
1320 newClientRect = rectClient;
1321 rc = SendNCCalcSize(TRUE, &newWindowRect, &oldWindowRect, &client, lpWndPos, &newClientRect);
1322 rectClient = newClientRect; //must update rectClient here
1323
1324 dprintf(("MsgFormatFrame: old client rect (%d,%d)(%d,%d), new client (%d,%d)(%d,%d)", client.left, client.top, client.right, client.bottom, rectClient.left, rectClient.top, rectClient.right, rectClient.bottom));
1325 dprintf(("MsgFormatFrame: old window rect (%d,%d)(%d,%d), new window (%d,%d)(%d,%d)", oldWindowRect.left, oldWindowRect.top, oldWindowRect.right, oldWindowRect.bottom, rectWindow.left, rectWindow.top, rectWindow.right, rectWindow.bottom));
1326
1327 if(!CanReceiveSizeMsgs() || !EqualRect(&client, &rectClient)) {
1328 OSLibWinSetClientPos(getOS2WindowHandle(), rectClient.left, rectClient.top, getClientWidth(), getClientHeight(), getWindowHeight());
1329 }
1330
1331#if 1
1332//this doesn't always work
1333// if(CanReceiveSizeMsgs() && (client.left != rectClient.left || client.top != rectClient.top))
1334 if(CanReceiveSizeMsgs() && ((oldWindowRect.right - oldWindowRect.left < rectClient.left
1335 || oldWindowRect.bottom - oldWindowRect.top < rectClient.top) ||
1336 (EqualRect(&oldWindowRect, &rectWindow) && (client.left != rectClient.left || client.top != rectClient.top))))
1337 {
1338 Win32BaseWindow *child = (Win32BaseWindow *)getFirstChild();
1339
1340 //client rectangle has moved -> inform children
1341 dprintf(("MsgFormatFrame -> client rectangle has changed, move children"));
1342 while(child) {
1343 ::SetWindowPos(child->getWindowHandle(),
1344 HWND_TOP, child->getWindowRect()->left,
1345 child->getWindowRect()->top, 0, 0,
1346 SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOZORDER);
1347 child = (Win32BaseWindow *)child->getNextChild();
1348 }
1349 }
1350#endif
1351 if(fOS2Look && ((dwStyle & WS_CAPTION) == WS_CAPTION))
1352 {
1353 RECT rect = {0};
1354 BOOL fCloseButton;
1355
1356 fCloseButton = !(windowClass && (windowClass->getClassLongA(GCL_STYLE) & CS_NOCLOSE));
1357
1358 int height = getWindowHeight();
1359 RECTLOS2 rectOS2;
1360
1361 AdjustRectOuter(&rect, FALSE);
1362
1363 rect.left = -rect.left;
1364 rect.top = rect.bottom - rect.top;
1365 rect.right = rectWindow.right - rectWindow.left - rect.right;
1366
1367 rectOS2.xLeft = rect.left;
1368 rectOS2.xRight = rect.right;
1369 rectOS2.yBottom = height - rect.top;
1370 rectOS2.yTop = height - rect.bottom;
1371
1372 //@@PF Disable close button as well when needed by application
1373 OSLibChangeCloseButtonState(getOS2FrameWindowHandle(), fCloseButton);
1374 OSLibWinPositionFrameControls(getOS2FrameWindowHandle(), &rectOS2,
1375 dwStyle, dwExStyle, IconForWindow(ICON_SMALL),
1376 fCloseButton, windowClass->getIcon() != NULL);
1377 }
1378 return rc;
1379}
1380//******************************************************************************
1381//******************************************************************************
1382ULONG Win32BaseWindow::MsgSetText(LPSTR lpsz, LONG cch)
1383{
1384 return SendMessageA(getWindowHandle(),WM_SETTEXT, 0, (LPARAM)lpsz);
1385}
1386//******************************************************************************
1387//******************************************************************************
1388ULONG Win32BaseWindow::MsgGetTextLength()
1389{
1390 return SendMessageA(getWindowHandle(),WM_GETTEXTLENGTH, 0, 0);
1391}
1392//******************************************************************************
1393//******************************************************************************
1394void Win32BaseWindow::MsgGetText(char *wndtext, ULONG textlength)
1395{
1396 SendMessageA(getWindowHandle(),WM_GETTEXT, textlength, (LPARAM)wndtext);
1397}
1398//******************************************************************************
1399//******************************************************************************
1400BOOL Win32BaseWindow::isMDIClient()
1401{
1402 return FALSE;
1403}
1404//******************************************************************************
1405//******************************************************************************
1406BOOL Win32BaseWindow::isMDIChild()
1407{
1408 return FALSE;
1409}
1410//******************************************************************************
1411//TODO: Not complete
1412//******************************************************************************
1413BOOL Win32BaseWindow::isFrameWindow()
1414{
1415 if(getParent() == NULL)
1416 return TRUE;
1417
1418 return FALSE;
1419}
1420//******************************************************************************
1421//******************************************************************************
1422BOOL Win32BaseWindow::isDesktopWindow()
1423{
1424 return FALSE;
1425}
1426//******************************************************************************
1427//******************************************************************************
1428BOOL Win32BaseWindow::IsWindowIconic()
1429{
1430 return ((getStyle() & WS_MINIMIZE) && windowClass->getIcon());
1431}
1432//******************************************************************************
1433//******************************************************************************
1434SCROLLBAR_INFO *Win32BaseWindow::getScrollInfo(int nBar)
1435{
1436 switch(nBar)
1437 {
1438 case SB_HORZ:
1439 if (!horzScrollInfo)
1440 {
1441 horzScrollInfo = (SCROLLBAR_INFO*)malloc(sizeof(SCROLLBAR_INFO));
1442 if (!horzScrollInfo) break;
1443 horzScrollInfo->MinVal = horzScrollInfo->CurVal = horzScrollInfo->Page = 0;
1444 horzScrollInfo->MaxVal = 100;
1445 horzScrollInfo->flags = ESB_ENABLE_BOTH;
1446 }
1447 return horzScrollInfo;
1448
1449 case SB_VERT:
1450 if (!vertScrollInfo)
1451 {
1452 vertScrollInfo = (SCROLLBAR_INFO*)malloc(sizeof(SCROLLBAR_INFO));
1453 if (!vertScrollInfo) break;
1454 vertScrollInfo->MinVal = vertScrollInfo->CurVal = vertScrollInfo->Page = 0;
1455 vertScrollInfo->MaxVal = 100;
1456 vertScrollInfo->flags = ESB_ENABLE_BOTH;
1457 }
1458 return vertScrollInfo;
1459 }
1460
1461 return NULL;
1462}
1463//******************************************************************************
1464//******************************************************************************
1465LRESULT Win32BaseWindow::DefWndControlColor(UINT ctlType, HDC hdc)
1466{
1467 //SvL: Set background color to default button color (not window (white))
1468 if(ctlType == CTLCOLOR_BTN)
1469 {
1470 SetBkColor(hdc, GetSysColor(COLOR_BTNFACE));
1471 SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
1472 return GetSysColorBrush(COLOR_BTNFACE);
1473 }
1474 //SvL: Set background color to default dialog color if window is dialog
1475 if((ctlType == CTLCOLOR_DLG || ctlType == CTLCOLOR_STATIC) && IsDialog()) {
1476 SetBkColor(hdc, GetSysColor(COLOR_BTNFACE));
1477 SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
1478 return GetSysColorBrush(COLOR_BTNFACE);
1479 }
1480 if( ctlType == CTLCOLOR_SCROLLBAR)
1481 {
1482 HBRUSH hb = GetSysColorBrush(COLOR_SCROLLBAR);
1483 COLORREF bk = GetSysColor(COLOR_3DHILIGHT);
1484 SetTextColor( hdc, GetSysColor(COLOR_3DFACE));
1485 SetBkColor( hdc, bk);
1486
1487 /* if COLOR_WINDOW happens to be the same as COLOR_3DHILIGHT
1488 * we better use 0x55aa bitmap brush to make scrollbar's background
1489 * look different from the window background.
1490 */
1491 if (bk == GetSysColor(COLOR_WINDOW)) {
1492 return GetPattern55AABrush();
1493 }
1494
1495 UnrealizeObject( hb );
1496 return (LRESULT)hb;
1497 }
1498
1499 SetTextColor( hdc, GetSysColor(COLOR_WINDOWTEXT));
1500
1501 if ((ctlType == CTLCOLOR_EDIT) || (ctlType == CTLCOLOR_LISTBOX))
1502 {
1503 SetBkColor( hdc, GetSysColor(COLOR_WINDOW) );
1504 }
1505 else
1506 {
1507 SetBkColor( hdc, GetSysColor(COLOR_3DFACE) );
1508 return (LRESULT)GetSysColorBrush(COLOR_3DFACE);
1509 }
1510 return (LRESULT)GetSysColorBrush(COLOR_WINDOW);
1511}
1512//******************************************************************************
1513//******************************************************************************
1514LRESULT Win32BaseWindow::DefWndPrint(HDC hdc,ULONG uFlags)
1515{
1516 /*
1517 * Visibility flag.
1518 */
1519 if ( (uFlags & PRF_CHECKVISIBLE) &&
1520 !IsWindowVisible(getWindowHandle()) )
1521 return 0;
1522
1523 /*
1524 * Unimplemented flags.
1525 */
1526 if ( (uFlags & PRF_CHILDREN) ||
1527 (uFlags & PRF_OWNED) ||
1528 (uFlags & PRF_NONCLIENT) )
1529 {
1530 dprintf(("WM_PRINT message with unsupported flags\n"));
1531 }
1532
1533 /*
1534 * Background
1535 */
1536 if ( uFlags & PRF_ERASEBKGND)
1537 SendMessageA(getWindowHandle(),WM_ERASEBKGND, (WPARAM)hdc, 0);
1538
1539 /*
1540 * Client area
1541 */
1542 if ( uFlags & PRF_CLIENT)
1543 SendMessageA(getWindowHandle(),WM_PRINTCLIENT, (WPARAM)hdc, PRF_CLIENT);
1544
1545
1546 return 0;
1547}
1548//******************************************************************************
1549//******************************************************************************
1550LRESULT Win32BaseWindow::DefWindowProcA(UINT Msg, WPARAM wParam, LPARAM lParam)
1551{
1552 switch(Msg)
1553 {
1554 case WM_CLOSE:
1555 dprintf(("DefWindowProcA: WM_CLOSE %x", getWindowHandle()));
1556 DestroyWindow();
1557 return 0;
1558
1559 case WM_GETTEXTLENGTH:
1560 return windowNameLength;
1561
1562 case WM_GETTEXT:
1563 if (!lParam || !wParam)
1564 return 0;
1565 if (!windowNameA)
1566 ((LPSTR)lParam)[0] = 0;
1567 else
1568 memcpy((LPSTR)lParam, windowNameA, min(windowNameLength+1, wParam) );
1569 return min(windowNameLength, wParam);
1570
1571 case WM_SETTEXT:
1572 {
1573 LPCSTR lpsz = (LPCSTR)lParam;
1574
1575 // reallocate if new buffer is larger
1576 if (!lParam)
1577 {
1578 free(windowNameA);
1579 free(windowNameW);
1580 windowNameLength = 0;
1581 windowNameA = NULL;
1582 windowNameW = NULL;
1583 }
1584 else
1585 {
1586 // determine length of new text
1587 int iTextLength = strlen(lpsz);
1588
1589 if (windowNameLength < iTextLength)
1590 {
1591 if (windowNameA)
1592 {
1593 free(windowNameA);
1594 windowNameA = NULL;
1595 }
1596
1597 if (windowNameW)
1598 {
1599 free(windowNameW);
1600 windowNameW = NULL;
1601 }
1602 }
1603
1604 windowNameLength = iTextLength;
1605 if(!windowNameA)
1606 windowNameA = (LPSTR)_smalloc(windowNameLength+1);
1607 memcpy(windowNameA, lpsz, windowNameLength+1);
1608 if(!windowNameW)
1609 windowNameW = (LPWSTR)_smalloc((windowNameLength+1)*sizeof(WCHAR));
1610 lstrcpynAtoW(windowNameW, windowNameA, windowNameLength+1);
1611 }
1612
1613 dprintf(("WM_SETTEXT of %x to %s\n", Win32Hwnd, lParam));
1614 if ((dwStyle & WS_CAPTION) == WS_CAPTION)
1615 {
1616 HandleNCPaint((HRGN)1);
1617 if(hTaskList) {
1618 OSLibWinChangeTaskList(hTaskList, OS2HwndFrame, getWindowNameA(), (getStyle() & WS_VISIBLE) ? 1 : 0);
1619 }
1620 if(fOS2Look) {
1621 OSLibWinSetTitleBarText(OS2HwndFrame, getWindowNameA());
1622 }
1623 }
1624
1625 return TRUE;
1626 }
1627
1628 case WM_SETREDRAW:
1629 {
1630 if (wParam)
1631 {
1632 setStyle(getStyle() | WS_VISIBLE);
1633 dprintf(("Enable window update for %x", getWindowHandle()));
1634 OSLibWinEnableWindowUpdate(OS2HwndFrame, OS2Hwnd, TRUE);
1635 }
1636 else
1637 {
1638 if (getStyle() & WS_VISIBLE)
1639 {
1640 setStyle(getStyle() & ~WS_VISIBLE);
1641 dprintf(("Disable window update for %x", getWindowHandle()));
1642 OSLibWinEnableWindowUpdate(OS2HwndFrame, OS2Hwnd, FALSE);
1643 }
1644 }
1645 return 0;
1646 }
1647
1648 case WM_CTLCOLORMSGBOX:
1649 case WM_CTLCOLOREDIT:
1650 case WM_CTLCOLORLISTBOX:
1651 case WM_CTLCOLORBTN:
1652 case WM_CTLCOLORDLG:
1653 case WM_CTLCOLORSTATIC:
1654 case WM_CTLCOLORSCROLLBAR:
1655 return DefWndControlColor(Msg - WM_CTLCOLORMSGBOX, (HDC)wParam);
1656
1657 case WM_CTLCOLOR:
1658 return DefWndControlColor(HIWORD(lParam), (HDC)wParam);
1659
1660 case WM_VKEYTOITEM:
1661 case WM_CHARTOITEM:
1662 return -1;
1663
1664 case WM_PARENTNOTIFY:
1665 return 0;
1666
1667 case WM_MOUSEACTIVATE:
1668 {
1669 HWND hwnd = getWindowHandle();
1670
1671 dprintf(("DefWndProc: WM_MOUSEACTIVATE for %x Msg %s", Win32Hwnd, GetMsgText(HIWORD(lParam))));
1672 if (::GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
1673 {
1674 LONG ret = ::SendMessageW( ::GetParent(hwnd), WM_MOUSEACTIVATE, wParam, lParam );
1675 if (ret) return ret;
1676 }
1677
1678 /* Caption clicks are handled by the NC_HandleNCLButtonDown() */
1679 return (LOWORD(lParam) >= HTCLIENT) ? MA_ACTIVATE : MA_NOACTIVATE;
1680 }
1681
1682 case WM_ACTIVATE:
1683 /* The default action in Windows is to set the keyboard focus to
1684 * the window, if it's being activated and not minimized */
1685 if (LOWORD(wParam) != WA_INACTIVE) {
1686 if(!(getStyle() & WS_MINIMIZE))
1687 SetFocus(getWindowHandle());
1688 }
1689 return 0;
1690
1691 case WM_SETCURSOR:
1692 {
1693 dprintf(("DefWndProc: WM_SETCURSOR for %x Msg %s", Win32Hwnd, GetMsgText(HIWORD(lParam))));
1694 if((getStyle() & WS_CHILD))
1695 {
1696 if(getParent()) {
1697 LRESULT rc = SendMessageA(getParent()->getWindowHandle(), WM_SETCURSOR, wParam, lParam);
1698 if(rc) return rc;
1699 }
1700 }
1701 if (wParam == getWindowHandle())
1702 {
1703 HCURSOR hCursor;
1704
1705 switch(LOWORD(lParam))
1706 {
1707 case HTCLIENT:
1708 hCursor = windowClass ? windowClass->getCursor():LoadCursorA(0,IDC_ARROWA);
1709 break;
1710
1711 case HTLEFT:
1712 case HTRIGHT:
1713 hCursor = LoadCursorA(0,IDC_SIZEWEA);
1714 break;
1715
1716 case HTTOP:
1717 case HTBOTTOM:
1718 hCursor = LoadCursorA(0,IDC_SIZENSA);
1719 break;
1720
1721 case HTTOPLEFT:
1722 case HTBOTTOMRIGHT:
1723 hCursor = LoadCursorA(0,IDC_SIZENWSEA);
1724 break;
1725
1726 case HTTOPRIGHT:
1727 case HTBOTTOMLEFT:
1728 hCursor = LoadCursorA(0,IDC_SIZENESWA);
1729 break;
1730
1731 default:
1732 hCursor = LoadCursorA(0,IDC_ARROWA);
1733 break;
1734 }
1735
1736 if (hCursor)
1737 {
1738 SetCursor(hCursor);
1739 return 1;
1740 }
1741 else return 0;
1742 }
1743 else return 0;
1744 }
1745
1746 case WM_MOUSEMOVE:
1747 return 0;
1748
1749 case WM_MOUSEWHEEL:
1750 if (::GetWindowLongA( getWindowHandle(), GWL_STYLE ) & WS_CHILD)
1751 return ::SendMessageA( ::GetParent(getWindowHandle()), WM_MOUSEWHEEL, wParam, lParam );
1752 break;
1753
1754 case WM_WINDOWPOSCHANGED:
1755 {
1756 PWINDOWPOS wpos = (PWINDOWPOS)lParam;
1757 WPARAM wp = SIZE_RESTORED;
1758
1759 //According to Wine these are always sent, but experiments in Windows NT4, SP6
1760 //show otherwise
1761 if (!(wpos->flags & SWP_NOMOVE) && !(wpos->flags & SWP_NOCLIENTMOVE))
1762 {
1763 SendMessageA(getWindowHandle(),WM_MOVE, 0, MAKELONG(rectClient.left,rectClient.top));
1764 }
1765 //According to Wine these are always sent, but experiments in Windows NT4, SP6
1766 //show otherwise
1767 if (!(wpos->flags & SWP_NOSIZE) && !(wpos->flags & SWP_NOCLIENTSIZE))
1768 {
1769 if (dwStyle & WS_MAXIMIZE) wp = SIZE_MAXIMIZED;
1770 else
1771 if (dwStyle & WS_MINIMIZE) wp = SIZE_MINIMIZED;
1772
1773 SendMessageA(getWindowHandle(),WM_SIZE, wp, MAKELONG(rectClient.right - rectClient.left,
1774 rectClient.bottom - rectClient.top));
1775 }
1776 return 0;
1777 }
1778 case WM_WINDOWPOSCHANGING:
1779 return HandleWindowPosChanging((WINDOWPOS *)lParam);
1780
1781 case WM_ERASEBKGND:
1782 case WM_ICONERASEBKGND:
1783 {
1784 RECT rect;
1785 int rc;
1786
1787 if (!windowClass || !windowClass->getBackgroundBrush()) return 0;
1788
1789 rc = GetClipBox( (HDC)wParam, &rect );
1790 if ((rc == SIMPLEREGION) || (rc == COMPLEXREGION))
1791 {
1792 HBRUSH hBrush = windowClass->getBackgroundBrush();
1793
1794 if (hBrush <= (HBRUSH)(SYSCOLOR_GetLastColor()+1))
1795 hBrush = GetSysColorBrush(hBrush-1);
1796
1797 FillRect( (HDC)wParam, &rect, hBrush);
1798 }
1799 return 1;
1800 }
1801
1802 case WM_PRINT:
1803 return DefWndPrint(wParam,lParam);
1804
1805 case WM_SYNCPAINT:
1806 RedrawWindow(getWindowHandle(), NULL, 0, RDW_ERASENOW | RDW_ERASE | RDW_ALLCHILDREN);
1807 return 0;
1808
1809 case WM_PAINTICON:
1810 case WM_PAINT:
1811 {
1812 PAINTSTRUCT ps;
1813 HDC hdc = BeginPaint(getWindowHandle(), &ps );
1814 if( hdc )
1815 {
1816 if( (getStyle() & WS_MINIMIZE) && (getWindowClass()->getIcon() || hIcon))
1817 {
1818 int x = (rectWindow.right - rectWindow.left - GetSystemMetrics(SM_CXICON))/2;
1819 int y = (rectWindow.bottom - rectWindow.top - GetSystemMetrics(SM_CYICON))/2;
1820 dprintf(("Painting class icon: vis rect=(%i,%i - %i,%i)\n", ps.rcPaint.left, ps.rcPaint.top, ps.rcPaint.right, ps.rcPaint.bottom ));
1821 DrawIcon(hdc, x, y, hIcon ? hIcon:getWindowClass()->getIcon() );
1822 }
1823 EndPaint(getWindowHandle(), &ps );
1824 }
1825 return 0;
1826 }
1827
1828 case WM_GETDLGCODE:
1829 return 0;
1830
1831 case WM_NCPAINT:
1832 return HandleNCPaint((HRGN)wParam);
1833
1834 case WM_NCACTIVATE:
1835 return HandleNCActivate(wParam);
1836
1837 case WM_NCCREATE:
1838 return(TRUE);
1839
1840 case WM_NCDESTROY:
1841 return 0;
1842
1843 case WM_NCCALCSIZE:
1844 return HandleNCCalcSize((BOOL)wParam,(RECT*)lParam);
1845
1846 case WM_NCLBUTTONDOWN:
1847 return HandleNCLButtonDown(wParam,lParam);
1848
1849 case WM_LBUTTONDBLCLK:
1850 case WM_NCLBUTTONDBLCLK:
1851 return HandleNCLButtonDblClk(wParam,lParam);
1852
1853 case WM_NCRBUTTONDOWN:
1854 case WM_NCRBUTTONDBLCLK:
1855 case WM_NCMBUTTONDOWN:
1856 case WM_NCMBUTTONDBLCLK:
1857 if (lastHitTestVal == HTERROR) MessageBeep(MB_ICONEXCLAMATION);
1858 return 0;
1859
1860 case WM_NCRBUTTONUP:
1861 return HandleNCRButtonUp(wParam,lParam);
1862
1863 case WM_NCMBUTTONUP:
1864 return 0;
1865
1866 case WM_NCHITTEST:
1867 {
1868 POINT point;
1869 LRESULT retvalue;
1870
1871 point.x = (SHORT)LOWORD(lParam);
1872 point.y = (SHORT)HIWORD(lParam);
1873
1874 retvalue = HandleNCHitTest(point);
1875#if 0 //CB: let the Corel people fix the bugs first
1876 if(retvalue == HTMENU)
1877 MENU_TrackMouseMenuBar_MouseMove(Win32Hwnd,point,TRUE);
1878 else
1879 MENU_TrackMouseMenuBar_MouseMove(Win32Hwnd,point,FALSE);
1880#endif
1881 return retvalue;
1882 }
1883
1884 case WM_SYSCOMMAND:
1885 {
1886 POINT point;
1887
1888 point.x = LOWORD(lParam);
1889 point.y = HIWORD(lParam);
1890 return HandleSysCommand(wParam,&point);
1891 }
1892
1893 case WM_KEYDOWN:
1894 if(wParam == VK_F10) iF10Key = VK_F10;
1895 break;
1896
1897 case WM_SYSKEYDOWN:
1898 {
1899 if( HIWORD(lParam) & KEYDATA_ALT )
1900 {
1901 /* if( HIWORD(lParam) & ~KEYDATA_PREVSTATE ) */
1902 if( wParam == VK_MENU && !iMenuSysKey )
1903 iMenuSysKey = 1;
1904 else
1905 iMenuSysKey = 0;
1906
1907 iF10Key = 0;
1908
1909 if( wParam == VK_F4 ) /* try to close the window */
1910 {
1911 HWND top = GetTopParent();
1912 if (!(GetClassLongW( top, GCL_STYLE ) & CS_NOCLOSE))
1913 PostMessageW( top, WM_SYSCOMMAND, SC_CLOSE, 0 );
1914 }
1915
1916 //Default OS/2 app behaviour for system keys
1917 if(fOS2Look)
1918 {
1919 if( wParam == VK_F5 ) /* try to restore the window */
1920 {
1921 HWND top = GetTopParent();
1922 /* No checks needed SC_RESTORE handler does them */
1923 PostMessageW( top, WM_SYSCOMMAND, SC_RESTORE, 0 );
1924 }
1925
1926 if( wParam == VK_F7 ) /* size the window */
1927 {
1928 HWND top = GetTopParent();
1929 PostMessageW( top, WM_SYSCOMMAND, SC_MOVE, 0 );
1930 }
1931
1932 if( wParam == VK_F8 ) /* move the window */
1933 {
1934 HWND top = GetTopParent();
1935 if ( GetWindowLongA(top, GWL_STYLE) & WS_SIZEBOX)
1936 PostMessageW( top, WM_SYSCOMMAND, SC_SIZE, 0 );
1937 }
1938
1939 if( wParam == VK_F9 ) /* try to minimize the window */
1940 {
1941 HWND top = GetTopParent();
1942 if ( GetWindowLongA(top, GWL_STYLE) & WS_MINIMIZEBOX)
1943 PostMessageW( top, WM_SYSCOMMAND, SC_MINIMIZE, 0 );
1944 }
1945
1946 if( wParam == VK_F10 ) /* try to maximize the window */
1947 {
1948 HWND top = GetTopParent();
1949 if ( GetWindowLongA(top, GWL_STYLE) & WS_MAXIMIZEBOX)
1950 PostMessageW( top, WM_SYSCOMMAND, SC_MAXIMIZE, 0 );
1951 }
1952 }
1953
1954 }
1955 else if( wParam == VK_F10 )
1956 iF10Key = 1;
1957 else
1958 if( wParam == VK_ESCAPE && (GetKeyState(VK_SHIFT) & 0x8000))
1959 SendMessageW(getWindowHandle(), WM_SYSCOMMAND, SC_KEYMENU, VK_SPACE );
1960
1961 Win32BaseWindow *siblingWindow;
1962 HWND sibling;
1963 char nameBuffer [40], mnemonic;
1964 int nameLength;
1965
1966 GetWindowTextA (nameBuffer, 40);
1967
1968 // search all sibling to see it this key is their mnemonic
1969 sibling = GetWindow (GW_HWNDFIRST);
1970 while (sibling != 0) {
1971 siblingWindow = GetWindowFromHandle (sibling);
1972 nameLength = siblingWindow->GetWindowTextA (nameBuffer, 40);
1973
1974 // find the siblings mnemonic
1975 mnemonic = '\0';
1976 for (int i=0 ; i<nameLength ; i++) {
1977 if (IsDBCSLeadByte(nameBuffer[i])) {
1978 // Skip DBCS
1979 continue;
1980 }
1981 if (nameBuffer [i] == '&') {
1982 mnemonic = nameBuffer [i+1];
1983 if ((mnemonic >= 'a') && (mnemonic <= 'z'))
1984 mnemonic -= 32; // make it uppercase
1985 break; // stop searching
1986 }
1987 }
1988
1989 // key matches siblings mnemonic, send mouseclick
1990 if (mnemonic == (char) wParam) {
1991 ::SendMessageA(siblingWindow->getWindowHandle(), BM_CLICK, 0, 0);
1992 }
1993 sibling = siblingWindow->GetNextWindow (GW_HWNDNEXT);
1994 RELEASE_WNDOBJ(siblingWindow);
1995 }
1996
1997 return 0;
1998 }
1999
2000 case WM_KEYUP:
2001 case WM_SYSKEYUP:
2002 /* Press and release F10 or ALT */
2003 if (((wParam == VK_MENU) && iMenuSysKey) ||
2004 ((wParam == VK_F10) && iF10Key))
2005 ::SendMessageW( GetTopParent(), WM_SYSCOMMAND, SC_KEYMENU, 0L );
2006 iMenuSysKey = iF10Key = 0;
2007 break;
2008
2009 case WM_SYSCHAR:
2010 {
2011 iMenuSysKey = 0;
2012 if (wParam == VK_RETURN && (getStyle() & WS_MINIMIZE))
2013 {
2014 PostMessageA(getWindowHandle(), WM_SYSCOMMAND,
2015 (WPARAM)SC_RESTORE, 0L );
2016 break;
2017 }
2018 if((HIWORD(lParam) & KEYDATA_ALT) && wParam)
2019 {
2020 if (wParam == VK_TAB || wParam == VK_ESCAPE || wParam == VK_F4)
2021 break;
2022 if (wParam == VK_SPACE && (getStyle() & WS_CHILD)) {
2023 ::SendMessageW(GetParent(), Msg, wParam, lParam );
2024 }
2025 else ::SendMessageA(getWindowHandle(), WM_SYSCOMMAND, (WPARAM)SC_KEYMENU, (LPARAM)(DWORD)wParam );
2026 }
2027#if 0
2028 else /* check for Ctrl-Esc */
2029 if (wParam != VK_ESCAPE) MessageBeep(0);
2030 break;
2031#endif
2032 }
2033
2034 case WM_SETHOTKEY:
2035 hotkey = wParam;
2036 return 1; //CB: always successful
2037
2038 case WM_GETHOTKEY:
2039 return hotkey;
2040
2041 case WM_RBUTTONUP:
2042 {
2043 POINT pt;
2044 pt.x = SLOWORD(lParam);
2045 pt.y = SHIWORD(lParam);
2046 ClientToScreen(getWindowHandle(), &pt);
2047 SendMessageA( getWindowHandle(), WM_CONTEXTMENU, getWindowHandle(),MAKELPARAM(pt.x, pt.y) );
2048 }
2049 break;
2050
2051 case WM_CONTEXTMENU:
2052 if ((dwStyle & WS_CHILD) && getParent())
2053 SendMessageA(getParent()->getWindowHandle(), WM_CONTEXTMENU,wParam,lParam);
2054 else
2055 {
2056 LONG hitcode;
2057 POINT pt;
2058 if (!GetSysMenu()) return 0;
2059 pt.x = SLOWORD(lParam);
2060 pt.y = SHIWORD(lParam);
2061 hitcode = HandleNCHitTest(pt);
2062
2063 /* Track system popup if click was in the caption area. */
2064 if (hitcode==HTCAPTION || hitcode==HTSYSMENU)
2065 TrackPopupMenu(GetSysMenu(),
2066 TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
2067 pt.x, pt.y, 0, getWindowHandle(), NULL);
2068 }
2069 return 0;
2070
2071 case WM_SHOWWINDOW:
2072 if (!lParam) return 0; /* sent from ShowWindow */
2073 if (!(dwStyle & WS_POPUP) || !owner) return 0;
2074 if ((dwStyle & WS_VISIBLE) && wParam) return 0;
2075 else if (!(dwStyle & WS_VISIBLE) && !wParam) return 0;
2076 ShowWindow(wParam ? SW_SHOW:SW_HIDE);
2077 return 0;
2078
2079 case WM_CANCELMODE:
2080 if (getParent() == windowDesktop) EndMenu();
2081 if (GetCapture() == Win32Hwnd) ReleaseCapture();
2082 return 0;
2083
2084 case WM_DROPOBJECT:
2085 return DRAG_FILE;
2086
2087 case WM_QUERYDROPOBJECT:
2088 return (dwExStyle & WS_EX_ACCEPTFILES) ? 1:0;
2089
2090 case WM_QUERYDRAGICON:
2091 {
2092 HICON hDragIcon = windowClass->getCursor();
2093 UINT len;
2094
2095 if(hDragIcon) return (LRESULT)hDragIcon;
2096 for(len = 1; len < 64; len++)
2097 {
2098 hDragIcon = LoadIconA(hInstance,MAKEINTRESOURCEA(len));
2099 if(hDragIcon)
2100 return (LRESULT)hDragIcon;
2101 }
2102 return (LRESULT)LoadIconA(0,IDI_APPLICATIONA);
2103 }
2104
2105 case WM_QUERYOPEN:
2106 case WM_QUERYENDSESSION:
2107 return 1;
2108
2109 case WM_NOTIFYFORMAT:
2110 return IsWindowUnicode() ? NFR_UNICODE:NFR_ANSI;
2111
2112 case WM_SETICON:
2113 case WM_GETICON:
2114 {
2115 LRESULT result = 0;
2116
2117 /* Set the appropriate icon members in the window structure. */
2118 if (wParam == ICON_SMALL)
2119 {
2120 result = hIconSm;
2121 if (Msg == WM_SETICON)
2122 hIconSm = (HICON)lParam;
2123 }
2124 else
2125 {
2126 result = hIcon;
2127 if (Msg == WM_SETICON)
2128 {
2129 hIcon = (HICON)lParam;
2130 if ((dwStyle & WS_CAPTION) == WS_CAPTION)
2131 OSLibWinSetIcon(OS2HwndFrame,hIcon);
2132 }
2133 }
2134 if ((Msg == WM_SETICON) && ((dwStyle & WS_CAPTION) == WS_CAPTION))
2135 HandleNCPaint((HRGN)1);
2136
2137 return result;
2138 }
2139
2140 case WM_HELP:
2141 if (getParent()) SendMessageA(getParent()->getWindowHandle(), Msg,wParam,lParam);
2142 break;
2143
2144 case WM_NOTIFY:
2145 return 0; //comctl32 controls expect this
2146
2147 default:
2148 return 0;
2149 }
2150 return 0;
2151}
2152//******************************************************************************
2153//******************************************************************************
2154LRESULT Win32BaseWindow::DefWindowProcW(UINT Msg, WPARAM wParam, LPARAM lParam)
2155{
2156 switch(Msg)
2157 {
2158 case WM_GETTEXTLENGTH:
2159 return windowNameLength;
2160
2161 case WM_GETTEXT:
2162 if (!lParam || !wParam)
2163 return 0;
2164 if (!windowNameW)
2165 ((LPWSTR)lParam)[0] = 0;
2166 else
2167 memcpy((LPSTR)lParam, windowNameW, min( sizeof(WCHAR) * (windowNameLength+1), wParam) );
2168 return min(windowNameLength, wParam);
2169
2170 case WM_SETTEXT:
2171 {
2172 LPWSTR lpsz = (LPWSTR)lParam;
2173
2174 // reallocate if new buffer is larger
2175 if (!lParam)
2176 {
2177 free(windowNameA);
2178 free(windowNameW);
2179 windowNameLength = 0;
2180 windowNameA = NULL;
2181 windowNameW = NULL;
2182 }
2183 else
2184 {
2185 // determine length of new text
2186 int iTextLength = lstrlenW(lpsz);
2187
2188 if (windowNameLength < iTextLength)
2189 {
2190 if (windowNameA)
2191 {
2192 free(windowNameA);
2193 windowNameA = NULL;
2194 }
2195
2196 if (windowNameW)
2197 {
2198 free(windowNameW);
2199 windowNameW = NULL;
2200 }
2201 }
2202
2203 windowNameLength = iTextLength;
2204 if(!windowNameW)
2205 windowNameW = (LPWSTR)_smalloc((windowNameLength+1)*sizeof(WCHAR));
2206 memcpy(windowNameW, lpsz, (windowNameLength+1) * sizeof(WCHAR));
2207 if(!windowNameA)
2208 windowNameA = (LPSTR)_smalloc(windowNameLength+1);
2209 lstrcpynWtoA(windowNameA, windowNameW, windowNameLength+1);
2210 }
2211
2212 dprintf(("WM_SETTEXT of %x\n",Win32Hwnd));
2213 if ((dwStyle & WS_CAPTION) == WS_CAPTION)
2214 {
2215 HandleNCPaint((HRGN)1);
2216 if(hTaskList) {
2217 OSLibWinChangeTaskList(hTaskList, OS2HwndFrame, getWindowNameA(), (getStyle() & WS_VISIBLE) ? 1 : 0);
2218 }
2219 if(fOS2Look) {
2220 OSLibWinSetTitleBarText(OS2HwndFrame, getWindowNameA());
2221 }
2222 }
2223
2224 return TRUE;
2225 }
2226
2227 default:
2228 return DefWindowProcA(Msg, wParam, lParam);
2229 }
2230}
2231//******************************************************************************
2232//******************************************************************************
2233void Win32BaseWindow::NotifyParent(UINT Msg, WPARAM wParam, LPARAM lParam)
2234{
2235 Win32BaseWindow *window = this;
2236 Win32BaseWindow *parentwindow;
2237
2238 while(window)
2239 {
2240 if(window->getStyle() & WS_CHILD && !(window->getExStyle() & WS_EX_NOPARENTNOTIFY) )
2241 {
2242 /* Notify the parent window only */
2243 parentwindow = window->getParent();
2244 if(parentwindow) {
2245 SendMessageA(parentwindow->getWindowHandle(), WM_PARENTNOTIFY, MAKEWPARAM(Msg, getWindowId()), lParam );
2246 }
2247 }
2248 else break;
2249
2250 window = parentwindow;
2251 }
2252}
2253//******************************************************************************
2254// Returns the big or small icon for the window, falling back to the
2255// class as windows does.
2256//******************************************************************************
2257HICON Win32BaseWindow::IconForWindow(WPARAM fType)
2258{
2259 HICON hWndIcon;
2260
2261 if (fType == ICON_BIG)
2262 {
2263 if (hIcon)
2264 hWndIcon = hIcon;
2265 else
2266 if (windowClass && windowClass->getIcon())
2267 hWndIcon = windowClass->getIcon();
2268 else
2269 if (!(dwStyle & DS_MODALFRAME))
2270 hWndIcon = LoadImageA(0,MAKEINTRESOURCEA(OIC_ODINICON),IMAGE_ICON,0,0,LR_DEFAULTCOLOR);
2271 else hWndIcon = 0;
2272 }
2273 else
2274 {
2275 if (hIconSm)
2276 hWndIcon = hIconSm;
2277 else
2278 if (hIcon)
2279 hWndIcon = hIcon;
2280 else
2281 if (windowClass && windowClass->getIconSm())
2282 hWndIcon = windowClass->getIconSm();
2283 else
2284 if (windowClass && windowClass->getIcon())
2285 hWndIcon = windowClass->getIcon();
2286 else
2287 if (!(dwStyle & DS_MODALFRAME))
2288 hWndIcon = LoadImageA(0,MAKEINTRESOURCEA(OIC_ODINICON),IMAGE_ICON,0,0,LR_DEFAULTCOLOR);
2289 else hWndIcon = 0;
2290 }
2291
2292 return hWndIcon;
2293}
2294//******************************************************************************
2295//******************************************************************************
2296BOOL Win32BaseWindow::ShowWindow(ULONG nCmdShow)
2297{
2298 ULONG swp = 0;
2299 HWND hWinAfter;
2300 BOOL rc,wasVisible,showFlag;
2301 RECT newPos = {0, 0, 0, 0};
2302
2303 dprintf(("ShowWindow %x %x", getWindowHandle(), nCmdShow));
2304 wasVisible = (getStyle() & WS_VISIBLE) != 0;
2305
2306 dwOldStyle = getStyle();
2307
2308 switch(nCmdShow)
2309 {
2310 case SW_HIDE:
2311 if (!wasVisible) goto END;
2312
2313 swp |= SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER;
2314 break;
2315
2316 case SW_SHOWMINNOACTIVE:
2317 swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2318 /* fall through */
2319 case SW_SHOWMINIMIZED:
2320 swp |= SWP_SHOWWINDOW;
2321 /* fall through */
2322 case SW_MINIMIZE:
2323 swp |= SWP_FRAMECHANGED;
2324 if( !(getStyle() & WS_MINIMIZE) ) {
2325 swp |= MinMaximize(SW_MINIMIZE, &newPos );
2326 fMinMaxChange = TRUE; //-> invalidate entire window in WM_CALCINVALIDRECT
2327 }
2328 else swp |= SWP_NOSIZE | SWP_NOMOVE;
2329 break;
2330
2331 case SW_SHOWMAXIMIZED: /* same as SW_MAXIMIZE */
2332 swp |= SWP_SHOWWINDOW | SWP_FRAMECHANGED;
2333 if( !(getStyle() & WS_MAXIMIZE) ) {
2334 swp |= MinMaximize(SW_MAXIMIZE, &newPos );
2335 fMinMaxChange = TRUE; //-> invalidate entire window in WM_CALCINVALIDRECT
2336 }
2337 else swp |= SWP_NOSIZE | SWP_NOMOVE;
2338 break;
2339
2340 case SW_SHOWNA:
2341 swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2342 /* fall through */
2343 case SW_SHOW:
2344 swp |= SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
2345
2346 /*
2347 * ShowWindow has a little peculiar behavior that if the
2348 * window is already the topmost window, it will not
2349 * activate it.
2350 */
2351 if (::GetTopWindow((HWND)0)==getWindowHandle() && (wasVisible || GetActiveWindow() == getWindowHandle()))
2352 swp |= SWP_NOACTIVATE;
2353
2354 break;
2355
2356 case SW_SHOWNOACTIVATE:
2357 swp |= SWP_NOZORDER;
2358 if (GetActiveWindow())
2359 swp |= SWP_NOACTIVATE;
2360 /* fall through */
2361 case SW_SHOWNORMAL: /* same as SW_NORMAL: */
2362 case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
2363 case SW_RESTORE:
2364 dprintf(("ShowWindow:restoring window"));
2365
2366 swp |= SWP_SHOWWINDOW | SWP_FRAMECHANGED;
2367 if( getStyle() & (WS_MINIMIZE | WS_MAXIMIZE) ) {
2368 swp |= MinMaximize(SW_RESTORE, &newPos );
2369 fMinMaxChange = TRUE; //-> invalidate entire window in WM_CALCINVALIDRECT
2370 }
2371 else swp |= SWP_NOSIZE | SWP_NOMOVE;
2372 break;
2373 }
2374
2375 showFlag = (nCmdShow != SW_HIDE);
2376 if (showFlag != wasVisible)
2377 {
2378 SendMessageA(getWindowHandle(),WM_SHOWWINDOW, showFlag, 0 );
2379 if (!::IsWindow( getWindowHandle() )) goto END;
2380 }
2381
2382 /* We can't activate a child window */
2383 if((getStyle() & WS_CHILD) && !(getExStyle() & WS_EX_MDICHILD))
2384 swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2385
2386 if (!(getStyle() & WS_MINIMIZE)) {
2387 SetWindowPos(HWND_TOP, newPos.left, newPos.top, newPos.right, newPos.bottom, LOWORD(swp), TRUE);
2388 }
2389 else OSLibWinMinimizeWindow(getOS2FrameWindowHandle());
2390
2391 if(!(swp & SWP_NOACTIVATE) && (!(getStyle() & WS_MINIMIZE))) {
2392 OSLibWinSetActiveWindow(OS2HwndFrame);
2393 }
2394
2395 if (flags & WIN_NEED_SIZE)
2396 {
2397 /* should happen only in CreateWindowEx() */
2398 int wParam = SIZE_RESTORED;
2399
2400 flags &= ~WIN_NEED_SIZE;
2401 if (dwStyle & WS_MAXIMIZE)
2402 wParam = SIZE_MAXIMIZED;
2403 else
2404 if (dwStyle & WS_MINIMIZE)
2405 wParam = SIZE_MINIMIZED;
2406
2407 SendMessageA(getWindowHandle(),WM_SIZE, wParam,
2408 MAKELONG(rectClient.right-rectClient.left,
2409 rectClient.bottom-rectClient.top));
2410 SendMessageA(getWindowHandle(),WM_MOVE,0,MAKELONG(rectClient.left,rectClient.top));
2411 }
2412//testestest
2413 //temporary workaround for file dialogs with template dialog child
2414 //they don't redraw when switching directories
2415 //For some reason the new child's (syslistview32) update rectangle stays
2416 //empty after its parent is made visible with ShowWindow
2417 //TODO: find real cause
2418 if(!wasVisible) {
2419 InvalidateRect(getWindowHandle(), NULL, TRUE);
2420 }
2421//testestest
2422
2423END:
2424 fMinMaxChange = FALSE;
2425 return wasVisible;
2426}
2427//******************************************************************************
2428//******************************************************************************
2429BOOL Win32BaseWindow::SetWindowPos(HWND hwndInsertAfter, int x, int y, int cx,
2430 int cy, UINT fuFlags, BOOL fShowWindow)
2431{
2432 BOOL rc = FALSE;
2433 Win32BaseWindow *window;
2434 HWND hParent = 0;
2435 RECT oldClientRect = rectClient;
2436
2437 if (fuFlags &
2438 ~(SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER |
2439 SWP_NOREDRAW | SWP_NOACTIVATE | SWP_FRAMECHANGED |
2440 SWP_SHOWWINDOW | SWP_HIDEWINDOW | SWP_NOCOPYBITS |
2441 SWP_NOOWNERZORDER | SWP_NOSENDCHANGING | SWP_DEFERERASE |
2442 SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_ASYNCWINDOWPOS))
2443 {
2444 dprintf(("ERROR: SetWindowPos; UNKNOWN flag"));
2445 return FALSE;
2446 }
2447
2448 if( fuFlags & (SWP_DEFERERASE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_ASYNCWINDOWPOS)) {
2449 dprintf(("WARNING: SetWindowPos; unsupported flag"));
2450 }
2451
2452 if(IsWindowDestroyed()) {
2453 //changing the position of a window that's being destroyed can cause crashes in PMMERGE
2454 dprintf(("SetWindowPos; window already destroyed"));
2455 return TRUE;
2456 }
2457
2458#if 0
2459 /* Fix redundant flags */
2460 if(getStyle() & WS_VISIBLE) {
2461 fuFlags &= ~SWP_SHOWWINDOW;
2462 }
2463 else
2464 {
2465 if (!(fuFlags & SWP_SHOWWINDOW))
2466 fuFlags |= SWP_NOREDRAW;
2467 fuFlags &= ~SWP_HIDEWINDOW;
2468 }
2469
2470//// if(cx < 0) cx = 0;
2471//// if(cy < 0) cy = 0;
2472
2473 if((rectWindow.right - rectWindow.left == cx) && (rectWindow.bottom - rectWindow.top == cy)) {
2474 fuFlags |= SWP_NOSIZE; /* Already the right size */
2475 }
2476
2477 if((rectWindow.left == x) && (rectWindow.top == y)) {
2478 fuFlags |= SWP_NOMOVE; /* Already the right position */
2479 }
2480
2481 if(getWindowHandle() == GetActiveWindow()) {
2482 fuFlags |= SWP_NOACTIVATE; /* Already active */
2483 }
2484 else
2485 if((getStyle() & (WS_POPUP | WS_CHILD)) != WS_CHILD )
2486 {
2487 if(!(fuFlags & SWP_NOACTIVATE)) /* Bring to the top when activating */
2488 {
2489 fuFlags &= ~SWP_NOZORDER;
2490 hwndInsertAfter = HWND_TOP;
2491 }
2492 }
2493 /* TODO: Check hwndInsertAfter */
2494#endif
2495
2496 //Note: Solitaire crashes when receiving WM_SIZE messages before WM_CREATE
2497 if(state < STATE_POST_WMNCCREATE)
2498 {//don't change size; modify internal structures only
2499 //TODO: not 100% correct yet (activate)
2500 dprintf2(("state < STATE_POST_WMNCCREATE"));
2501 if(!(fuFlags & SWP_NOZORDER)) {
2502 hwndLinkAfter = hwndInsertAfter;
2503 }
2504 if(!(fuFlags & SWP_NOMOVE)) {
2505 rectWindow.bottom = (rectWindow.bottom - rectWindow.top) + y;
2506 rectWindow.top = y;
2507 rectWindow.right = (rectWindow.right - rectWindow.left) + x;
2508 rectWindow.left = x;
2509 }
2510 if(!(fuFlags & SWP_NOSIZE)) {
2511 rectWindow.bottom = rectWindow.top + cy;
2512 rectWindow.right = rectWindow.left + cx;
2513 }
2514 return TRUE;
2515 }
2516
2517 WINDOWPOS wpos;
2518 SWP swp, swpOld;
2519 wpos.flags = fuFlags;
2520 wpos.cy = cy;
2521 wpos.cx = cx;
2522 wpos.x = x;
2523 wpos.y = y;
2524 wpos.hwndInsertAfter = hwndInsertAfter;
2525 wpos.hwnd = getWindowHandle();
2526
2527 if(~fuFlags & (SWP_NOMOVE | SWP_NOSIZE))
2528 {
2529 if (isChild())
2530 {
2531 if(!getParent()) {
2532 dprintf(("WARNING: Win32BaseWindow::SetWindowPos window %x is child but has no parent!!", getWindowHandle()));
2533 }
2534 }
2535 OSLibWinQueryWindowPos(OS2HwndFrame, &swpOld);
2536 }
2537 if((dwOldStyle & WS_MINIMIZE) && (getStyle() & WS_MINIMIZE))
2538 {//don't allow size changes if the window is minimized
2539 //we will update the restore position at the end of this method
2540 if(!(wpos.flags & SWP_NOSIZE)) {
2541 //TODO: updating the window rectangle doesn't look right
2542 wpos.flags |= SWP_NOSIZE;
2543 rectWindow.right = rectWindow.left + wpos.cx;
2544 rectWindow.bottom = rectWindow.top + wpos.cy;
2545 dprintf(("WARNING: Don't allow size change for minimized window; only save new restore position"));
2546 dprintf(("new window rectangle (%d,%d)(%d,%d)", rectWindow.left, rectWindow.top, rectWindow.right, rectWindow.bottom));
2547 }
2548 }
2549
2550 if(getParent()) {
2551 OSLibMapWINDOWPOStoSWP(&wpos, &swp, &swpOld, getParent()->getClientHeight(),
2552 OS2HwndFrame);
2553 }
2554 else OSLibMapWINDOWPOStoSWP(&wpos, &swp, &swpOld, OSLibQueryScreenHeight(), OS2HwndFrame);
2555
2556 if (swp.fl == 0) {
2557 dprintf2(("swp.fl == 0"));
2558 if(fuFlags & SWP_FRAMECHANGED)
2559 {
2560 NotifyFrameChanged(&wpos, &oldClientRect);
2561 }
2562 if(!fShowWindow)
2563 {
2564 //Restore position always changes when the window position is changed
2565 dprintf(("Save new restore position (%d,%d)(%d,%d)", rectWindow.left, rectWindow.top, rectWindow.right, rectWindow.bottom));
2566 windowpos.rcNormalPosition = rectWindow;
2567 }
2568 return TRUE;
2569 }
2570
2571// if ((swp.fl & SWPOS_ZORDER) && (swp.hwndInsertBehind > HWNDOS_BOTTOM))
2572 if ((swp.hwndInsertBehind > HWNDOS_BOTTOM))
2573 {
2574 Win32BaseWindow *wndBehind = Win32BaseWindow::GetWindowFromHandle(swp.hwndInsertBehind);
2575 if(wndBehind) {
2576 swp.hwndInsertBehind = wndBehind->getOS2FrameWindowHandle();
2577 RELEASE_WNDOBJ(wndBehind);
2578 }
2579 else {
2580 dprintf(("ERROR: SetWindowPos: hwndInsertBehind %x invalid!",swp.hwndInsertBehind));
2581 swp.hwndInsertBehind = 0;
2582 }
2583 }
2584 swp.hwnd = OS2HwndFrame;
2585
2586 //SvL: Must also deactivate the window when hiding it or else focus won't
2587 // change. (NOTE: make sure this doesn't cause regressions (01-02-2003)
2588 if((swp.fl & (SWPOS_HIDE|SWPOS_DEACTIVATE)) == (SWPOS_HIDE|SWPOS_DEACTIVATE))
2589 {
2590 //we must make sure the owner is not disabled or else the focus will
2591 //be switched to the wrong window
2592 Win32BaseWindow *topOwner;
2593
2594 if(getOwner() == NULL) {
2595 windowDesktop->addRef();
2596 topOwner = windowDesktop;
2597 }
2598 else topOwner = GetWindowFromHandle(getOwner()->GetTopParent());
2599
2600 if(topOwner != NULL) {
2601 DWORD dwStyle = topOwner->GetWindowLong(GWL_STYLE, FALSE);
2602 if(dwStyle & WS_DISABLED) {
2603 swp.fl &= ~SWPOS_DEACTIVATE;
2604 }
2605 }
2606 else DebugInt3();
2607 }
2608
2609 if(fuFlags & SWP_SHOWWINDOW && !IsWindowVisible(getWindowHandle())) {
2610 setStyle(getStyle() | WS_VISIBLE);
2611 if(hTaskList) {
2612 dprintf(("Adding window %x to tasklist", getWindowHandle()));
2613 OSLibWinChangeTaskList(hTaskList, OS2HwndFrame, getWindowNameA(), 1);
2614 }
2615 }
2616 else
2617 if((fuFlags & SWP_HIDEWINDOW) && IsWindowVisible(getWindowHandle())) {
2618 setStyle(getStyle() & ~WS_VISIBLE);
2619 if(hTaskList && !(getStyle() & WS_MINIMIZE)) {
2620 dprintf(("Removing window %x from tasklist", getWindowHandle()));
2621 OSLibWinChangeTaskList(hTaskList, OS2HwndFrame, getWindowNameA(), 0);
2622 }
2623 }
2624 dprintf (("WinSetWindowPos %x %x (%d,%d)(%d,%d) %x", swp.hwnd, swp.hwndInsertBehind, swp.x, swp.y, swp.cx, swp.cy, swp.fl));
2625
2626 rc = OSLibWinSetMultWindowPos(&swp, 1);
2627 if(rc == FALSE)
2628 {
2629 dprintf(("OSLibWinSetMultWindowPos failed! Error %x",OSLibWinGetLastError()));
2630 return 0;
2631 }
2632
2633 if((fuFlags & SWP_FRAMECHANGED) && (fuFlags & (SWP_NOMOVE | SWP_NOSIZE) == (SWP_NOMOVE | SWP_NOSIZE)))
2634 {
2635 NotifyFrameChanged(&wpos, &oldClientRect);
2636 }
2637 if(!fShowWindow)
2638 {
2639 //Restore position always changes when the window position is changed
2640 dprintf(("Save new restore position (%d,%d)(%d,%d)", rectWindow.left, rectWindow.top, rectWindow.right, rectWindow.bottom));
2641 windowpos.rcNormalPosition = rectWindow;
2642 }
2643 //MSDN says the entire client area will be invalidated when SWP_NOCOPYBITS
2644 //is specified (fixes repaint issues when window is made smaller)
2645 if((fuFlags & (SWP_NOCOPYBITS|SWP_NOREDRAW)) == SWP_NOCOPYBITS) {
2646 InvalidateRect(getWindowHandle(), NULL, TRUE);
2647 }
2648 return (rc);
2649}
2650//******************************************************************************
2651//Called by ScrollWindowEx (dc.cpp) to notify child window that it has moved
2652//******************************************************************************
2653BOOL Win32BaseWindow::ScrollWindow(int dx, int dy)
2654{
2655 rectWindow.left += dx;
2656 rectWindow.right += dx;
2657 rectWindow.top += dy;
2658 rectWindow.bottom += dy;
2659 SendMessageA(getWindowHandle(),WM_MOVE, 0, MAKELONG(rectClient.left, rectClient.top));
2660 return TRUE;
2661}
2662//******************************************************************************
2663//******************************************************************************
2664void Win32BaseWindow::NotifyFrameChanged(WINDOWPOS *wpos, RECT *oldClientRect)
2665{
2666 HRGN hrgn, hrgnClient;
2667 RECT rect;
2668
2669 MsgFormatFrame(NULL);
2670
2671 if(RECT_WIDTH(rectClient) != RECT_WIDTH(*oldClientRect) ||
2672 RECT_HEIGHT(rectClient) != RECT_HEIGHT(*oldClientRect))
2673 {
2674 wpos->flags &= ~(SWP_NOSIZE|SWP_NOCLIENTSIZE);
2675 wpos->cx = RECT_WIDTH(rectWindow);
2676 wpos->cy = RECT_HEIGHT(rectWindow);
2677 }
2678
2679 if(rectClient.left != oldClientRect->left ||
2680 rectClient.top != oldClientRect->top)
2681 {
2682 wpos->flags &= ~(SWP_NOMOVE|SWP_NOCLIENTMOVE);
2683 wpos->x = rectWindow.left;
2684 wpos->y = rectWindow.top;
2685 }
2686
2687 WINDOWPOS wpOld = *wpos;
2688 if(!(wpos->flags & SWP_NOSENDCHANGING))
2689 SendMessageA(getWindowHandle(),WM_WINDOWPOSCHANGING, 0, (LPARAM)wpos);
2690
2691 if ((wpos->hwndInsertAfter != wpOld.hwndInsertAfter) ||
2692 (wpos->x != wpOld.x) || (wpos->y != wpOld.y) || (wpos->cx != wpOld.cx) || (wpos->cy != wpOld.cy) || (wpos->flags != wpOld.flags))
2693 {
2694 dprintf(("WARNING, NotifyFrameChanged: TODO -> adjust flags!!!!"));
2695 SetWindowPos(wpos->hwndInsertAfter, wpos->x, wpos->y, wpos->cx, wpos->cy, wpos->flags | SWP_NOSENDCHANGING);
2696 }
2697 else SendMessageA(getWindowHandle(),WM_WINDOWPOSCHANGED, 0, (LPARAM)wpos);
2698
2699 //Calculate invalid areas
2700 rect = rectWindow;
2701 OffsetRect(&rect, -rectWindow.left, -rectWindow.top);
2702 hrgn = CreateRectRgnIndirect(&rect);
2703 if (!hrgn) {
2704 dprintf(("ERROR: NotifyFrameChanged, CreateRectRgnIndirect failed!!"));
2705 return;
2706 }
2707 rect = rectClient;
2708 hrgnClient = CreateRectRgnIndirect(&rect);
2709 if (!hrgn) {
2710 dprintf(("ERROR: NotifyFrameChanged, CreateRectRgnIndirect failed!!"));
2711 return;
2712 }
2713 CombineRgn(hrgn, hrgn, hrgnClient, RGN_DIFF);
2714 DeleteObject(hrgnClient);
2715
2716 if(!EqualRect(oldClientRect, &rectClient)) {
2717 UnionRect(oldClientRect, oldClientRect, &rectClient);
2718 hrgnClient = CreateRectRgnIndirect(oldClientRect);
2719 if (!hrgn) {
2720 dprintf(("ERROR: NotifyFrameChanged, CreateRectRgnIndirect failed!!"));
2721 return;
2722 }
2723 CombineRgn(hrgn, hrgn, hrgnClient, RGN_OR);
2724 DeleteObject(hrgnClient);
2725 }
2726 RedrawWindow(getWindowHandle(), NULL, hrgn, RDW_ALLCHILDREN |
2727 RDW_INVALIDATE | RDW_ERASE | RDW_FRAME);
2728 DeleteObject(hrgn);
2729}
2730//******************************************************************************
2731//TODO: Check how this api really works in NT
2732//******************************************************************************
2733BOOL Win32BaseWindow::SetWindowPlacement(WINDOWPLACEMENT *wndpl)
2734{
2735 dprintf(("SetWindowPlacement %x min (%d,%d)", getWindowHandle(), wndpl->ptMinPosition.x, wndpl->ptMinPosition.y));
2736 dprintf(("SetWindowPlacement %x max (%d,%d)", getWindowHandle(), wndpl->ptMaxPosition.x, wndpl->ptMaxPosition.y));
2737 dprintf(("SetWindowPlacement %x norm (%d,%d)(%d,%d)", getWindowHandle(), wndpl->rcNormalPosition.left, wndpl->rcNormalPosition.top, wndpl->rcNormalPosition.right, wndpl->rcNormalPosition.bottom));
2738 windowpos.ptMinPosition = wndpl->ptMinPosition;
2739 windowpos.ptMaxPosition = wndpl->ptMaxPosition;
2740 windowpos.rcNormalPosition = wndpl->rcNormalPosition;
2741
2742 if(getStyle() & WS_MINIMIZE )
2743 {
2744 //TODO: Why can't this be (0,0)?
2745 if(wndpl->flags & WPF_SETMINPOSITION && !(!windowpos.ptMinPosition.x && !windowpos.ptMinPosition.y)) {
2746 SetWindowPos(0, windowpos.ptMinPosition.x, windowpos.ptMinPosition.y,
2747 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
2748 }
2749 }
2750 else
2751 if(getStyle() & WS_MAXIMIZE )
2752 {
2753 //TODO: Why can't this be (0,0)?
2754 if(windowpos.ptMaxPosition.x != 0 || windowpos.ptMaxPosition.y != 0 )
2755 SetWindowPos(0, windowpos.ptMaxPosition.x, windowpos.ptMaxPosition.y,
2756 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
2757 }
2758 else {
2759 SetWindowPos(0, windowpos.rcNormalPosition.left, windowpos.rcNormalPosition.top,
2760 windowpos.rcNormalPosition.right - windowpos.rcNormalPosition.left,
2761 windowpos.rcNormalPosition.bottom - windowpos.rcNormalPosition.top,
2762 SWP_NOZORDER | SWP_NOACTIVATE );
2763 }
2764 ShowWindow(wndpl->showCmd);
2765 if( ::IsWindow(getWindowHandle()) && getStyle() & WS_MINIMIZE )
2766 {
2767 /* SDK: ...valid only the next time... */
2768 if(wndpl->flags & WPF_RESTORETOMAXIMIZED)
2769 setFlags(getFlags() | WIN_RESTORE_MAX);
2770 }
2771 return TRUE;
2772}
2773//******************************************************************************
2774//******************************************************************************
2775BOOL Win32BaseWindow::GetWindowPlacement(LPWINDOWPLACEMENT wndpl)
2776{
2777 wndpl->length = sizeof(*wndpl);
2778 if(getStyle() & WS_MINIMIZE )
2779 wndpl->showCmd = SW_SHOWMINIMIZED;
2780 else wndpl->showCmd = (getStyle() & WS_MAXIMIZE) ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL;
2781
2782 //TODO: Verify if this is correct -> SDK docs claim this flag must always be set to 0
2783 if(getFlags() & WIN_RESTORE_MAX )
2784 wndpl->flags = WPF_RESTORETOMAXIMIZED;
2785 else wndpl->flags = 0;
2786
2787 wndpl->ptMinPosition = windowpos.ptMinPosition;
2788 wndpl->ptMaxPosition = windowpos.ptMaxPosition;
2789 //Must be in parent coordinates (or screen if no parent); verified in NT4, SP6
2790 wndpl->rcNormalPosition = windowpos.rcNormalPosition;
2791
2792 return TRUE;
2793}
2794//******************************************************************************
2795//Also destroys all the child windows (destroy children first, parent last)
2796//TODO: Don't rely on PM to do the right thing. Send WM_(NC)DESTROY &
2797// destroy children ourselves (see Wine)
2798//******************************************************************************
2799BOOL Win32BaseWindow::DestroyWindow()
2800{
2801 HWND hwnd = getWindowHandle();
2802
2803 dprintf(("DestroyWindow %x", hwnd));
2804
2805#if 0
2806 /* Look whether the focus is within the tree of windows we will
2807 * be destroying.
2808 */
2809 HWND hwndFocus = GetFocus();
2810 if (hwndFocus == hwnd || ::IsChild( hwnd, hwndFocus ))
2811 {
2812 HWND parent = GetAncestor( hwnd, GA_PARENT );
2813 if (parent == GetDesktopWindow()) parent = 0;
2814 SetFocus( parent );
2815 }
2816#endif
2817 /* Call hooks */
2818 if(HOOK_CallHooksA( WH_CBT, HCBT_DESTROYWND, getWindowHandle(), 0L))
2819 {
2820 return FALSE;
2821 }
2822
2823 if(!(getStyle() & WS_CHILD) && getOwner() == NULL)
2824 {
2825 HOOK_CallHooksA(WH_SHELL, HSHELL_WINDOWDESTROYED, getWindowHandle(), 0L);
2826 /* FIXME: clean up palette - see "Internals" p.352 */
2827 }
2828
2829 if((getStyle() & WS_CHILD) && !(getExStyle() & WS_EX_NOPARENTNOTIFY))
2830 {
2831 if(getParent() && getParent()->IsWindowDestroyed() == FALSE)
2832 {
2833 /* Notify the parent window only */
2834 SendMessageA(getParent()->getWindowHandle(), WM_PARENTNOTIFY, MAKEWPARAM(WM_DESTROY, getWindowId()), (LPARAM)getWindowHandle());
2835 if(!::IsWindow(hwnd) )
2836 {
2837 return TRUE;
2838 }
2839 }
2840//// else DebugInt3();
2841 }
2842 /* Hide the window */
2843 if(IsWindowVisible(getWindowHandle()))
2844 {
2845 SetWindowPos(0, 0, 0, 0, 0, SWP_HIDEWINDOW |
2846 SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE);
2847 if(!::IsWindow(hwnd))
2848 {
2849 return TRUE;
2850 }
2851 }
2852 dprintf(("DestroyWindow %x -> HIDDEN", hwnd));
2853
2854 // check the handle for the last active popup window
2855 Win32BaseWindow* owner = getOwner();
2856 if (NULL != owner)
2857 {
2858 if (owner->getLastActive() == hwnd)
2859 owner->setLastActive( owner->getWindowHandle() );
2860
2861 //SvL: Not sure this is correct, but it solves the problem of reassigning
2862 // activation. A disabled window will never be activated ->
2863 // possible that the wrong window is chosen by PM.
2864 // PM chooses another window to be activated before WM_DESTROY is
2865 // sent. VPC enables the owner when it receives that message,
2866 // but by then it's too late.
2867 // (MFC created modeless dialog)
2868 //TODO: This might be the wrong place to do it. EndDialog is called,
2869 // so perhaps it should be done there. (although Wine only
2870 // enables the owner if the dialog is modal)
2871 ::EnableWindow(owner->getWindowHandle(), 1);
2872 }
2873
2874 fDestroyWindowCalled = TRUE;
2875
2876//hack alert; PM crashes if child calls DestroyWindow for parent/owner in WM_DESTROY
2877// handler; must postpone it
2878 if(fChildDestructionInProgress) {
2879 dprintf(("Postponing parent destruction because of dying child"));
2880 OSLibPostMessageDirect(OS2HwndFrame, WIN32APP_POSTPONEDESTROY, 0, 0);
2881 return TRUE;
2882 }
2883
2884 BOOL fOldChildDestructionInProgress = FALSE;
2885 if(GetParent()) {
2886 Win32BaseWindow *window = Win32BaseWindow::GetWindowFromHandle(GetParent());
2887 if(window) {
2888 fOldChildDestructionInProgress = window->IsChildDestructionInProgress();
2889 window->SetChildDestructionInProgress(TRUE);
2890 RELEASE_WNDOBJ(window);
2891 }
2892 }
2893//hack end
2894
2895 BOOL ret = OSLibWinDestroyWindow(OS2HwndFrame);
2896
2897//hack alert; PM crashes if child calls DestroyWindow for parent/owner in WM_DESTROY
2898// handler; must postpone it
2899 if(GetParent()) {
2900 Win32BaseWindow *window = Win32BaseWindow::GetWindowFromHandle(GetParent());
2901 if(window) {
2902 window->SetChildDestructionInProgress(fOldChildDestructionInProgress);
2903 RELEASE_WNDOBJ(window);
2904 }
2905 }
2906//hack end
2907 return ret;
2908}
2909//******************************************************************************
2910//******************************************************************************
2911Win32BaseWindow *Win32BaseWindow::getParent()
2912{
2913 Win32BaseWindow *wndparent = (Win32BaseWindow *)ChildWindow::getParentOfChild();
2914 //experiment
2915#if 0
2916 return ((ULONG)wndparent == (ULONG)windowDesktop) ? NULL : wndparent;
2917#else
2918 return wndparent;
2919#endif
2920}
2921//******************************************************************************
2922//Note: does not set last error if no parent (verified in NT4, SP6)
2923//******************************************************************************
2924HWND Win32BaseWindow::GetParent()
2925{
2926 Win32BaseWindow *wndparent = (Win32BaseWindow *)ChildWindow::getParentOfChild();
2927
2928 if(getStyle() & WS_CHILD)
2929 {
2930 if(wndparent) {
2931 return wndparent->getWindowHandle();
2932 }
2933 dprintf(("WARNING: GetParent: WS_CHILD but no parent!!"));
2934 DebugInt3();
2935 return 0;
2936 }
2937 else
2938 if(getStyle() & WS_POPUP)
2939 return (getOwner()) ? getOwner()->getWindowHandle() : 0;
2940 else return 0;
2941}
2942//******************************************************************************
2943//******************************************************************************
2944HWND Win32BaseWindow::SetParent(HWND hwndNewParent)
2945{
2946 HWND oldhwnd;
2947 Win32BaseWindow *newparent;
2948 Win32BaseWindow *oldparent = (Win32BaseWindow *)ChildWindow::getParentOfChild();
2949 BOOL fShow = FALSE;
2950
2951 if(oldparent) {
2952 oldhwnd = oldparent->getWindowHandle();
2953 oldparent->removeChild(this);
2954 }
2955 else oldhwnd = 0;
2956
2957 /* Windows hides the window first, then shows it again
2958 * including the WM_SHOWWINDOW messages and all */
2959 if(IsWindowCreated() && (getStyle() & WS_VISIBLE)) {
2960 ShowWindow(SW_HIDE);
2961 fShow = TRUE;
2962 }
2963 if(oldparent) {
2964 //release parent here (increased refcount during creation)
2965 RELEASE_WNDOBJ(oldparent);
2966 }
2967 newparent = GetWindowFromHandle(hwndNewParent);
2968 if(newparent && !newparent->isDesktopWindow())
2969 {
2970 setParent(newparent);
2971 getParent()->addChild(this);
2972 fParentChange = TRUE;
2973 // in case we haven't finished creating the window whose parent we're
2974 // setting here, the OS/2 HWND might not exist yet and we call the PM
2975 // API with a NULLHANDLE - no problem
2976 // when we create the OS/2 window lateron, we will create it with the
2977 // right parent anyway.
2978 OSLibWinSetParent(getOS2FrameWindowHandle(), getParent()->getOS2WindowHandle());
2979 if(!(getStyle() & WS_CHILD))
2980 {
2981 if(getWindowId())
2982 {
2983 DestroyMenu( (HMENU) getWindowId() );
2984 setWindowId(0);
2985 }
2986 }
2987 //SvL: Even though the win32 coordinates might not change, the PM
2988 // coordinates can. We must make sure the control stays at the
2989 // same position (y) relative to the (new) parent.
2990 // TODO: shouldn't we check the state of the window and not do it in INIT state?
2991 SetWindowPos(HWND_TOPMOST, rectWindow.left, rectWindow.top, 0, 0,
2992 SWP_NOACTIVATE|SWP_NOSIZE);
2993 fParentChange = FALSE;
2994 }
2995 else {
2996 if(newparent) RELEASE_WNDOBJ(newparent);
2997
2998 setParent(windowDesktop);
2999 windowDesktop->addRef();
3000 windowDesktop->addChild(this);
3001 OSLibWinSetParent(getOS2FrameWindowHandle(), OSLIB_HWND_DESKTOP);
3002
3003 //Do not change the window id!
3004//// setWindowId(0);
3005 }
3006 /* SetParent additionally needs to make hwndChild the topmost window
3007 in the x-order and send the expected WM_WINDOWPOSCHANGING and
3008 WM_WINDOWPOSCHANGED notification messages.
3009 */
3010 if(state >= STATE_PRE_WMNCCREATE) {
3011 SetWindowPos(HWND_TOPMOST, 0, 0, 0, 0,
3012 SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|(fShow? SWP_SHOWWINDOW : 0));
3013
3014 /* FIXME: a WM_MOVE is also generated (in the DefWindowProc handler
3015 * for WM_WINDOWPOSCHANGED) in Windows, should probably remove SWP_NOMOVE */
3016 }
3017 return oldhwnd;
3018}
3019//******************************************************************************
3020//******************************************************************************
3021BOOL Win32BaseWindow::IsChild(HWND hwndParent)
3022{
3023 // PH: Optimizer won't unroll calls to getParent() even
3024 // in release build.
3025 Win32BaseWindow *_parent = getParent();
3026
3027 if(_parent)
3028 {
3029 if(_parent->getWindowHandle() == hwndParent)
3030 return TRUE;
3031
3032 return _parent->IsChild(hwndParent);
3033 }
3034 else
3035 return 0;
3036}
3037//******************************************************************************
3038//******************************************************************************
3039HWND Win32BaseWindow::GetTopWindow()
3040{
3041 HWND hwndTop;
3042 Win32BaseWindow *topwindow;
3043
3044 hwndTop = OSLibWinQueryWindow(getOS2WindowHandle(), QWOS_TOP);
3045 if(!isDesktopWindow())
3046 {
3047 topwindow = GetWindowFromOS2FrameHandle(hwndTop);
3048 //Note: GetTopWindow can't return a window that hasn't processed
3049 // WM_NCCREATE yet (verified in NT4, SP6)
3050 if(topwindow) {
3051 if(topwindow->state >= STATE_POST_WMNCCREATE) {
3052 hwndTop = topwindow->getWindowHandle();
3053 }
3054 else hwndTop = topwindow->GetWindow(GW_HWNDNEXT);
3055 RELEASE_WNDOBJ(topwindow);
3056 return hwndTop;
3057 }
3058 if(topwindow) RELEASE_WNDOBJ(topwindow);
3059 return 0;
3060 }
3061 while(hwndTop) {
3062 topwindow = GetWindowFromOS2FrameHandle(hwndTop);
3063 //Note: GetTopWindow can't return a window that hasn't processed
3064 // WM_NCCREATE yet (verified in NT4, SP6)
3065 if(topwindow) {
3066 if(topwindow->state >= STATE_POST_WMNCCREATE) {
3067 hwndTop = topwindow->getWindowHandle();
3068 }
3069 else hwndTop = topwindow->GetWindow(GW_HWNDNEXT);
3070 RELEASE_WNDOBJ(topwindow);
3071 return hwndTop;
3072 }
3073 if(topwindow) RELEASE_WNDOBJ(topwindow);
3074 hwndTop = OSLibWinQueryWindow(hwndTop, QWOS_NEXT);
3075 }
3076
3077 return 0;
3078}
3079//******************************************************************************
3080// Get the top-level parent for a child window.
3081//******************************************************************************
3082HWND Win32BaseWindow::GetTopParent()
3083{
3084 Win32BaseWindow *window = this;
3085 HWND hwndTopParent = 0;
3086
3087 lock();
3088 while(window && (window->getStyle() & WS_CHILD))
3089 {
3090 window = window->getParent();
3091 }
3092 if(window) {
3093 hwndTopParent = window->getWindowHandle();
3094 }
3095 unlock();
3096 return hwndTopParent;
3097}
3098//******************************************************************************
3099//TODO: Should not enumerate children that are created during the enumeration!
3100//TODO: Do this more efficiently
3101//******************************************************************************
3102BOOL Win32BaseWindow::EnumChildWindows(WNDENUMPROC lpfn, LPARAM lParam)
3103{
3104 BOOL rc = TRUE;
3105 HWND hwnd;
3106 Win32BaseWindow *prevchild = 0, *child = 0;
3107
3108 dprintf(("EnumChildWindows of %x parameter %x %x (%x)", getWindowHandle(), lpfn, lParam, getFirstChild()));
3109 lock();
3110 for (child = (Win32BaseWindow *)getFirstChild(); child != NULL; child = (Win32BaseWindow *)child->getNextChild())
3111 {
3112 dprintf(("EnumChildWindows: enumerating child %x (owner %x; parent %x)", child->getWindowHandle(), (child->getOwner()) ? child->getOwner()->getWindowHandle() : 0, getWindowHandle()));
3113 hwnd = child->getWindowHandle();
3114 if(child->IsWindowDestroyed() || child->getOwner()) {
3115 continue; //shouldn't have an owner (Wine)
3116 }
3117 child->addRef();
3118 unlock();
3119 if(lpfn(hwnd, lParam) == FALSE)
3120 {
3121 child->release();
3122 return FALSE;
3123 }
3124 child->release();
3125 lock();
3126 //check if the window still exists
3127 if(!::IsWindow(hwnd))
3128 {
3129 child = prevchild;
3130 if(child == NULL) break;
3131 continue;
3132 }
3133 if(child->getFirstChild() != NULL)
3134 {
3135 dprintf(("EnumChildWindows: Enumerate children of %x", child->getWindowHandle()));
3136 child->addRef();
3137 unlock();
3138 if(child->EnumChildWindows(lpfn, lParam) == FALSE)
3139 {
3140 child->release();
3141 return FALSE;
3142 }
3143 child->release();
3144 lock();
3145 }
3146 prevchild = child;
3147 }
3148 unlock();
3149 return rc;
3150}
3151//******************************************************************************
3152//Enumerate first-level children only and check thread id
3153//******************************************************************************
3154BOOL Win32BaseWindow::EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
3155{
3156 Win32BaseWindow *child = 0;
3157 ULONG tid, pid;
3158 BOOL rc;
3159 HWND hwnd;
3160
3161 dprintf(("EnumThreadWindows %x %x %x", dwThreadId, lpfn, lParam));
3162
3163 for (child = (Win32BaseWindow *)getFirstChild(); child; child = (Win32BaseWindow *)child->getNextChild())
3164 {
3165 OSLibWinQueryWindowProcess(child->getOS2WindowHandle(), &pid, &tid);
3166
3167 if(dwThreadId == tid) {
3168 dprintf2(("EnumThreadWindows: Found Window %x", child->getWindowHandle()));
3169 if((rc = lpfn(child->getWindowHandle(), lParam)) == FALSE) {
3170 break;
3171 }
3172 }
3173 }
3174 return TRUE;
3175}
3176//******************************************************************************
3177//Enumerate first-level children only
3178//******************************************************************************
3179BOOL Win32BaseWindow::EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
3180{
3181 Win32BaseWindow *window;
3182 BOOL rc;
3183 HWND hwnd = WNDHANDLE_MAGIC_HIGHWORD;
3184 DWORD dwStyle;
3185
3186 dprintf(("EnumWindows %x %x", lpfn, lParam));
3187
3188 for(int i=0;i<MAX_WINDOW_HANDLES;i++)
3189 {
3190 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
3191 if(window) {
3192 if(window->getWindowHandle() != hwnd) {
3193 dprintf(("CORRUPT WINDOW %x %x", window, hwnd));
3194 }
3195 RELEASE_WNDOBJ(window);
3196 dwStyle = ::GetWindowLongA(hwnd, GWL_STYLE);
3197 if ((dwStyle & WS_POPUP) || ((dwStyle & WS_CAPTION) == WS_CAPTION))
3198 {
3199 dprintf2(("EnumWindows: Found Window %x", hwnd));
3200 if((rc = lpfn(hwnd, lParam)) == FALSE) {
3201 break;
3202 }
3203 }
3204 }
3205 hwnd++;
3206 }
3207 return TRUE;
3208}
3209//******************************************************************************
3210//******************************************************************************
3211HWND Win32BaseWindow::FindWindowById(int id)
3212{
3213 HWND hwnd;
3214
3215 lock();
3216 for (Win32BaseWindow *child = (Win32BaseWindow *)getFirstChild(); child; child = (Win32BaseWindow *)child->getNextChild())
3217 {
3218 if (child->getWindowId() == id)
3219 {
3220 hwnd = child->getWindowHandle();
3221 unlock();
3222 return hwnd;
3223 }
3224 }
3225 unlock();
3226 return 0;
3227}
3228//******************************************************************************
3229//TODO:
3230//We assume (for now) that if hwndParent or hwndChildAfter are real window handles, that
3231//the current process owns them.
3232//******************************************************************************
3233HWND Win32BaseWindow::FindWindowEx(HWND hwndParent, HWND hwndChildAfter, ATOM atom, LPSTR lpszWindow)
3234{
3235 Win32BaseWindow *parent = GetWindowFromHandle(hwndParent);
3236 Win32BaseWindow *child = GetWindowFromHandle(hwndChildAfter);
3237 Win32BaseWindow *firstchild = child;
3238
3239 dprintf(("FindWindowEx %x %x %x %s", hwndParent, hwndChildAfter, atom, lpszWindow));
3240 if((hwndParent != 0 && !parent) ||
3241 (hwndChildAfter != 0 && !child) ||
3242 (hwndParent == 0 && hwndChildAfter != 0))
3243 {
3244 if(parent) RELEASE_WNDOBJ(parent);
3245 if(firstchild) RELEASE_WNDOBJ(firstchild);
3246 dprintf(("Win32BaseWindow::FindWindowEx: parent or child not found %x %x", hwndParent, hwndChildAfter));
3247 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
3248 return 0;
3249 }
3250 SetLastError(0);
3251 if(hwndParent != 0)
3252 {//if the current process owns the window, just do a quick search
3253 lock(&critsect);
3254 child = (Win32BaseWindow *)parent->getFirstChild();
3255 if(hwndChildAfter != 0)
3256 {
3257 while(child)
3258 {
3259 if(child->getWindowHandle() == hwndChildAfter)
3260 {
3261 child = (Win32BaseWindow *)child->getNextChild();
3262 break;
3263 }
3264 child = (Win32BaseWindow *)child->getNextChild();
3265 }
3266 }
3267 while(child)
3268 {
3269 //According to Wine, the class doesn't need to be specified
3270 if((!atom || child->getWindowClass()->getAtom() == atom) &&
3271 (!lpszWindow || child->hasWindowName(lpszWindow)))
3272 {
3273 dprintf(("FindWindowEx: Found window %x", child->getWindowHandle()));
3274 HWND hwndChild = child->getWindowHandle();
3275 unlock(&critsect);
3276 if(parent) RELEASE_WNDOBJ(parent);
3277 if(firstchild) RELEASE_WNDOBJ(firstchild);
3278 dprintf(("FindWindowEx: Found window %x", child->getWindowHandle()));
3279 return hwndChild;
3280 }
3281 child = (Win32BaseWindow *)child->getNextChild();
3282 }
3283 unlock(&critsect);
3284 if(parent) RELEASE_WNDOBJ(parent);
3285 if(firstchild) RELEASE_WNDOBJ(firstchild);
3286 }
3287 else {
3288 Win32BaseWindow *wnd;
3289 HWND henum, hwnd;
3290
3291 henum = OSLibWinBeginEnumWindows(OSLIB_HWND_DESKTOP);
3292 hwnd = OSLibWinGetNextWindow(henum);
3293
3294 while(hwnd)
3295 {
3296 wnd = GetWindowFromOS2FrameHandle(hwnd);
3297 if(wnd == NULL) {
3298 hwnd = OSLibWinQueryClientWindow(hwnd);
3299 if(hwnd) wnd = GetWindowFromOS2Handle(hwnd);
3300 }
3301
3302 if(wnd) {
3303 //According to Wine, the class doesn't need to be specified
3304 if((!atom || wnd->getWindowClass()->getAtom() == atom) &&
3305 (!lpszWindow || wnd->hasWindowName(lpszWindow)))
3306 {
3307 OSLibWinEndEnumWindows(henum);
3308 dprintf(("FindWindowEx: Found window %x", wnd->getWindowHandle()));
3309 HWND hwndret = wnd->getWindowHandle();
3310 RELEASE_WNDOBJ(wnd);
3311 return hwndret;
3312 }
3313 RELEASE_WNDOBJ(wnd);
3314 }
3315 hwnd = OSLibWinGetNextWindow(henum);
3316 }
3317 OSLibWinEndEnumWindows(henum);
3318 if(parent) RELEASE_WNDOBJ(parent);
3319 if(firstchild) RELEASE_WNDOBJ(firstchild);
3320 }
3321 SetLastError(ERROR_CANNOT_FIND_WND_CLASS); //TODO: not always correct
3322 return 0;
3323}
3324//******************************************************************************
3325//******************************************************************************
3326HWND Win32BaseWindow::GetWindow(UINT uCmd)
3327{
3328 HWND hwndRelated = 0;
3329 Win32BaseWindow *window;
3330
3331 switch(uCmd)
3332 {
3333 case GW_HWNDFIRST:
3334 window = (Win32BaseWindow *)getParent();
3335 if(window)
3336 {
3337 hwndRelated = OSLibWinQueryWindow(window->getOS2WindowHandle(), QWOS_TOP);
3338 window = GetWindowFromOS2FrameHandle(hwndRelated);
3339 if(window) {
3340 hwndRelated = window->getWindowHandle();
3341 RELEASE_WNDOBJ(window);
3342 }
3343 else hwndRelated = 0;
3344 }
3345 else {
3346 dprintf(("WARNING: GW_HWNDFIRST not correctly implemented for toplevel/most windows!"));
3347 hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
3348 }
3349 break;
3350
3351 case GW_HWNDLAST:
3352 window = (Win32BaseWindow *)getParent();
3353 if(window) {
3354 hwndRelated = OSLibWinQueryWindow(window->getOS2WindowHandle(), QWOS_BOTTOM);
3355 dprintf(("os2 handle %x", hwndRelated));
3356 window = GetWindowFromOS2FrameHandle(hwndRelated);
3357 if(window) {
3358 hwndRelated = window->getWindowHandle();
3359 RELEASE_WNDOBJ(window);
3360 }
3361 else hwndRelated = 0;
3362 }
3363 else {
3364 dprintf(("WARNING: GW_HWNDLAST not correctly implemented for toplevel/most windows!"));
3365 hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
3366 }
3367 break;
3368
3369 case GW_HWNDNEXT:
3370 if(getParent()) {
3371 hwndRelated = OSLibWinQueryWindow(getOS2FrameWindowHandle(), QWOS_NEXT);
3372 window = GetWindowFromOS2FrameHandle(hwndRelated);
3373 if(window) {
3374 hwndRelated = window->getWindowHandle();
3375 RELEASE_WNDOBJ(window);
3376 }
3377 else hwndRelated = 0;
3378 }
3379 else {
3380 dprintf(("WARNING: GW_HWNDNEXT not correctly implemented for toplevel/most windows!"));
3381 hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
3382 }
3383 break;
3384
3385 case GW_HWNDPREV:
3386 if(getParent()) {
3387 hwndRelated = OSLibWinQueryWindow(getOS2FrameWindowHandle(), QWOS_PREV);
3388 window = GetWindowFromOS2FrameHandle(hwndRelated);
3389 if(window) {
3390 hwndRelated = window->getWindowHandle();
3391 RELEASE_WNDOBJ(window);
3392 }
3393 else hwndRelated = 0;
3394 }
3395 else {
3396 dprintf(("WARNING: GW_HWNDPREV not correctly implemented for toplevel/most windows!"));
3397 hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
3398 }
3399 break;
3400
3401 case GW_OWNER:
3402 {
3403 Win32BaseWindow *owner = getOwner();
3404 if(owner) {
3405 hwndRelated = owner->getWindowHandle();
3406 }
3407 break;
3408 }
3409
3410 case GW_CHILD:
3411 hwndRelated = OSLibWinQueryWindow(getOS2WindowHandle(), QWOS_TOP);
3412 window = GetWindowFromOS2FrameHandle(hwndRelated);
3413
3414 //Before a window has processed WM_NCCREATE:
3415 //- GetWindow(parent, GW_CHILD) can't return that window handle
3416 //(verified in NT4, SP6)
3417 if(window) {
3418 if(window->state >= STATE_POST_WMNCCREATE) {
3419 hwndRelated = window->getWindowHandle();
3420 RELEASE_WNDOBJ(window);
3421 }
3422 else {
3423 hwndRelated = window->GetWindow(GW_HWNDNEXT);
3424 RELEASE_WNDOBJ(window);
3425 }
3426 }
3427 else hwndRelated = 0;
3428
3429 break;
3430
3431 //for internal use only
3432 case GW_HWNDNEXTCHILD:
3433 lock();
3434 window = (Win32BaseWindow *)getNextChild();
3435 if(window) {
3436 hwndRelated = window->getWindowHandle();
3437 }
3438 else hwndRelated = 0;
3439 unlock();
3440 break;
3441
3442 case GW_HWNDPREVCHILD:
3443 DebugInt3();
3444 break;
3445
3446 case GW_HWNDFIRSTCHILD:
3447 lock();
3448 window = (Win32BaseWindow *)getFirstChild();
3449 if(window) {
3450 hwndRelated = window->getWindowHandle();
3451 }
3452 else hwndRelated = 0;
3453 unlock();
3454 break;
3455
3456 case GW_HWNDLASTCHILD:
3457 lock();
3458 window = (Win32BaseWindow *)getFirstChild();
3459 if(window) {
3460 while (window->getNextChild())
3461 {
3462 window = (Win32BaseWindow *)window->getNextChild();
3463 }
3464 hwndRelated = window->getWindowHandle();
3465 }
3466 else hwndRelated = 0;
3467 unlock();
3468 break;
3469 }
3470end:
3471 dprintf(("GetWindow %x %d returned %x", getWindowHandle(), uCmd, hwndRelated));
3472 return hwndRelated;
3473}
3474//******************************************************************************
3475//******************************************************************************
3476HWND Win32BaseWindow::SetActiveWindow()
3477{
3478 HWND hwndActive;
3479
3480 dprintf(("SetActiveWindow %x", getWindowHandle()));
3481 if(getStyle() & WS_CHILD) {
3482// if(getStyle() & (WS_DISABLED | WS_CHILD)) {
3483 dprintf(("WARNING: Window is a child or disabled"));
3484 return 0;
3485 }
3486
3487 if(GetActiveWindow() == getWindowHandle()) {
3488 dprintf(("Window already active"));
3489 return getWindowHandle();
3490 }
3491 if (HOOK_IsHooked( WH_CBT ))
3492 {
3493 CBTACTIVATESTRUCT cbta;
3494 LRESULT ret;
3495
3496 cbta.fMouse = FALSE;
3497 cbta.hWndActive = GetActiveWindow();
3498 ret = HOOK_CallHooksA(WH_CBT, HCBT_ACTIVATE, getWindowHandle(), (LPARAM)&cbta);
3499 if(ret)
3500 {
3501 dprintf(("SetActiveWindow %x, CBT hook cancelled operation", getWindowHandle()));
3502 return cbta.hWndActive;
3503 }
3504 }
3505 SetWindowPos(HWND_TOP, 0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
3506
3507// if(OSLibWinSetActiveWindow(OS2Hwnd) == FALSE) {
3508// dprintf(("OSLibWinSetActiveWindow %x returned FALSE!", OS2Hwnd));
3509// }
3510 hwndActive = GetActiveWindow();
3511 return (hwndActive) ? hwndActive : windowDesktop->getWindowHandle(); //pretend the desktop was active
3512}
3513//******************************************************************************
3514//Used to change active status of an mdi window
3515//******************************************************************************
3516BOOL Win32BaseWindow::DeactivateChildWindow()
3517{
3518 /* child windows get a WM_CHILDACTIVATE message */
3519 if((getStyle() & (WS_CHILD | WS_POPUP)) == WS_CHILD )
3520 {
3521 ULONG flags = OSLibWinGetWindowULong(getOS2WindowHandle(), OFFSET_WIN32FLAGS);
3522 OSLibWinSetWindowULong(getOS2WindowHandle(), OFFSET_WIN32FLAGS, (flags & ~WINDOWFLAG_ACTIVE));
3523 return TRUE;
3524 }
3525 DebugInt3(); //should not be called for non-child window
3526 return FALSE;
3527}
3528//******************************************************************************
3529//WM_ENABLE is sent to hwnd, but not to it's children (as it should be)
3530//******************************************************************************
3531BOOL Win32BaseWindow::EnableWindow(BOOL fEnable)
3532{
3533 BOOL rc;
3534
3535 dprintf(("Win32BaseWindow::EnableWindow %x %d", getWindowHandle(), fEnable));
3536 //return true if previous state was disabled, else false (sdk docs)
3537 rc = (getStyle() & WS_DISABLED) != 0;
3538 if(rc && !fEnable) {
3539 SendMessageA(getWindowHandle(), WM_CANCELMODE, 0, 0);
3540 }
3541 OSLibWinEnableWindow(OS2HwndFrame, fEnable);
3542 if(fEnable == FALSE) {
3543 //SvL: No need to clear focus as PM already does this
3544 if(getWindowHandle() == GetCapture()) {
3545 ReleaseCapture(); /* A disabled window can't capture the mouse */
3546 dprintf(("Released capture for window %x that is being disabled", getWindowHandle()));
3547 }
3548 }
3549 return rc;
3550}
3551//******************************************************************************
3552//******************************************************************************
3553BOOL Win32BaseWindow::CloseWindow()
3554{
3555 if (::GetWindowLongW( getWindowHandle() , GWL_STYLE ) & WS_CHILD) return FALSE;
3556 ShowWindow( SW_MINIMIZE );
3557 return TRUE;
3558}
3559//******************************************************************************
3560//TODO: Not be 100% correct; should return active window of current thread
3561// or NULL when there is none -> WinQueryActiveWindow just returns
3562// the current active window
3563//******************************************************************************
3564HWND Win32BaseWindow::GetActiveWindow()
3565{
3566 HWND hwndActive;
3567
3568 hwndActive = OSLibWinQueryActiveWindow();
3569 return OS2ToWin32Handle(hwndActive);
3570}
3571//******************************************************************************
3572//******************************************************************************
3573BOOL Win32BaseWindow::hasWindowName(LPSTR wndname, BOOL fUnicode)
3574{
3575 INT len = GetWindowTextLength(fUnicode);
3576 BOOL res;
3577
3578 if (wndname == NULL)
3579 return (len == 0);
3580
3581 len++;
3582 if (fUnicode)
3583 {
3584 WCHAR *text = (WCHAR*)malloc(len*sizeof(WCHAR));
3585
3586 GetWindowTextW(text,len);
3587 res = (lstrcmpW(text,(LPWSTR)wndname) == 0);
3588 free(text);
3589 }
3590 else
3591 {
3592 CHAR *text = (CHAR*)malloc(len*sizeof(CHAR));
3593
3594 GetWindowTextA(text,len);
3595 res = (strcmp(text,wndname) == 0);
3596 free(text);
3597 }
3598
3599 return res;
3600}
3601//******************************************************************************
3602//******************************************************************************
3603CHAR *Win32BaseWindow::getWindowNamePtrA()
3604{
3605 INT len = GetWindowTextLength(FALSE);
3606 CHAR *text;
3607
3608 if (len == 0) return NULL;
3609 len++;
3610 text = (CHAR*)malloc(len*sizeof(CHAR));
3611 GetWindowTextA(text,len);
3612
3613 return text;
3614}
3615//******************************************************************************
3616//******************************************************************************
3617WCHAR *Win32BaseWindow::getWindowNamePtrW()
3618{
3619 INT len = GetWindowTextLength(TRUE);
3620 WCHAR *text;
3621
3622 if (len == 0) return NULL;
3623 len++;
3624 text = (WCHAR*)malloc(len*sizeof(WCHAR));
3625 GetWindowTextW(text,len);
3626
3627 return text;
3628}
3629//******************************************************************************
3630//******************************************************************************
3631VOID Win32BaseWindow::freeWindowNamePtr(PVOID namePtr)
3632{
3633 if (namePtr) free(namePtr);
3634}
3635//******************************************************************************
3636//When using this API for a window that was created by a different process, NT
3637//does NOT send WM_GETTEXTLENGTH.
3638//******************************************************************************
3639int Win32BaseWindow::GetWindowTextLength(BOOL fUnicode)
3640{
3641 //if the destination window is created by this process, send message
3642 if(dwProcessId == currentProcessId)
3643 {
3644 if(fUnicode) {
3645 return SendMessageW(getWindowHandle(), WM_GETTEXTLENGTH,0,0);
3646 }
3647 else return SendMessageA(getWindowHandle(), WM_GETTEXTLENGTH,0,0);
3648 }
3649 //else get data directory from window structure
3650 //TODO: must lock window structure.... (TODO)
3651 return windowNameLength;
3652}
3653//******************************************************************************
3654//When using this API for a window that was created by a different process, NT
3655//does NOT send WM_GETTEXT.
3656//******************************************************************************
3657int Win32BaseWindow::GetWindowTextA(LPSTR lpsz, int cch)
3658{
3659 //if the destination window is created by this process, send message
3660 if(dwProcessId == currentProcessId) {
3661 return SendMessageA(getWindowHandle(),WM_GETTEXT,(WPARAM)cch,(LPARAM)lpsz);
3662 }
3663
3664 //else get data directory from window structure
3665 if (!lpsz || !cch) return 0;
3666 if (!windowNameA) lpsz[0] = 0;
3667 else memcpy(lpsz, windowNameA, min(windowNameLength + 1, cch) );
3668 return min(windowNameLength, cch);
3669}
3670//******************************************************************************
3671//When using this API for a window that was created by a different process, NT
3672//does NOT send WM_GETTEXT.
3673//******************************************************************************
3674int Win32BaseWindow::GetWindowTextW(LPWSTR lpsz, int cch)
3675{
3676 //if the destination window is created by this process, send message
3677 if(dwProcessId == currentProcessId) {
3678 return ::SendMessageW(getWindowHandle(), WM_GETTEXT,(WPARAM)cch,(LPARAM)lpsz);
3679 }
3680 //else get data directory from window structure
3681 if (!lpsz || !cch)
3682 return 0;
3683 if (!windowNameW)
3684 lpsz[0] = 0;
3685 else
3686 memcpy(lpsz, windowNameW, min( sizeof(WCHAR) * (windowNameLength+1), cch));
3687
3688 return min(windowNameLength, cch);
3689}
3690//******************************************************************************
3691//TODO: How does this work when the target window belongs to a different process???
3692//******************************************************************************
3693BOOL Win32BaseWindow::SetWindowTextA(LPSTR lpsz)
3694{
3695 return SendMessageA(getWindowHandle(),WM_SETTEXT,0,(LPARAM)lpsz);
3696}
3697//******************************************************************************
3698//******************************************************************************
3699BOOL Win32BaseWindow::SetWindowTextW(LPWSTR lpsz)
3700{
3701 return SendMessageW(getWindowHandle(), WM_SETTEXT,0,(LPARAM)lpsz);
3702}
3703//******************************************************************************
3704//******************************************************************************
3705LONG Win32BaseWindow::SetWindowLong(int index, ULONG value, BOOL fUnicode)
3706{
3707 LONG oldval;
3708
3709 switch(index) {
3710 case GWL_EXSTYLE:
3711 {
3712 STYLESTRUCT ss;
3713
3714 if(dwExStyle == value) {
3715 oldval = value;
3716 break;
3717 }
3718 ss.styleOld = dwExStyle;
3719 ss.styleNew = value;
3720 dprintf(("SetWindowLong GWL_EXSTYLE %x old %x new style %x", getWindowHandle(), dwExStyle, value));
3721 SendMessageA(getWindowHandle(),WM_STYLECHANGING,GWL_EXSTYLE,(LPARAM)&ss);
3722 setExStyle(ss.styleNew);
3723 SendMessageA(getWindowHandle(),WM_STYLECHANGED,GWL_EXSTYLE,(LPARAM)&ss);
3724 OSLibSetWindowStyle(getOS2FrameWindowHandle(), getOS2WindowHandle(), getStyle(), getExStyle());
3725 oldval = ss.styleOld;
3726 break;
3727 }
3728 case GWL_STYLE:
3729 {
3730 STYLESTRUCT ss;
3731
3732 //SvL: TODO: Can you change minimize or maximize status here too?
3733
3734 if(dwStyle == value) {
3735 oldval = value;
3736 break;
3737 }
3738 dprintf(("SetWindowLong GWL_STYLE %x old %x new style %x (%x)", getWindowHandle(), dwStyle, value));
3739
3740 //Changing WS_CHILD style is allowed
3741 ss.styleOld = getStyle();
3742 ss.styleNew = value;
3743 SendMessageA(getWindowHandle(),WM_STYLECHANGING,GWL_STYLE,(LPARAM)&ss);
3744 setStyle(ss.styleNew);
3745 SendMessageA(getWindowHandle(),WM_STYLECHANGED,GWL_STYLE,(LPARAM)&ss);
3746 OSLibSetWindowStyle(getOS2FrameWindowHandle(), getOS2WindowHandle(),
3747 getStyle(), getExStyle());
3748
3749 //TODO: Might not be correct to use ShowWindow here
3750 if((ss.styleOld & WS_VISIBLE) != (ss.styleNew & WS_VISIBLE)) {
3751 if(ss.styleNew & WS_VISIBLE)
3752 ShowWindow(SW_SHOWNOACTIVATE);
3753 else ShowWindow(SW_HIDE);
3754 }
3755#ifdef DEBUG
3756 PrintWindowStyle(ss.styleNew, 0);
3757#endif
3758 oldval = ss.styleOld;
3759 break;
3760 }
3761 case GWL_WNDPROC:
3762 {
3763 //Note: Type of SetWindowLong determines new window proc type
3764 // UNLESS the new window proc has already been registered
3765 // (use the old type in that case)
3766 // (VERIFIED in NT 4, SP6)
3767 WINDOWPROCTYPE type = WINPROC_GetProcType((HWINDOWPROC)value);
3768 if(type == WIN_PROC_INVALID) {
3769 type = (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A;
3770 }
3771 oldval = (LONG)WINPROC_GetProc(win32wndproc, (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A);
3772 dprintf(("SetWindowLong%c GWL_WNDPROC %x old %x new wndproc %x", (fUnicode) ? 'W' : 'A', getWindowHandle(), oldval, value));
3773 WINPROC_SetProc((HWINDOWPROC *)&win32wndproc, (WNDPROC)value, type, WIN_PROC_WINDOW);
3774 break;
3775 }
3776 case GWL_HINSTANCE:
3777 oldval = hInstance;
3778 hInstance = value;
3779 break;
3780
3781 case GWL_HWNDPARENT:
3782 oldval = SetParent((HWND)value);
3783 break;
3784
3785 case GWL_ID:
3786 dprintf(("GWL_ID old %x, new %x", getWindowId(), value));
3787 oldval = getWindowId();
3788 setWindowId(value);
3789 break;
3790
3791 case GWL_USERDATA:
3792 oldval = userData;
3793 userData = value;
3794 break;
3795
3796 default:
3797 if(index >= 0 && index + sizeof(ULONG) <= nrUserWindowBytes)
3798 {
3799 oldval = *(ULONG *)(userWindowBytes + index);
3800 *(ULONG *)(userWindowBytes + index) = value;
3801 break;
3802 }
3803 dprintf(("WARNING: SetWindowLong%c %x %d %x returned %x INVALID index!", (fUnicode) ? 'W' : 'A', getWindowHandle(), index, value));
3804 SetLastError(ERROR_INVALID_INDEX); //verified in NT4, SP6
3805 return 0;
3806 }
3807 //Note: NT4, SP6 does not set the last error to 0
3808 SetLastError(ERROR_SUCCESS);
3809 dprintf2(("SetWindowLong%c %x %d %x returned %x", (fUnicode) ? 'W' : 'A', getWindowHandle(), index, value, oldval));
3810 return oldval;
3811}
3812//******************************************************************************
3813//******************************************************************************
3814ULONG Win32BaseWindow::GetWindowLong(int index, BOOL fUnicode)
3815{
3816 ULONG value;
3817
3818 switch(index) {
3819 case GWL_EXSTYLE:
3820 value = dwExStyle;
3821 break;
3822 case GWL_STYLE:
3823 value = dwStyle;
3824 break;
3825 case GWL_WNDPROC:
3826 value = (LONG)WINPROC_GetProc(win32wndproc, (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A);
3827 break;
3828 case GWL_HINSTANCE:
3829 value = hInstance;
3830 break;
3831 case GWL_HWNDPARENT:
3832 value = GetParent();
3833 break;
3834 case GWL_ID:
3835 value = getWindowId();
3836 break;
3837 case GWL_USERDATA:
3838 value = userData;
3839 break;
3840 default:
3841 if(index >= 0 && index + sizeof(ULONG) <= nrUserWindowBytes)
3842 {
3843 value = *(ULONG *)(userWindowBytes + index);
3844 break;
3845 }
3846 dprintf(("WARNING: GetWindowLong%c %x %d %x returned %x INVALID index!", (fUnicode) ? 'W' : 'A', getWindowHandle(), index, value));
3847 SetLastError(ERROR_INVALID_INDEX); //verified in NT4, SP6
3848 return 0;
3849 }
3850 dprintf2(("GetWindowLong%c %x %d %x", (fUnicode) ? 'W' : 'A', getWindowHandle(), index, value));
3851 //Note: NT4, SP6 does not set the last error to 0
3852 SetLastError(ERROR_SUCCESS);
3853 return value;
3854}
3855//******************************************************************************
3856//******************************************************************************
3857WORD Win32BaseWindow::SetWindowWord(int index, WORD value)
3858{
3859 WORD oldval;
3860
3861 if(index >= 0 && index + sizeof(WORD) <= nrUserWindowBytes)
3862 {
3863 oldval = *(WORD *)(userWindowBytes + index);
3864 *(WORD *)(userWindowBytes + index) = value;
3865 //Note: NT4, SP6 does not set the last error to 0
3866 dprintf2(("SetWindowWord %x %d %x returned %x", getWindowHandle(), index, value, oldval));
3867 SetLastError(ERROR_SUCCESS);
3868 return oldval;
3869 }
3870 switch(index)
3871 {
3872 case GWW_HINSTANCE:
3873 oldval = hInstance;
3874 hInstance = value;
3875 break;
3876
3877 case GWW_HWNDPARENT:
3878 oldval = SetParent((HWND)(WNDHANDLE_MAGIC_HIGHWORD | value));
3879 break;
3880
3881 case GWW_ID:
3882 oldval = getWindowId();
3883 setWindowId(value);
3884 break;
3885
3886 default:
3887 dprintf(("WARNING: SetWindowWord %x %d %x returned %x INVALID index!", getWindowHandle(), index, value));
3888 SetLastError(ERROR_INVALID_INDEX); //verified in NT4, SP6
3889 return 0;
3890 }
3891 //Note: NT4, SP6 does not set the last error to 0
3892 SetLastError(ERROR_SUCCESS);
3893 dprintf2(("SetWindowWord %x %d %x returned %x", getWindowHandle(), index, value, oldval));
3894 return oldval;
3895}
3896//******************************************************************************
3897//******************************************************************************
3898WORD Win32BaseWindow::GetWindowWord(int index)
3899{
3900 if(index >= 0 && index + sizeof(WORD) <= nrUserWindowBytes)
3901 {
3902 //Note: NT4, SP6 does not set the last error to 0
3903 SetLastError(ERROR_SUCCESS);
3904 dprintf2(("GetWindowWord %x %d %x", getWindowHandle(), index, *(WORD *)(userWindowBytes + index)));
3905 return *(WORD *)(userWindowBytes + index);
3906 }
3907 switch(index)
3908 {
3909 case GWW_ID:
3910 if(HIWORD(getWindowId()))
3911 dprintf(("WARNING: GWW_ID: discards high bits of 0x%08x!\n", getWindowId()));
3912 return (WORD)getWindowId();
3913
3914 case GWW_HWNDPARENT:
3915 dprintf(("WARNING: GWW_HWNDPARENT: discards high bits of 0x%08x!\n", GetParent()));
3916 return (WORD) GetParent();
3917
3918 case GWW_HINSTANCE:
3919 if (HIWORD(hInstance))
3920 dprintf(("WARNING: GWW_HINSTANCE: discards high bits of 0x%08x!\n", hInstance));
3921 return (WORD)hInstance;
3922 }
3923
3924 dprintf(("WARNING: GetWindowWord %x %d returned %x INVALID index!", getWindowHandle(), index));
3925 SetLastError(ERROR_INVALID_INDEX); //verified in NT4, SP6
3926 return 0;
3927}
3928//******************************************************************************
3929//Locates window in linked list and increases reference count (if found)
3930//Window object must be unreferenced after usage
3931//******************************************************************************
3932Win32BaseWindow *Win32BaseWindow::GetWindowFromHandle(HWND hwnd)
3933{
3934 Win32BaseWindow *window;
3935
3936////TODO: temporary workaround for crashes in Opera (pmwinx; releasesemaphore)
3937//// while browsing
3938//// Not thread safe now!
3939//// lock(&critsect);
3940 if(HwGetWindowHandleData(hwnd, (DWORD *)&window) == TRUE) {
3941 if(window) {
3942//// dprintf(("addRef %x; refcount %d", hwnd, window->getRefCount()+1));
3943 window->addRef();
3944 }
3945//// unlock(&critsect);
3946 return window;
3947 }
3948//// unlock(&critsect);
3949// dprintf2(("Win32BaseWindow::GetWindowFromHandle: not a win32 window %x", hwnd));
3950 return NULL;
3951}
3952//******************************************************************************
3953//Locates window in linked list and increases reference count (if found)
3954//Window object must be unreferenced after usage
3955//******************************************************************************
3956Win32BaseWindow *Win32BaseWindow::GetWindowFromOS2Handle(HWND hwndOS2)
3957{
3958 DWORD magic;
3959 HWND hwnd;
3960
3961 if(hwndOS2 == OSLIB_HWND_DESKTOP)
3962 {
3963 windowDesktop->addRef();
3964 return windowDesktop;
3965 }
3966
3967 hwnd = (HWND)OSLibWinGetWindowULong(hwndOS2, OFFSET_WIN32WNDPTR);
3968 magic = OSLibWinGetWindowULong(hwndOS2, OFFSET_WIN32PM_MAGIC);
3969
3970 if(hwnd && CheckMagicDword(magic)) {
3971 return GetWindowFromHandle(hwnd);
3972 }
3973// dprintf2(("Win32BaseWindow::GetWindowFromOS2Handle: not an Odin os2 window %x", hwndOS2));
3974 return 0;
3975}
3976//******************************************************************************
3977//Locates window in linked list and increases reference count (if found)
3978//Window object must be unreferenced after usage
3979//******************************************************************************
3980Win32BaseWindow *Win32BaseWindow::GetWindowFromOS2FrameHandle(HWND hwnd)
3981{
3982 return GetWindowFromOS2Handle(OSLibWinWindowFromID(hwnd,OSLIB_FID_CLIENT));
3983}
3984//******************************************************************************
3985//******************************************************************************
3986HWND WIN32API Win32ToOS2Handle(HWND hwnd)
3987{
3988 HWND hwndOS2;
3989
3990 Win32BaseWindow *window = Win32BaseWindow::GetWindowFromHandle(hwnd);
3991
3992 if(window) {
3993 hwndOS2 = window->getOS2WindowHandle();
3994 RELEASE_WNDOBJ(window);
3995 return hwndOS2;
3996 }
3997// dprintf2(("Win32BaseWindow::Win32ToOS2Handle: not a win32 window %x", hwnd));
3998 return hwnd;
3999}
4000//******************************************************************************
4001//******************************************************************************
4002HWND WIN32API Win32ToOS2FrameHandle(HWND hwnd)
4003{
4004 HWND hwndOS2;
4005
4006 Win32BaseWindow *window = Win32BaseWindow::GetWindowFromHandle(hwnd);
4007
4008 if(window) {
4009 hwndOS2 = window->getOS2FrameWindowHandle();
4010 RELEASE_WNDOBJ(window);
4011 return hwndOS2;
4012 }
4013// dprintf2(("Win32BaseWindow::Win32ToOS2Handle: not a win32 window %x", hwnd));
4014 return hwnd;
4015}
4016//******************************************************************************
4017//******************************************************************************
4018HWND WIN32API OS2ToWin32Handle(HWND hwnd)
4019{
4020 Win32BaseWindow *window = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
4021 HWND hwndWin32;
4022
4023 if(window) {
4024 hwndWin32 = window->getWindowHandle();
4025 RELEASE_WNDOBJ(window);
4026 return hwndWin32;
4027 }
4028 window = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwnd);
4029 if(window) {
4030 hwndWin32 = window->getWindowHandle();
4031 RELEASE_WNDOBJ(window);
4032 return hwndWin32;
4033 }
4034
4035// dprintf2(("Win32BaseWindow::OS2ToWin32Handle: not a win32 window %x", hwnd));
4036 return 0;
4037// else return hwnd; //OS/2 window handle
4038}
4039#ifdef DEBUG
4040LONG Win32BaseWindow::addRef()
4041{
4042// dprintf2(("addRef %x %d", getWindowHandle(), getRefCount()+1));
4043 return GenericObject::addRef();
4044}
4045//******************************************************************************
4046//******************************************************************************
4047LONG Win32BaseWindow::release(char *function, int line)
4048{
4049// dprintf2(("release %s %d %x %d", function, line, getWindowHandle(), getRefCount()-1));
4050 return GenericObject::release();
4051}
4052#endif
4053//******************************************************************************
4054//******************************************************************************
4055GenericObject *Win32BaseWindow::windows = NULL;
4056CRITICAL_SECTION Win32BaseWindow::critsect = {0};
4057
4058//******************************************************************************
4059//******************************************************************************
4060#ifdef DEBUG
4061void PrintWindowStyle(DWORD dwStyle, DWORD dwExStyle)
4062{
4063 char style[256] = "";
4064 char exstyle[256] = "";
4065
4066 /* Window styles */
4067 if(dwStyle & WS_CHILD)
4068 strcat(style, "WS_CHILD ");
4069 if(dwStyle & WS_POPUP)
4070 strcat(style, "WS_POPUP ");
4071 if(dwStyle & WS_VISIBLE)
4072 strcat(style, "WS_VISIBLE ");
4073 if(dwStyle & WS_DISABLED)
4074 strcat(style, "WS_DISABLED ");
4075 if(dwStyle & WS_CLIPSIBLINGS)
4076 strcat(style, "WS_CLIPSIBLINGS ");
4077 if(dwStyle & WS_CLIPCHILDREN)
4078 strcat(style, "WS_CLIPCHILDREN ");
4079 if(dwStyle & WS_MAXIMIZE)
4080 strcat(style, "WS_MAXIMIZE ");
4081 if(dwStyle & WS_MINIMIZE)
4082 strcat(style, "WS_MINIMIZE ");
4083 if(dwStyle & WS_GROUP)
4084 strcat(style, "WS_GROUP ");
4085 if(dwStyle & WS_TABSTOP)
4086 strcat(style, "WS_TABSTOP ");
4087
4088 if((dwStyle & WS_CAPTION) == WS_CAPTION)
4089 strcat(style, "WS_CAPTION ");
4090 if(dwStyle & WS_DLGFRAME)
4091 strcat(style, "WS_DLGFRAME ");
4092 if(dwStyle & WS_BORDER)
4093 strcat(style, "WS_BORDER ");
4094
4095 if(dwStyle & WS_VSCROLL)
4096 strcat(style, "WS_VSCROLL ");
4097 if(dwStyle & WS_HSCROLL)
4098 strcat(style, "WS_HSCROLL ");
4099 if(dwStyle & WS_SYSMENU)
4100 strcat(style, "WS_SYSMENU ");
4101 if(dwStyle & WS_THICKFRAME)
4102 strcat(style, "WS_THICKFRAME ");
4103 if(dwStyle & WS_MINIMIZEBOX)
4104 strcat(style, "WS_MINIMIZEBOX ");
4105 if(dwStyle & WS_MAXIMIZEBOX)
4106 strcat(style, "WS_MAXIMIZEBOX ");
4107
4108 if(dwExStyle & WS_EX_DLGMODALFRAME)
4109 strcat(exstyle, "WS_EX_DLGMODALFRAME ");
4110 if(dwExStyle & WS_EX_ACCEPTFILES)
4111 strcat(exstyle, "WS_EX_ACCEPTFILES ");
4112 if(dwExStyle & WS_EX_NOPARENTNOTIFY)
4113 strcat(exstyle, "WS_EX_NOPARENTNOTIFY ");
4114 if(dwExStyle & WS_EX_TOPMOST)
4115 strcat(exstyle, "WS_EX_TOPMOST ");
4116 if(dwExStyle & WS_EX_TRANSPARENT)
4117 strcat(exstyle, "WS_EX_TRANSPARENT ");
4118
4119 if(dwExStyle & WS_EX_MDICHILD)
4120 strcat(exstyle, "WS_EX_MDICHILD ");
4121 if(dwExStyle & WS_EX_TOOLWINDOW)
4122 strcat(exstyle, "WS_EX_TOOLWINDOW ");
4123 if(dwExStyle & WS_EX_WINDOWEDGE)
4124 strcat(exstyle, "WS_EX_WINDOWEDGE ");
4125 if(dwExStyle & WS_EX_CLIENTEDGE)
4126 strcat(exstyle, "WS_EX_CLIENTEDGE ");
4127 if(dwExStyle & WS_EX_CONTEXTHELP)
4128 strcat(exstyle, "WS_EX_CONTEXTHELP ");
4129 if(dwExStyle & WS_EX_RIGHT)
4130 strcat(exstyle, "WS_EX_RIGHT ");
4131 if(dwExStyle & WS_EX_LEFT)
4132 strcat(exstyle, "WS_EX_LEFT ");
4133 if(dwExStyle & WS_EX_RTLREADING)
4134 strcat(exstyle, "WS_EX_RTLREADING ");
4135 if(dwExStyle & WS_EX_LTRREADING)
4136 strcat(exstyle, "WS_EX_LTRREADING ");
4137 if(dwExStyle & WS_EX_LEFTSCROLLBAR)
4138 strcat(exstyle, "WS_EX_LEFTSCROLLBAR ");
4139 if(dwExStyle & WS_EX_RIGHTSCROLLBAR)
4140 strcat(exstyle, "WS_EX_RIGHTSCROLLBAR ");
4141 if(dwExStyle & WS_EX_CONTROLPARENT)
4142 strcat(exstyle, "WS_EX_CONTROLPARENT ");
4143 if(dwExStyle & WS_EX_STATICEDGE)
4144 strcat(exstyle, "WS_EX_STATICEDGE ");
4145 if(dwExStyle & WS_EX_APPWINDOW)
4146 strcat(exstyle, "WS_EX_APPWINDOW ");
4147
4148 dprintf(("Window style: %x %s", dwStyle, style));
4149 dprintf(("Window exStyle: %x %s", dwExStyle, exstyle));
4150}
4151#endif
4152//******************************************************************************
4153//******************************************************************************
Note: See TracBrowser for help on using the repository browser.