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