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