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
8 // Copyright: (c) 1998 Julian Smart
9 // (c) 2008-2009 Vadim Zeitlin
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
13 // ===========================================================================
15 // ===========================================================================
17 // ---------------------------------------------------------------------------
19 // ---------------------------------------------------------------------------
21 // For compilers that support precompilation, includes "wx.h".
22 #include "wx/wxprec.h"
28 #if wxUSE_MDI && !defined(__WXUNIVERSAL__)
37 #include "wx/dialog.h"
38 #include "wx/statusbr.h"
39 #include "wx/settings.h"
42 #include "wx/toolbar.h"
45 #include "wx/stockitem.h"
46 #include "wx/msw/private.h"
50 // ---------------------------------------------------------------------------
52 // ---------------------------------------------------------------------------
54 extern wxMenu
*wxCurrentPopupMenu
;
56 extern void wxRemoveHandleAssociation(wxWindow
*win
);
61 // ---------------------------------------------------------------------------
63 // ---------------------------------------------------------------------------
65 // This range gives a maximum of 500 MDI children. Should be enough :-)
66 const int wxFIRST_MDI_CHILD
= 4100;
67 const int wxLAST_MDI_CHILD
= 4600;
69 // The MDI "Window" menu label
70 const char *WINDOW_MENU_LABEL
= gettext_noop("&Window");
72 // ---------------------------------------------------------------------------
74 // ---------------------------------------------------------------------------
76 // set the MDI menus (by sending the WM_MDISETMENU message) and update the menu
77 // of the parent of win (which is supposed to be the MDI client window)
78 void MDISetMenu(wxWindow
*win
, HMENU hmenuFrame
, HMENU hmenuWindow
);
80 // insert the window menu (subMenu) into menu just before "Help" submenu or at
81 // the very end if not found
82 void MDIInsertWindowMenu(wxWindow
*win
, WXHMENU hMenu
, HMENU subMenu
);
84 // Remove the window menu
85 void MDIRemoveWindowMenu(wxWindow
*win
, WXHMENU hMenu
);
87 // unpack the parameters of WM_MDIACTIVATE message
88 void UnpackMDIActivate(WXWPARAM wParam
, WXLPARAM lParam
,
89 WXWORD
*activate
, WXHWND
*hwndAct
, WXHWND
*hwndDeact
);
91 // return the HMENU of the MDI menu
93 // this function works correctly even when we don't have a window menu and just
95 inline HMENU
GetMDIWindowMenu(wxMDIParentFrame
*frame
)
97 wxMenu
*menu
= frame
->GetWindowMenu();
98 return menu
? GetHmenuOf(menu
) : 0;
101 } // anonymous namespace
103 // ===========================================================================
105 // ===========================================================================
107 // ---------------------------------------------------------------------------
109 // ---------------------------------------------------------------------------
111 IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame
, wxFrame
)
112 IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame
, wxFrame
)
113 IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow
, wxWindow
)
115 BEGIN_EVENT_TABLE(wxMDIParentFrame
, wxFrame
)
116 EVT_SIZE(wxMDIParentFrame::OnSize
)
117 EVT_ICONIZE(wxMDIParentFrame::OnIconized
)
118 EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged
)
121 EVT_MENU_RANGE(wxFIRST_MDI_CHILD
, wxLAST_MDI_CHILD
,
122 wxMDIParentFrame::OnMDIChild
)
123 EVT_MENU_RANGE(wxID_MDI_WINDOW_FIRST
, wxID_MDI_WINDOW_LAST
,
124 wxMDIParentFrame::OnMDICommand
)
125 #endif // wxUSE_MENUS
128 BEGIN_EVENT_TABLE(wxMDIChildFrame
, wxFrame
)
129 EVT_IDLE(wxMDIChildFrame::OnIdle
)
132 BEGIN_EVENT_TABLE(wxMDIClientWindow
, wxWindow
)
133 EVT_SCROLL(wxMDIClientWindow::OnScroll
)
136 // ===========================================================================
137 // wxMDIParentFrame: the frame which contains the client window which manages
139 // ===========================================================================
141 bool wxMDIParentFrame::Create(wxWindow
*parent
,
143 const wxString
& title
,
147 const wxString
& name
)
149 // this style can be used to prevent a window from having the standard MDI
151 if ( !(style
& wxFRAME_NO_WINDOW_MENU
) )
153 // normal case: we have the window menu, so construct it
154 m_windowMenu
= new wxMenu
;
156 m_windowMenu
->Append(wxID_MDI_WINDOW_CASCADE
, _("&Cascade"));
157 m_windowMenu
->Append(wxID_MDI_WINDOW_TILE_HORZ
, _("Tile &Horizontally"));
158 m_windowMenu
->Append(wxID_MDI_WINDOW_TILE_VERT
, _("Tile &Vertically"));
159 m_windowMenu
->AppendSeparator();
160 m_windowMenu
->Append(wxID_MDI_WINDOW_ARRANGE_ICONS
, _("&Arrange Icons"));
161 m_windowMenu
->Append(wxID_MDI_WINDOW_NEXT
, _("&Next"));
162 m_windowMenu
->Append(wxID_MDI_WINDOW_PREV
, _("&Previous"));
165 #if wxUSE_MENUS && wxUSE_ACCEL
166 // the default menu doesn't have any accelerators (even if we have it)
167 m_accelWindowMenu
= NULL
;
168 #endif // wxUSE_MENUS && wxUSE_ACCEL
171 wxTopLevelWindows
.Append(this);
174 m_windowStyle
= style
;
177 parent
->AddChild(this);
179 if ( id
!= wxID_ANY
)
182 m_windowId
= NewControlId();
185 WXDWORD msflags
= MSWGetCreateWindowFlags(&exflags
);
186 msflags
&= ~WS_VSCROLL
;
187 msflags
&= ~WS_HSCROLL
;
189 if ( !wxWindow::MSWCreate(wxApp::GetRegisteredClassName(_T("wxMDIFrame")),
198 SetOwnBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE
));
200 // unlike (almost?) all other windows, frames are created hidden
206 wxMDIParentFrame::~wxMDIParentFrame()
208 // see comment in ~wxMDIChildFrame
210 m_frameToolBar
= NULL
;
213 m_frameStatusBar
= NULL
;
214 #endif // wxUSE_STATUSBAR
216 #if wxUSE_MENUS && wxUSE_ACCEL
217 delete m_accelWindowMenu
;
218 #endif // wxUSE_MENUS && wxUSE_ACCEL
222 // the MDI frame menubar is not automatically deleted by Windows unlike for
225 ::DestroyMenu((HMENU
)m_hMenu
);
227 if ( m_clientWindow
)
229 if ( m_clientWindow
->MSWGetOldWndProc() )
230 m_clientWindow
->UnsubclassWin();
232 m_clientWindow
->SetHWND(0);
233 delete m_clientWindow
;
237 // ----------------------------------------------------------------------------
238 // wxMDIParentFrame child management
239 // ----------------------------------------------------------------------------
241 wxMDIChildFrame
*wxMDIParentFrame::GetActiveChild() const
243 HWND hWnd
= (HWND
)::SendMessage(GetWinHwnd(GetClientWindow()),
244 WM_MDIGETACTIVE
, 0, 0L);
248 return static_cast<wxMDIChildFrame
*>(wxFindWinFromHandle(hWnd
));
251 int wxMDIParentFrame::GetChildFramesCount() const
254 for ( wxWindowList::const_iterator i
= GetChildren().begin();
255 i
!= GetChildren().end();
258 if ( wxDynamicCast(*i
, wxMDIChildFrame
) )
267 void wxMDIParentFrame::AddMDIChild(wxMDIChildFrame
* WXUNUSED(child
))
269 switch ( GetChildFramesCount() )
272 // first MDI child was just added, we need to insert the window
273 // menu now if we have it
276 // and disable the items which can't be used until we have more
278 UpdateWindowMenu(false);
282 // second MDI child was added, enable the menu items which were
283 // disabled because they didn't make sense for a single window
284 UpdateWindowMenu(true);
289 void wxMDIParentFrame::RemoveMDIChild(wxMDIChildFrame
* WXUNUSED(child
))
291 switch ( GetChildFramesCount() )
294 // last MDI child is being removed, remove the now unnecessary
298 // there is no need to call UpdateWindowMenu(true) here so this is
299 // not quite symmetric to AddMDIChild() above
303 // only one MDI child is going to remain, disable the menu commands
304 // which don't make sense for a single child window
305 UpdateWindowMenu(false);
310 // ----------------------------------------------------------------------------
311 // wxMDIParentFrame window menu handling
312 // ----------------------------------------------------------------------------
314 void wxMDIParentFrame::AddWindowMenu()
317 MDIInsertWindowMenu(GetClientWindow(), m_hMenu
, GetMDIWindowMenu(this));
320 void wxMDIParentFrame::RemoveWindowMenu()
323 MDIRemoveWindowMenu(GetClientWindow(), m_hMenu
);
326 void wxMDIParentFrame::UpdateWindowMenu(bool enable
)
330 m_windowMenu
->Enable(wxID_MDI_WINDOW_NEXT
, enable
);
331 m_windowMenu
->Enable(wxID_MDI_WINDOW_PREV
, enable
);
335 #if wxUSE_MENUS_NATIVE
337 void wxMDIParentFrame::InternalSetMenuBar()
339 if ( GetActiveChild() )
343 else // we don't have any MDI children yet
345 // wait until we do to add the window menu but do set the main menu for
346 // now (this is done by AddWindowMenu() as a side effect)
347 MDISetMenu(GetClientWindow(), (HMENU
)m_hMenu
, NULL
);
351 #endif // wxUSE_MENUS_NATIVE
353 void wxMDIParentFrame::SetWindowMenu(wxMenu
* menu
)
355 if ( menu
!= m_windowMenu
)
357 // notice that Remove/AddWindowMenu() are safe to call even when
358 // m_windowMenu is NULL
369 delete m_accelWindowMenu
;
370 m_accelWindowMenu
= NULL
;
372 if ( menu
&& menu
->HasAccels() )
373 m_accelWindowMenu
= menu
->CreateAccelTable();
374 #endif // wxUSE_ACCEL
377 // ----------------------------------------------------------------------------
378 // wxMDIParentFrame other menu-related stuff
379 // ----------------------------------------------------------------------------
381 void wxMDIParentFrame::DoMenuUpdates(wxMenu
* menu
)
383 wxMDIChildFrame
*child
= GetActiveChild();
386 wxEvtHandler
* source
= child
->GetEventHandler();
387 wxMenuBar
* bar
= child
->GetMenuBar();
391 menu
->UpdateUI(source
);
397 int nCount
= bar
->GetMenuCount();
398 for (int n
= 0; n
< nCount
; n
++)
399 bar
->GetMenu(n
)->UpdateUI(source
);
405 wxFrameBase::DoMenuUpdates(menu
);
409 wxMenuItem
*wxMDIParentFrame::FindItemInMenuBar(int menuId
) const
411 wxMenuItem
*item
= wxFrame::FindItemInMenuBar(menuId
);
412 if ( !item
&& GetActiveChild() )
414 item
= GetActiveChild()->FindItemInMenuBar(menuId
);
417 if ( !item
&& m_windowMenu
)
418 item
= m_windowMenu
->FindItem(menuId
);
423 WXHMENU
wxMDIParentFrame::MSWGetActiveMenu() const
425 wxMDIChildFrame
* const child
= GetActiveChild();
428 const WXHMENU hmenu
= child
->MSWGetActiveMenu();
433 return wxFrame::MSWGetActiveMenu();
436 #endif // wxUSE_MENUS
438 // ----------------------------------------------------------------------------
439 // wxMDIParentFrame event handling
440 // ----------------------------------------------------------------------------
442 void wxMDIParentFrame::UpdateClientSize()
444 if ( GetClientWindow() )
447 GetClientSize(&width
, &height
);
449 GetClientWindow()->SetSize(0, 0, width
, height
);
453 void wxMDIParentFrame::OnSize(wxSizeEvent
& WXUNUSED(event
))
457 // do not call event.Skip() here, it somehow messes up MDI client window
460 void wxMDIParentFrame::OnIconized(wxIconizeEvent
& event
)
464 if ( !event
.IsIconized() )
468 // Responds to colour changes, and passes event on to children.
469 void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent
& event
)
471 if ( m_clientWindow
)
473 m_clientWindow
->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE
));
474 m_clientWindow
->Refresh();
480 WXHICON
wxMDIParentFrame::GetDefaultIcon() const
482 // we don't have any standard icons (any more)
486 // ---------------------------------------------------------------------------
488 // ---------------------------------------------------------------------------
490 void wxMDIParentFrame::Cascade()
492 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE
, 0, 0);
495 void wxMDIParentFrame::Tile(wxOrientation orient
)
497 wxASSERT_MSG( orient
== wxHORIZONTAL
|| orient
== wxVERTICAL
,
498 _T("invalid orientation value") );
500 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE
,
501 orient
== wxHORIZONTAL
? MDITILE_HORIZONTAL
502 : MDITILE_VERTICAL
, 0);
505 void wxMDIParentFrame::ArrangeIcons()
507 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDIICONARRANGE
, 0, 0);
510 void wxMDIParentFrame::ActivateNext()
512 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT
, 0, 0);
515 void wxMDIParentFrame::ActivatePrevious()
517 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT
, 0, 1);
520 // ---------------------------------------------------------------------------
521 // the MDI parent frame window proc
522 // ---------------------------------------------------------------------------
524 WXLRESULT
wxMDIParentFrame::MSWWindowProc(WXUINT message
,
529 bool processed
= false;
535 WXWORD state
, minimized
;
537 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
539 processed
= HandleActivate(state
, minimized
!= 0, hwnd
);
544 // system messages such as SC_CLOSE are sent as WM_COMMANDs to the
545 // parent MDI frame and we must let the DefFrameProc() have them
546 // for these commands to work (without it, closing the maximized
547 // MDI children doesn't work, for example)
551 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
553 if ( cmd
== 0 /* menu */ &&
554 id
>= SC_SIZE
/* first system menu command */ )
556 MSWDefWindowProc(message
, wParam
, lParam
);
563 m_clientWindow
= OnCreateClient();
564 // Uses own style for client style
565 if ( !m_clientWindow
->CreateClient(this, GetWindowStyleFlag()) )
567 wxLogMessage(_("Failed to create MDI parent frame."));
578 // we erase background ourselves
583 // though we don't (usually) resize the MDI client to exactly fit
584 // the client area we need to pass this one to DefFrameProc to
585 // allow the children to show
590 rc
= wxFrame::MSWWindowProc(message
, wParam
, lParam
);
595 bool wxMDIParentFrame::HandleActivate(int state
, bool minimized
, WXHWND activate
)
597 bool processed
= false;
599 if ( wxWindow::HandleActivate(state
, minimized
, activate
) )
605 // If this window is an MDI parent, we must also send an OnActivate message
606 // to the current child.
607 if ( GetActiveChild() &&
608 ((state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
)) )
610 wxActivateEvent
event(wxEVT_ACTIVATE
, true, GetActiveChild()->GetId());
611 event
.SetEventObject( GetActiveChild() );
612 if ( GetActiveChild()->HandleWindowEvent(event
) )
621 void wxMDIParentFrame::OnMDIChild(wxCommandEvent
& event
)
623 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
626 wxWindow
*child
= node
->GetData();
627 if ( child
->GetHWND() )
629 int childId
= wxGetWindowId(child
->GetHWND());
630 if ( childId
== event
.GetId() )
632 ::SendMessage( GetWinHwnd(GetClientWindow()),
634 (WPARAM
)child
->GetHWND(), 0);
639 node
= node
->GetNext();
642 wxFAIL_MSG( "unknown MDI child selected?" );
645 void wxMDIParentFrame::OnMDICommand(wxCommandEvent
& event
)
650 switch ( event
.GetId() )
652 case wxID_MDI_WINDOW_CASCADE
:
654 wParam
= MDITILE_SKIPDISABLED
;
657 case wxID_MDI_WINDOW_TILE_HORZ
:
658 wParam
|= MDITILE_HORIZONTAL
;
661 case wxID_MDI_WINDOW_TILE_VERT
:
663 wParam
= MDITILE_VERTICAL
;
665 wParam
|= MDITILE_SKIPDISABLED
;
668 case wxID_MDI_WINDOW_ARRANGE_ICONS
:
669 msg
= WM_MDIICONARRANGE
;
672 case wxID_MDI_WINDOW_NEXT
:
674 lParam
= 0; // next child
677 case wxID_MDI_WINDOW_PREV
:
679 lParam
= 1; // previous child
683 wxFAIL_MSG( "unknown MDI command" );
687 ::SendMessage(GetWinHwnd(GetClientWindow()), msg
, wParam
, lParam
);
690 #endif // wxUSE_MENUS
692 bool wxMDIParentFrame::TryBefore(wxEvent
& event
)
694 // menu (and toolbar) events should be sent to the active child frame
696 if ( event
.GetEventType() == wxEVT_COMMAND_MENU_SELECTED
)
698 wxMDIChildFrame
* const child
= GetActiveChild();
699 if ( child
&& child
->ProcessEventHere(event
) )
703 return wxMDIParentFrameBase::TryBefore(event
);
706 WXLRESULT
wxMDIParentFrame::MSWDefWindowProc(WXUINT message
,
711 if ( GetClientWindow() )
712 clientWnd
= GetClientWindow()->GetHWND();
716 return DefFrameProc(GetHwnd(), (HWND
)clientWnd
, message
, wParam
, lParam
);
719 bool wxMDIParentFrame::MSWTranslateMessage(WXMSG
* msg
)
721 MSG
*pMsg
= (MSG
*)msg
;
723 // first let the current child get it
724 wxMDIChildFrame
* const child
= GetActiveChild();
725 if ( child
&& child
->MSWTranslateMessage(msg
) )
730 // then try out accelerator table (will also check the accelerators for the
731 // normal menu items)
732 if ( wxFrame::MSWTranslateMessage(msg
) )
737 #if wxUSE_MENUS && wxUSE_ACCEL
738 // but it doesn't check for the (custom) accelerators of the window menu
739 // items as it's not part of the menu bar as it's handled by Windows itself
740 // so we need to do this explicitly
741 if ( m_accelWindowMenu
&& m_accelWindowMenu
->Translate(this, msg
) )
743 #endif // wxUSE_MENUS && wxUSE_ACCEL
745 // finally, check for MDI specific built-in accelerators
746 if ( pMsg
->message
== WM_KEYDOWN
|| pMsg
->message
== WM_SYSKEYDOWN
)
748 if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg
))
755 // ===========================================================================
757 // ===========================================================================
759 void wxMDIChildFrame::Init()
761 m_needsResize
= true;
762 m_needsInitialShow
= true;
765 bool wxMDIChildFrame::Create(wxMDIParentFrame
*parent
,
767 const wxString
& title
,
771 const wxString
& name
)
773 m_mdiParent
= parent
;
777 if ( id
!= wxID_ANY
)
780 m_windowId
= NewControlId();
784 parent
->AddChild(this);
795 wxApp::GetRegisteredClassName(_T("wxMDIChildFrame"), COLOR_WINDOW
);
796 if ( !(style
& wxFULL_REPAINT_ON_RESIZE
) )
797 className
+= wxApp::GetNoRedrawClassSuffix();
799 mcs
.szClass
= className
.wx_str();
800 mcs
.szTitle
= title
.wx_str();
801 mcs
.hOwner
= wxGetInstance();
802 if (x
!= wxDefaultCoord
)
805 mcs
.x
= CW_USEDEFAULT
;
807 if (y
!= wxDefaultCoord
)
810 mcs
.y
= CW_USEDEFAULT
;
812 if (width
!= wxDefaultCoord
)
815 mcs
.cx
= CW_USEDEFAULT
;
817 if (height
!= wxDefaultCoord
)
820 mcs
.cy
= CW_USEDEFAULT
;
822 DWORD msflags
= WS_OVERLAPPED
| WS_CLIPCHILDREN
;
823 if (style
& wxMINIMIZE_BOX
)
824 msflags
|= WS_MINIMIZEBOX
;
825 if (style
& wxMAXIMIZE_BOX
)
826 msflags
|= WS_MAXIMIZEBOX
;
827 if (style
& wxRESIZE_BORDER
)
828 msflags
|= WS_THICKFRAME
;
829 if (style
& wxSYSTEM_MENU
)
830 msflags
|= WS_SYSMENU
;
831 if ((style
& wxMINIMIZE
) || (style
& wxICONIZE
))
832 msflags
|= WS_MINIMIZE
;
833 if (style
& wxMAXIMIZE
)
834 msflags
|= WS_MAXIMIZE
;
835 if (style
& wxCAPTION
)
836 msflags
|= WS_CAPTION
;
842 wxWindowCreationHook
hook(this);
844 m_hWnd
= (WXHWND
)::SendMessage(GetWinHwnd(parent
->GetClientWindow()),
845 WM_MDICREATE
, 0, (LPARAM
)&mcs
);
849 wxLogLastError(_T("WM_MDICREATE"));
855 parent
->AddMDIChild(this);
860 wxMDIChildFrame::~wxMDIChildFrame()
862 // if we hadn't been created, there is nothing to destroy
866 GetMDIParent()->RemoveMDIChild(this);
868 // will be destroyed by DestroyChildren() but reset them before calling it
869 // to avoid using dangling pointers if a callback comes in the meanwhile
871 m_frameToolBar
= NULL
;
874 m_frameStatusBar
= NULL
;
875 #endif // wxUSE_STATUSBAR
879 MDIRemoveWindowMenu(NULL
, m_hMenu
);
884 bool wxMDIChildFrame::Show(bool show
)
886 m_needsInitialShow
= false;
888 if (!wxFrame::Show(show
))
891 // KH: Without this call, new MDI children do not become active.
892 // This was added here after the same BringWindowToTop call was
893 // removed from wxTopLevelWindow::Show (November 2005)
895 ::BringWindowToTop(GetHwnd());
897 // we need to refresh the MDI frame window menu to include (or exclude if
898 // we've been hidden) this frame
899 wxMDIParentFrame
* const parent
= GetMDIParent();
900 MDISetMenu(parent
->GetClientWindow(), NULL
, NULL
);
906 wxMDIChildFrame::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
908 // we need to disable client area origin adjustments used for the child
909 // windows for the frame itself
910 wxMDIChildFrameBase::DoSetSize(x
, y
, width
, height
, sizeFlags
);
913 // Set the client size (i.e. leave the calculation of borders etc.
915 void wxMDIChildFrame::DoSetClientSize(int width
, int height
)
917 HWND hWnd
= GetHwnd();
920 ::GetClientRect(hWnd
, &rect
);
923 GetWindowRect(hWnd
, &rect2
);
925 // Find the difference between the entire window (title bar and all)
926 // and the client area; add this to the new client size to move the
928 int actual_width
= rect2
.right
- rect2
.left
- rect
.right
+ width
;
929 int actual_height
= rect2
.bottom
- rect2
.top
- rect
.bottom
+ height
;
932 if (GetStatusBar() && GetStatusBar()->IsShown())
935 GetStatusBar()->GetSize(&sx
, &sy
);
938 #endif // wxUSE_STATUSBAR
941 point
.x
= rect2
.left
;
944 // If there's an MDI parent, must subtract the parent's top left corner
945 // since MoveWindow moves relative to the parent
946 wxMDIParentFrame
* const mdiParent
= GetMDIParent();
947 ::ScreenToClient(GetHwndOf(mdiParent
->GetClientWindow()), &point
);
949 MoveWindow(hWnd
, point
.x
, point
.y
, actual_width
, actual_height
, (BOOL
)true);
951 wxSize
size(width
, height
);
952 wxSizeEvent
event(size
, m_windowId
);
953 event
.SetEventObject( this );
954 HandleWindowEvent(event
);
957 // Unlike other wxTopLevelWindowBase, the mdi child's "GetPosition" is not the
958 // same as its GetScreenPosition
959 void wxMDIChildFrame::DoGetScreenPosition(int *x
, int *y
) const
961 HWND hWnd
= GetHwnd();
964 ::GetWindowRect(hWnd
, &rect
);
972 void wxMDIChildFrame::DoGetPosition(int *x
, int *y
) const
975 GetWindowRect(GetHwnd(), &rect
);
980 // Since we now have the absolute screen coords,
981 // if there's a parent we must subtract its top left corner
982 wxMDIParentFrame
* const mdiParent
= GetMDIParent();
983 ::ScreenToClient(GetHwndOf(mdiParent
->GetClientWindow()), &point
);
991 void wxMDIChildFrame::InternalSetMenuBar()
993 wxMDIParentFrame
* const parent
= GetMDIParent();
995 MDIInsertWindowMenu(parent
->GetClientWindow(),
996 m_hMenu
, GetMDIWindowMenu(parent
));
999 void wxMDIChildFrame::DetachMenuBar()
1001 MDIRemoveWindowMenu(NULL
, m_hMenu
);
1002 wxFrame::DetachMenuBar();
1005 WXHICON
wxMDIChildFrame::GetDefaultIcon() const
1007 // we don't have any standard icons (any more)
1011 // ---------------------------------------------------------------------------
1013 // ---------------------------------------------------------------------------
1015 void wxMDIChildFrame::Maximize(bool maximize
)
1017 wxMDIParentFrame
* const parent
= GetMDIParent();
1018 if ( parent
&& parent
->GetClientWindow() )
1020 ::SendMessage(GetWinHwnd(parent
->GetClientWindow()),
1021 maximize
? WM_MDIMAXIMIZE
: WM_MDIRESTORE
,
1022 (WPARAM
)GetHwnd(), 0);
1026 void wxMDIChildFrame::Restore()
1028 wxMDIParentFrame
* const parent
= GetMDIParent();
1029 if ( parent
&& parent
->GetClientWindow() )
1031 ::SendMessage(GetWinHwnd(parent
->GetClientWindow()), WM_MDIRESTORE
,
1032 (WPARAM
) GetHwnd(), 0);
1036 void wxMDIChildFrame::Activate()
1038 wxMDIParentFrame
* const parent
= GetMDIParent();
1039 if ( parent
&& parent
->GetClientWindow() )
1041 ::SendMessage(GetWinHwnd(parent
->GetClientWindow()), WM_MDIACTIVATE
,
1042 (WPARAM
) GetHwnd(), 0);
1046 // ---------------------------------------------------------------------------
1047 // MDI window proc and message handlers
1048 // ---------------------------------------------------------------------------
1050 WXLRESULT
wxMDIChildFrame::MSWWindowProc(WXUINT message
,
1055 bool processed
= false;
1059 case WM_GETMINMAXINFO
:
1060 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
1063 case WM_MDIACTIVATE
:
1066 WXHWND hwndAct
, hwndDeact
;
1067 UnpackMDIActivate(wParam
, lParam
, &act
, &hwndAct
, &hwndDeact
);
1069 processed
= HandleMDIActivate(act
, hwndAct
, hwndDeact
);
1074 // must pass WM_MOVE to DefMDIChildProc() to recalculate MDI client
1075 // scrollbars if necessary
1080 // must pass WM_SIZE to DefMDIChildProc(), otherwise many weird
1082 MSWDefWindowProc(message
, wParam
, lParam
);
1085 case WM_WINDOWPOSCHANGING
:
1086 processed
= HandleWindowPosChanging((LPWINDOWPOS
)lParam
);
1091 rc
= wxFrame::MSWWindowProc(message
, wParam
, lParam
);
1096 bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate
),
1100 wxMDIParentFrame
* const parent
= GetMDIParent();
1102 WXHMENU hMenuToSet
= 0;
1106 if ( m_hWnd
== hwndAct
)
1109 parent
->SetActiveChild(this);
1111 WXHMENU hMenuChild
= m_hMenu
;
1113 hMenuToSet
= hMenuChild
;
1115 else if ( m_hWnd
== hwndDeact
)
1117 wxASSERT_MSG( parent
->GetActiveChild() == this,
1118 wxT("can't deactivate MDI child which wasn't active!") );
1121 parent
->SetActiveChild(NULL
);
1123 WXHMENU hMenuParent
= parent
->m_hMenu
;
1125 // activate the the parent menu only when there is no other child
1126 // that has been activated
1127 if ( hMenuParent
&& !hwndAct
)
1128 hMenuToSet
= hMenuParent
;
1132 // we have nothing to do with it
1138 MDISetMenu(parent
->GetClientWindow(),
1139 (HMENU
)hMenuToSet
, GetMDIWindowMenu(parent
));
1142 wxActivateEvent
event(wxEVT_ACTIVATE
, activated
, m_windowId
);
1143 event
.SetEventObject( this );
1145 ResetWindowStyle(NULL
);
1147 return HandleWindowEvent(event
);
1150 bool wxMDIChildFrame::HandleWindowPosChanging(void *pos
)
1152 WINDOWPOS
*lpPos
= (WINDOWPOS
*)pos
;
1154 if (!(lpPos
->flags
& SWP_NOSIZE
))
1157 DWORD dwExStyle
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1158 DWORD dwStyle
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1159 if (ResetWindowStyle((void *) & rectClient
) && (dwStyle
& WS_MAXIMIZE
))
1161 ::AdjustWindowRectEx(&rectClient
, dwStyle
, false, dwExStyle
);
1162 lpPos
->x
= rectClient
.left
;
1163 lpPos
->y
= rectClient
.top
;
1164 lpPos
->cx
= rectClient
.right
- rectClient
.left
;
1165 lpPos
->cy
= rectClient
.bottom
- rectClient
.top
;
1172 bool wxMDIChildFrame::HandleGetMinMaxInfo(void *mmInfo
)
1174 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
1176 // let the default window proc calculate the size of MDI children
1177 // frames because it is based on the size of the MDI client window,
1178 // not on the values specified in wxWindow m_max variables
1179 bool processed
= MSWDefWindowProc(WM_GETMINMAXINFO
, 0, (LPARAM
)mmInfo
) != 0;
1181 int minWidth
= GetMinWidth(),
1182 minHeight
= GetMinHeight();
1184 // but allow GetSizeHints() to set the min size
1185 if ( minWidth
!= wxDefaultCoord
)
1187 info
->ptMinTrackSize
.x
= minWidth
;
1192 if ( minHeight
!= wxDefaultCoord
)
1194 info
->ptMinTrackSize
.y
= minHeight
;
1202 // ---------------------------------------------------------------------------
1203 // MDI specific message translation/preprocessing
1204 // ---------------------------------------------------------------------------
1206 WXLRESULT
wxMDIChildFrame::MSWDefWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
1208 return DefMDIChildProc(GetHwnd(),
1209 (UINT
)message
, (WPARAM
)wParam
, (LPARAM
)lParam
);
1212 bool wxMDIChildFrame::MSWTranslateMessage(WXMSG
* msg
)
1214 // we must pass the parent frame to ::TranslateAccelerator(), otherwise it
1215 // doesn't do its job correctly for MDI child menus
1216 return MSWDoTranslateMessage(GetMDIParent(), msg
);
1219 // ---------------------------------------------------------------------------
1221 // ---------------------------------------------------------------------------
1223 void wxMDIChildFrame::MSWDestroyWindow()
1225 wxMDIParentFrame
* const parent
= GetMDIParent();
1227 // Must make sure this handle is invalidated (set to NULL) since all sorts
1228 // of things could happen after the child client is destroyed, but before
1229 // the wxFrame is destroyed.
1231 HWND oldHandle
= (HWND
)GetHWND();
1232 SendMessage(GetWinHwnd(parent
->GetClientWindow()), WM_MDIDESTROY
,
1233 (WPARAM
)oldHandle
, 0);
1235 if (parent
->GetActiveChild() == NULL
)
1236 ResetWindowStyle(NULL
);
1240 ::DestroyMenu((HMENU
) m_hMenu
);
1243 wxRemoveHandleAssociation(this);
1247 // Change the client window's extended style so we don't get a client edge
1248 // style when a child is maximised (a double border looks silly.)
1249 bool wxMDIChildFrame::ResetWindowStyle(void *vrect
)
1251 RECT
*rect
= (RECT
*)vrect
;
1252 wxMDIParentFrame
* const pFrameWnd
= GetMDIParent();
1253 wxMDIChildFrame
* pChild
= pFrameWnd
->GetActiveChild();
1255 if (!pChild
|| (pChild
== this))
1257 HWND hwndClient
= GetWinHwnd(pFrameWnd
->GetClientWindow());
1258 DWORD dwStyle
= ::GetWindowLong(hwndClient
, GWL_EXSTYLE
);
1260 // we want to test whether there is a maximized child, so just set
1261 // dwThisStyle to 0 if there is no child at all
1262 DWORD dwThisStyle
= pChild
1263 ? ::GetWindowLong(GetWinHwnd(pChild
), GWL_STYLE
) : 0;
1264 DWORD dwNewStyle
= dwStyle
;
1265 if ( dwThisStyle
& WS_MAXIMIZE
)
1266 dwNewStyle
&= ~(WS_EX_CLIENTEDGE
);
1268 dwNewStyle
|= WS_EX_CLIENTEDGE
;
1270 if (dwStyle
!= dwNewStyle
)
1272 // force update of everything
1273 ::RedrawWindow(hwndClient
, NULL
, NULL
,
1274 RDW_INVALIDATE
| RDW_ALLCHILDREN
);
1275 ::SetWindowLong(hwndClient
, GWL_EXSTYLE
, dwNewStyle
);
1276 ::SetWindowPos(hwndClient
, NULL
, 0, 0, 0, 0,
1277 SWP_FRAMECHANGED
| SWP_NOACTIVATE
|
1278 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOZORDER
|
1281 ::GetClientRect(hwndClient
, rect
);
1290 // ===========================================================================
1291 // wxMDIClientWindow: the window of predefined (by Windows) class which
1292 // contains the child frames
1293 // ===========================================================================
1295 bool wxMDIClientWindow::CreateClient(wxMDIParentFrame
*parent
, long style
)
1297 m_backgroundColour
= wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE
);
1299 CLIENTCREATESTRUCT ccs
;
1300 m_windowStyle
= style
;
1303 ccs
.hWindowMenu
= GetMDIWindowMenu(parent
);
1304 ccs
.idFirstChild
= wxFIRST_MDI_CHILD
;
1306 DWORD msStyle
= MDIS_ALLCHILDSTYLES
| WS_VISIBLE
| WS_CHILD
|
1307 WS_CLIPCHILDREN
| WS_CLIPSIBLINGS
;
1309 if ( style
& wxHSCROLL
)
1310 msStyle
|= WS_HSCROLL
;
1311 if ( style
& wxVSCROLL
)
1312 msStyle
|= WS_VSCROLL
;
1314 DWORD exStyle
= WS_EX_CLIENTEDGE
;
1316 wxWindowCreationHook
hook(this);
1317 m_hWnd
= (WXHWND
)::CreateWindowEx
1327 (LPSTR
)(LPCLIENTCREATESTRUCT
)&ccs
);
1330 wxLogLastError(wxT("CreateWindowEx(MDI client)"));
1335 SubclassWin(m_hWnd
);
1340 // Explicitly call default scroll behaviour
1341 void wxMDIClientWindow::OnScroll(wxScrollEvent
& event
)
1343 // Note: for client windows, the scroll position is not set in
1344 // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what
1345 // scroll position we're at.
1346 // This makes it hard to paint patterns or bitmaps in the background,
1347 // and have the client area scrollable as well.
1349 if ( event
.GetOrientation() == wxHORIZONTAL
)
1350 m_scrollX
= event
.GetPosition(); // Always returns zero!
1352 m_scrollY
= event
.GetPosition(); // Always returns zero!
1357 void wxMDIClientWindow::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1359 // Try to fix a problem whereby if you show an MDI child frame, then reposition the
1360 // client area, you can end up with a non-refreshed portion in the client window
1361 // (see OGL studio sample). So check if the position is changed and if so,
1362 // redraw the MDI child frames.
1364 const wxPoint oldPos
= GetPosition();
1366 wxWindow::DoSetSize(x
, y
, width
, height
, sizeFlags
| wxSIZE_FORCE
);
1368 const wxPoint newPos
= GetPosition();
1370 if ((newPos
.x
!= oldPos
.x
) || (newPos
.y
!= oldPos
.y
))
1374 wxWindowList::compatibility_iterator node
= GetParent()->GetChildren().GetFirst();
1377 wxWindow
*child
= node
->GetData();
1378 if (child
->IsKindOf(CLASSINFO(wxMDIChildFrame
)))
1380 ::RedrawWindow(GetHwndOf(child
),
1387 node
= node
->GetNext();
1393 void wxMDIChildFrame::OnIdle(wxIdleEvent
& event
)
1395 // wxMSW prior to 2.5.3 created MDI child frames as visible, which resulted
1396 // in flicker e.g. when the frame contained controls with non-trivial
1397 // layout. Since 2.5.3, the frame is created hidden as all other top level
1398 // windows. In order to maintain backward compatibility, the frame is shown
1399 // in OnIdle, unless Show(false) was called by the programmer before.
1400 if ( m_needsInitialShow
)
1405 // MDI child frames get their WM_SIZE when they're constructed but at this
1406 // moment they don't have any children yet so all child windows will be
1407 // positioned incorrectly when they are added later - to fix this, we
1408 // generate an artificial size event here
1409 if ( m_needsResize
)
1411 m_needsResize
= false; // avoid any possibility of recursion
1419 // ---------------------------------------------------------------------------
1420 // private helper functions
1421 // ---------------------------------------------------------------------------
1426 void MDISetMenu(wxWindow
*win
, HMENU hmenuFrame
, HMENU hmenuWindow
)
1428 if ( hmenuFrame
|| hmenuWindow
)
1430 if ( !::SendMessage(GetWinHwnd(win
),
1433 (LPARAM
)hmenuWindow
) )
1435 DWORD err
= ::GetLastError();
1437 wxLogApiError(_T("SendMessage(WM_MDISETMENU)"), err
);
1441 // update menu bar of the parent window
1442 wxWindow
*parent
= win
->GetParent();
1443 wxCHECK_RET( parent
, wxT("MDI client without parent frame? weird...") );
1445 ::SendMessage(GetWinHwnd(win
), WM_MDIREFRESHMENU
, 0, 0L);
1447 ::DrawMenuBar(GetWinHwnd(parent
));
1450 void MDIInsertWindowMenu(wxWindow
*win
, WXHMENU hMenu
, HMENU menuWin
)
1452 HMENU hmenu
= (HMENU
)hMenu
;
1456 // Try to insert Window menu in front of Help, otherwise append it.
1457 int N
= GetMenuItemCount(hmenu
);
1458 bool inserted
= false;
1459 for ( int i
= 0; i
< N
; i
++ )
1462 if ( !::GetMenuString(hmenu
, i
, buf
, WXSIZEOF(buf
), MF_BYPOSITION
) )
1464 wxLogLastError(wxT("GetMenuString"));
1469 const wxString label
= wxStripMenuCodes(buf
);
1470 if ( label
== wxGetStockLabel(wxID_HELP
, wxSTOCK_NOFLAGS
) )
1473 ::InsertMenu(hmenu
, i
, MF_BYPOSITION
| MF_POPUP
| MF_STRING
,
1475 wxGetTranslation(WINDOW_MENU_LABEL
).wx_str());
1482 ::AppendMenu(hmenu
, MF_POPUP
,
1484 wxGetTranslation(WINDOW_MENU_LABEL
).wx_str());
1488 MDISetMenu(win
, hmenu
, menuWin
);
1491 void MDIRemoveWindowMenu(wxWindow
*win
, WXHMENU hMenu
)
1493 HMENU hmenu
= (HMENU
)hMenu
;
1499 int N
= ::GetMenuItemCount(hmenu
);
1500 for ( int i
= 0; i
< N
; i
++ )
1502 if ( !::GetMenuString(hmenu
, i
, buf
, WXSIZEOF(buf
), MF_BYPOSITION
) )
1504 // Ignore successful read of menu string with length 0 which
1505 // occurs, for example, for a maximized MDI child system menu
1506 if ( ::GetLastError() != 0 )
1508 wxLogLastError(wxT("GetMenuString"));
1514 if ( wxStrcmp(buf
, wxGetTranslation(WINDOW_MENU_LABEL
)) == 0 )
1516 if ( !::RemoveMenu(hmenu
, i
, MF_BYPOSITION
) )
1518 wxLogLastError(wxT("RemoveMenu"));
1528 // we don't change the windows menu, but we update the main one
1529 MDISetMenu(win
, hmenu
, NULL
);
1533 void UnpackMDIActivate(WXWPARAM wParam
, WXLPARAM lParam
,
1534 WXWORD
*activate
, WXHWND
*hwndAct
, WXHWND
*hwndDeact
)
1537 *hwndAct
= (WXHWND
)lParam
;
1538 *hwndDeact
= (WXHWND
)wParam
;
1541 } // anonymous namespace
1543 #endif // wxUSE_MDI && !defined(__WXUNIVERSAL__)