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