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

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

fix for alt key & menu activation; fixed color of highlighted menubar item
File size: 143.8 KB
Line 
1/* $Id: win32wbase.cpp,v 1.351 2003-01-04 12:21:44 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 return (rc);
2644}
2645//******************************************************************************
2646//Called by ScrollWindowEx (dc.cpp) to notify child window that it has moved
2647//******************************************************************************
2648BOOL Win32BaseWindow::ScrollWindow(int dx, int dy)
2649{
2650 rectWindow.left += dx;
2651 rectWindow.right += dx;
2652 rectWindow.top += dy;
2653 rectWindow.bottom += dy;
2654 SendMessageA(getWindowHandle(),WM_MOVE, 0, MAKELONG(rectClient.left, rectClient.top));
2655 return TRUE;
2656}
2657//******************************************************************************
2658//******************************************************************************
2659void Win32BaseWindow::NotifyFrameChanged(WINDOWPOS *wpos, RECT *oldClientRect)
2660{
2661 HRGN hrgn, hrgnClient;
2662 RECT rect;
2663
2664 MsgFormatFrame(NULL);
2665
2666 if(RECT_WIDTH(rectClient) != RECT_WIDTH(*oldClientRect) ||
2667 RECT_HEIGHT(rectClient) != RECT_HEIGHT(*oldClientRect))
2668 {
2669 wpos->flags &= ~(SWP_NOSIZE|SWP_NOCLIENTSIZE);
2670 wpos->cx = RECT_WIDTH(rectWindow);
2671 wpos->cy = RECT_HEIGHT(rectWindow);
2672 }
2673
2674 if(rectClient.left != oldClientRect->left ||
2675 rectClient.top != oldClientRect->top)
2676 {
2677 wpos->flags &= ~(SWP_NOMOVE|SWP_NOCLIENTMOVE);
2678 wpos->x = rectWindow.left;
2679 wpos->y = rectWindow.top;
2680 }
2681
2682 WINDOWPOS wpOld = *wpos;
2683 if(!(wpos->flags & SWP_NOSENDCHANGING))
2684 SendMessageA(getWindowHandle(),WM_WINDOWPOSCHANGING, 0, (LPARAM)wpos);
2685
2686 if ((wpos->hwndInsertAfter != wpOld.hwndInsertAfter) ||
2687 (wpos->x != wpOld.x) || (wpos->y != wpOld.y) || (wpos->cx != wpOld.cx) || (wpos->cy != wpOld.cy) || (wpos->flags != wpOld.flags))
2688 {
2689 dprintf(("WARNING, NotifyFrameChanged: TODO -> adjust flags!!!!"));
2690 SetWindowPos(wpos->hwndInsertAfter, wpos->x, wpos->y, wpos->cx, wpos->cy, wpos->flags | SWP_NOSENDCHANGING);
2691 }
2692 else SendMessageA(getWindowHandle(),WM_WINDOWPOSCHANGED, 0, (LPARAM)wpos);
2693
2694 //Calculate invalid areas
2695 rect = rectWindow;
2696 OffsetRect(&rect, -rectWindow.left, -rectWindow.top);
2697 hrgn = CreateRectRgnIndirect(&rect);
2698 if (!hrgn) {
2699 dprintf(("ERROR: NotifyFrameChanged, CreateRectRgnIndirect failed!!"));
2700 return;
2701 }
2702 rect = rectClient;
2703 hrgnClient = CreateRectRgnIndirect(&rect);
2704 if (!hrgn) {
2705 dprintf(("ERROR: NotifyFrameChanged, CreateRectRgnIndirect failed!!"));
2706 return;
2707 }
2708 CombineRgn(hrgn, hrgn, hrgnClient, RGN_DIFF);
2709 DeleteObject(hrgnClient);
2710
2711 if(!EqualRect(oldClientRect, &rectClient)) {
2712 UnionRect(oldClientRect, oldClientRect, &rectClient);
2713 hrgnClient = CreateRectRgnIndirect(oldClientRect);
2714 if (!hrgn) {
2715 dprintf(("ERROR: NotifyFrameChanged, CreateRectRgnIndirect failed!!"));
2716 return;
2717 }
2718 CombineRgn(hrgn, hrgn, hrgnClient, RGN_OR);
2719 DeleteObject(hrgnClient);
2720 }
2721 RedrawWindow(getWindowHandle(), NULL, hrgn, RDW_ALLCHILDREN |
2722 RDW_INVALIDATE | RDW_ERASE | RDW_FRAME);
2723 DeleteObject(hrgn);
2724}
2725//******************************************************************************
2726//TODO: Check how this api really works in NT
2727//******************************************************************************
2728BOOL Win32BaseWindow::SetWindowPlacement(WINDOWPLACEMENT *wndpl)
2729{
2730 dprintf(("SetWindowPlacement %x min (%d,%d)", getWindowHandle(), wndpl->ptMinPosition.x, wndpl->ptMinPosition.y));
2731 dprintf(("SetWindowPlacement %x max (%d,%d)", getWindowHandle(), wndpl->ptMaxPosition.x, wndpl->ptMaxPosition.y));
2732 dprintf(("SetWindowPlacement %x norm (%d,%d)(%d,%d)", getWindowHandle(), wndpl->rcNormalPosition.left, wndpl->rcNormalPosition.top, wndpl->rcNormalPosition.right, wndpl->rcNormalPosition.bottom));
2733 windowpos.ptMinPosition = wndpl->ptMinPosition;
2734 windowpos.ptMaxPosition = wndpl->ptMaxPosition;
2735 windowpos.rcNormalPosition = wndpl->rcNormalPosition;
2736
2737 if(getStyle() & WS_MINIMIZE )
2738 {
2739 //TODO: Why can't this be (0,0)?
2740 if(wndpl->flags & WPF_SETMINPOSITION && !(!windowpos.ptMinPosition.x && !windowpos.ptMinPosition.y)) {
2741 SetWindowPos(0, windowpos.ptMinPosition.x, windowpos.ptMinPosition.y,
2742 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
2743 }
2744 }
2745 else
2746 if(getStyle() & WS_MAXIMIZE )
2747 {
2748 //TODO: Why can't this be (0,0)?
2749 if(windowpos.ptMaxPosition.x != 0 || windowpos.ptMaxPosition.y != 0 )
2750 SetWindowPos(0, windowpos.ptMaxPosition.x, windowpos.ptMaxPosition.y,
2751 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
2752 }
2753 else {
2754 SetWindowPos(0, windowpos.rcNormalPosition.left, windowpos.rcNormalPosition.top,
2755 windowpos.rcNormalPosition.right - windowpos.rcNormalPosition.left,
2756 windowpos.rcNormalPosition.bottom - windowpos.rcNormalPosition.top,
2757 SWP_NOZORDER | SWP_NOACTIVATE );
2758 }
2759 ShowWindow(wndpl->showCmd);
2760 if( ::IsWindow(getWindowHandle()) && getStyle() & WS_MINIMIZE )
2761 {
2762 /* SDK: ...valid only the next time... */
2763 if(wndpl->flags & WPF_RESTORETOMAXIMIZED)
2764 setFlags(getFlags() | WIN_RESTORE_MAX);
2765 }
2766 return TRUE;
2767}
2768//******************************************************************************
2769//******************************************************************************
2770BOOL Win32BaseWindow::GetWindowPlacement(LPWINDOWPLACEMENT wndpl)
2771{
2772 wndpl->length = sizeof(*wndpl);
2773 if(getStyle() & WS_MINIMIZE )
2774 wndpl->showCmd = SW_SHOWMINIMIZED;
2775 else wndpl->showCmd = (getStyle() & WS_MAXIMIZE) ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL;
2776
2777 //TODO: Verify if this is correct -> SDK docs claim this flag must always be set to 0
2778 if(getFlags() & WIN_RESTORE_MAX )
2779 wndpl->flags = WPF_RESTORETOMAXIMIZED;
2780 else wndpl->flags = 0;
2781
2782 wndpl->ptMinPosition = windowpos.ptMinPosition;
2783 wndpl->ptMaxPosition = windowpos.ptMaxPosition;
2784 //Must be in parent coordinates (or screen if no parent); verified in NT4, SP6
2785 wndpl->rcNormalPosition = windowpos.rcNormalPosition;
2786
2787 return TRUE;
2788}
2789//******************************************************************************
2790//Also destroys all the child windows (destroy children first, parent last)
2791//TODO: Don't rely on PM to do the right thing. Send WM_(NC)DESTROY &
2792// destroy children ourselves (see Wine)
2793//******************************************************************************
2794BOOL Win32BaseWindow::DestroyWindow()
2795{
2796 HWND hwnd = getWindowHandle();
2797
2798 dprintf(("DestroyWindow %x", hwnd));
2799
2800#if 0
2801 /* Look whether the focus is within the tree of windows we will
2802 * be destroying.
2803 */
2804 HWND hwndFocus = GetFocus();
2805 if (hwndFocus == hwnd || ::IsChild( hwnd, hwndFocus ))
2806 {
2807 HWND parent = GetAncestor( hwnd, GA_PARENT );
2808 if (parent == GetDesktopWindow()) parent = 0;
2809 SetFocus( parent );
2810 }
2811#endif
2812 /* Call hooks */
2813 if(HOOK_CallHooksA( WH_CBT, HCBT_DESTROYWND, getWindowHandle(), 0L))
2814 {
2815 return FALSE;
2816 }
2817
2818 if(!(getStyle() & WS_CHILD) && getOwner() == NULL)
2819 {
2820 HOOK_CallHooksA(WH_SHELL, HSHELL_WINDOWDESTROYED, getWindowHandle(), 0L);
2821 /* FIXME: clean up palette - see "Internals" p.352 */
2822 }
2823
2824 if((getStyle() & WS_CHILD) && !(getExStyle() & WS_EX_NOPARENTNOTIFY))
2825 {
2826 if(getParent() && getParent()->IsWindowDestroyed() == FALSE)
2827 {
2828 /* Notify the parent window only */
2829 SendMessageA(getParent()->getWindowHandle(), WM_PARENTNOTIFY, MAKEWPARAM(WM_DESTROY, getWindowId()), (LPARAM)getWindowHandle());
2830 if(!::IsWindow(hwnd) )
2831 {
2832 return TRUE;
2833 }
2834 }
2835//// else DebugInt3();
2836 }
2837 /* Hide the window */
2838 if(IsWindowVisible(getWindowHandle()))
2839 {
2840 SetWindowPos(0, 0, 0, 0, 0, SWP_HIDEWINDOW |
2841 SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE);
2842 if(!::IsWindow(hwnd))
2843 {
2844 return TRUE;
2845 }
2846 }
2847 dprintf(("DestroyWindow %x -> HIDDEN", hwnd));
2848
2849 // check the handle for the last active popup window
2850 Win32BaseWindow* owner = getOwner();
2851 if (NULL != owner)
2852 {
2853 if (owner->getLastActive() == hwnd)
2854 owner->setLastActive( owner->getWindowHandle() );
2855
2856 //SvL: Not sure this is correct, but it solves the problem of reassigning
2857 // activation. A disabled window will never be activated ->
2858 // possible that the wrong window is chosen by PM.
2859 // PM chooses another window to be activated before WM_DESTROY is
2860 // sent. VPC enables the owner when it receives that message,
2861 // but by then it's too late.
2862 // (MFC created modeless dialog)
2863 //TODO: This might be the wrong place to do it. EndDialog is called,
2864 // so perhaps it should be done there. (although Wine only
2865 // enables the owner if the dialog is modal)
2866 ::EnableWindow(owner->getWindowHandle(), 1);
2867 }
2868
2869 fDestroyWindowCalled = TRUE;
2870
2871//hack alert; PM crashes if child calls DestroyWindow for parent/owner in WM_DESTROY
2872// handler; must postpone it
2873 if(fChildDestructionInProgress) {
2874 dprintf(("Postponing parent destruction because of dying child"));
2875 OSLibPostMessageDirect(OS2HwndFrame, WIN32APP_POSTPONEDESTROY, 0, 0);
2876 return TRUE;
2877 }
2878
2879 BOOL fOldChildDestructionInProgress = FALSE;
2880 if(GetParent()) {
2881 Win32BaseWindow *window = Win32BaseWindow::GetWindowFromHandle(GetParent());
2882 if(window) {
2883 fOldChildDestructionInProgress = window->IsChildDestructionInProgress();
2884 window->SetChildDestructionInProgress(TRUE);
2885 RELEASE_WNDOBJ(window);
2886 }
2887 }
2888//hack end
2889
2890 BOOL ret = OSLibWinDestroyWindow(OS2HwndFrame);
2891
2892//hack alert; PM crashes if child calls DestroyWindow for parent/owner in WM_DESTROY
2893// handler; must postpone it
2894 if(GetParent()) {
2895 Win32BaseWindow *window = Win32BaseWindow::GetWindowFromHandle(GetParent());
2896 if(window) {
2897 window->SetChildDestructionInProgress(fOldChildDestructionInProgress);
2898 RELEASE_WNDOBJ(window);
2899 }
2900 }
2901//hack end
2902 return ret;
2903}
2904//******************************************************************************
2905//******************************************************************************
2906Win32BaseWindow *Win32BaseWindow::getParent()
2907{
2908 Win32BaseWindow *wndparent = (Win32BaseWindow *)ChildWindow::getParentOfChild();
2909 //experiment
2910#if 0
2911 return ((ULONG)wndparent == (ULONG)windowDesktop) ? NULL : wndparent;
2912#else
2913 return wndparent;
2914#endif
2915}
2916//******************************************************************************
2917//Note: does not set last error if no parent (verified in NT4, SP6)
2918//******************************************************************************
2919HWND Win32BaseWindow::GetParent()
2920{
2921 Win32BaseWindow *wndparent = (Win32BaseWindow *)ChildWindow::getParentOfChild();
2922
2923 if(getStyle() & WS_CHILD)
2924 {
2925 if(wndparent) {
2926 return wndparent->getWindowHandle();
2927 }
2928 dprintf(("WARNING: GetParent: WS_CHILD but no parent!!"));
2929 DebugInt3();
2930 return 0;
2931 }
2932 else
2933 if(getStyle() & WS_POPUP)
2934 return (getOwner()) ? getOwner()->getWindowHandle() : 0;
2935 else return 0;
2936}
2937//******************************************************************************
2938//******************************************************************************
2939HWND Win32BaseWindow::SetParent(HWND hwndNewParent)
2940{
2941 HWND oldhwnd;
2942 Win32BaseWindow *newparent;
2943 Win32BaseWindow *oldparent = (Win32BaseWindow *)ChildWindow::getParentOfChild();
2944 BOOL fShow = FALSE;
2945
2946 if(oldparent) {
2947 oldhwnd = oldparent->getWindowHandle();
2948 oldparent->removeChild(this);
2949 }
2950 else oldhwnd = 0;
2951
2952 /* Windows hides the window first, then shows it again
2953 * including the WM_SHOWWINDOW messages and all */
2954 if(IsWindowCreated() && (getStyle() & WS_VISIBLE)) {
2955 ShowWindow(SW_HIDE);
2956 fShow = TRUE;
2957 }
2958 if(oldparent) {
2959 //release parent here (increased refcount during creation)
2960 RELEASE_WNDOBJ(oldparent);
2961 }
2962 newparent = GetWindowFromHandle(hwndNewParent);
2963 if(newparent && !newparent->isDesktopWindow())
2964 {
2965 setParent(newparent);
2966 getParent()->addChild(this);
2967 fParentChange = TRUE;
2968 // in case we haven't finished creating the window whose parent we're
2969 // setting here, the OS/2 HWND might not exist yet and we call the PM
2970 // API with a NULLHANDLE - no problem
2971 // when we create the OS/2 window lateron, we will create it with the
2972 // right parent anyway.
2973 OSLibWinSetParent(getOS2FrameWindowHandle(), getParent()->getOS2WindowHandle());
2974 if(!(getStyle() & WS_CHILD))
2975 {
2976 if(getWindowId())
2977 {
2978 DestroyMenu( (HMENU) getWindowId() );
2979 setWindowId(0);
2980 }
2981 }
2982 //SvL: Even though the win32 coordinates might not change, the PM
2983 // coordinates can. We must make sure the control stays at the
2984 // same position (y) relative to the (new) parent.
2985 // TODO: shouldn't we check the state of the window and not do it in INIT state?
2986 SetWindowPos(HWND_TOPMOST, rectWindow.left, rectWindow.top, 0, 0,
2987 SWP_NOACTIVATE|SWP_NOSIZE);
2988 fParentChange = FALSE;
2989 }
2990 else {
2991 if(newparent) RELEASE_WNDOBJ(newparent);
2992
2993 setParent(windowDesktop);
2994 windowDesktop->addRef();
2995 windowDesktop->addChild(this);
2996 OSLibWinSetParent(getOS2FrameWindowHandle(), OSLIB_HWND_DESKTOP);
2997
2998 //Do not change the window id!
2999//// setWindowId(0);
3000 }
3001 /* SetParent additionally needs to make hwndChild the topmost window
3002 in the x-order and send the expected WM_WINDOWPOSCHANGING and
3003 WM_WINDOWPOSCHANGED notification messages.
3004 */
3005 if(state >= STATE_PRE_WMNCCREATE) {
3006 SetWindowPos(HWND_TOPMOST, 0, 0, 0, 0,
3007 SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|(fShow? SWP_SHOWWINDOW : 0));
3008
3009 /* FIXME: a WM_MOVE is also generated (in the DefWindowProc handler
3010 * for WM_WINDOWPOSCHANGED) in Windows, should probably remove SWP_NOMOVE */
3011 }
3012 return oldhwnd;
3013}
3014//******************************************************************************
3015//******************************************************************************
3016BOOL Win32BaseWindow::IsChild(HWND hwndParent)
3017{
3018 // PH: Optimizer won't unroll calls to getParent() even
3019 // in release build.
3020 Win32BaseWindow *_parent = getParent();
3021
3022 if(_parent)
3023 {
3024 if(_parent->getWindowHandle() == hwndParent)
3025 return TRUE;
3026
3027 return _parent->IsChild(hwndParent);
3028 }
3029 else
3030 return 0;
3031}
3032//******************************************************************************
3033//******************************************************************************
3034HWND Win32BaseWindow::GetTopWindow()
3035{
3036 HWND hwndTop;
3037 Win32BaseWindow *topwindow;
3038
3039 hwndTop = OSLibWinQueryWindow(getOS2WindowHandle(), QWOS_TOP);
3040 if(!isDesktopWindow())
3041 {
3042 topwindow = GetWindowFromOS2FrameHandle(hwndTop);
3043 //Note: GetTopWindow can't return a window that hasn't processed
3044 // WM_NCCREATE yet (verified in NT4, SP6)
3045 if(topwindow) {
3046 if(topwindow->state >= STATE_POST_WMNCCREATE) {
3047 hwndTop = topwindow->getWindowHandle();
3048 }
3049 else hwndTop = topwindow->GetWindow(GW_HWNDNEXT);
3050 RELEASE_WNDOBJ(topwindow);
3051 return hwndTop;
3052 }
3053 if(topwindow) RELEASE_WNDOBJ(topwindow);
3054 return 0;
3055 }
3056 while(hwndTop) {
3057 topwindow = GetWindowFromOS2FrameHandle(hwndTop);
3058 //Note: GetTopWindow can't return a window that hasn't processed
3059 // WM_NCCREATE yet (verified in NT4, SP6)
3060 if(topwindow) {
3061 if(topwindow->state >= STATE_POST_WMNCCREATE) {
3062 hwndTop = topwindow->getWindowHandle();
3063 }
3064 else hwndTop = topwindow->GetWindow(GW_HWNDNEXT);
3065 RELEASE_WNDOBJ(topwindow);
3066 return hwndTop;
3067 }
3068 if(topwindow) RELEASE_WNDOBJ(topwindow);
3069 hwndTop = OSLibWinQueryWindow(hwndTop, QWOS_NEXT);
3070 }
3071
3072 return 0;
3073}
3074//******************************************************************************
3075// Get the top-level parent for a child window.
3076//******************************************************************************
3077HWND Win32BaseWindow::GetTopParent()
3078{
3079 Win32BaseWindow *window = this;
3080 HWND hwndTopParent = 0;
3081
3082 lock();
3083 while(window && (window->getStyle() & WS_CHILD))
3084 {
3085 window = window->getParent();
3086 }
3087 if(window) {
3088 hwndTopParent = window->getWindowHandle();
3089 }
3090 unlock();
3091 return hwndTopParent;
3092}
3093//******************************************************************************
3094//TODO: Should not enumerate children that are created during the enumeration!
3095//TODO: Do this more efficiently
3096//******************************************************************************
3097BOOL Win32BaseWindow::EnumChildWindows(WNDENUMPROC lpfn, LPARAM lParam)
3098{
3099 BOOL rc = TRUE;
3100 HWND hwnd;
3101 Win32BaseWindow *prevchild = 0, *child = 0;
3102
3103 dprintf(("EnumChildWindows of %x parameter %x %x (%x)", getWindowHandle(), lpfn, lParam, getFirstChild()));
3104 lock();
3105 for (child = (Win32BaseWindow *)getFirstChild(); child != NULL; child = (Win32BaseWindow *)child->getNextChild())
3106 {
3107 dprintf(("EnumChildWindows: enumerating child %x (owner %x; parent %x)", child->getWindowHandle(), (child->getOwner()) ? child->getOwner()->getWindowHandle() : 0, getWindowHandle()));
3108 hwnd = child->getWindowHandle();
3109 if(child->IsWindowDestroyed() || child->getOwner()) {
3110 continue; //shouldn't have an owner (Wine)
3111 }
3112 child->addRef();
3113 unlock();
3114 if(lpfn(hwnd, lParam) == FALSE)
3115 {
3116 child->release();
3117 return FALSE;
3118 }
3119 child->release();
3120 lock();
3121 //check if the window still exists
3122 if(!::IsWindow(hwnd))
3123 {
3124 child = prevchild;
3125 if(child == NULL) break;
3126 continue;
3127 }
3128 if(child->getFirstChild() != NULL)
3129 {
3130 dprintf(("EnumChildWindows: Enumerate children of %x", child->getWindowHandle()));
3131 child->addRef();
3132 unlock();
3133 if(child->EnumChildWindows(lpfn, lParam) == FALSE)
3134 {
3135 child->release();
3136 return FALSE;
3137 }
3138 child->release();
3139 lock();
3140 }
3141 prevchild = child;
3142 }
3143 unlock();
3144 return rc;
3145}
3146//******************************************************************************
3147//Enumerate first-level children only and check thread id
3148//******************************************************************************
3149BOOL Win32BaseWindow::EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
3150{
3151 Win32BaseWindow *child = 0;
3152 ULONG tid, pid;
3153 BOOL rc;
3154 HWND hwnd;
3155
3156 dprintf(("EnumThreadWindows %x %x %x", dwThreadId, lpfn, lParam));
3157
3158 for (child = (Win32BaseWindow *)getFirstChild(); child; child = (Win32BaseWindow *)child->getNextChild())
3159 {
3160 OSLibWinQueryWindowProcess(child->getOS2WindowHandle(), &pid, &tid);
3161
3162 if(dwThreadId == tid) {
3163 dprintf2(("EnumThreadWindows: Found Window %x", child->getWindowHandle()));
3164 if((rc = lpfn(child->getWindowHandle(), lParam)) == FALSE) {
3165 break;
3166 }
3167 }
3168 }
3169 return TRUE;
3170}
3171//******************************************************************************
3172//Enumerate first-level children only
3173//******************************************************************************
3174BOOL Win32BaseWindow::EnumWindows(WNDENUMPROC lpfn, LPARAM lParam)
3175{
3176 Win32BaseWindow *window;
3177 BOOL rc;
3178 HWND hwnd = WNDHANDLE_MAGIC_HIGHWORD;
3179 DWORD dwStyle;
3180
3181 dprintf(("EnumWindows %x %x", lpfn, lParam));
3182
3183 for(int i=0;i<MAX_WINDOW_HANDLES;i++)
3184 {
3185 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
3186 if(window) {
3187 if(window->getWindowHandle() != hwnd) {
3188 dprintf(("CORRUPT WINDOW %x %x", window, hwnd));
3189 }
3190 RELEASE_WNDOBJ(window);
3191 dwStyle = ::GetWindowLongA(hwnd, GWL_STYLE);
3192 if ((dwStyle & WS_POPUP) || ((dwStyle & WS_CAPTION) == WS_CAPTION))
3193 {
3194 dprintf2(("EnumWindows: Found Window %x", hwnd));
3195 if((rc = lpfn(hwnd, lParam)) == FALSE) {
3196 break;
3197 }
3198 }
3199 }
3200 hwnd++;
3201 }
3202 return TRUE;
3203}
3204//******************************************************************************
3205//******************************************************************************
3206HWND Win32BaseWindow::FindWindowById(int id)
3207{
3208 HWND hwnd;
3209
3210 lock();
3211 for (Win32BaseWindow *child = (Win32BaseWindow *)getFirstChild(); child; child = (Win32BaseWindow *)child->getNextChild())
3212 {
3213 if (child->getWindowId() == id)
3214 {
3215 hwnd = child->getWindowHandle();
3216 unlock();
3217 return hwnd;
3218 }
3219 }
3220 unlock();
3221 return 0;
3222}
3223//******************************************************************************
3224//TODO:
3225//We assume (for now) that if hwndParent or hwndChildAfter are real window handles, that
3226//the current process owns them.
3227//******************************************************************************
3228HWND Win32BaseWindow::FindWindowEx(HWND hwndParent, HWND hwndChildAfter, ATOM atom, LPSTR lpszWindow)
3229{
3230 Win32BaseWindow *parent = GetWindowFromHandle(hwndParent);
3231 Win32BaseWindow *child = GetWindowFromHandle(hwndChildAfter);
3232 Win32BaseWindow *firstchild = child;
3233
3234 dprintf(("FindWindowEx %x %x %x %s", hwndParent, hwndChildAfter, atom, lpszWindow));
3235 if((hwndParent != 0 && !parent) ||
3236 (hwndChildAfter != 0 && !child) ||
3237 (hwndParent == 0 && hwndChildAfter != 0))
3238 {
3239 if(parent) RELEASE_WNDOBJ(parent);
3240 if(firstchild) RELEASE_WNDOBJ(firstchild);
3241 dprintf(("Win32BaseWindow::FindWindowEx: parent or child not found %x %x", hwndParent, hwndChildAfter));
3242 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
3243 return 0;
3244 }
3245 SetLastError(0);
3246 if(hwndParent != 0)
3247 {//if the current process owns the window, just do a quick search
3248 lock(&critsect);
3249 child = (Win32BaseWindow *)parent->getFirstChild();
3250 if(hwndChildAfter != 0)
3251 {
3252 while(child)
3253 {
3254 if(child->getWindowHandle() == hwndChildAfter)
3255 {
3256 child = (Win32BaseWindow *)child->getNextChild();
3257 break;
3258 }
3259 child = (Win32BaseWindow *)child->getNextChild();
3260 }
3261 }
3262 while(child)
3263 {
3264 //According to Wine, the class doesn't need to be specified
3265 if((!atom || child->getWindowClass()->getAtom() == atom) &&
3266 (!lpszWindow || child->hasWindowName(lpszWindow)))
3267 {
3268 dprintf(("FindWindowEx: Found window %x", child->getWindowHandle()));
3269 HWND hwndChild = child->getWindowHandle();
3270 unlock(&critsect);
3271 if(parent) RELEASE_WNDOBJ(parent);
3272 if(firstchild) RELEASE_WNDOBJ(firstchild);
3273 dprintf(("FindWindowEx: Found window %x", child->getWindowHandle()));
3274 return hwndChild;
3275 }
3276 child = (Win32BaseWindow *)child->getNextChild();
3277 }
3278 unlock(&critsect);
3279 if(parent) RELEASE_WNDOBJ(parent);
3280 if(firstchild) RELEASE_WNDOBJ(firstchild);
3281 }
3282 else {
3283 Win32BaseWindow *wnd;
3284 HWND henum, hwnd;
3285
3286 henum = OSLibWinBeginEnumWindows(OSLIB_HWND_DESKTOP);
3287 hwnd = OSLibWinGetNextWindow(henum);
3288
3289 while(hwnd)
3290 {
3291 wnd = GetWindowFromOS2FrameHandle(hwnd);
3292 if(wnd == NULL) {
3293 hwnd = OSLibWinQueryClientWindow(hwnd);
3294 if(hwnd) wnd = GetWindowFromOS2Handle(hwnd);
3295 }
3296
3297 if(wnd) {
3298 //According to Wine, the class doesn't need to be specified
3299 if((!atom || wnd->getWindowClass()->getAtom() == atom) &&
3300 (!lpszWindow || wnd->hasWindowName(lpszWindow)))
3301 {
3302 OSLibWinEndEnumWindows(henum);
3303 dprintf(("FindWindowEx: Found window %x", wnd->getWindowHandle()));
3304 HWND hwndret = wnd->getWindowHandle();
3305 RELEASE_WNDOBJ(wnd);
3306 return hwndret;
3307 }
3308 RELEASE_WNDOBJ(wnd);
3309 }
3310 hwnd = OSLibWinGetNextWindow(henum);
3311 }
3312 OSLibWinEndEnumWindows(henum);
3313 if(parent) RELEASE_WNDOBJ(parent);
3314 if(firstchild) RELEASE_WNDOBJ(firstchild);
3315 }
3316 SetLastError(ERROR_CANNOT_FIND_WND_CLASS); //TODO: not always correct
3317 return 0;
3318}
3319//******************************************************************************
3320//******************************************************************************
3321HWND Win32BaseWindow::GetWindow(UINT uCmd)
3322{
3323 HWND hwndRelated = 0;
3324 Win32BaseWindow *window;
3325
3326 switch(uCmd)
3327 {
3328 case GW_HWNDFIRST:
3329 window = (Win32BaseWindow *)getParent();
3330 if(window)
3331 {
3332 hwndRelated = OSLibWinQueryWindow(window->getOS2WindowHandle(), QWOS_TOP);
3333 window = GetWindowFromOS2FrameHandle(hwndRelated);
3334 if(window) {
3335 hwndRelated = window->getWindowHandle();
3336 RELEASE_WNDOBJ(window);
3337 }
3338 else hwndRelated = 0;
3339 }
3340 else {
3341 dprintf(("WARNING: GW_HWNDFIRST not correctly implemented for toplevel/most windows!"));
3342 hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
3343 }
3344 break;
3345
3346 case GW_HWNDLAST:
3347 window = (Win32BaseWindow *)getParent();
3348 if(window) {
3349 hwndRelated = OSLibWinQueryWindow(window->getOS2WindowHandle(), QWOS_BOTTOM);
3350 dprintf(("os2 handle %x", hwndRelated));
3351 window = GetWindowFromOS2FrameHandle(hwndRelated);
3352 if(window) {
3353 hwndRelated = window->getWindowHandle();
3354 RELEASE_WNDOBJ(window);
3355 }
3356 else hwndRelated = 0;
3357 }
3358 else {
3359 dprintf(("WARNING: GW_HWNDLAST not correctly implemented for toplevel/most windows!"));
3360 hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
3361 }
3362 break;
3363
3364 case GW_HWNDNEXT:
3365 if(getParent()) {
3366 hwndRelated = OSLibWinQueryWindow(getOS2FrameWindowHandle(), QWOS_NEXT);
3367 window = GetWindowFromOS2FrameHandle(hwndRelated);
3368 if(window) {
3369 hwndRelated = window->getWindowHandle();
3370 RELEASE_WNDOBJ(window);
3371 }
3372 else hwndRelated = 0;
3373 }
3374 else {
3375 dprintf(("WARNING: GW_HWNDNEXT not correctly implemented for toplevel/most windows!"));
3376 hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
3377 }
3378 break;
3379
3380 case GW_HWNDPREV:
3381 if(getParent()) {
3382 hwndRelated = OSLibWinQueryWindow(getOS2FrameWindowHandle(), QWOS_PREV);
3383 window = GetWindowFromOS2FrameHandle(hwndRelated);
3384 if(window) {
3385 hwndRelated = window->getWindowHandle();
3386 RELEASE_WNDOBJ(window);
3387 }
3388 else hwndRelated = 0;
3389 }
3390 else {
3391 dprintf(("WARNING: GW_HWNDPREV not correctly implemented for toplevel/most windows!"));
3392 hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
3393 }
3394 break;
3395
3396 case GW_OWNER:
3397 {
3398 Win32BaseWindow *owner = getOwner();
3399 if(owner) {
3400 hwndRelated = owner->getWindowHandle();
3401 }
3402 break;
3403 }
3404
3405 case GW_CHILD:
3406 hwndRelated = OSLibWinQueryWindow(getOS2WindowHandle(), QWOS_TOP);
3407 window = GetWindowFromOS2FrameHandle(hwndRelated);
3408
3409 //Before a window has processed WM_NCCREATE:
3410 //- GetWindow(parent, GW_CHILD) can't return that window handle
3411 //(verified in NT4, SP6)
3412 if(window) {
3413 if(window->state >= STATE_POST_WMNCCREATE) {
3414 hwndRelated = window->getWindowHandle();
3415 RELEASE_WNDOBJ(window);
3416 }
3417 else {
3418 hwndRelated = window->GetWindow(GW_HWNDNEXT);
3419 RELEASE_WNDOBJ(window);
3420 }
3421 }
3422 else hwndRelated = 0;
3423
3424 break;
3425
3426 //for internal use only
3427 case GW_HWNDNEXTCHILD:
3428 lock();
3429 window = (Win32BaseWindow *)getNextChild();
3430 if(window) {
3431 hwndRelated = window->getWindowHandle();
3432 }
3433 else hwndRelated = 0;
3434 unlock();
3435 break;
3436
3437 case GW_HWNDPREVCHILD:
3438 DebugInt3();
3439 break;
3440
3441 case GW_HWNDFIRSTCHILD:
3442 lock();
3443 window = (Win32BaseWindow *)getFirstChild();
3444 if(window) {
3445 hwndRelated = window->getWindowHandle();
3446 }
3447 else hwndRelated = 0;
3448 unlock();
3449 break;
3450
3451 case GW_HWNDLASTCHILD:
3452 lock();
3453 window = (Win32BaseWindow *)getFirstChild();
3454 if(window) {
3455 while (window->getNextChild())
3456 {
3457 window = (Win32BaseWindow *)window->getNextChild();
3458 }
3459 hwndRelated = window->getWindowHandle();
3460 }
3461 else hwndRelated = 0;
3462 unlock();
3463 break;
3464 }
3465end:
3466 dprintf(("GetWindow %x %d returned %x", getWindowHandle(), uCmd, hwndRelated));
3467 return hwndRelated;
3468}
3469//******************************************************************************
3470//******************************************************************************
3471HWND Win32BaseWindow::SetActiveWindow()
3472{
3473 HWND hwndActive;
3474
3475 dprintf(("SetActiveWindow %x", getWindowHandle()));
3476 if(getStyle() & WS_CHILD) {
3477// if(getStyle() & (WS_DISABLED | WS_CHILD)) {
3478 dprintf(("WARNING: Window is a child or disabled"));
3479 return 0;
3480 }
3481
3482 if(GetActiveWindow() == getWindowHandle()) {
3483 dprintf(("Window already active"));
3484 return getWindowHandle();
3485 }
3486 if (HOOK_IsHooked( WH_CBT ))
3487 {
3488 CBTACTIVATESTRUCT cbta;
3489 LRESULT ret;
3490
3491 cbta.fMouse = FALSE;
3492 cbta.hWndActive = GetActiveWindow();
3493 ret = HOOK_CallHooksA(WH_CBT, HCBT_ACTIVATE, getWindowHandle(), (LPARAM)&cbta);
3494 if(ret)
3495 {
3496 dprintf(("SetActiveWindow %x, CBT hook cancelled operation", getWindowHandle()));
3497 return cbta.hWndActive;
3498 }
3499 }
3500 SetWindowPos(HWND_TOP, 0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
3501
3502// if(OSLibWinSetActiveWindow(OS2Hwnd) == FALSE) {
3503// dprintf(("OSLibWinSetActiveWindow %x returned FALSE!", OS2Hwnd));
3504// }
3505 hwndActive = GetActiveWindow();
3506 return (hwndActive) ? hwndActive : windowDesktop->getWindowHandle(); //pretend the desktop was active
3507}
3508//******************************************************************************
3509//Used to change active status of an mdi window
3510//******************************************************************************
3511BOOL Win32BaseWindow::DeactivateChildWindow()
3512{
3513 /* child windows get a WM_CHILDACTIVATE message */
3514 if((getStyle() & (WS_CHILD | WS_POPUP)) == WS_CHILD )
3515 {
3516 ULONG flags = OSLibWinGetWindowULong(getOS2WindowHandle(), OFFSET_WIN32FLAGS);
3517 OSLibWinSetWindowULong(getOS2WindowHandle(), OFFSET_WIN32FLAGS, (flags & ~WINDOWFLAG_ACTIVE));
3518 return TRUE;
3519 }
3520 DebugInt3(); //should not be called for non-child window
3521 return FALSE;
3522}
3523//******************************************************************************
3524//WM_ENABLE is sent to hwnd, but not to it's children (as it should be)
3525//******************************************************************************
3526BOOL Win32BaseWindow::EnableWindow(BOOL fEnable)
3527{
3528 BOOL rc;
3529
3530 dprintf(("Win32BaseWindow::EnableWindow %x %d", getWindowHandle(), fEnable));
3531 //return true if previous state was disabled, else false (sdk docs)
3532 rc = (getStyle() & WS_DISABLED) != 0;
3533 if(rc && !fEnable) {
3534 SendMessageA(getWindowHandle(), WM_CANCELMODE, 0, 0);
3535 }
3536 OSLibWinEnableWindow(OS2HwndFrame, fEnable);
3537 if(fEnable == FALSE) {
3538 //SvL: No need to clear focus as PM already does this
3539 if(getWindowHandle() == GetCapture()) {
3540 ReleaseCapture(); /* A disabled window can't capture the mouse */
3541 dprintf(("Released capture for window %x that is being disabled", getWindowHandle()));
3542 }
3543 }
3544 return rc;
3545}
3546//******************************************************************************
3547//******************************************************************************
3548BOOL Win32BaseWindow::CloseWindow()
3549{
3550 if (::GetWindowLongW( getWindowHandle() , GWL_STYLE ) & WS_CHILD) return FALSE;
3551 ShowWindow( SW_MINIMIZE );
3552 return TRUE;
3553}
3554//******************************************************************************
3555//TODO: Not be 100% correct; should return active window of current thread
3556// or NULL when there is none -> WinQueryActiveWindow just returns
3557// the current active window
3558//******************************************************************************
3559HWND Win32BaseWindow::GetActiveWindow()
3560{
3561 HWND hwndActive;
3562
3563 hwndActive = OSLibWinQueryActiveWindow();
3564 return OS2ToWin32Handle(hwndActive);
3565}
3566//******************************************************************************
3567//******************************************************************************
3568BOOL Win32BaseWindow::hasWindowName(LPSTR wndname, BOOL fUnicode)
3569{
3570 INT len = GetWindowTextLength(fUnicode);
3571 BOOL res;
3572
3573 if (wndname == NULL)
3574 return (len == 0);
3575
3576 len++;
3577 if (fUnicode)
3578 {
3579 WCHAR *text = (WCHAR*)malloc(len*sizeof(WCHAR));
3580
3581 GetWindowTextW(text,len);
3582 res = (lstrcmpW(text,(LPWSTR)wndname) == 0);
3583 free(text);
3584 }
3585 else
3586 {
3587 CHAR *text = (CHAR*)malloc(len*sizeof(CHAR));
3588
3589 GetWindowTextA(text,len);
3590 res = (strcmp(text,wndname) == 0);
3591 free(text);
3592 }
3593
3594 return res;
3595}
3596//******************************************************************************
3597//******************************************************************************
3598CHAR *Win32BaseWindow::getWindowNamePtrA()
3599{
3600 INT len = GetWindowTextLength(FALSE);
3601 CHAR *text;
3602
3603 if (len == 0) return NULL;
3604 len++;
3605 text = (CHAR*)malloc(len*sizeof(CHAR));
3606 GetWindowTextA(text,len);
3607
3608 return text;
3609}
3610//******************************************************************************
3611//******************************************************************************
3612WCHAR *Win32BaseWindow::getWindowNamePtrW()
3613{
3614 INT len = GetWindowTextLength(TRUE);
3615 WCHAR *text;
3616
3617 if (len == 0) return NULL;
3618 len++;
3619 text = (WCHAR*)malloc(len*sizeof(WCHAR));
3620 GetWindowTextW(text,len);
3621
3622 return text;
3623}
3624//******************************************************************************
3625//******************************************************************************
3626VOID Win32BaseWindow::freeWindowNamePtr(PVOID namePtr)
3627{
3628 if (namePtr) free(namePtr);
3629}
3630//******************************************************************************
3631//When using this API for a window that was created by a different process, NT
3632//does NOT send WM_GETTEXTLENGTH.
3633//******************************************************************************
3634int Win32BaseWindow::GetWindowTextLength(BOOL fUnicode)
3635{
3636 //if the destination window is created by this process, send message
3637 if(dwProcessId == currentProcessId)
3638 {
3639 if(fUnicode) {
3640 return SendMessageW(getWindowHandle(), WM_GETTEXTLENGTH,0,0);
3641 }
3642 else return SendMessageA(getWindowHandle(), WM_GETTEXTLENGTH,0,0);
3643 }
3644 //else get data directory from window structure
3645 //TODO: must lock window structure.... (TODO)
3646 return windowNameLength;
3647}
3648//******************************************************************************
3649//When using this API for a window that was created by a different process, NT
3650//does NOT send WM_GETTEXT.
3651//******************************************************************************
3652int Win32BaseWindow::GetWindowTextA(LPSTR lpsz, int cch)
3653{
3654 //if the destination window is created by this process, send message
3655 if(dwProcessId == currentProcessId) {
3656 return SendMessageA(getWindowHandle(),WM_GETTEXT,(WPARAM)cch,(LPARAM)lpsz);
3657 }
3658
3659 //else get data directory from window structure
3660 if (!lpsz || !cch) return 0;
3661 if (!windowNameA) lpsz[0] = 0;
3662 else memcpy(lpsz, windowNameA, min(windowNameLength + 1, cch) );
3663 return min(windowNameLength, cch);
3664}
3665//******************************************************************************
3666//When using this API for a window that was created by a different process, NT
3667//does NOT send WM_GETTEXT.
3668//******************************************************************************
3669int Win32BaseWindow::GetWindowTextW(LPWSTR lpsz, int cch)
3670{
3671 //if the destination window is created by this process, send message
3672 if(dwProcessId == currentProcessId) {
3673 return ::SendMessageW(getWindowHandle(), WM_GETTEXT,(WPARAM)cch,(LPARAM)lpsz);
3674 }
3675 //else get data directory from window structure
3676 if (!lpsz || !cch)
3677 return 0;
3678 if (!windowNameW)
3679 lpsz[0] = 0;
3680 else
3681 memcpy(lpsz, windowNameW, min( sizeof(WCHAR) * (windowNameLength+1), cch));
3682
3683 return min(windowNameLength, cch);
3684}
3685//******************************************************************************
3686//TODO: How does this work when the target window belongs to a different process???
3687//******************************************************************************
3688BOOL Win32BaseWindow::SetWindowTextA(LPSTR lpsz)
3689{
3690 return SendMessageA(getWindowHandle(),WM_SETTEXT,0,(LPARAM)lpsz);
3691}
3692//******************************************************************************
3693//******************************************************************************
3694BOOL Win32BaseWindow::SetWindowTextW(LPWSTR lpsz)
3695{
3696 return SendMessageW(getWindowHandle(), WM_SETTEXT,0,(LPARAM)lpsz);
3697}
3698//******************************************************************************
3699//******************************************************************************
3700LONG Win32BaseWindow::SetWindowLong(int index, ULONG value, BOOL fUnicode)
3701{
3702 LONG oldval;
3703
3704 switch(index) {
3705 case GWL_EXSTYLE:
3706 {
3707 STYLESTRUCT ss;
3708
3709 if(dwExStyle == value) {
3710 oldval = value;
3711 break;
3712 }
3713 ss.styleOld = dwExStyle;
3714 ss.styleNew = value;
3715 dprintf(("SetWindowLong GWL_EXSTYLE %x old %x new style %x", getWindowHandle(), dwExStyle, value));
3716 SendMessageA(getWindowHandle(),WM_STYLECHANGING,GWL_EXSTYLE,(LPARAM)&ss);
3717 setExStyle(ss.styleNew);
3718 SendMessageA(getWindowHandle(),WM_STYLECHANGED,GWL_EXSTYLE,(LPARAM)&ss);
3719 OSLibSetWindowStyle(getOS2FrameWindowHandle(), getOS2WindowHandle(), getStyle(), getExStyle());
3720 oldval = ss.styleOld;
3721 break;
3722 }
3723 case GWL_STYLE:
3724 {
3725 STYLESTRUCT ss;
3726
3727 //SvL: TODO: Can you change minimize or maximize status here too?
3728
3729 if(dwStyle == value) {
3730 oldval = value;
3731 break;
3732 }
3733 dprintf(("SetWindowLong GWL_STYLE %x old %x new style %x (%x)", getWindowHandle(), dwStyle, value));
3734
3735 //Changing WS_CHILD style is allowed
3736 ss.styleOld = getStyle();
3737 ss.styleNew = value;
3738 SendMessageA(getWindowHandle(),WM_STYLECHANGING,GWL_STYLE,(LPARAM)&ss);
3739 setStyle(ss.styleNew);
3740 SendMessageA(getWindowHandle(),WM_STYLECHANGED,GWL_STYLE,(LPARAM)&ss);
3741 OSLibSetWindowStyle(getOS2FrameWindowHandle(), getOS2WindowHandle(),
3742 getStyle(), getExStyle());
3743
3744 //TODO: Might not be correct to use ShowWindow here
3745 if((ss.styleOld & WS_VISIBLE) != (ss.styleNew & WS_VISIBLE)) {
3746 if(ss.styleNew & WS_VISIBLE)
3747 ShowWindow(SW_SHOWNOACTIVATE);
3748 else ShowWindow(SW_HIDE);
3749 }
3750#ifdef DEBUG
3751 PrintWindowStyle(ss.styleNew, 0);
3752#endif
3753 oldval = ss.styleOld;
3754 break;
3755 }
3756 case GWL_WNDPROC:
3757 {
3758 //Note: Type of SetWindowLong determines new window proc type
3759 // UNLESS the new window proc has already been registered
3760 // (use the old type in that case)
3761 // (VERIFIED in NT 4, SP6)
3762 WINDOWPROCTYPE type = WINPROC_GetProcType((HWINDOWPROC)value);
3763 if(type == WIN_PROC_INVALID) {
3764 type = (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A;
3765 }
3766 oldval = (LONG)WINPROC_GetProc(win32wndproc, (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A);
3767 dprintf(("SetWindowLong%c GWL_WNDPROC %x old %x new wndproc %x", (fUnicode) ? 'W' : 'A', getWindowHandle(), oldval, value));
3768 WINPROC_SetProc((HWINDOWPROC *)&win32wndproc, (WNDPROC)value, type, WIN_PROC_WINDOW);
3769 break;
3770 }
3771 case GWL_HINSTANCE:
3772 oldval = hInstance;
3773 hInstance = value;
3774 break;
3775
3776 case GWL_HWNDPARENT:
3777 oldval = SetParent((HWND)value);
3778 break;
3779
3780 case GWL_ID:
3781 dprintf(("GWL_ID old %x, new %x", getWindowId(), value));
3782 oldval = getWindowId();
3783 setWindowId(value);
3784 break;
3785
3786 case GWL_USERDATA:
3787 oldval = userData;
3788 userData = value;
3789 break;
3790
3791 default:
3792 if(index >= 0 && index + sizeof(ULONG) <= nrUserWindowBytes)
3793 {
3794 oldval = *(ULONG *)(userWindowBytes + index);
3795 *(ULONG *)(userWindowBytes + index) = value;
3796 break;
3797 }
3798 dprintf(("WARNING: SetWindowLong%c %x %d %x returned %x INVALID index!", (fUnicode) ? 'W' : 'A', getWindowHandle(), index, value));
3799 SetLastError(ERROR_INVALID_INDEX); //verified in NT4, SP6
3800 return 0;
3801 }
3802 //Note: NT4, SP6 does not set the last error to 0
3803 SetLastError(ERROR_SUCCESS);
3804 dprintf2(("SetWindowLong%c %x %d %x returned %x", (fUnicode) ? 'W' : 'A', getWindowHandle(), index, value, oldval));
3805 return oldval;
3806}
3807//******************************************************************************
3808//******************************************************************************
3809ULONG Win32BaseWindow::GetWindowLong(int index, BOOL fUnicode)
3810{
3811 ULONG value;
3812
3813 switch(index) {
3814 case GWL_EXSTYLE:
3815 value = dwExStyle;
3816 break;
3817 case GWL_STYLE:
3818 value = dwStyle;
3819 break;
3820 case GWL_WNDPROC:
3821 value = (LONG)WINPROC_GetProc(win32wndproc, (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A);
3822 break;
3823 case GWL_HINSTANCE:
3824 value = hInstance;
3825 break;
3826 case GWL_HWNDPARENT:
3827 value = GetParent();
3828 break;
3829 case GWL_ID:
3830 value = getWindowId();
3831 break;
3832 case GWL_USERDATA:
3833 value = userData;
3834 break;
3835 default:
3836 if(index >= 0 && index + sizeof(ULONG) <= nrUserWindowBytes)
3837 {
3838 value = *(ULONG *)(userWindowBytes + index);
3839 break;
3840 }
3841 dprintf(("WARNING: GetWindowLong%c %x %d %x returned %x INVALID index!", (fUnicode) ? 'W' : 'A', getWindowHandle(), index, value));
3842 SetLastError(ERROR_INVALID_INDEX); //verified in NT4, SP6
3843 return 0;
3844 }
3845 dprintf2(("GetWindowLong%c %x %d %x", (fUnicode) ? 'W' : 'A', getWindowHandle(), index, value));
3846 //Note: NT4, SP6 does not set the last error to 0
3847 SetLastError(ERROR_SUCCESS);
3848 return value;
3849}
3850//******************************************************************************
3851//******************************************************************************
3852WORD Win32BaseWindow::SetWindowWord(int index, WORD value)
3853{
3854 WORD oldval;
3855
3856 if(index >= 0 && index + sizeof(WORD) <= nrUserWindowBytes)
3857 {
3858 oldval = *(WORD *)(userWindowBytes + index);
3859 *(WORD *)(userWindowBytes + index) = value;
3860 //Note: NT4, SP6 does not set the last error to 0
3861 dprintf2(("SetWindowWord %x %d %x returned %x", getWindowHandle(), index, value, oldval));
3862 SetLastError(ERROR_SUCCESS);
3863 return oldval;
3864 }
3865 switch(index)
3866 {
3867 case GWW_HINSTANCE:
3868 oldval = hInstance;
3869 hInstance = value;
3870 break;
3871
3872 case GWW_HWNDPARENT:
3873 oldval = SetParent((HWND)(WNDHANDLE_MAGIC_HIGHWORD | value));
3874 break;
3875
3876 case GWW_ID:
3877 oldval = getWindowId();
3878 setWindowId(value);
3879 break;
3880
3881 default:
3882 dprintf(("WARNING: SetWindowWord %x %d %x returned %x INVALID index!", getWindowHandle(), index, value));
3883 SetLastError(ERROR_INVALID_INDEX); //verified in NT4, SP6
3884 return 0;
3885 }
3886 //Note: NT4, SP6 does not set the last error to 0
3887 SetLastError(ERROR_SUCCESS);
3888 dprintf2(("SetWindowWord %x %d %x returned %x", getWindowHandle(), index, value, oldval));
3889 return oldval;
3890}
3891//******************************************************************************
3892//******************************************************************************
3893WORD Win32BaseWindow::GetWindowWord(int index)
3894{
3895 if(index >= 0 && index + sizeof(WORD) <= nrUserWindowBytes)
3896 {
3897 //Note: NT4, SP6 does not set the last error to 0
3898 SetLastError(ERROR_SUCCESS);
3899 dprintf2(("GetWindowWord %x %d %x", getWindowHandle(), index, *(WORD *)(userWindowBytes + index)));
3900 return *(WORD *)(userWindowBytes + index);
3901 }
3902 switch(index)
3903 {
3904 case GWW_ID:
3905 if(HIWORD(getWindowId()))
3906 dprintf(("WARNING: GWW_ID: discards high bits of 0x%08x!\n", getWindowId()));
3907 return (WORD)getWindowId();
3908
3909 case GWW_HWNDPARENT:
3910 dprintf(("WARNING: GWW_HWNDPARENT: discards high bits of 0x%08x!\n", GetParent()));
3911 return (WORD) GetParent();
3912
3913 case GWW_HINSTANCE:
3914 if (HIWORD(hInstance))
3915 dprintf(("WARNING: GWW_HINSTANCE: discards high bits of 0x%08x!\n", hInstance));
3916 return (WORD)hInstance;
3917 }
3918
3919 dprintf(("WARNING: GetWindowWord %x %d returned %x INVALID index!", getWindowHandle(), index));
3920 SetLastError(ERROR_INVALID_INDEX); //verified in NT4, SP6
3921 return 0;
3922}
3923//******************************************************************************
3924//Locates window in linked list and increases reference count (if found)
3925//Window object must be unreferenced after usage
3926//******************************************************************************
3927Win32BaseWindow *Win32BaseWindow::GetWindowFromHandle(HWND hwnd)
3928{
3929 Win32BaseWindow *window;
3930
3931////TODO: temporary workaround for crashes in Opera (pmwinx; releasesemaphore)
3932//// while browsing
3933//// Not thread safe now!
3934//// lock(&critsect);
3935 if(HwGetWindowHandleData(hwnd, (DWORD *)&window) == TRUE) {
3936 if(window) {
3937//// dprintf(("addRef %x; refcount %d", hwnd, window->getRefCount()+1));
3938 window->addRef();
3939 }
3940//// unlock(&critsect);
3941 return window;
3942 }
3943//// unlock(&critsect);
3944// dprintf2(("Win32BaseWindow::GetWindowFromHandle: not a win32 window %x", hwnd));
3945 return NULL;
3946}
3947//******************************************************************************
3948//Locates window in linked list and increases reference count (if found)
3949//Window object must be unreferenced after usage
3950//******************************************************************************
3951Win32BaseWindow *Win32BaseWindow::GetWindowFromOS2Handle(HWND hwndOS2)
3952{
3953 DWORD magic;
3954 HWND hwnd;
3955
3956 if(hwndOS2 == OSLIB_HWND_DESKTOP)
3957 {
3958 windowDesktop->addRef();
3959 return windowDesktop;
3960 }
3961
3962 hwnd = (HWND)OSLibWinGetWindowULong(hwndOS2, OFFSET_WIN32WNDPTR);
3963 magic = OSLibWinGetWindowULong(hwndOS2, OFFSET_WIN32PM_MAGIC);
3964
3965 if(hwnd && CheckMagicDword(magic)) {
3966 return GetWindowFromHandle(hwnd);
3967 }
3968// dprintf2(("Win32BaseWindow::GetWindowFromOS2Handle: not an Odin os2 window %x", hwndOS2));
3969 return 0;
3970}
3971//******************************************************************************
3972//Locates window in linked list and increases reference count (if found)
3973//Window object must be unreferenced after usage
3974//******************************************************************************
3975Win32BaseWindow *Win32BaseWindow::GetWindowFromOS2FrameHandle(HWND hwnd)
3976{
3977 return GetWindowFromOS2Handle(OSLibWinWindowFromID(hwnd,OSLIB_FID_CLIENT));
3978}
3979//******************************************************************************
3980//******************************************************************************
3981HWND WIN32API Win32ToOS2Handle(HWND hwnd)
3982{
3983 HWND hwndOS2;
3984
3985 Win32BaseWindow *window = Win32BaseWindow::GetWindowFromHandle(hwnd);
3986
3987 if(window) {
3988 hwndOS2 = window->getOS2WindowHandle();
3989 RELEASE_WNDOBJ(window);
3990 return hwndOS2;
3991 }
3992// dprintf2(("Win32BaseWindow::Win32ToOS2Handle: not a win32 window %x", hwnd));
3993 return hwnd;
3994}
3995//******************************************************************************
3996//******************************************************************************
3997HWND WIN32API Win32ToOS2FrameHandle(HWND hwnd)
3998{
3999 HWND hwndOS2;
4000
4001 Win32BaseWindow *window = Win32BaseWindow::GetWindowFromHandle(hwnd);
4002
4003 if(window) {
4004 hwndOS2 = window->getOS2FrameWindowHandle();
4005 RELEASE_WNDOBJ(window);
4006 return hwndOS2;
4007 }
4008// dprintf2(("Win32BaseWindow::Win32ToOS2Handle: not a win32 window %x", hwnd));
4009 return hwnd;
4010}
4011//******************************************************************************
4012//******************************************************************************
4013HWND WIN32API OS2ToWin32Handle(HWND hwnd)
4014{
4015 Win32BaseWindow *window = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
4016 HWND hwndWin32;
4017
4018 if(window) {
4019 hwndWin32 = window->getWindowHandle();
4020 RELEASE_WNDOBJ(window);
4021 return hwndWin32;
4022 }
4023 window = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwnd);
4024 if(window) {
4025 hwndWin32 = window->getWindowHandle();
4026 RELEASE_WNDOBJ(window);
4027 return hwndWin32;
4028 }
4029
4030// dprintf2(("Win32BaseWindow::OS2ToWin32Handle: not a win32 window %x", hwnd));
4031 return 0;
4032// else return hwnd; //OS/2 window handle
4033}
4034#ifdef DEBUG
4035LONG Win32BaseWindow::addRef()
4036{
4037// dprintf2(("addRef %x %d", getWindowHandle(), getRefCount()+1));
4038 return GenericObject::addRef();
4039}
4040//******************************************************************************
4041//******************************************************************************
4042LONG Win32BaseWindow::release(char *function, int line)
4043{
4044// dprintf2(("release %s %d %x %d", function, line, getWindowHandle(), getRefCount()-1));
4045 return GenericObject::release();
4046}
4047#endif
4048//******************************************************************************
4049//******************************************************************************
4050GenericObject *Win32BaseWindow::windows = NULL;
4051CRITICAL_SECTION Win32BaseWindow::critsect = {0};
4052
4053//******************************************************************************
4054//******************************************************************************
4055#ifdef DEBUG
4056void PrintWindowStyle(DWORD dwStyle, DWORD dwExStyle)
4057{
4058 char style[256] = "";
4059 char exstyle[256] = "";
4060
4061 /* Window styles */
4062 if(dwStyle & WS_CHILD)
4063 strcat(style, "WS_CHILD ");
4064 if(dwStyle & WS_POPUP)
4065 strcat(style, "WS_POPUP ");
4066 if(dwStyle & WS_VISIBLE)
4067 strcat(style, "WS_VISIBLE ");
4068 if(dwStyle & WS_DISABLED)
4069 strcat(style, "WS_DISABLED ");
4070 if(dwStyle & WS_CLIPSIBLINGS)
4071 strcat(style, "WS_CLIPSIBLINGS ");
4072 if(dwStyle & WS_CLIPCHILDREN)
4073 strcat(style, "WS_CLIPCHILDREN ");
4074 if(dwStyle & WS_MAXIMIZE)
4075 strcat(style, "WS_MAXIMIZE ");
4076 if(dwStyle & WS_MINIMIZE)
4077 strcat(style, "WS_MINIMIZE ");
4078 if(dwStyle & WS_GROUP)
4079 strcat(style, "WS_GROUP ");
4080 if(dwStyle & WS_TABSTOP)
4081 strcat(style, "WS_TABSTOP ");
4082
4083 if((dwStyle & WS_CAPTION) == WS_CAPTION)
4084 strcat(style, "WS_CAPTION ");
4085 if(dwStyle & WS_DLGFRAME)
4086 strcat(style, "WS_DLGFRAME ");
4087 if(dwStyle & WS_BORDER)
4088 strcat(style, "WS_BORDER ");
4089
4090 if(dwStyle & WS_VSCROLL)
4091 strcat(style, "WS_VSCROLL ");
4092 if(dwStyle & WS_HSCROLL)
4093 strcat(style, "WS_HSCROLL ");
4094 if(dwStyle & WS_SYSMENU)
4095 strcat(style, "WS_SYSMENU ");
4096 if(dwStyle & WS_THICKFRAME)
4097 strcat(style, "WS_THICKFRAME ");
4098 if(dwStyle & WS_MINIMIZEBOX)
4099 strcat(style, "WS_MINIMIZEBOX ");
4100 if(dwStyle & WS_MAXIMIZEBOX)
4101 strcat(style, "WS_MAXIMIZEBOX ");
4102
4103 if(dwExStyle & WS_EX_DLGMODALFRAME)
4104 strcat(exstyle, "WS_EX_DLGMODALFRAME ");
4105 if(dwExStyle & WS_EX_ACCEPTFILES)
4106 strcat(exstyle, "WS_EX_ACCEPTFILES ");
4107 if(dwExStyle & WS_EX_NOPARENTNOTIFY)
4108 strcat(exstyle, "WS_EX_NOPARENTNOTIFY ");
4109 if(dwExStyle & WS_EX_TOPMOST)
4110 strcat(exstyle, "WS_EX_TOPMOST ");
4111 if(dwExStyle & WS_EX_TRANSPARENT)
4112 strcat(exstyle, "WS_EX_TRANSPARENT ");
4113
4114 if(dwExStyle & WS_EX_MDICHILD)
4115 strcat(exstyle, "WS_EX_MDICHILD ");
4116 if(dwExStyle & WS_EX_TOOLWINDOW)
4117 strcat(exstyle, "WS_EX_TOOLWINDOW ");
4118 if(dwExStyle & WS_EX_WINDOWEDGE)
4119 strcat(exstyle, "WS_EX_WINDOWEDGE ");
4120 if(dwExStyle & WS_EX_CLIENTEDGE)
4121 strcat(exstyle, "WS_EX_CLIENTEDGE ");
4122 if(dwExStyle & WS_EX_CONTEXTHELP)
4123 strcat(exstyle, "WS_EX_CONTEXTHELP ");
4124 if(dwExStyle & WS_EX_RIGHT)
4125 strcat(exstyle, "WS_EX_RIGHT ");
4126 if(dwExStyle & WS_EX_LEFT)
4127 strcat(exstyle, "WS_EX_LEFT ");
4128 if(dwExStyle & WS_EX_RTLREADING)
4129 strcat(exstyle, "WS_EX_RTLREADING ");
4130 if(dwExStyle & WS_EX_LTRREADING)
4131 strcat(exstyle, "WS_EX_LTRREADING ");
4132 if(dwExStyle & WS_EX_LEFTSCROLLBAR)
4133 strcat(exstyle, "WS_EX_LEFTSCROLLBAR ");
4134 if(dwExStyle & WS_EX_RIGHTSCROLLBAR)
4135 strcat(exstyle, "WS_EX_RIGHTSCROLLBAR ");
4136 if(dwExStyle & WS_EX_CONTROLPARENT)
4137 strcat(exstyle, "WS_EX_CONTROLPARENT ");
4138 if(dwExStyle & WS_EX_STATICEDGE)
4139 strcat(exstyle, "WS_EX_STATICEDGE ");
4140 if(dwExStyle & WS_EX_APPWINDOW)
4141 strcat(exstyle, "WS_EX_APPWINDOW ");
4142
4143 dprintf(("Window style: %x %s", dwStyle, style));
4144 dprintf(("Window exStyle: %x %s", dwExStyle, exstyle));
4145}
4146#endif
4147//******************************************************************************
4148//******************************************************************************
Note: See TracBrowser for help on using the repository browser.