X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4f3b37fd0e60dcdf61c951e3c220fe267e8257f8..364f3b070071ee73e417a3770342d779774288e8:/src/msw/mdi.cpp?ds=sidebyside diff --git a/src/msw/mdi.cpp b/src/msw/mdi.cpp index 611dbbe4ae..dd19650db6 100644 --- a/src/msw/mdi.cpp +++ b/src/msw/mdi.cpp @@ -2,11 +2,12 @@ // Name: src/msw/mdi.cpp // Purpose: MDI classes for wxMSW // Author: Julian Smart -// Modified by: +// Modified by: Vadim Zeitlin on 2008-11-04 to use the base classes // Created: 04/01/98 // RCS-ID: $Id$ -// Copyright: (c) Julian Smart and Markus Holzem -// Licence: wxWindows license +// Copyright: (c) 1998 Julian Smart +// (c) 2008-2009 Vadim Zeitlin +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// // =========================================================================== @@ -17,10 +18,6 @@ // headers // --------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "mdi.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -28,69 +25,49 @@ #pragma hdrstop #endif +#if wxUSE_MDI && !defined(__WXUNIVERSAL__) + +#include "wx/mdi.h" + #ifndef WX_PRECOMP - #include "wx/setup.h" #include "wx/frame.h" #include "wx/menu.h" #include "wx/app.h" #include "wx/utils.h" #include "wx/dialog.h" - #if wxUSE_STATUSBAR - #include "wx/statusbr.h" - #endif + #include "wx/statusbr.h" #include "wx/settings.h" #include "wx/intl.h" #include "wx/log.h" + #include "wx/toolbar.h" #endif -#include "wx/mdi.h" +#include "wx/stockitem.h" #include "wx/msw/private.h" -#if wxUSE_STATUSBAR && wxUSE_NATIVE_STATUSBAR - #include "wx/msw/statbr95.h" -#endif - -#if wxUSE_TOOLBAR - #include "wx/toolbar.h" -#endif // wxUSE_TOOLBAR - #include // --------------------------------------------------------------------------- // global variables // --------------------------------------------------------------------------- -extern wxWindowList wxModelessWindows; // from dialog.cpp extern wxMenu *wxCurrentPopupMenu; -extern const wxChar *wxMDIFrameClassName; // from app.cpp -extern const wxChar *wxMDIChildFrameClassName; -extern const wxChar *wxMDIChildFrameClassNameNoRedraw; - -extern void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win); extern void wxRemoveHandleAssociation(wxWindow *win); -static HWND invalidHandle = 0; +namespace +{ // --------------------------------------------------------------------------- // constants // --------------------------------------------------------------------------- -static const int IDM_WINDOWTILE = 4001; -static const int IDM_WINDOWTILEHOR = 4001; -static const int IDM_WINDOWCASCADE = 4002; -static const int IDM_WINDOWICONS = 4003; -static const int IDM_WINDOWNEXT = 4004; -static const int IDM_WINDOWTILEVERT = 4005; -static const int IDM_WINDOWPREV = 4006; - // This range gives a maximum of 500 MDI children. Should be enough :-) -static const int wxFIRST_MDI_CHILD = 4100; -static const int wxLAST_MDI_CHILD = 4600; +const int wxFIRST_MDI_CHILD = 4100; +const int wxLAST_MDI_CHILD = 4600; -// Status border dimensions -static const int wxTHICK_LINE_BORDER = 3; -static const int wxTHICK_LINE_WIDTH = 1; +// The MDI "Window" menu label +const char *WINDOW_MENU_LABEL = gettext_noop("&Window"); // --------------------------------------------------------------------------- // private functions @@ -98,32 +75,31 @@ static const int wxTHICK_LINE_WIDTH = 1; // set the MDI menus (by sending the WM_MDISETMENU message) and update the menu // of the parent of win (which is supposed to be the MDI client window) -static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow); +void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow); // insert the window menu (subMenu) into menu just before "Help" submenu or at // the very end if not found -static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu); +void MDIInsertWindowMenu(wxWindow *win, WXHMENU hMenu, HMENU subMenu); // Remove the window menu -static void RemoveWindowMenu(wxWindow *win, WXHMENU menu); - -// is this an id of an MDI child? -inline bool IsMdiCommandId(int id) -{ - return (id >= wxFIRST_MDI_CHILD) && (id <= wxLAST_MDI_CHILD); -} +void MDIRemoveWindowMenu(wxWindow *win, WXHMENU hMenu); // unpack the parameters of WM_MDIACTIVATE message -static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam, - WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact); +void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam, + WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact); // return the HMENU of the MDI menu -static inline HMENU GetMDIWindowMenu(wxMDIParentFrame *frame) +// +// this function works correctly even when we don't have a window menu and just +// returns 0 then +inline HMENU GetMDIWindowMenu(wxMDIParentFrame *frame) { wxMenu *menu = frame->GetWindowMenu(); return menu ? GetHmenuOf(menu) : 0; } +} // anonymous namespace + // =========================================================================== // implementation // =========================================================================== @@ -138,7 +114,15 @@ IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow) BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame) EVT_SIZE(wxMDIParentFrame::OnSize) + EVT_ICONIZE(wxMDIParentFrame::OnIconized) EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged) + +#if wxUSE_MENUS + EVT_MENU_RANGE(wxFIRST_MDI_CHILD, wxLAST_MDI_CHILD, + wxMDIParentFrame::OnMDIChild) + EVT_MENU_RANGE(wxID_MDI_WINDOW_FIRST, wxID_MDI_WINDOW_LAST, + wxMDIParentFrame::OnMDICommand) +#endif // wxUSE_MENUS END_EVENT_TABLE() BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame) @@ -154,12 +138,12 @@ END_EVENT_TABLE() // the children // =========================================================================== -wxMDIParentFrame::wxMDIParentFrame() +void wxMDIParentFrame::Init() { - m_clientWindow = NULL; - m_currentChild = NULL; - m_windowMenu = (wxMenu*) NULL; - m_parentFrameActive = TRUE; +#if wxUSE_MENUS && wxUSE_ACCEL + // the default menu doesn't have any accelerators (even if we have it) + m_accelWindowMenu = NULL; +#endif // wxUSE_MENUS && wxUSE_ACCEL } bool wxMDIParentFrame::Create(wxWindow *parent, @@ -170,30 +154,22 @@ bool wxMDIParentFrame::Create(wxWindow *parent, long style, const wxString& name) { - m_clientWindow = NULL; - m_currentChild = NULL; - // this style can be used to prevent a window from having the standard MDI // "Window" menu - if ( style & wxFRAME_NO_WINDOW_MENU ) - { - m_windowMenu = (wxMenu *)NULL; - } - else // normal case: we have the window menu, so construct it + if ( !(style & wxFRAME_NO_WINDOW_MENU) ) { + // normal case: we have the window menu, so construct it m_windowMenu = new wxMenu; - m_windowMenu->Append(IDM_WINDOWCASCADE, _("&Cascade")); - m_windowMenu->Append(IDM_WINDOWTILEHOR, _("Tile &Horizontally")); - m_windowMenu->Append(IDM_WINDOWTILEVERT, _("Tile &Vertically")); + m_windowMenu->Append(wxID_MDI_WINDOW_CASCADE, _("&Cascade")); + m_windowMenu->Append(wxID_MDI_WINDOW_TILE_HORZ, _("Tile &Horizontally")); + m_windowMenu->Append(wxID_MDI_WINDOW_TILE_VERT, _("Tile &Vertically")); m_windowMenu->AppendSeparator(); - m_windowMenu->Append(IDM_WINDOWICONS, _("&Arrange Icons")); - m_windowMenu->Append(IDM_WINDOWNEXT, _("&Next")); - m_windowMenu->Append(IDM_WINDOWPREV, _("&Previous")); + m_windowMenu->Append(wxID_MDI_WINDOW_ARRANGE_ICONS, _("&Arrange Icons")); + m_windowMenu->Append(wxID_MDI_WINDOW_NEXT, _("&Next")); + m_windowMenu->Append(wxID_MDI_WINDOW_PREV, _("&Previous")); } - m_parentFrameActive = TRUE; - if (!parent) wxTopLevelWindows.Append(this); @@ -203,52 +179,53 @@ bool wxMDIParentFrame::Create(wxWindow *parent, if ( parent ) parent->AddChild(this); - if ( id > -1 ) + if ( id != wxID_ANY ) m_windowId = id; else m_windowId = NewControlId(); WXDWORD exflags; WXDWORD msflags = MSWGetCreateWindowFlags(&exflags); + msflags &= ~WS_VSCROLL; + msflags &= ~WS_HSCROLL; - if ( !wxWindow::MSWCreate(wxMDIFrameClassName, - title, + if ( !wxWindow::MSWCreate(wxApp::GetRegisteredClassName(wxT("wxMDIFrame")), + title.wx_str(), pos, size, msflags, exflags) ) { - return FALSE; + return false; } - wxModelessWindows.Append(this); + SetOwnBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE)); // unlike (almost?) all other windows, frames are created hidden - m_isShown = FALSE; + m_isShown = false; - return TRUE; + return true; } wxMDIParentFrame::~wxMDIParentFrame() { - DestroyChildren(); - - // already delete by DestroyChildren() + // see comment in ~wxMDIChildFrame +#if wxUSE_TOOLBAR m_frameToolBar = NULL; +#endif +#if wxUSE_STATUSBAR m_frameStatusBar = NULL; +#endif // wxUSE_STATUSBAR - if (m_windowMenu) - { - delete m_windowMenu; - m_windowMenu = (wxMenu*) NULL; - } +#if wxUSE_MENUS && wxUSE_ACCEL + delete m_accelWindowMenu; +#endif // wxUSE_MENUS && wxUSE_ACCEL + + DestroyChildren(); // the MDI frame menubar is not automatically deleted by Windows unlike for // the normal frames if ( m_hMenu ) - { ::DestroyMenu((HMENU)m_hMenu); - m_hMenu = (WXHMENU)NULL; - } if ( m_clientWindow ) { @@ -260,43 +237,221 @@ wxMDIParentFrame::~wxMDIParentFrame() } } +// ---------------------------------------------------------------------------- +// wxMDIParentFrame child management +// ---------------------------------------------------------------------------- + +wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const +{ + HWND hWnd = (HWND)::SendMessage(GetWinHwnd(GetClientWindow()), + WM_MDIGETACTIVE, 0, 0L); + if ( !hWnd ) + return NULL; + + return static_cast(wxFindWinFromHandle(hWnd)); +} + +int wxMDIParentFrame::GetChildFramesCount() const +{ + int count = 0; + for ( wxWindowList::const_iterator i = GetChildren().begin(); + i != GetChildren().end(); + ++i ) + { + if ( wxDynamicCast(*i, wxMDIChildFrame) ) + count++; + } + + return count; +} + +#if wxUSE_MENUS + +void wxMDIParentFrame::AddMDIChild(wxMDIChildFrame * WXUNUSED(child)) +{ + switch ( GetChildFramesCount() ) + { + case 1: + // first MDI child was just added, we need to insert the window + // menu now if we have it + AddWindowMenu(); + + // and disable the items which can't be used until we have more + // than one child + UpdateWindowMenu(false); + break; + + case 2: + // second MDI child was added, enable the menu items which were + // disabled because they didn't make sense for a single window + UpdateWindowMenu(true); + break; + } +} + +void wxMDIParentFrame::RemoveMDIChild(wxMDIChildFrame * WXUNUSED(child)) +{ + switch ( GetChildFramesCount() ) + { + case 1: + // last MDI child is being removed, remove the now unnecessary + // window menu too + RemoveWindowMenu(); + + // there is no need to call UpdateWindowMenu(true) here so this is + // not quite symmetric to AddMDIChild() above + break; + + case 2: + // only one MDI child is going to remain, disable the menu commands + // which don't make sense for a single child window + UpdateWindowMenu(false); + break; + } +} + +// ---------------------------------------------------------------------------- +// wxMDIParentFrame window menu handling +// ---------------------------------------------------------------------------- + +void wxMDIParentFrame::AddWindowMenu() +{ + if ( m_windowMenu ) + { + // For correct handling of the events from this menu we also must + // attach it to the menu bar. + m_windowMenu->Attach(GetMenuBar()); + + MDIInsertWindowMenu(GetClientWindow(), m_hMenu, GetMDIWindowMenu(this)); + } +} + +void wxMDIParentFrame::RemoveWindowMenu() +{ + if ( m_windowMenu ) + { + MDIRemoveWindowMenu(GetClientWindow(), m_hMenu); + + m_windowMenu->Detach(); + } +} + +void wxMDIParentFrame::UpdateWindowMenu(bool enable) +{ + if ( m_windowMenu ) + { + m_windowMenu->Enable(wxID_MDI_WINDOW_NEXT, enable); + m_windowMenu->Enable(wxID_MDI_WINDOW_PREV, enable); + } +} + #if wxUSE_MENUS_NATIVE void wxMDIParentFrame::InternalSetMenuBar() { - m_parentFrameActive = TRUE; - - InsertWindowMenu(GetClientWindow(), m_hMenu, GetMDIWindowMenu(this)); + if ( GetActiveChild() ) + { + AddWindowMenu(); + } + else // we don't have any MDI children yet + { + // wait until we do to add the window menu but do set the main menu for + // now (this is done by AddWindowMenu() as a side effect) + MDISetMenu(GetClientWindow(), (HMENU)m_hMenu, NULL); + } } #endif // wxUSE_MENUS_NATIVE void wxMDIParentFrame::SetWindowMenu(wxMenu* menu) { - if (m_windowMenu) + if ( menu != m_windowMenu ) { - if (GetMenuBar()) - { - // Remove old window menu - RemoveWindowMenu(GetClientWindow(), m_hMenu); - } + // notice that Remove/AddWindowMenu() are safe to call even when + // m_windowMenu is NULL + RemoveWindowMenu(); delete m_windowMenu; - m_windowMenu = (wxMenu*) NULL; + + m_windowMenu = menu; + + AddWindowMenu(); } - if (menu) +#if wxUSE_ACCEL + wxDELETE(m_accelWindowMenu); + + if ( menu && menu->HasAccels() ) + m_accelWindowMenu = menu->CreateAccelTable(); +#endif // wxUSE_ACCEL +} + +// ---------------------------------------------------------------------------- +// wxMDIParentFrame other menu-related stuff +// ---------------------------------------------------------------------------- + +void wxMDIParentFrame::DoMenuUpdates(wxMenu* menu) +{ + wxMDIChildFrame *child = GetActiveChild(); + if ( child ) { - m_windowMenu = menu; - if (GetMenuBar()) + wxEvtHandler* source = child->GetEventHandler(); + wxMenuBar* bar = child->GetMenuBar(); + + if (menu) { - InsertWindowMenu(GetClientWindow(), m_hMenu, - GetHmenuOf(m_windowMenu)); + menu->UpdateUI(source); } + else + { + if ( bar != NULL ) + { + int nCount = bar->GetMenuCount(); + for (int n = 0; n < nCount; n++) + bar->GetMenu(n)->UpdateUI(source); + } + } + } + else + { + wxFrameBase::DoMenuUpdates(menu); + } +} + +wxMenuItem *wxMDIParentFrame::FindItemInMenuBar(int menuId) const +{ + wxMenuItem *item = wxFrame::FindItemInMenuBar(menuId); + if ( !item && GetActiveChild() ) + { + item = GetActiveChild()->FindItemInMenuBar(menuId); + } + + if ( !item && m_windowMenu ) + item = m_windowMenu->FindItem(menuId); + + return item; +} + +WXHMENU wxMDIParentFrame::MSWGetActiveMenu() const +{ + wxMDIChildFrame * const child = GetActiveChild(); + if ( child ) + { + const WXHMENU hmenu = child->MSWGetActiveMenu(); + if ( hmenu ) + return hmenu; } + + return wxFrame::MSWGetActiveMenu(); } -void wxMDIParentFrame::OnSize(wxSizeEvent&) +#endif // wxUSE_MENUS + +// ---------------------------------------------------------------------------- +// wxMDIParentFrame event handling +// ---------------------------------------------------------------------------- + +void wxMDIParentFrame::UpdateClientSize() { if ( GetClientWindow() ) { @@ -307,22 +462,19 @@ void wxMDIParentFrame::OnSize(wxSizeEvent&) } } -// Returns the active MDI child window -wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const +void wxMDIParentFrame::OnSize(wxSizeEvent& WXUNUSED(event)) { - HWND hWnd = (HWND)::SendMessage(GetWinHwnd(GetClientWindow()), - WM_MDIGETACTIVE, 0, 0L); - if ( hWnd == 0 ) - return NULL; - else - return (wxMDIChildFrame *)wxFindWinFromHandle((WXHWND) hWnd); + UpdateClientSize(); + + // do not call event.Skip() here, it somehow messes up MDI client window } -// Create the client window class (don't Create the window, just return a new -// class) -wxMDIClientWindow *wxMDIParentFrame::OnCreateClient() +void wxMDIParentFrame::OnIconized(wxIconizeEvent& event) { - return new wxMDIClientWindow; + event.Skip(); + + if ( !event.IsIconized() ) + UpdateClientSize(); } // Responds to colour changes, and passes event on to children. @@ -339,8 +491,8 @@ void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event) WXHICON wxMDIParentFrame::GetDefaultIcon() const { - return (WXHICON)(wxSTD_MDIPARENTFRAME_ICON ? wxSTD_MDIPARENTFRAME_ICON - : wxDEFAULT_MDIPARENTFRAME_ICON); + // we don't have any standard icons (any more) + return (WXHICON)0; } // --------------------------------------------------------------------------- @@ -352,10 +504,14 @@ void wxMDIParentFrame::Cascade() ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0); } -// TODO: add a direction argument (hor/vert) -void wxMDIParentFrame::Tile() +void wxMDIParentFrame::Tile(wxOrientation orient) { - ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE, MDITILE_HORIZONTAL, 0); + wxASSERT_MSG( orient == wxHORIZONTAL || orient == wxVERTICAL, + wxT("invalid orientation value") ); + + ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE, + orient == wxHORIZONTAL ? MDITILE_HORIZONTAL + : MDITILE_VERTICAL, 0); } void wxMDIParentFrame::ArrangeIcons() @@ -377,12 +533,12 @@ void wxMDIParentFrame::ActivatePrevious() // the MDI parent frame window proc // --------------------------------------------------------------------------- -long wxMDIParentFrame::MSWWindowProc(WXUINT message, - WXWPARAM wParam, - WXLPARAM lParam) +WXLRESULT wxMDIParentFrame::MSWWindowProc(WXUINT message, + WXWPARAM wParam, + WXLPARAM lParam) { - long rc = 0; - bool processed = FALSE; + WXLRESULT rc = 0; + bool processed = false; switch ( message ) { @@ -397,22 +553,22 @@ long wxMDIParentFrame::MSWWindowProc(WXUINT message, break; case WM_COMMAND: + // system messages such as SC_CLOSE are sent as WM_COMMANDs to the + // parent MDI frame and we must let the DefFrameProc() have them + // for these commands to work (without it, closing the maximized + // MDI children doesn't work, for example) { WXWORD id, cmd; WXHWND hwnd; UnpackCommand(wParam, lParam, &id, &hwnd, &cmd); - (void)HandleCommand(id, cmd, hwnd); - - // even if the frame didn't process it, there is no need to try it - // once again (i.e. call wxFrame::HandleCommand()) - we just dud it, - // so pretend we processed the message anyhow - processed = TRUE; + if ( cmd == 0 /* menu */ && + id >= SC_SIZE /* first system menu command */ ) + { + MSWDefWindowProc(message, wParam, lParam); + processed = true; + } } - - // always pass this message DefFrameProc(), otherwise MDI menu - // commands (and sys commands - more surprizingly!) won't work - MSWDefWindowProc(message, wParam, lParam); break; case WM_CREATE: @@ -425,38 +581,7 @@ long wxMDIParentFrame::MSWWindowProc(WXUINT message, rc = -1; } - processed = TRUE; - break; - - case WM_ERASEBKGND: - processed = TRUE; - - // we erase background ourselves - rc = TRUE; - break; - - case WM_MENUSELECT: - { - WXWORD item, flags; - WXHMENU hmenu; - UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu); - - if ( m_parentFrameActive ) - { - processed = HandleMenuSelect(item, flags, hmenu); - } - else if (m_currentChild) - { - processed = m_currentChild-> - HandleMenuSelect(item, flags, hmenu); - } - } - break; - - case WM_SIZE: - // as we don't (usually) resize the MDI client to exactly fit the - // client area (we put it below the toolbar, above statusbar &c), - // we should not pass this one to DefFrameProc + processed = true; break; } @@ -468,130 +593,116 @@ long wxMDIParentFrame::MSWWindowProc(WXUINT message, bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate) { - bool processed = FALSE; + bool processed = false; if ( wxWindow::HandleActivate(state, minimized, activate) ) { // already processed - processed = TRUE; + processed = true; } // If this window is an MDI parent, we must also send an OnActivate message // to the current child. - if ( (m_currentChild != NULL) && + if ( GetActiveChild() && ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) ) { - wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_currentChild->GetId()); - event.SetEventObject( m_currentChild ); - if ( m_currentChild->GetEventHandler()->ProcessEvent(event) ) - processed = TRUE; + wxActivateEvent event(wxEVT_ACTIVATE, true, GetActiveChild()->GetId()); + event.SetEventObject( GetActiveChild() ); + if ( GetActiveChild()->HandleWindowEvent(event) ) + processed = true; } return processed; } -bool wxMDIParentFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd) +#if wxUSE_MENUS + +void wxMDIParentFrame::OnMDIChild(wxCommandEvent& event) { - // In case it's e.g. a toolbar. - if ( hwnd ) + wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); + while ( node ) { - wxWindow *win = wxFindWinFromHandle(hwnd); - if ( win ) - return win->MSWCommand(cmd, id); + wxWindow *child = node->GetData(); + if ( child->GetHWND() ) + { + int childId = wxGetWindowId(child->GetHWND()); + if ( childId == event.GetId() ) + { + ::SendMessage( GetWinHwnd(GetClientWindow()), + WM_MDIACTIVATE, + (WPARAM)child->GetHWND(), 0); + return; + } + } + + node = node->GetNext(); } - // is it one of standard MDI commands? + wxFAIL_MSG( "unknown MDI child selected?" ); +} + +void wxMDIParentFrame::OnMDICommand(wxCommandEvent& event) +{ WXWPARAM wParam = 0; WXLPARAM lParam = 0; int msg; - switch ( id ) + switch ( event.GetId() ) { - case IDM_WINDOWCASCADE: + case wxID_MDI_WINDOW_CASCADE: msg = WM_MDICASCADE; wParam = MDITILE_SKIPDISABLED; break; - case IDM_WINDOWTILEHOR: + case wxID_MDI_WINDOW_TILE_HORZ: wParam |= MDITILE_HORIZONTAL; // fall through - case IDM_WINDOWTILEVERT: + case wxID_MDI_WINDOW_TILE_VERT: if ( !wParam ) wParam = MDITILE_VERTICAL; msg = WM_MDITILE; wParam |= MDITILE_SKIPDISABLED; break; - case IDM_WINDOWICONS: + case wxID_MDI_WINDOW_ARRANGE_ICONS: msg = WM_MDIICONARRANGE; break; - case IDM_WINDOWNEXT: + case wxID_MDI_WINDOW_NEXT: msg = WM_MDINEXT; lParam = 0; // next child break; - case IDM_WINDOWPREV: + case wxID_MDI_WINDOW_PREV: msg = WM_MDINEXT; lParam = 1; // previous child break; default: - msg = 0; + wxFAIL_MSG( "unknown MDI command" ); + return; } - if ( msg ) - { - ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, lParam); - - return TRUE; - } + ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, lParam); +} - // FIXME VZ: what does this test do?? - if (id >= 0xF000) - { - return FALSE; // Get WndProc to call default proc - } +#endif // wxUSE_MENUS - if ( IsMdiCommandId(id) ) - { - wxWindowList::Node* node = GetChildren().GetFirst(); - while ( node ) - { - wxWindow* child = node->GetData(); - if ( child->GetHWND() ) - { - long childId = wxGetWindowId(child->GetHWND()); - if (childId == (long)id) - { - ::SendMessage( GetWinHwnd(GetClientWindow()), - WM_MDIACTIVATE, - (WPARAM)child->GetHWND(), 0); - return TRUE; - } - } - node = node->GetNext(); - } - } - else if ( m_parentFrameActive ) - { - return ProcessCommand(id); - } - else if ( m_currentChild ) - { - return m_currentChild->HandleCommand(id, cmd, hwnd); - } - else +bool wxMDIParentFrame::TryBefore(wxEvent& event) +{ + // menu (and toolbar) events should be sent to the active child frame + // first, if any + if ( event.GetEventType() == wxEVT_COMMAND_MENU_SELECTED ) { - // this shouldn't happen because it means that our messages are being - // lost (they're not sent to the parent frame nor to the children) - wxFAIL_MSG(wxT("MDI parent frame is not active, yet there is no active MDI child?")); + wxMDIChildFrame * const child = GetActiveChild(); + if ( child && child->ProcessWindowEventLocally(event) ) + return true; } - return FALSE; + return wxMDIParentFrameBase::TryBefore(event); } -long wxMDIParentFrame::MSWDefWindowProc(WXUINT message, +WXLRESULT wxMDIParentFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) { @@ -609,26 +720,35 @@ bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg) MSG *pMsg = (MSG *)msg; // first let the current child get it - if ( m_currentChild && m_currentChild->GetHWND() && - m_currentChild->MSWTranslateMessage(msg) ) + wxMDIChildFrame * const child = GetActiveChild(); + if ( child && child->MSWTranslateMessage(msg) ) { - return TRUE; + return true; } - // then try out accel table (will also check the menu accels) + // then try out accelerator table (will also check the accelerators for the + // normal menu items) if ( wxFrame::MSWTranslateMessage(msg) ) { - return TRUE; + return true; } - // finally, check for MDI specific built in accel keys +#if wxUSE_MENUS && wxUSE_ACCEL + // but it doesn't check for the (custom) accelerators of the window menu + // items as it's not part of the menu bar as it's handled by Windows itself + // so we need to do this explicitly + if ( m_accelWindowMenu && m_accelWindowMenu->Translate(this, msg) ) + return true; +#endif // wxUSE_MENUS && wxUSE_ACCEL + + // finally, check for MDI specific built-in accelerators if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN ) { if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg)) - return TRUE; + return true; } - return FALSE; + return false; } // =========================================================================== @@ -637,7 +757,8 @@ bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg) void wxMDIChildFrame::Init() { - m_needsResize = TRUE; + m_needsResize = true; + m_needsInitialShow = true; } bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, @@ -648,13 +769,14 @@ bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, long style, const wxString& name) { + m_mdiParent = parent; + SetName(name); - wxWindowBase::Show(TRUE); // MDI child frame starts off shown - if ( id > -1 ) + if ( id != wxID_ANY ) m_windowId = id; else - m_windowId = (int)NewControlId(); + m_windowId = NewControlId(); if ( parent ) { @@ -668,37 +790,40 @@ bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, MDICREATESTRUCT mcs; - mcs.szClass = style & wxNO_FULL_REPAINT_ON_RESIZE - ? wxMDIChildFrameClassNameNoRedraw - : wxMDIChildFrameClassName; - mcs.szTitle = title; + wxString className = + wxApp::GetRegisteredClassName(wxT("wxMDIChildFrame"), COLOR_WINDOW); + if ( !(style & wxFULL_REPAINT_ON_RESIZE) ) + className += wxApp::GetNoRedrawClassSuffix(); + + mcs.szClass = className.wx_str(); + mcs.szTitle = title.wx_str(); mcs.hOwner = wxGetInstance(); - if (x > -1) + if (x != wxDefaultCoord) mcs.x = x; else mcs.x = CW_USEDEFAULT; - if (y > -1) + if (y != wxDefaultCoord) mcs.y = y; else mcs.y = CW_USEDEFAULT; - if (width > -1) + if (width != wxDefaultCoord) mcs.cx = width; else mcs.cx = CW_USEDEFAULT; - if (height > -1) + if (height != wxDefaultCoord) mcs.cy = height; else mcs.cy = CW_USEDEFAULT; - DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN | WS_THICKFRAME | WS_VISIBLE ; + DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN; if (style & wxMINIMIZE_BOX) msflags |= WS_MINIMIZEBOX; if (style & wxMAXIMIZE_BOX) msflags |= WS_MAXIMIZEBOX; - if (style & wxTHICK_FRAME) + if (style & wxRESIZE_BORDER) msflags |= WS_THICKFRAME; if (style & wxSYSTEM_MENU) msflags |= WS_SYSMENU; @@ -716,30 +841,76 @@ bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, wxWindowCreationHook hook(this); m_hWnd = (WXHWND)::SendMessage(GetWinHwnd(parent->GetClientWindow()), - WM_MDICREATE, 0, (LONG)(LPSTR)&mcs); + WM_MDICREATE, 0, (LPARAM)&mcs); - wxAssociateWinWithHandle((HWND) GetHWND(), this); + if ( !m_hWnd ) + { + wxLogLastError(wxT("WM_MDICREATE")); + return false; + } + + SubclassWin(m_hWnd); - wxModelessWindows.Append(this); + parent->AddMDIChild(this); - return TRUE; + return true; } wxMDIChildFrame::~wxMDIChildFrame() { - DestroyChildren(); + // if we hadn't been created, there is nothing to destroy + if ( !m_hWnd ) + return; - // already deleted by DestroyChildren() + GetMDIParent()->RemoveMDIChild(this); + + // will be destroyed by DestroyChildren() but reset them before calling it + // to avoid using dangling pointers if a callback comes in the meanwhile +#if wxUSE_TOOLBAR m_frameToolBar = NULL; +#endif +#if wxUSE_STATUSBAR m_frameStatusBar = NULL; +#endif // wxUSE_STATUSBAR - RemoveWindowMenu(NULL, m_hMenu); + DestroyChildren(); + + MDIRemoveWindowMenu(NULL, m_hMenu); MSWDestroyWindow(); } +bool wxMDIChildFrame::Show(bool show) +{ + m_needsInitialShow = false; + + if (!wxFrame::Show(show)) + return false; + + // KH: Without this call, new MDI children do not become active. + // This was added here after the same BringWindowToTop call was + // removed from wxTopLevelWindow::Show (November 2005) + if ( show ) + ::BringWindowToTop(GetHwnd()); + + // we need to refresh the MDI frame window menu to include (or exclude if + // we've been hidden) this frame + wxMDIParentFrame * const parent = GetMDIParent(); + MDISetMenu(parent->GetClientWindow(), NULL, NULL); + + return true; +} + +void +wxMDIChildFrame::DoSetSize(int x, int y, int width, int height, int sizeFlags) +{ + // we need to disable client area origin adjustments used for the child + // windows for the frame itself + wxMDIChildFrameBase::DoSetSize(x, y, width, height, sizeFlags); +} + // Set the client size (i.e. leave the calculation of borders etc. -// to wxWindows) +// to wxWidgets) void wxMDIChildFrame::DoSetClientSize(int width, int height) { HWND hWnd = GetHwnd(); @@ -756,12 +927,14 @@ void wxMDIChildFrame::DoSetClientSize(int width, int height) int actual_width = rect2.right - rect2.left - rect.right + width; int actual_height = rect2.bottom - rect2.top - rect.bottom + height; +#if wxUSE_STATUSBAR if (GetStatusBar() && GetStatusBar()->IsShown()) { int sx, sy; GetStatusBar()->GetSize(&sx, &sy); actual_height += sy; } +#endif // wxUSE_STATUSBAR POINT point; point.x = rect2.left; @@ -769,16 +942,32 @@ void wxMDIChildFrame::DoSetClientSize(int width, int height) // If there's an MDI parent, must subtract the parent's top left corner // since MoveWindow moves relative to the parent - wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent(); - ::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &point); + wxMDIParentFrame * const mdiParent = GetMDIParent(); + ::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point); - MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)TRUE); + MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)true); - wxSizeEvent event(wxSize(width, height), m_windowId); + wxSize size(width, height); + wxSizeEvent event(size, m_windowId); event.SetEventObject( this ); - GetEventHandler()->ProcessEvent(event); + HandleWindowEvent(event); +} + +// Unlike other wxTopLevelWindowBase, the mdi child's "GetPosition" is not the +// same as its GetScreenPosition +void wxMDIChildFrame::DoGetScreenPosition(int *x, int *y) const +{ + HWND hWnd = GetHwnd(); + + RECT rect; + ::GetWindowRect(hWnd, &rect); + if (x) + *x = rect.left; + if (y) + *y = rect.top; } + void wxMDIChildFrame::DoGetPosition(int *x, int *y) const { RECT rect; @@ -789,27 +978,33 @@ void wxMDIChildFrame::DoGetPosition(int *x, int *y) const // Since we now have the absolute screen coords, // if there's a parent we must subtract its top left corner - wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent(); - ::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &point); + wxMDIParentFrame * const mdiParent = GetMDIParent(); + ::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point); - *x = point.x; - *y = point.y; + if (x) + *x = point.x; + if (y) + *y = point.y; } void wxMDIChildFrame::InternalSetMenuBar() { - wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); + wxMDIParentFrame * const parent = GetMDIParent(); - InsertWindowMenu(parent->GetClientWindow(), + MDIInsertWindowMenu(parent->GetClientWindow(), m_hMenu, GetMDIWindowMenu(parent)); +} - parent->m_parentFrameActive = FALSE; +void wxMDIChildFrame::DetachMenuBar() +{ + MDIRemoveWindowMenu(NULL, m_hMenu); + wxFrame::DetachMenuBar(); } WXHICON wxMDIChildFrame::GetDefaultIcon() const { - return (WXHICON)(wxSTD_MDICHILDFRAME_ICON ? wxSTD_MDICHILDFRAME_ICON - : wxDEFAULT_MDICHILDFRAME_ICON); + // we don't have any standard icons (any more) + return (WXHICON)0; } // --------------------------------------------------------------------------- @@ -818,7 +1013,7 @@ WXHICON wxMDIChildFrame::GetDefaultIcon() const void wxMDIChildFrame::Maximize(bool maximize) { - wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); + wxMDIParentFrame * const parent = GetMDIParent(); if ( parent && parent->GetClientWindow() ) { ::SendMessage(GetWinHwnd(parent->GetClientWindow()), @@ -829,7 +1024,7 @@ void wxMDIChildFrame::Maximize(bool maximize) void wxMDIChildFrame::Restore() { - wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); + wxMDIParentFrame * const parent = GetMDIParent(); if ( parent && parent->GetClientWindow() ) { ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE, @@ -839,7 +1034,7 @@ void wxMDIChildFrame::Restore() void wxMDIChildFrame::Activate() { - wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); + wxMDIParentFrame * const parent = GetMDIParent(); if ( parent && parent->GetClientWindow() ) { ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE, @@ -851,26 +1046,15 @@ void wxMDIChildFrame::Activate() // MDI window proc and message handlers // --------------------------------------------------------------------------- -long wxMDIChildFrame::MSWWindowProc(WXUINT message, - WXWPARAM wParam, - WXLPARAM lParam) +WXLRESULT wxMDIChildFrame::MSWWindowProc(WXUINT message, + WXWPARAM wParam, + WXLPARAM lParam) { - long rc = 0; - bool processed = FALSE; + WXLRESULT rc = 0; + bool processed = false; switch ( message ) { - case WM_COMMAND: - { - WORD id, cmd; - WXHWND hwnd; - UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam, - &id, &hwnd, &cmd); - - processed = HandleCommand(id, cmd, (WXHWND)hwnd); - } - break; - case WM_GETMINMAXINFO: processed = HandleGetMinMaxInfo((MINMAXINFO *)lParam); break; @@ -897,11 +1081,6 @@ long wxMDIChildFrame::MSWWindowProc(WXUINT message, MSWDefWindowProc(message, wParam, lParam); break; - case WM_SYSCOMMAND: - // DefMDIChildProc handles SC_{NEXT/PREV}WINDOW here, so pass it - // the message (the base class version does not) - return MSWDefWindowProc(message, wParam, lParam); - case WM_WINDOWPOSCHANGING: processed = HandleWindowPosChanging((LPWINDOWPOS)lParam); break; @@ -913,103 +1092,64 @@ long wxMDIChildFrame::MSWWindowProc(WXUINT message, return rc; } -bool wxMDIChildFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd) -{ - // In case it's e.g. a toolbar. - if ( hwnd ) - { - wxWindow *win = wxFindWinFromHandle(hwnd); - if (win) - return win->MSWCommand(cmd, id); - } - - if (wxCurrentPopupMenu) - { - wxMenu *popupMenu = wxCurrentPopupMenu; - wxCurrentPopupMenu = NULL; - if (popupMenu->MSWCommand(cmd, id)) - return TRUE; - } - - bool processed; - if (GetMenuBar() && GetMenuBar()->FindItem(id)) - { - processed = ProcessCommand(id); - } - else - { - processed = FALSE; - } - - return processed; -} - bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate), WXHWND hwndAct, WXHWND hwndDeact) { - wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); + wxMDIParentFrame * const parent = GetMDIParent(); - HMENU menuToSet = 0; + WXHMENU hMenuToSet = 0; bool activated; if ( m_hWnd == hwndAct ) { - activated = TRUE; - parent->m_currentChild = this; + activated = true; + parent->SetActiveChild(this); - HMENU child_menu = (HMENU)GetWinMenu(); - if ( child_menu ) - { - parent->m_parentFrameActive = FALSE; - - menuToSet = child_menu; - } + WXHMENU hMenuChild = m_hMenu; + if ( hMenuChild ) + hMenuToSet = hMenuChild; } else if ( m_hWnd == hwndDeact ) { - wxASSERT_MSG( parent->m_currentChild == this, + wxASSERT_MSG( parent->GetActiveChild() == this, wxT("can't deactivate MDI child which wasn't active!") ); - activated = FALSE; - parent->m_currentChild = NULL; + activated = false; + parent->SetActiveChild(NULL); - HMENU parent_menu = (HMENU)parent->GetWinMenu(); + WXHMENU hMenuParent = parent->m_hMenu; - // activate the the parent menu only when there is no other child + // activate the parent menu only when there is no other child // that has been activated - if ( parent_menu && !hwndAct ) - { - parent->m_parentFrameActive = TRUE; - - menuToSet = parent_menu; - } + if ( hMenuParent && !hwndAct ) + hMenuToSet = hMenuParent; } else { // we have nothing to do with it - return FALSE; + return false; } - if ( menuToSet ) + if ( hMenuToSet ) { MDISetMenu(parent->GetClientWindow(), - menuToSet, GetMDIWindowMenu(parent)); + (HMENU)hMenuToSet, GetMDIWindowMenu(parent)); } wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId); event.SetEventObject( this ); - ResetWindowStyle((void *)NULL); + ResetWindowStyle(NULL); - return GetEventHandler()->ProcessEvent(event); + return HandleWindowEvent(event); } bool wxMDIChildFrame::HandleWindowPosChanging(void *pos) { WINDOWPOS *lpPos = (WINDOWPOS *)pos; -#if defined(__WIN95__) + if (!(lpPos->flags & SWP_NOSIZE)) { RECT rectClient; @@ -1017,21 +1157,15 @@ bool wxMDIChildFrame::HandleWindowPosChanging(void *pos) DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE); if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE)) { - ::AdjustWindowRectEx(&rectClient, dwStyle, FALSE, dwExStyle); + ::AdjustWindowRectEx(&rectClient, dwStyle, false, dwExStyle); lpPos->x = rectClient.left; lpPos->y = rectClient.top; lpPos->cx = rectClient.right - rectClient.left; lpPos->cy = rectClient.bottom - rectClient.top; } - wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent(); - if (pFrameWnd && pFrameWnd->GetToolBar() && pFrameWnd->GetToolBar()->IsShown()) - { - pFrameWnd->GetToolBar()->Refresh(); - } } -#endif // Win95 - return FALSE; + return false; } bool wxMDIChildFrame::HandleGetMinMaxInfo(void *mmInfo) @@ -1047,28 +1181,28 @@ bool wxMDIChildFrame::HandleGetMinMaxInfo(void *mmInfo) minHeight = GetMinHeight(); // but allow GetSizeHints() to set the min size - if ( minWidth != -1 ) + if ( minWidth != wxDefaultCoord ) { info->ptMinTrackSize.x = minWidth; - processed = TRUE; + processed = true; } - if ( minHeight != -1 ) + if ( minHeight != wxDefaultCoord ) { info->ptMinTrackSize.y = minHeight; - processed = TRUE; + processed = true; } - return TRUE; + return processed; } // --------------------------------------------------------------------------- // MDI specific message translation/preprocessing // --------------------------------------------------------------------------- -long wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXUINT wParam, WXLPARAM lParam) +WXLRESULT wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) { return DefMDIChildProc(GetHwnd(), (UINT)message, (WPARAM)wParam, (LPARAM)lParam); @@ -1076,7 +1210,9 @@ long wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXUINT wParam, WXLPARAM l bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg) { - return wxFrame::MSWTranslateMessage(msg); + // we must pass the parent frame to ::TranslateAccelerator(), otherwise it + // doesn't do its job correctly for MDI child menus + return MSWDoTranslateMessage(GetMDIParent(), msg); } // --------------------------------------------------------------------------- @@ -1085,9 +1221,7 @@ bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg) void wxMDIChildFrame::MSWDestroyWindow() { - invalidHandle = GetHwnd(); - - wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); + wxMDIParentFrame * const parent = GetMDIParent(); // Must make sure this handle is invalidated (set to NULL) since all sorts // of things could happen after the child client is destroyed, but before @@ -1097,10 +1231,8 @@ void wxMDIChildFrame::MSWDestroyWindow() SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY, (WPARAM)oldHandle, 0); - if (parent->GetActiveChild() == (wxMDIChildFrame*) NULL) - ResetWindowStyle((void*) NULL); - - invalidHandle = 0; + if (parent->GetActiveChild() == NULL) + ResetWindowStyle(NULL); if (m_hMenu) { @@ -1115,10 +1247,10 @@ void wxMDIChildFrame::MSWDestroyWindow() // style when a child is maximised (a double border looks silly.) bool wxMDIChildFrame::ResetWindowStyle(void *vrect) { -#if defined(__WIN95__) RECT *rect = (RECT *)vrect; - wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent(); + wxMDIParentFrame * const pFrameWnd = GetMDIParent(); wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild(); + if (!pChild || (pChild == this)) { HWND hwndClient = GetWinHwnd(pFrameWnd->GetClientWindow()); @@ -1147,12 +1279,11 @@ bool wxMDIChildFrame::ResetWindowStyle(void *vrect) if (rect) ::GetClientRect(hwndClient, rect); - return TRUE; + return true; } } -#endif // Win95 - return FALSE; + return false; } // =========================================================================== @@ -1179,11 +1310,7 @@ bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style) if ( style & wxVSCROLL ) msStyle |= WS_VSCROLL; -#if defined(__WIN95__) DWORD exStyle = WS_EX_CLIENTEDGE; -#else - DWORD exStyle = 0; -#endif wxWindowCreationHook hook(this); m_hWnd = (WXHWND)::CreateWindowEx @@ -1201,12 +1328,12 @@ bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style) { wxLogLastError(wxT("CreateWindowEx(MDI client)")); - return FALSE; + return false; } SubclassWin(m_hWnd); - return TRUE; + return true; } // Explicitly call default scroll behaviour @@ -1233,26 +1360,30 @@ void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeF // (see OGL studio sample). So check if the position is changed and if so, // redraw the MDI child frames. - wxPoint oldPos = GetPosition(); + const wxPoint oldPos = GetPosition(); - wxWindow::DoSetSize(x, y, width, height, sizeFlags); + wxWindow::DoSetSize(x, y, width, height, sizeFlags | wxSIZE_FORCE); - wxPoint newPos = GetPosition(); + const wxPoint newPos = GetPosition(); if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y)) { if (GetParent()) { - wxNode* node = GetParent()->GetChildren().First(); + wxWindowList::compatibility_iterator node = GetParent()->GetChildren().GetFirst(); while (node) { - wxWindow* child = (wxWindow*) node->Data(); + wxWindow *child = node->GetData(); if (child->IsKindOf(CLASSINFO(wxMDIChildFrame))) { - HWND hWnd = (HWND) child->GetHWND(); - ::RedrawWindow(hWnd, NULL, NULL, RDW_FRAME|RDW_ALLCHILDREN|RDW_INVALIDATE ); + ::RedrawWindow(GetHwndOf(child), + NULL, + NULL, + RDW_FRAME | + RDW_ALLCHILDREN | + RDW_INVALIDATE); } - node = node->Next(); + node = node->GetNext(); } } } @@ -1260,13 +1391,23 @@ void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeF void wxMDIChildFrame::OnIdle(wxIdleEvent& event) { + // wxMSW prior to 2.5.3 created MDI child frames as visible, which resulted + // in flicker e.g. when the frame contained controls with non-trivial + // layout. Since 2.5.3, the frame is created hidden as all other top level + // windows. In order to maintain backward compatibility, the frame is shown + // in OnIdle, unless Show(false) was called by the programmer before. + if ( m_needsInitialShow ) + { + Show(true); + } + // MDI child frames get their WM_SIZE when they're constructed but at this // moment they don't have any children yet so all child windows will be // positioned incorrectly when they are added later - to fix this, we // generate an artificial size event here if ( m_needsResize ) { - m_needsResize = FALSE; // avoid any possibility of recursion + m_needsResize = false; // avoid any possibility of recursion SendSizeEvent(); } @@ -1275,89 +1416,105 @@ void wxMDIChildFrame::OnIdle(wxIdleEvent& event) } // --------------------------------------------------------------------------- -// non member functions +// private helper functions // --------------------------------------------------------------------------- -static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow) +namespace { - ::SendMessage(GetWinHwnd(win), WM_MDISETMENU, -#ifdef __WIN32__ - (WPARAM)hmenuFrame, (LPARAM)hmenuWindow -#else - 0, MAKELPARAM(hmenuFrame, hmenuWindow) -#endif - ); + +void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow) +{ + if ( hmenuFrame || hmenuWindow ) + { + if ( !::SendMessage(GetWinHwnd(win), + WM_MDISETMENU, + (WPARAM)hmenuFrame, + (LPARAM)hmenuWindow) ) + { + DWORD err = ::GetLastError(); + if ( err ) + { + wxLogApiError(wxT("SendMessage(WM_MDISETMENU)"), err); + } + } + } // update menu bar of the parent window wxWindow *parent = win->GetParent(); wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") ); -#ifndef __WIN16__ ::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L); -#endif ::DrawMenuBar(GetWinHwnd(parent)); } -static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu) +void MDIInsertWindowMenu(wxWindow *win, WXHMENU hMenu, HMENU menuWin) { - // Try to insert Window menu in front of Help, otherwise append it. - HMENU hmenu = (HMENU)menu; + HMENU hmenu = (HMENU)hMenu; - if (subMenu) + if ( menuWin ) { + // Try to insert Window menu in front of Help, otherwise append it. int N = GetMenuItemCount(hmenu); - bool success = FALSE; + bool inserted = false; for ( int i = 0; i < N; i++ ) { wxChar buf[256]; - int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION); - if ( chars == 0 ) + if ( !::GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) ) { wxLogLastError(wxT("GetMenuString")); continue; } - if ( wxStripMenuCodes(wxString(buf)).IsSameAs(_("Help")) ) + const wxString label = wxStripMenuCodes(buf); + if ( label == wxGetStockLabel(wxID_HELP, wxSTOCK_NOFLAGS) ) { - success = TRUE; + inserted = true; ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING, - (UINT)subMenu, _("&Window")); + (UINT_PTR)menuWin, + wxString(wxGetTranslation(WINDOW_MENU_LABEL)).wx_str()); break; } } - if ( !success ) + if ( !inserted ) { - ::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, _("&Window")); + ::AppendMenu(hmenu, MF_POPUP, + (UINT_PTR)menuWin, + wxString(wxGetTranslation(WINDOW_MENU_LABEL)).wx_str()); } } - MDISetMenu(win, hmenu, subMenu); + MDISetMenu(win, hmenu, menuWin); } -static void RemoveWindowMenu(wxWindow *win, WXHMENU menu) +void MDIRemoveWindowMenu(wxWindow *win, WXHMENU hMenu) { - HMENU hMenu = (HMENU)menu; + HMENU hmenu = (HMENU)hMenu; - if ( hMenu ) + if ( hmenu ) { wxChar buf[1024]; - int N = ::GetMenuItemCount(hMenu); + int N = ::GetMenuItemCount(hmenu); for ( int i = 0; i < N; i++ ) { - if ( !::GetMenuString(hMenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) ) + if ( !::GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) ) { - wxLogLastError(wxT("GetMenuString")); + // Ignore successful read of menu string with length 0 which + // occurs, for example, for a maximized MDI child system menu + if ( ::GetLastError() != 0 ) + { + wxLogLastError(wxT("GetMenuString")); + } continue; } - if ( wxStrcmp(buf, _("&Window")) == 0 ) + if ( wxStrcmp(buf, wxGetTranslation(WINDOW_MENU_LABEL)) == 0 ) { - if ( !::RemoveMenu(hMenu, i, MF_BYPOSITION) ) + if ( !::RemoveMenu(hmenu, i, MF_BYPOSITION) ) { wxLogLastError(wxT("RemoveMenu")); } @@ -1370,20 +1527,18 @@ static void RemoveWindowMenu(wxWindow *win, WXHMENU menu) if ( win ) { // we don't change the windows menu, but we update the main one - MDISetMenu(win, hMenu, NULL); + MDISetMenu(win, hmenu, NULL); } } -static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam, +void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam, WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact) { -#ifdef __WIN32__ - *activate = TRUE; + *activate = true; *hwndAct = (WXHWND)lParam; *hwndDeact = (WXHWND)wParam; -#else // Win16 - *activate = (WXWORD)wParam; - *hwndAct = (WXHWND)LOWORD(lParam); - *hwndDeact = (WXHWND)HIWORD(lParam); -#endif // Win32/Win16 } + +} // anonymous namespace + +#endif // wxUSE_MDI && !defined(__WXUNIVERSAL__)