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