]> git.saurik.com Git - wxWidgets.git/blame - src/msw/mdi.cpp
updated to generate ZIP files with DOS line endings
[wxWidgets.git] / src / msw / mdi.cpp
CommitLineData
2bda0e17 1/////////////////////////////////////////////////////////////////////////////
a967ef9d
VZ
2// Name: src/msw/mdi.cpp
3// Purpose: MDI classes for wxMSW
2bda0e17
KB
4// Author: Julian Smart
5// Modified by:
6// Created: 04/01/98
7// RCS-ID: $Id$
6c9a19aa 8// Copyright: (c) Julian Smart
65571936 9// Licence: wxWindows licence
2bda0e17
KB
10/////////////////////////////////////////////////////////////////////////////
11
a23fd0e1
VZ
12// ===========================================================================
13// declarations
14// ===========================================================================
15
16// ---------------------------------------------------------------------------
17// headers
18// ---------------------------------------------------------------------------
19
14f355c2 20#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
a23fd0e1 21 #pragma implementation "mdi.h"
2bda0e17
KB
22#endif
23
24// For compilers that support precompilation, includes "wx.h".
25#include "wx/wxprec.h"
26
27#ifdef __BORLANDC__
a23fd0e1 28 #pragma hdrstop
2bda0e17
KB
29#endif
30
efd17a1d 31#if wxUSE_MDI && !defined(__WXUNIVERSAL__)
b442f107 32
2bda0e17 33#ifndef WX_PRECOMP
a23fd0e1
VZ
34 #include "wx/setup.h"
35 #include "wx/frame.h"
36 #include "wx/menu.h"
37 #include "wx/app.h"
38 #include "wx/utils.h"
39 #include "wx/dialog.h"
7c0ea335
VZ
40 #if wxUSE_STATUSBAR
41 #include "wx/statusbr.h"
42 #endif
a23fd0e1 43 #include "wx/settings.h"
0c589ad0
BM
44 #include "wx/intl.h"
45 #include "wx/log.h"
2bda0e17
KB
46#endif
47
48#include "wx/mdi.h"
49#include "wx/msw/private.h"
50
7c0ea335 51#if wxUSE_STATUSBAR && wxUSE_NATIVE_STATUSBAR
3096bd2f 52 #include "wx/msw/statbr95.h"
2bda0e17
KB
53#endif
54
7c0ea335
VZ
55#if wxUSE_TOOLBAR
56 #include "wx/toolbar.h"
57#endif // wxUSE_TOOLBAR
58
2bda0e17
KB
59#include <string.h>
60
a23fd0e1
VZ
61// ---------------------------------------------------------------------------
62// global variables
63// ---------------------------------------------------------------------------
64
e1a6fc11 65extern wxMenu *wxCurrentPopupMenu;
2bda0e17 66
3ca6a5f0 67extern const wxChar *wxMDIFrameClassName; // from app.cpp
2ffa221c 68extern const wxChar *wxMDIChildFrameClassName;
3ca6a5f0 69extern const wxChar *wxMDIChildFrameClassNameNoRedraw;
c7527e3f 70extern void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win);
ac6482e0 71extern void wxRemoveHandleAssociation(wxWindow *win);
a23fd0e1 72
42e69d6b
VZ
73static HWND invalidHandle = 0;
74
a23fd0e1
VZ
75// ---------------------------------------------------------------------------
76// constants
77// ---------------------------------------------------------------------------
78
79static const int IDM_WINDOWTILE = 4001;
42e69d6b 80static const int IDM_WINDOWTILEHOR = 4001;
a23fd0e1
VZ
81static const int IDM_WINDOWCASCADE = 4002;
82static const int IDM_WINDOWICONS = 4003;
83static const int IDM_WINDOWNEXT = 4004;
42e69d6b 84static const int IDM_WINDOWTILEVERT = 4005;
4f3b37fd 85static const int IDM_WINDOWPREV = 4006;
a23fd0e1
VZ
86
87// This range gives a maximum of 500 MDI children. Should be enough :-)
88static const int wxFIRST_MDI_CHILD = 4100;
89static const int wxLAST_MDI_CHILD = 4600;
2bda0e17
KB
90
91// Status border dimensions
a23fd0e1
VZ
92static const int wxTHICK_LINE_BORDER = 3;
93static const int wxTHICK_LINE_WIDTH = 1;
2bda0e17 94
42e69d6b
VZ
95// ---------------------------------------------------------------------------
96// private functions
97// ---------------------------------------------------------------------------
98
99// set the MDI menus (by sending the WM_MDISETMENU message) and update the menu
100// of the parent of win (which is supposed to be the MDI client window)
101static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow);
102
103// insert the window menu (subMenu) into menu just before "Help" submenu or at
104// the very end if not found
105static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu);
106
df61c009
JS
107// Remove the window menu
108static void RemoveWindowMenu(wxWindow *win, WXHMENU menu);
109
42e69d6b
VZ
110// is this an id of an MDI child?
111inline bool IsMdiCommandId(int id)
112{
113 return (id >= wxFIRST_MDI_CHILD) && (id <= wxLAST_MDI_CHILD);
114}
115
4e152a23 116// unpack the parameters of WM_MDIACTIVATE message
2917e920
BM
117static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
118 WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact);
42e69d6b 119
4e152a23
VZ
120// return the HMENU of the MDI menu
121static inline HMENU GetMDIWindowMenu(wxMDIParentFrame *frame)
122{
123 wxMenu *menu = frame->GetWindowMenu();
124 return menu ? GetHmenuOf(menu) : 0;
125}
126
a23fd0e1
VZ
127// ===========================================================================
128// implementation
129// ===========================================================================
130
131// ---------------------------------------------------------------------------
132// wxWin macros
133// ---------------------------------------------------------------------------
2bda0e17 134
225fe9d6
VZ
135IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
136IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
137IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
2bda0e17
KB
138
139BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
a23fd0e1 140 EVT_SIZE(wxMDIParentFrame::OnSize)
a23fd0e1 141 EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
2bda0e17
KB
142END_EVENT_TABLE()
143
f6bcfd97
BP
144BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
145 EVT_IDLE(wxMDIChildFrame::OnIdle)
146END_EVENT_TABLE()
147
2bda0e17 148BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
a23fd0e1 149 EVT_SCROLL(wxMDIClientWindow::OnScroll)
2bda0e17
KB
150END_EVENT_TABLE()
151
42e69d6b
VZ
152// ===========================================================================
153// wxMDIParentFrame: the frame which contains the client window which manages
154// the children
155// ===========================================================================
2bda0e17 156
c2dcfdef 157wxMDIParentFrame::wxMDIParentFrame()
2bda0e17
KB
158{
159 m_clientWindow = NULL;
160 m_currentChild = NULL;
df61c009 161 m_windowMenu = (wxMenu*) NULL;
4f8090e0 162 m_parentFrameActive = true;
2bda0e17
KB
163}
164
165bool wxMDIParentFrame::Create(wxWindow *parent,
a23fd0e1
VZ
166 wxWindowID id,
167 const wxString& title,
168 const wxPoint& pos,
169 const wxSize& size,
170 long style,
171 const wxString& name)
2bda0e17 172{
2bda0e17
KB
173 m_clientWindow = NULL;
174 m_currentChild = NULL;
df61c009 175
3d8dea7e
VZ
176 // this style can be used to prevent a window from having the standard MDI
177 // "Window" menu
178 if ( style & wxFRAME_NO_WINDOW_MENU )
179 {
180 m_windowMenu = (wxMenu *)NULL;
181 }
182 else // normal case: we have the window menu, so construct it
df61c009 183 {
df61c009
JS
184 m_windowMenu = new wxMenu;
185
b0a2157c
VZ
186 m_windowMenu->Append(IDM_WINDOWCASCADE, _("&Cascade"));
187 m_windowMenu->Append(IDM_WINDOWTILEHOR, _("Tile &Horizontally"));
188 m_windowMenu->Append(IDM_WINDOWTILEVERT, _("Tile &Vertically"));
df61c009 189 m_windowMenu->AppendSeparator();
b0a2157c
VZ
190 m_windowMenu->Append(IDM_WINDOWICONS, _("&Arrange Icons"));
191 m_windowMenu->Append(IDM_WINDOWNEXT, _("&Next"));
4f3b37fd 192 m_windowMenu->Append(IDM_WINDOWPREV, _("&Previous"));
df61c009
JS
193 }
194
4f8090e0 195 m_parentFrameActive = true;
2bda0e17
KB
196
197 if (!parent)
198 wxTopLevelWindows.Append(this);
199
200 SetName(name);
201 m_windowStyle = style;
202
b225f659
VZ
203 if ( parent )
204 parent->AddChild(this);
2bda0e17 205
598ddd96 206 if ( id != wxID_ANY )
2bda0e17
KB
207 m_windowId = id;
208 else
b225f659 209 m_windowId = NewControlId();
2bda0e17 210
912c192f
VZ
211 WXDWORD exflags;
212 WXDWORD msflags = MSWGetCreateWindowFlags(&exflags);
ea723360
JS
213 msflags &= ~WS_VSCROLL;
214 msflags &= ~WS_HSCROLL;
2bda0e17 215
b225f659 216 if ( !wxWindow::MSWCreate(wxMDIFrameClassName,
3ca6a5f0 217 title,
b225f659
VZ
218 pos, size,
219 msflags,
220 exflags) )
3ca6a5f0 221 {
4f8090e0 222 return false;
3ca6a5f0 223 }
2bda0e17 224
f6bcfd97 225 // unlike (almost?) all other windows, frames are created hidden
4f8090e0 226 m_isShown = false;
f6bcfd97 227
4f8090e0 228 return true;
2bda0e17
KB
229}
230
c2dcfdef 231wxMDIParentFrame::~wxMDIParentFrame()
2bda0e17 232{
d1e44484 233 // see comment in ~wxMDIChildFrame
1904aa72 234#if wxUSE_TOOLBAR
f048e32f 235 m_frameToolBar = NULL;
1904aa72 236#endif
67a99992 237#if wxUSE_STATUSBAR
c0bcc480 238 m_frameStatusBar = NULL;
67a99992 239#endif // wxUSE_STATUSBAR
f048e32f 240
d1e44484
VZ
241 DestroyChildren();
242
df61c009
JS
243 if (m_windowMenu)
244 {
245 delete m_windowMenu;
246 m_windowMenu = (wxMenu*) NULL;
247 }
2bda0e17 248
4e152a23
VZ
249 // the MDI frame menubar is not automatically deleted by Windows unlike for
250 // the normal frames
251 if ( m_hMenu )
252 {
253 ::DestroyMenu((HMENU)m_hMenu);
7c46a16b 254 m_hMenu = (WXHMENU)NULL;
4e152a23
VZ
255 }
256
42e69d6b
VZ
257 if ( m_clientWindow )
258 {
259 if ( m_clientWindow->MSWGetOldWndProc() )
260 m_clientWindow->UnsubclassWin();
2bda0e17 261
42e69d6b
VZ
262 m_clientWindow->SetHWND(0);
263 delete m_clientWindow;
264 }
2bda0e17
KB
265}
266
1e6feb95
VZ
267#if wxUSE_MENUS_NATIVE
268
42e69d6b 269void wxMDIParentFrame::InternalSetMenuBar()
2bda0e17 270{
4f8090e0 271 m_parentFrameActive = true;
2bda0e17 272
4e152a23 273 InsertWindowMenu(GetClientWindow(), m_hMenu, GetMDIWindowMenu(this));
2bda0e17
KB
274}
275
1e6feb95
VZ
276#endif // wxUSE_MENUS_NATIVE
277
df61c009
JS
278void wxMDIParentFrame::SetWindowMenu(wxMenu* menu)
279{
280 if (m_windowMenu)
281 {
282 if (GetMenuBar())
283 {
284 // Remove old window menu
285 RemoveWindowMenu(GetClientWindow(), m_hMenu);
286 }
287
288 delete m_windowMenu;
289 m_windowMenu = (wxMenu*) NULL;
290 }
4e152a23 291
df61c009
JS
292 if (menu)
293 {
294 m_windowMenu = menu;
295 if (GetMenuBar())
b0a2157c
VZ
296 {
297 InsertWindowMenu(GetClientWindow(), m_hMenu,
88c49a0f 298 GetHmenuOf(m_windowMenu));
b0a2157c 299 }
df61c009
JS
300 }
301}
302
6aca4628
CE
303void wxMDIParentFrame::DoMenuUpdates(wxMenu* menu)
304{
305 wxMDIChildFrame *child = GetActiveChild();
306 if ( child )
307 {
308 wxEvtHandler* source = child->GetEventHandler();
309 wxMenuBar* bar = child->GetMenuBar();
310
311 if (menu)
312 {
313 menu->UpdateUI(source);
314 }
315 else
316 {
317 if ( bar != NULL )
318 {
319 int nCount = bar->GetMenuCount();
320 for (int n = 0; n < nCount; n++)
321 bar->GetMenu(n)->UpdateUI(source);
322 }
323 }
324 }
325 else
326 {
327 wxFrameBase::DoMenuUpdates(menu);
328 }
329}
330
a967ef9d 331void wxMDIParentFrame::OnSize(wxSizeEvent&)
2bda0e17 332{
2bda0e17 333 if ( GetClientWindow() )
42e69d6b
VZ
334 {
335 int width, height;
336 GetClientSize(&width, &height);
2bda0e17 337
42e69d6b
VZ
338 GetClientWindow()->SetSize(0, 0, width, height);
339 }
2bda0e17
KB
340}
341
2bda0e17 342// Returns the active MDI child window
c2dcfdef 343wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
2bda0e17 344{
a23fd0e1
VZ
345 HWND hWnd = (HWND)::SendMessage(GetWinHwnd(GetClientWindow()),
346 WM_MDIGETACTIVE, 0, 0L);
347 if ( hWnd == 0 )
348 return NULL;
349 else
350 return (wxMDIChildFrame *)wxFindWinFromHandle((WXHWND) hWnd);
2bda0e17
KB
351}
352
a23fd0e1
VZ
353// Create the client window class (don't Create the window, just return a new
354// class)
c2dcfdef 355wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
2bda0e17 356{
a23fd0e1 357 return new wxMDIClientWindow;
2bda0e17
KB
358}
359
360// Responds to colour changes, and passes event on to children.
361void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
362{
363 if ( m_clientWindow )
364 {
a756f210 365 m_clientWindow->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
2bda0e17
KB
366 m_clientWindow->Refresh();
367 }
2bda0e17 368
42e69d6b 369 event.Skip();
2bda0e17
KB
370}
371
82c9f85c
VZ
372WXHICON wxMDIParentFrame::GetDefaultIcon() const
373{
94826170
VZ
374 // we don't have any standard icons (any more)
375 return (WXHICON)0;
82c9f85c
VZ
376}
377
42e69d6b 378// ---------------------------------------------------------------------------
2bda0e17 379// MDI operations
42e69d6b
VZ
380// ---------------------------------------------------------------------------
381
c2dcfdef 382void wxMDIParentFrame::Cascade()
2bda0e17 383{
a23fd0e1 384 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0);
2bda0e17
KB
385}
386
42e69d6b 387// TODO: add a direction argument (hor/vert)
c2dcfdef 388void wxMDIParentFrame::Tile()
2bda0e17 389{
a23fd0e1 390 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE, MDITILE_HORIZONTAL, 0);
2bda0e17
KB
391}
392
c2dcfdef 393void wxMDIParentFrame::ArrangeIcons()
2bda0e17 394{
a23fd0e1 395 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDIICONARRANGE, 0, 0);
2bda0e17
KB
396}
397
c2dcfdef 398void wxMDIParentFrame::ActivateNext()
2bda0e17 399{
a23fd0e1 400 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 0);
2bda0e17
KB
401}
402
c2dcfdef 403void wxMDIParentFrame::ActivatePrevious()
2bda0e17 404{
a23fd0e1 405 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 1);
2bda0e17
KB
406}
407
42e69d6b 408// ---------------------------------------------------------------------------
a23fd0e1 409// the MDI parent frame window proc
42e69d6b
VZ
410// ---------------------------------------------------------------------------
411
c140b7e7 412WXLRESULT wxMDIParentFrame::MSWWindowProc(WXUINT message,
a23fd0e1
VZ
413 WXWPARAM wParam,
414 WXLPARAM lParam)
2bda0e17 415{
c140b7e7 416 WXLRESULT rc = 0;
4f8090e0 417 bool processed = false;
2bda0e17 418
a23fd0e1
VZ
419 switch ( message )
420 {
42e69d6b
VZ
421 case WM_ACTIVATE:
422 {
423 WXWORD state, minimized;
424 WXHWND hwnd;
425 UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
426
427 processed = HandleActivate(state, minimized != 0, hwnd);
428 }
429 break;
430
431 case WM_COMMAND:
432 {
433 WXWORD id, cmd;
434 WXHWND hwnd;
435 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
436
437 (void)HandleCommand(id, cmd, hwnd);
438
439 // even if the frame didn't process it, there is no need to try it
01ebf752 440 // once again (i.e. call wxFrame::HandleCommand()) - we just did it,
42e69d6b 441 // so pretend we processed the message anyhow
4f8090e0 442 processed = true;
42e69d6b 443 }
b3818fbe
VZ
444
445 // always pass this message DefFrameProc(), otherwise MDI menu
01ebf752 446 // commands (and sys commands - more surprisingly!) won't work
b3818fbe 447 MSWDefWindowProc(message, wParam, lParam);
42e69d6b
VZ
448 break;
449
a23fd0e1
VZ
450 case WM_CREATE:
451 m_clientWindow = OnCreateClient();
452 // Uses own style for client style
453 if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
454 {
455 wxLogMessage(_("Failed to create MDI parent frame."));
2bda0e17 456
a23fd0e1
VZ
457 rc = -1;
458 }
2bda0e17 459
4f8090e0 460 processed = true;
a23fd0e1 461 break;
2bda0e17 462
a23fd0e1 463 case WM_ERASEBKGND:
4f8090e0 464 processed = true;
2bda0e17 465
a23fd0e1 466 // we erase background ourselves
4f8090e0 467 rc = true;
a23fd0e1
VZ
468 break;
469
470 case WM_MENUSELECT:
471 {
42e69d6b
VZ
472 WXWORD item, flags;
473 WXHMENU hmenu;
474 UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu);
475
a23fd0e1
VZ
476 if ( m_parentFrameActive )
477 {
42e69d6b 478 processed = HandleMenuSelect(item, flags, hmenu);
a23fd0e1
VZ
479 }
480 else if (m_currentChild)
481 {
482 processed = m_currentChild->
42e69d6b 483 HandleMenuSelect(item, flags, hmenu);
a23fd0e1
VZ
484 }
485 }
486 break;
b3818fbe
VZ
487
488 case WM_SIZE:
0655ad29
VZ
489 // as we don't (usually) resize the MDI client to exactly fit the
490 // client area (we put it below the toolbar, above statusbar &c),
491 // we should not pass this one to DefFrameProc
b3818fbe 492 break;
a23fd0e1 493 }
2bda0e17 494
a23fd0e1
VZ
495 if ( !processed )
496 rc = wxFrame::MSWWindowProc(message, wParam, lParam);
2bda0e17 497
a23fd0e1 498 return rc;
2bda0e17
KB
499}
500
42e69d6b 501bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate)
2bda0e17 502{
4f8090e0 503 bool processed = false;
a23fd0e1 504
42e69d6b 505 if ( wxWindow::HandleActivate(state, minimized, activate) )
a23fd0e1
VZ
506 {
507 // already processed
4f8090e0 508 processed = true;
a23fd0e1 509 }
2bda0e17
KB
510
511 // If this window is an MDI parent, we must also send an OnActivate message
512 // to the current child.
42e69d6b 513 if ( (m_currentChild != NULL) &&
a23fd0e1 514 ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) )
c2dcfdef 515 {
4f8090e0 516 wxActivateEvent event(wxEVT_ACTIVATE, true, m_currentChild->GetId());
debe6624 517 event.SetEventObject( m_currentChild );
a23fd0e1 518 if ( m_currentChild->GetEventHandler()->ProcessEvent(event) )
4f8090e0 519 processed = true;
2bda0e17 520 }
a23fd0e1
VZ
521
522 return processed;
2bda0e17
KB
523}
524
42e69d6b 525bool wxMDIParentFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd)
2bda0e17 526{
2bda0e17 527 // In case it's e.g. a toolbar.
42e69d6b 528 if ( hwnd )
e1a6fc11 529 {
42e69d6b
VZ
530 wxWindow *win = wxFindWinFromHandle(hwnd);
531 if ( win )
532 return win->MSWCommand(cmd, id);
e1a6fc11
JS
533 }
534
42e69d6b
VZ
535 // is it one of standard MDI commands?
536 WXWPARAM wParam = 0;
4f3b37fd 537 WXLPARAM lParam = 0;
42e69d6b
VZ
538 int msg;
539 switch ( id )
2bda0e17 540 {
42e69d6b
VZ
541 case IDM_WINDOWCASCADE:
542 msg = WM_MDICASCADE;
543 wParam = MDITILE_SKIPDISABLED;
544 break;
545
546 case IDM_WINDOWTILEHOR:
547 wParam |= MDITILE_HORIZONTAL;
548 // fall through
549
550 case IDM_WINDOWTILEVERT:
551 if ( !wParam )
552 wParam = MDITILE_VERTICAL;
553 msg = WM_MDITILE;
554 wParam |= MDITILE_SKIPDISABLED;
555 break;
556
557 case IDM_WINDOWICONS:
558 msg = WM_MDIICONARRANGE;
559 break;
560
561 case IDM_WINDOWNEXT:
562 msg = WM_MDINEXT;
4f3b37fd
JS
563 lParam = 0; // next child
564 break;
565
566 case IDM_WINDOWPREV:
567 msg = WM_MDINEXT;
568 lParam = 1; // previous child
42e69d6b
VZ
569 break;
570
571 default:
572 msg = 0;
2bda0e17 573 }
c2dcfdef 574
42e69d6b 575 if ( msg )
2bda0e17 576 {
4f3b37fd 577 ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, lParam);
42e69d6b 578
4f8090e0 579 return true;
2bda0e17 580 }
42e69d6b
VZ
581
582 // FIXME VZ: what does this test do??
583 if (id >= 0xF000)
2bda0e17 584 {
4f8090e0 585 return false; // Get WndProc to call default proc
2bda0e17 586 }
42e69d6b
VZ
587
588 if ( IsMdiCommandId(id) )
2bda0e17 589 {
222ed1d6 590 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
42e69d6b 591 while ( node )
2bda0e17 592 {
d162a7ee 593 wxWindow *child = node->GetData();
42e69d6b 594 if ( child->GetHWND() )
2bda0e17 595 {
42e69d6b 596 long childId = wxGetWindowId(child->GetHWND());
48c12cb1 597 if (childId == (long)id)
42e69d6b
VZ
598 {
599 ::SendMessage( GetWinHwnd(GetClientWindow()),
600 WM_MDIACTIVATE,
601 (WPARAM)child->GetHWND(), 0);
4f8090e0 602 return true;
42e69d6b 603 }
2bda0e17 604 }
42e69d6b 605 node = node->GetNext();
2bda0e17 606 }
2bda0e17 607 }
42e69d6b 608 else if ( m_parentFrameActive )
2bda0e17 609 {
42e69d6b
VZ
610 return ProcessCommand(id);
611 }
612 else if ( m_currentChild )
613 {
614 return m_currentChild->HandleCommand(id, cmd, hwnd);
615 }
616 else
617 {
618 // this shouldn't happen because it means that our messages are being
619 // lost (they're not sent to the parent frame nor to the children)
f6bcfd97 620 wxFAIL_MSG(wxT("MDI parent frame is not active, yet there is no active MDI child?"));
2bda0e17 621 }
2bda0e17 622
4f8090e0 623 return false;
2bda0e17
KB
624}
625
c140b7e7 626WXLRESULT wxMDIParentFrame::MSWDefWindowProc(WXUINT message,
42e69d6b
VZ
627 WXWPARAM wParam,
628 WXLPARAM lParam)
2bda0e17 629{
c2dcfdef
VZ
630 WXHWND clientWnd;
631 if ( GetClientWindow() )
632 clientWnd = GetClientWindow()->GetHWND();
633 else
634 clientWnd = 0;
2bda0e17 635
a23fd0e1 636 return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam);
2bda0e17
KB
637}
638
57a7b7c1
JS
639bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg)
640{
a23fd0e1 641 MSG *pMsg = (MSG *)msg;
2bda0e17 642
f6bcfd97 643 // first let the current child get it
a23fd0e1
VZ
644 if ( m_currentChild && m_currentChild->GetHWND() &&
645 m_currentChild->MSWTranslateMessage(msg) )
646 {
4f8090e0 647 return true;
a23fd0e1 648 }
2bda0e17 649
f6bcfd97
BP
650 // then try out accel table (will also check the menu accels)
651 if ( wxFrame::MSWTranslateMessage(msg) )
a23fd0e1 652 {
4f8090e0 653 return true;
a23fd0e1 654 }
2bda0e17 655
f6bcfd97 656 // finally, check for MDI specific built in accel keys
a23fd0e1
VZ
657 if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN )
658 {
659 if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg))
4f8090e0 660 return true;
a23fd0e1 661 }
57a7b7c1 662
4f8090e0 663 return false;
2bda0e17
KB
664}
665
42e69d6b 666// ===========================================================================
a23fd0e1 667// wxMDIChildFrame
42e69d6b 668// ===========================================================================
2bda0e17 669
f6bcfd97 670void wxMDIChildFrame::Init()
2bda0e17 671{
4f8090e0 672 m_needsResize = true;
2596e9fb 673 m_needsInitialShow = true;
2bda0e17
KB
674}
675
676bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
a23fd0e1
VZ
677 wxWindowID id,
678 const wxString& title,
679 const wxPoint& pos,
680 const wxSize& size,
681 long style,
682 const wxString& name)
2bda0e17 683{
2bda0e17
KB
684 SetName(name);
685
598ddd96 686 if ( id != wxID_ANY )
2bda0e17
KB
687 m_windowId = id;
688 else
689 m_windowId = (int)NewControlId();
690
42e69d6b
VZ
691 if ( parent )
692 {
693 parent->AddChild(this);
694 }
2bda0e17 695
2bda0e17
KB
696 int x = pos.x;
697 int y = pos.y;
698 int width = size.x;
699 int height = size.y;
700
701 MDICREATESTRUCT mcs;
c2dcfdef 702
e441e1f4
VZ
703 mcs.szClass = style & wxFULL_REPAINT_ON_RESIZE
704 ? wxMDIChildFrameClassName
705 : wxMDIChildFrameClassNameNoRedraw;
2bda0e17
KB
706 mcs.szTitle = title;
707 mcs.hOwner = wxGetInstance();
598ddd96 708 if (x != wxDefaultCoord)
42e69d6b
VZ
709 mcs.x = x;
710 else
711 mcs.x = CW_USEDEFAULT;
2bda0e17 712
598ddd96 713 if (y != wxDefaultCoord)
42e69d6b
VZ
714 mcs.y = y;
715 else
716 mcs.y = CW_USEDEFAULT;
2bda0e17 717
598ddd96 718 if (width != wxDefaultCoord)
42e69d6b
VZ
719 mcs.cx = width;
720 else
721 mcs.cx = CW_USEDEFAULT;
2bda0e17 722
598ddd96 723 if (height != wxDefaultCoord)
42e69d6b
VZ
724 mcs.cy = height;
725 else
726 mcs.cy = CW_USEDEFAULT;
2bda0e17 727
2596e9fb 728 DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN;
2bda0e17
KB
729 if (style & wxMINIMIZE_BOX)
730 msflags |= WS_MINIMIZEBOX;
731 if (style & wxMAXIMIZE_BOX)
732 msflags |= WS_MAXIMIZEBOX;
733 if (style & wxTHICK_FRAME)
734 msflags |= WS_THICKFRAME;
735 if (style & wxSYSTEM_MENU)
736 msflags |= WS_SYSMENU;
737 if ((style & wxMINIMIZE) || (style & wxICONIZE))
738 msflags |= WS_MINIMIZE;
739 if (style & wxMAXIMIZE)
740 msflags |= WS_MAXIMIZE;
741 if (style & wxCAPTION)
742 msflags |= WS_CAPTION;
743
744 mcs.style = msflags;
745
746 mcs.lParam = 0;
747
b225f659
VZ
748 wxWindowCreationHook hook(this);
749
3ca6a5f0
BP
750 m_hWnd = (WXHWND)::SendMessage(GetWinHwnd(parent->GetClientWindow()),
751 WM_MDICREATE, 0, (LONG)(LPSTR)&mcs);
2bda0e17 752
c7527e3f 753 wxAssociateWinWithHandle((HWND) GetHWND(), this);
2bda0e17 754
4f8090e0 755 return true;
2bda0e17
KB
756}
757
c2dcfdef 758wxMDIChildFrame::~wxMDIChildFrame()
2bda0e17 759{
d1e44484
VZ
760 // will be destroyed by DestroyChildren() but reset them before calling it
761 // to avoid using dangling pointers if a callback comes in the meanwhile
1904aa72 762#if wxUSE_TOOLBAR
627a3091 763 m_frameToolBar = NULL;
1904aa72 764#endif
67a99992 765#if wxUSE_STATUSBAR
627a3091 766 m_frameStatusBar = NULL;
67a99992 767#endif // wxUSE_STATUSBAR
627a3091 768
d1e44484
VZ
769 DestroyChildren();
770
4e152a23
VZ
771 RemoveWindowMenu(NULL, m_hMenu);
772
c2dcfdef 773 MSWDestroyWindow();
2bda0e17
KB
774}
775
2596e9fb
VS
776bool wxMDIChildFrame::Show(bool show)
777{
778 m_needsInitialShow = false;
779 return wxFrame::Show(show);
780}
781
2bda0e17 782// Set the client size (i.e. leave the calculation of borders etc.
77ffb593 783// to wxWidgets)
cc2b7472 784void wxMDIChildFrame::DoSetClientSize(int width, int height)
2bda0e17 785{
b3818fbe 786 HWND hWnd = GetHwnd();
2bda0e17
KB
787
788 RECT rect;
2de8030d 789 ::GetClientRect(hWnd, &rect);
2bda0e17
KB
790
791 RECT rect2;
792 GetWindowRect(hWnd, &rect2);
793
794 // Find the difference between the entire window (title bar and all)
795 // and the client area; add this to the new client size to move the
796 // window
797 int actual_width = rect2.right - rect2.left - rect.right + width;
798 int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
799
67a99992 800#if wxUSE_STATUSBAR
a2327a9f 801 if (GetStatusBar() && GetStatusBar()->IsShown())
2bda0e17 802 {
c2dcfdef
VZ
803 int sx, sy;
804 GetStatusBar()->GetSize(&sx, &sy);
2bda0e17
KB
805 actual_height += sy;
806 }
67a99992 807#endif // wxUSE_STATUSBAR
2bda0e17
KB
808
809 POINT point;
810 point.x = rect2.left;
811 point.y = rect2.top;
812
813 // If there's an MDI parent, must subtract the parent's top left corner
814 // since MoveWindow moves relative to the parent
815 wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent();
816 ::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &point);
817
4f8090e0 818 MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)true);
debe6624 819
5c519b6c
WS
820 wxSize size(width, height);
821 wxSizeEvent event(size, m_windowId);
debe6624 822 event.SetEventObject( this );
2bda0e17 823 GetEventHandler()->ProcessEvent(event);
2bda0e17
KB
824}
825
cc2b7472 826void wxMDIChildFrame::DoGetPosition(int *x, int *y) const
2bda0e17
KB
827{
828 RECT rect;
b3818fbe 829 GetWindowRect(GetHwnd(), &rect);
2bda0e17
KB
830 POINT point;
831 point.x = rect.left;
832 point.y = rect.top;
833
834 // Since we now have the absolute screen coords,
835 // if there's a parent we must subtract its top left corner
836 wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent();
837 ::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &point);
838
839 *x = point.x;
840 *y = point.y;
841}
842
42e69d6b 843void wxMDIChildFrame::InternalSetMenuBar()
2bda0e17 844{
42e69d6b 845 wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
2bda0e17 846
4e152a23
VZ
847 InsertWindowMenu(parent->GetClientWindow(),
848 m_hMenu, GetMDIWindowMenu(parent));
2bda0e17 849
4f8090e0 850 parent->m_parentFrameActive = false;
2bda0e17
KB
851}
852
82c9f85c
VZ
853WXHICON wxMDIChildFrame::GetDefaultIcon() const
854{
94826170
VZ
855 // we don't have any standard icons (any more)
856 return (WXHICON)0;
82c9f85c
VZ
857}
858
42e69d6b 859// ---------------------------------------------------------------------------
2bda0e17 860// MDI operations
42e69d6b
VZ
861// ---------------------------------------------------------------------------
862
9b73db3c 863void wxMDIChildFrame::Maximize(bool maximize)
2bda0e17
KB
864{
865 wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
866 if ( parent && parent->GetClientWindow() )
9b73db3c
VZ
867 {
868 ::SendMessage(GetWinHwnd(parent->GetClientWindow()),
869 maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE,
870 (WPARAM)GetHwnd(), 0);
871 }
2bda0e17
KB
872}
873
c2dcfdef 874void wxMDIChildFrame::Restore()
2bda0e17
KB
875{
876 wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
877 if ( parent && parent->GetClientWindow() )
9b73db3c
VZ
878 {
879 ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE,
880 (WPARAM) GetHwnd(), 0);
881 }
2bda0e17
KB
882}
883
c2dcfdef 884void wxMDIChildFrame::Activate()
2bda0e17
KB
885{
886 wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
887 if ( parent && parent->GetClientWindow() )
9b73db3c
VZ
888 {
889 ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE,
890 (WPARAM) GetHwnd(), 0);
891 }
2bda0e17
KB
892}
893
42e69d6b
VZ
894// ---------------------------------------------------------------------------
895// MDI window proc and message handlers
896// ---------------------------------------------------------------------------
897
c140b7e7 898WXLRESULT wxMDIChildFrame::MSWWindowProc(WXUINT message,
42e69d6b
VZ
899 WXWPARAM wParam,
900 WXLPARAM lParam)
901{
c140b7e7 902 WXLRESULT rc = 0;
4f8090e0 903 bool processed = false;
42e69d6b
VZ
904
905 switch ( message )
906 {
907 case WM_COMMAND:
908 {
909 WORD id, cmd;
910 WXHWND hwnd;
911 UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam,
912 &id, &hwnd, &cmd);
913
914 processed = HandleCommand(id, cmd, (WXHWND)hwnd);
915 }
916 break;
917
42e69d6b 918 case WM_GETMINMAXINFO:
3ebcfb76
VZ
919 processed = HandleGetMinMaxInfo((MINMAXINFO *)lParam);
920 break;
42e69d6b
VZ
921
922 case WM_MDIACTIVATE:
923 {
924 WXWORD act;
925 WXHWND hwndAct, hwndDeact;
926 UnpackMDIActivate(wParam, lParam, &act, &hwndAct, &hwndDeact);
927
928 processed = HandleMDIActivate(act, hwndAct, hwndDeact);
929 }
b3818fbe
VZ
930 // fall through
931
932 case WM_MOVE:
933 // must pass WM_MOVE to DefMDIChildProc() to recalculate MDI client
934 // scrollbars if necessary
935
936 // fall through
937
938 case WM_SIZE:
939 // must pass WM_SIZE to DefMDIChildProc(), otherwise many weird
940 // things happen
941 MSWDefWindowProc(message, wParam, lParam);
42e69d6b
VZ
942 break;
943
b3818fbe
VZ
944 case WM_SYSCOMMAND:
945 // DefMDIChildProc handles SC_{NEXT/PREV}WINDOW here, so pass it
946 // the message (the base class version does not)
947 return MSWDefWindowProc(message, wParam, lParam);
948
42e69d6b
VZ
949 case WM_WINDOWPOSCHANGING:
950 processed = HandleWindowPosChanging((LPWINDOWPOS)lParam);
951 break;
952 }
953
954 if ( !processed )
955 rc = wxFrame::MSWWindowProc(message, wParam, lParam);
956
957 return rc;
958}
959
42e69d6b 960bool wxMDIChildFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd)
2bda0e17 961{
2bda0e17 962 // In case it's e.g. a toolbar.
42e69d6b
VZ
963 if ( hwnd )
964 {
965 wxWindow *win = wxFindWinFromHandle(hwnd);
966 if (win)
967 return win->MSWCommand(cmd, id);
968 }
2bda0e17 969
e1a6fc11
JS
970 if (wxCurrentPopupMenu)
971 {
972 wxMenu *popupMenu = wxCurrentPopupMenu;
973 wxCurrentPopupMenu = NULL;
974 if (popupMenu->MSWCommand(cmd, id))
4f8090e0 975 return true;
e1a6fc11
JS
976 }
977
3ca6a5f0 978 bool processed;
dd60b9ec 979 if (GetMenuBar() && GetMenuBar()->FindItem(id))
2bda0e17 980 {
3ca6a5f0 981 processed = ProcessCommand(id);
2bda0e17
KB
982 }
983 else
3ca6a5f0 984 {
4f8090e0 985 processed = false;
3ca6a5f0 986 }
42e69d6b 987
3ca6a5f0 988 return processed;
2bda0e17
KB
989}
990
42e69d6b
VZ
991bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate),
992 WXHWND hwndAct,
993 WXHWND hwndDeact)
2bda0e17 994{
42e69d6b 995 wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
2bda0e17 996
42e69d6b 997 HMENU menuToSet = 0;
57a7b7c1 998
42e69d6b 999 bool activated;
57a7b7c1 1000
42e69d6b
VZ
1001 if ( m_hWnd == hwndAct )
1002 {
4f8090e0 1003 activated = true;
42e69d6b 1004 parent->m_currentChild = this;
2bda0e17 1005
42e69d6b
VZ
1006 HMENU child_menu = (HMENU)GetWinMenu();
1007 if ( child_menu )
1008 {
4f8090e0 1009 parent->m_parentFrameActive = false;
2bda0e17 1010
42e69d6b
VZ
1011 menuToSet = child_menu;
1012 }
1013 }
1014 else if ( m_hWnd == hwndDeact )
2bda0e17 1015 {
42e69d6b 1016 wxASSERT_MSG( parent->m_currentChild == this,
223d09f6 1017 wxT("can't deactivate MDI child which wasn't active!") );
42e69d6b 1018
4f8090e0 1019 activated = false;
42e69d6b 1020 parent->m_currentChild = NULL;
2bda0e17 1021
42e69d6b 1022 HMENU parent_menu = (HMENU)parent->GetWinMenu();
f4075804
VZ
1023
1024 // activate the the parent menu only when there is no other child
1025 // that has been activated
1026 if ( parent_menu && !hwndAct )
42e69d6b 1027 {
4f8090e0 1028 parent->m_parentFrameActive = true;
42e69d6b
VZ
1029
1030 menuToSet = parent_menu;
1031 }
1032 }
1033 else
1034 {
18d2e170 1035 // we have nothing to do with it
4f8090e0 1036 return false;
2bda0e17 1037 }
debe6624 1038
42e69d6b
VZ
1039 if ( menuToSet )
1040 {
4e152a23
VZ
1041 MDISetMenu(parent->GetClientWindow(),
1042 menuToSet, GetMDIWindowMenu(parent));
42e69d6b
VZ
1043 }
1044
1045 wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId);
debe6624 1046 event.SetEventObject( this );
2bda0e17 1047
c03b48d7
GT
1048 ResetWindowStyle((void *)NULL);
1049
42e69d6b
VZ
1050 return GetEventHandler()->ProcessEvent(event);
1051}
1052
1053bool wxMDIChildFrame::HandleWindowPosChanging(void *pos)
1054{
1055 WINDOWPOS *lpPos = (WINDOWPOS *)pos;
1056#if defined(__WIN95__)
1057 if (!(lpPos->flags & SWP_NOSIZE))
2bda0e17 1058 {
42e69d6b 1059 RECT rectClient;
b3818fbe
VZ
1060 DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
1061 DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
42e69d6b
VZ
1062 if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE))
1063 {
4f8090e0 1064 ::AdjustWindowRectEx(&rectClient, dwStyle, false, dwExStyle);
42e69d6b
VZ
1065 lpPos->x = rectClient.left;
1066 lpPos->y = rectClient.top;
1067 lpPos->cx = rectClient.right - rectClient.left;
1068 lpPos->cy = rectClient.bottom - rectClient.top;
1069 }
1904aa72 1070#if wxUSE_TOOLBAR
42e69d6b 1071 wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
a2327a9f 1072 if (pFrameWnd && pFrameWnd->GetToolBar() && pFrameWnd->GetToolBar()->IsShown())
42e69d6b
VZ
1073 {
1074 pFrameWnd->GetToolBar()->Refresh();
1075 }
1904aa72 1076#endif
42e69d6b
VZ
1077 }
1078#endif // Win95
1079
4f8090e0 1080 return false;
42e69d6b
VZ
1081}
1082
3ebcfb76
VZ
1083bool wxMDIChildFrame::HandleGetMinMaxInfo(void *mmInfo)
1084{
1085 MINMAXINFO *info = (MINMAXINFO *)mmInfo;
1086
1087 // let the default window proc calculate the size of MDI children
1088 // frames because it is based on the size of the MDI client window,
1089 // not on the values specified in wxWindow m_max variables
d9f9aa2d 1090 bool processed = MSWDefWindowProc(WM_GETMINMAXINFO, 0, (LPARAM)mmInfo) != 0;
3ebcfb76 1091
e7dda1ff
VS
1092 int minWidth = GetMinWidth(),
1093 minHeight = GetMinHeight();
1094
3ebcfb76 1095 // but allow GetSizeHints() to set the min size
e7dda1ff 1096 if ( minWidth != -1 )
3ebcfb76 1097 {
e7dda1ff 1098 info->ptMinTrackSize.x = minWidth;
3ebcfb76 1099
4f8090e0 1100 processed = true;
3ebcfb76
VZ
1101 }
1102
e7dda1ff 1103 if ( minHeight != -1 )
3ebcfb76 1104 {
e7dda1ff 1105 info->ptMinTrackSize.y = minHeight;
3ebcfb76 1106
4f8090e0 1107 processed = true;
3ebcfb76
VZ
1108 }
1109
4c9d78a4 1110 return processed;
3ebcfb76
VZ
1111}
1112
42e69d6b
VZ
1113// ---------------------------------------------------------------------------
1114// MDI specific message translation/preprocessing
1115// ---------------------------------------------------------------------------
2bda0e17 1116
c140b7e7 1117WXLRESULT wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
42e69d6b
VZ
1118{
1119 return DefMDIChildProc(GetHwnd(),
1120 (UINT)message, (WPARAM)wParam, (LPARAM)lParam);
1121}
1122
1123bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg)
1124{
5a2762f0 1125 return wxFrame::MSWTranslateMessage(msg);
2bda0e17
KB
1126}
1127
42e69d6b
VZ
1128// ---------------------------------------------------------------------------
1129// misc
1130// ---------------------------------------------------------------------------
1131
c2dcfdef 1132void wxMDIChildFrame::MSWDestroyWindow()
2bda0e17 1133{
b3818fbe 1134 invalidHandle = GetHwnd();
2bda0e17 1135
42e69d6b 1136 wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
2bda0e17 1137
42e69d6b
VZ
1138 // Must make sure this handle is invalidated (set to NULL) since all sorts
1139 // of things could happen after the child client is destroyed, but before
1140 // the wxFrame is destroyed.
2bda0e17 1141
42e69d6b 1142 HWND oldHandle = (HWND)GetHWND();
b3818fbe
VZ
1143 SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY,
1144 (WPARAM)oldHandle, 0);
18d2e170
JS
1145
1146 if (parent->GetActiveChild() == (wxMDIChildFrame*) NULL)
1147 ResetWindowStyle((void*) NULL);
1148
42e69d6b 1149 invalidHandle = 0;
2bda0e17 1150
42e69d6b
VZ
1151 if (m_hMenu)
1152 {
1153 ::DestroyMenu((HMENU) m_hMenu);
1154 m_hMenu = 0;
1155 }
ac6482e0 1156 wxRemoveHandleAssociation(this);
42e69d6b 1157 m_hWnd = 0;
2bda0e17
KB
1158}
1159
42e69d6b
VZ
1160// Change the client window's extended style so we don't get a client edge
1161// style when a child is maximised (a double border looks silly.)
2bda0e17
KB
1162bool wxMDIChildFrame::ResetWindowStyle(void *vrect)
1163{
1164#if defined(__WIN95__)
1165 RECT *rect = (RECT *)vrect;
c2dcfdef
VZ
1166 wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
1167 wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild();
1168 if (!pChild || (pChild == this))
1169 {
47ca6bfb 1170 HWND hwndClient = GetWinHwnd(pFrameWnd->GetClientWindow());
8082a771
VZ
1171 DWORD dwStyle = ::GetWindowLong(hwndClient, GWL_EXSTYLE);
1172
1173 // we want to test whether there is a maximized child, so just set
1174 // dwThisStyle to 0 if there is no child at all
1175 DWORD dwThisStyle = pChild
1f3943e0 1176 ? ::GetWindowLong(GetWinHwnd(pChild), GWL_STYLE) : 0;
c2dcfdef 1177 DWORD dwNewStyle = dwStyle;
8082a771 1178 if ( dwThisStyle & WS_MAXIMIZE )
c2dcfdef
VZ
1179 dwNewStyle &= ~(WS_EX_CLIENTEDGE);
1180 else
1181 dwNewStyle |= WS_EX_CLIENTEDGE;
1182
1183 if (dwStyle != dwNewStyle)
1184 {
47ca6bfb
VZ
1185 // force update of everything
1186 ::RedrawWindow(hwndClient, NULL, NULL,
1187 RDW_INVALIDATE | RDW_ALLCHILDREN);
1188 ::SetWindowLong(hwndClient, GWL_EXSTYLE, dwNewStyle);
1189 ::SetWindowPos(hwndClient, NULL, 0, 0, 0, 0,
42e69d6b
VZ
1190 SWP_FRAMECHANGED | SWP_NOACTIVATE |
1191 SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
1192 SWP_NOCOPYBITS);
c2dcfdef 1193 if (rect)
47ca6bfb 1194 ::GetClientRect(hwndClient, rect);
2bda0e17 1195
4f8090e0 1196 return true;
2bda0e17 1197 }
c2dcfdef 1198 }
42e69d6b 1199#endif // Win95
a23fd0e1 1200
4f8090e0 1201 return false;
2bda0e17
KB
1202}
1203
42e69d6b
VZ
1204// ===========================================================================
1205// wxMDIClientWindow: the window of predefined (by Windows) class which
1206// contains the child frames
1207// ===========================================================================
2bda0e17 1208
debe6624 1209bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
2bda0e17 1210{
a756f210 1211 m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
2bda0e17 1212
42e69d6b
VZ
1213 CLIENTCREATESTRUCT ccs;
1214 m_windowStyle = style;
1215 m_parent = parent;
c2dcfdef 1216
4e152a23 1217 ccs.hWindowMenu = GetMDIWindowMenu(parent);
42e69d6b 1218 ccs.idFirstChild = wxFIRST_MDI_CHILD;
2bda0e17 1219
5c44cd05 1220 DWORD msStyle = MDIS_ALLCHILDSTYLES | WS_VISIBLE | WS_CHILD |
b0766406
JS
1221 WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
1222
42e69d6b
VZ
1223 if ( style & wxHSCROLL )
1224 msStyle |= WS_HSCROLL;
1225 if ( style & wxVSCROLL )
1226 msStyle |= WS_VSCROLL;
2bda0e17
KB
1227
1228#if defined(__WIN95__)
42e69d6b 1229 DWORD exStyle = WS_EX_CLIENTEDGE;
2bda0e17 1230#else
42e69d6b 1231 DWORD exStyle = 0;
2bda0e17
KB
1232#endif
1233
b225f659 1234 wxWindowCreationHook hook(this);
42e69d6b
VZ
1235 m_hWnd = (WXHWND)::CreateWindowEx
1236 (
1237 exStyle,
223d09f6 1238 wxT("MDICLIENT"),
42e69d6b
VZ
1239 NULL,
1240 msStyle,
1241 0, 0, 0, 0,
1242 GetWinHwnd(parent),
1243 NULL,
1244 wxGetInstance(),
1245 (LPSTR)(LPCLIENTCREATESTRUCT)&ccs);
1246 if ( !m_hWnd )
1247 {
f6bcfd97 1248 wxLogLastError(wxT("CreateWindowEx(MDI client)"));
2bda0e17 1249
4f8090e0 1250 return false;
42e69d6b 1251 }
2bda0e17 1252
42e69d6b 1253 SubclassWin(m_hWnd);
2bda0e17 1254
4f8090e0 1255 return true;
2bda0e17
KB
1256}
1257
1258// Explicitly call default scroll behaviour
1259void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
1260{
1261 // Note: for client windows, the scroll position is not set in
1262 // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what
1263 // scroll position we're at.
1264 // This makes it hard to paint patterns or bitmaps in the background,
1265 // and have the client area scrollable as well.
1266
1267 if ( event.GetOrientation() == wxHORIZONTAL )
1268 m_scrollX = event.GetPosition(); // Always returns zero!
1269 else
1270 m_scrollY = event.GetPosition(); // Always returns zero!
1271
42e69d6b
VZ
1272 event.Skip();
1273}
1274
ec06b234
JS
1275void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1276{
1277 // Try to fix a problem whereby if you show an MDI child frame, then reposition the
1278 // client area, you can end up with a non-refreshed portion in the client window
1279 // (see OGL studio sample). So check if the position is changed and if so,
1280 // redraw the MDI child frames.
1281
1282 wxPoint oldPos = GetPosition();
1283
1284 wxWindow::DoSetSize(x, y, width, height, sizeFlags);
1285
1286 wxPoint newPos = GetPosition();
1287
1288 if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y))
1289 {
1290 if (GetParent())
1291 {
222ed1d6 1292 wxWindowList::compatibility_iterator node = GetParent()->GetChildren().GetFirst();
ec06b234
JS
1293 while (node)
1294 {
d162a7ee 1295 wxWindow *child = node->GetData();
ec06b234
JS
1296 if (child->IsKindOf(CLASSINFO(wxMDIChildFrame)))
1297 {
d162a7ee
VZ
1298 ::RedrawWindow(GetHwndOf(child),
1299 NULL,
1300 NULL,
1301 RDW_FRAME |
1302 RDW_ALLCHILDREN |
1303 RDW_INVALIDATE);
ec06b234 1304 }
4f8090e0 1305 node = node->GetNext();
ec06b234
JS
1306 }
1307 }
1308 }
1309}
1310
f6bcfd97
BP
1311void wxMDIChildFrame::OnIdle(wxIdleEvent& event)
1312{
2596e9fb
VS
1313 // wxMSW prior to 2.5.3 created MDI child frames as visible, which resulted
1314 // in flicker e.g. when the frame contained controls with non-trivial
1315 // layout. Since 2.5.3, the frame is created hidden as all other top level
1316 // windows. In order to maintain backward compatibility, the frame is shown
1317 // in OnIdle, unless Show(false) was called by the programmer before.
1318 if ( m_needsInitialShow )
1319 {
1320 Show(true);
1321 }
5c519b6c 1322
f6bcfd97
BP
1323 // MDI child frames get their WM_SIZE when they're constructed but at this
1324 // moment they don't have any children yet so all child windows will be
1325 // positioned incorrectly when they are added later - to fix this, we
1326 // generate an artificial size event here
1327 if ( m_needsResize )
1328 {
4f8090e0 1329 m_needsResize = false; // avoid any possibility of recursion
f6bcfd97
BP
1330
1331 SendSizeEvent();
1332 }
1333
1334 event.Skip();
1335}
1336
42e69d6b
VZ
1337// ---------------------------------------------------------------------------
1338// non member functions
1339// ---------------------------------------------------------------------------
1340
1341static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow)
1342{
1343 ::SendMessage(GetWinHwnd(win), WM_MDISETMENU,
1344#ifdef __WIN32__
f6bcfd97 1345 (WPARAM)hmenuFrame, (LPARAM)hmenuWindow
42e69d6b 1346#else
f6bcfd97 1347 0, MAKELPARAM(hmenuFrame, hmenuWindow)
42e69d6b 1348#endif
f6bcfd97 1349 );
42e69d6b
VZ
1350
1351 // update menu bar of the parent window
1352 wxWindow *parent = win->GetParent();
223d09f6 1353 wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") );
42e69d6b 1354
a967ef9d 1355 ::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L);
788722ac 1356
42e69d6b
VZ
1357 ::DrawMenuBar(GetWinHwnd(parent));
1358}
1359
1360static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu)
1361{
1362 // Try to insert Window menu in front of Help, otherwise append it.
1363 HMENU hmenu = (HMENU)menu;
df61c009
JS
1364
1365 if (subMenu)
1366 {
4e152a23 1367 int N = GetMenuItemCount(hmenu);
4f8090e0 1368 bool success = false;
4e152a23 1369 for ( int i = 0; i < N; i++ )
42e69d6b 1370 {
4e152a23
VZ
1371 wxChar buf[256];
1372 int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION);
1373 if ( chars == 0 )
1374 {
1375 wxLogLastError(wxT("GetMenuString"));
42e69d6b 1376
4e152a23
VZ
1377 continue;
1378 }
1379
1380 if ( wxStripMenuCodes(wxString(buf)).IsSameAs(_("Help")) )
1381 {
4f8090e0 1382 success = true;
4e152a23
VZ
1383 ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
1384 (UINT)subMenu, _("&Window"));
1385 break;
1386 }
42e69d6b
VZ
1387 }
1388
4e152a23 1389 if ( !success )
42e69d6b 1390 {
4e152a23 1391 ::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, _("&Window"));
42e69d6b
VZ
1392 }
1393 }
1394
42e69d6b
VZ
1395 MDISetMenu(win, hmenu, subMenu);
1396}
1397
df61c009
JS
1398static void RemoveWindowMenu(wxWindow *win, WXHMENU menu)
1399{
4e152a23
VZ
1400 HMENU hMenu = (HMENU)menu;
1401
1402 if ( hMenu )
df61c009 1403 {
4e152a23
VZ
1404 wxChar buf[1024];
1405
1406 int N = ::GetMenuItemCount(hMenu);
1407 for ( int i = 0; i < N; i++ )
df61c009 1408 {
4e152a23
VZ
1409 if ( !::GetMenuString(hMenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) )
1410 {
2c62b3c3
VZ
1411 // Ignore successful read of menu string with length 0 which
1412 // occurs, for example, for a maximized MDI childs system menu
1413 if ( ::GetLastError() != 0 )
1414 {
1415 wxLogLastError(wxT("GetMenuString"));
1416 }
df61c009 1417
4e152a23
VZ
1418 continue;
1419 }
df61c009 1420
4e152a23
VZ
1421 if ( wxStrcmp(buf, _("&Window")) == 0 )
1422 {
1423 if ( !::RemoveMenu(hMenu, i, MF_BYPOSITION) )
1424 {
1425 wxLogLastError(wxT("RemoveMenu"));
1426 }
1427
1428 break;
1429 }
df61c009
JS
1430 }
1431 }
1432
4e152a23
VZ
1433 if ( win )
1434 {
1435 // we don't change the windows menu, but we update the main one
1436 MDISetMenu(win, hMenu, NULL);
1437 }
df61c009
JS
1438}
1439
2917e920
BM
1440static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
1441 WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact)
42e69d6b 1442{
4f8090e0 1443 *activate = true;
42e69d6b
VZ
1444 *hwndAct = (WXHWND)lParam;
1445 *hwndDeact = (WXHWND)wParam;
2bda0e17 1446}
b9f933ab 1447
efd17a1d 1448#endif // wxUSE_MDI && !defined(__WXUNIVERSAL__)
b9f933ab 1449