X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/a23fd0e1d1329a4a258b4defb3e0b0001b700c6e..bfedf6212c58824b38bffb7ebd9ec78479769141:/src/msw/mdi.cpp diff --git a/src/msw/mdi.cpp b/src/msw/mdi.cpp index 7f933c7c84..1afd35dd6c 100644 --- a/src/msw/mdi.cpp +++ b/src/msw/mdi.cpp @@ -1,6 +1,6 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: mdi.cpp -// Purpose: MDI classes +// Name: src/msw/mdi.cpp +// Purpose: MDI classes for wxMSW // Author: Julian Smart // Modified by: // Created: 04/01/98 @@ -35,17 +35,27 @@ #include "wx/app.h" #include "wx/utils.h" #include "wx/dialog.h" - #include "wx/statusbr.h" + #if wxUSE_STATUSBAR + #include "wx/statusbr.h" + #endif #include "wx/settings.h" + #include "wx/intl.h" + #include "wx/log.h" #endif +#if wxUSE_MDI_ARCHITECTURE && !defined(__WXUNIVERSAL__) + #include "wx/mdi.h" #include "wx/msw/private.h" -#if wxUSE_NATIVE_STATUSBAR - #include +#if wxUSE_STATUSBAR && wxUSE_NATIVE_STATUSBAR + #include "wx/msw/statbr95.h" #endif +#if wxUSE_TOOLBAR + #include "wx/toolbar.h" +#endif // wxUSE_TOOLBAR + #include // --------------------------------------------------------------------------- @@ -55,20 +65,26 @@ extern wxWindowList wxModelessWindows; // from dialog.cpp extern wxMenu *wxCurrentPopupMenu; -extern char wxMDIFrameClassName[]; -extern char wxMDIChildFrameClassName[]; -extern wxWindow *wxWndHook; // from window.cpp +extern const wxChar *wxMDIFrameClassName; // from app.cpp +extern const wxChar *wxMDIChildFrameClassName; +extern const wxChar *wxMDIChildFrameClassNameNoRedraw; -extern wxList *wxWinHandleList; +extern void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win); +extern void wxRemoveHandleAssociation(wxWindow *win); + +static HWND invalidHandle = 0; // --------------------------------------------------------------------------- // 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; @@ -78,6 +94,38 @@ static const int wxLAST_MDI_CHILD = 4600; static const int wxTHICK_LINE_BORDER = 3; static const int wxTHICK_LINE_WIDTH = 1; +// --------------------------------------------------------------------------- +// private functions +// --------------------------------------------------------------------------- + +// 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); + +// 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); + +// 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); +} + +// unpack the parameters of WM_MDIACTIVATE message +static 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) +{ + wxMenu *menu = frame->GetWindowMenu(); + return menu ? GetHmenuOf(menu) : 0; +} + // =========================================================================== // implementation // =========================================================================== @@ -86,31 +134,33 @@ static const int wxTHICK_LINE_WIDTH = 1; // wxWin macros // --------------------------------------------------------------------------- -#if !USE_SHARED_LIBRARY - IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame) - IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame) - IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow) -#endif // USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame) +IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame) +IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow) BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame) EVT_SIZE(wxMDIParentFrame::OnSize) - EVT_ACTIVATE(wxMDIParentFrame::OnActivate) EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged) END_EVENT_TABLE() +BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame) + EVT_IDLE(wxMDIChildFrame::OnIdle) +END_EVENT_TABLE() + BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow) EVT_SCROLL(wxMDIClientWindow::OnScroll) END_EVENT_TABLE() -// --------------------------------------------------------------------------- -// wxMDIParentFrame -// --------------------------------------------------------------------------- +// =========================================================================== +// wxMDIParentFrame: the frame which contains the client window which manages +// the children +// =========================================================================== wxMDIParentFrame::wxMDIParentFrame() { m_clientWindow = NULL; m_currentChild = NULL; - m_windowMenu = 0; + m_windowMenu = (wxMenu*) NULL; m_parentFrameActive = TRUE; } @@ -122,11 +172,28 @@ bool wxMDIParentFrame::Create(wxWindow *parent, long style, const wxString& name) { - m_defaultIcon = (WXHICON) (wxSTD_MDIPARENTFRAME_ICON ? wxSTD_MDIPARENTFRAME_ICON : wxDEFAULT_MDIPARENTFRAME_ICON); - m_clientWindow = NULL; m_currentChild = NULL; - m_windowMenu = 0; + + // 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 + { + 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->AppendSeparator(); + m_windowMenu->Append(IDM_WINDOWICONS, _("&Arrange Icons")); + m_windowMenu->Append(IDM_WINDOWNEXT, _("&Next")); + m_windowMenu->Append(IDM_WINDOWPREV, _("&Previous")); + } + m_parentFrameActive = TRUE; if (!parent) @@ -135,141 +202,111 @@ bool wxMDIParentFrame::Create(wxWindow *parent, SetName(name); m_windowStyle = style; - if (parent) parent->AddChild(this); + if ( parent ) + parent->AddChild(this); if ( id > -1 ) m_windowId = id; else - m_windowId = (int)NewControlId(); + m_windowId = NewControlId(); - int x = pos.x; - int y = pos.y; - int width = size.x; - int height = size.y; - - m_windowMenu = (WXHMENU) ::LoadMenu(wxGetInstance(), "wxWindowMenu"); - - DWORD msflags = WS_OVERLAPPED ; - if (style & wxMINIMIZE_BOX) - msflags |= WS_MINIMIZEBOX; - if (style & wxMAXIMIZE_BOX) - msflags |= WS_MAXIMIZEBOX; - if (style & wxTHICK_FRAME) - msflags |= WS_THICKFRAME; - if (style & wxSYSTEM_MENU) - msflags |= WS_SYSMENU; - if ((style & wxMINIMIZE) || (style & wxICONIZE)) - msflags |= WS_MINIMIZE; - if (style & wxMAXIMIZE) - msflags |= WS_MAXIMIZE; - if (style & wxCAPTION) - msflags |= WS_CAPTION; - - // Adding WS_CLIPCHILDREN causes children not to be properly - // drawn when first displaying them. -// if (style & wxCLIP_CHILDREN) -// msflags |= WS_CLIPCHILDREN; + WXDWORD exflags; + WXDWORD msflags = MSWGetCreateWindowFlags(&exflags); - wxWindow::MSWCreate(m_windowId, parent, wxMDIFrameClassName, this, title, x, y, width, height, - msflags); + if ( !wxWindow::MSWCreate(wxMDIFrameClassName, + title, + pos, size, + msflags, + exflags) ) + { + return FALSE; + } wxModelessWindows.Append(this); + // unlike (almost?) all other windows, frames are created hidden + m_isShown = FALSE; + return TRUE; } wxMDIParentFrame::~wxMDIParentFrame() { - DestroyChildren(); + DestroyChildren(); - DestroyMenu((HMENU) m_windowMenu); // Destroy dummy "Window" menu - m_windowMenu = 0; + // already delete by DestroyChildren() + m_frameToolBar = NULL; + m_frameStatusBar = NULL; - if (m_clientWindow->MSWGetOldWndProc()) - m_clientWindow->UnsubclassWin(); + if (m_windowMenu) + { + delete m_windowMenu; + m_windowMenu = (wxMenu*) NULL; + } - m_clientWindow->SetHWND(0); - delete m_clientWindow; -} + // 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; + } -void wxMDIParentFrame::SetMenuBar(wxMenuBar *menu_bar) -{ - if (!menu_bar) - { - m_frameMenuBar = NULL; - return; - } + if ( m_clientWindow ) + { + if ( m_clientWindow->MSWGetOldWndProc() ) + m_clientWindow->UnsubclassWin(); - if ( menu_bar->IsAttached() ) - return; + m_clientWindow->SetHWND(0); + delete m_clientWindow; + } +} - m_hMenu = menu_bar->Create(); +#if wxUSE_MENUS_NATIVE - if (m_frameMenuBar) - delete m_frameMenuBar; +void wxMDIParentFrame::InternalSetMenuBar() +{ + m_parentFrameActive = TRUE; - // MDI parent-specific code follows + InsertWindowMenu(GetClientWindow(), m_hMenu, GetMDIWindowMenu(this)); +} - HMENU subMenu = GetSubMenu((HMENU) m_windowMenu, 0); +#endif // wxUSE_MENUS_NATIVE - // Try to insert Window menu in front of Help, otherwise append it. - HMENU menu = (HMENU)m_hMenu; - int N = GetMenuItemCount(menu); - bool success = FALSE; - for (int i = 0; i < N; i++) - { - char buf[100]; - int chars = GetMenuString(menu, i, buf, 100, MF_BYPOSITION); - if ((chars > 0) && (strcmp(buf, "&Help") == 0 || - strcmp(buf, "Help") == 0)) +void wxMDIParentFrame::SetWindowMenu(wxMenu* menu) +{ + if (m_windowMenu) + { + if (GetMenuBar()) { - success = TRUE; - InsertMenu(menu, i, MF_BYPOSITION | MF_POPUP | MF_STRING, - (UINT)subMenu, "&Window"); - break; + // Remove old window menu + RemoveWindowMenu(GetClientWindow(), m_hMenu); } - } - if (!success) - AppendMenu(menu, MF_POPUP, - (UINT)subMenu, - "&Window"); - m_parentFrameActive = TRUE; -#ifdef __WIN32__ - SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDISETMENU, - (WPARAM)menu, - (LPARAM)subMenu); -#else - SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDISETMENU, 0, - MAKELPARAM(menu, subMenu)); -#endif - DrawMenuBar((HWND) GetHWND()); - m_frameMenuBar = menu_bar; - menu_bar->Attach(this); -} + delete m_windowMenu; + m_windowMenu = (wxMenu*) NULL; + } -void wxMDIParentFrame::OnSize(wxSizeEvent& event) -{ -#if wxUSE_CONSTRAINTS - if ( GetAutoLayout() ) + if (menu) { - Layout(); - return; + m_windowMenu = menu; + if (GetMenuBar()) + { + InsertWindowMenu(GetClientWindow(), m_hMenu, + GetHmenuOf(m_windowMenu)); + } } -#endif // wxUSE_CONSTRAINTS - - int x = 0; - int y = 0; - int width, height; - GetClientSize(&width, &height); - - if ( GetClientWindow() ) - GetClientWindow()->SetSize(x, y, width, height); } -void wxMDIParentFrame::OnActivate(wxActivateEvent& event) +void wxMDIParentFrame::OnSize(wxSizeEvent&) { - // Do nothing + if ( GetClientWindow() ) + { + int width, height; + GetClientSize(&width, &height); + + GetClientWindow()->SetSize(0, 0, width, height); + } } // Returns the active MDI child window @@ -295,28 +332,29 @@ void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event) { if ( m_clientWindow ) { - m_clientWindow->SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE)); + m_clientWindow->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE)); m_clientWindow->Refresh(); } -/* - if ( m_frameToolBar ) - { - wxSysColourChangedEvent event2; - event2.eventObject = m_frameToolBar; - m_frameToolBar->GetEventHandler()->ProcessEvent(event2); - } -*/ - // Propagate the event to the non-top-level children - wxFrame::OnSysColourChanged(event); + event.Skip(); +} + +WXHICON wxMDIParentFrame::GetDefaultIcon() const +{ + return (WXHICON)(wxSTD_MDIPARENTFRAME_ICON ? wxSTD_MDIPARENTFRAME_ICON + : wxDEFAULT_MDIPARENTFRAME_ICON); } +// --------------------------------------------------------------------------- // MDI operations +// --------------------------------------------------------------------------- + void wxMDIParentFrame::Cascade() { ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0); } +// TODO: add a direction argument (hor/vert) void wxMDIParentFrame::Tile() { ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE, MDITILE_HORIZONTAL, 0); @@ -337,7 +375,10 @@ void wxMDIParentFrame::ActivatePrevious() ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 1); } +// --------------------------------------------------------------------------- // the MDI parent frame window proc +// --------------------------------------------------------------------------- + long wxMDIParentFrame::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) @@ -347,6 +388,35 @@ long wxMDIParentFrame::MSWWindowProc(WXUINT message, switch ( message ) { + case WM_ACTIVATE: + { + WXWORD state, minimized; + WXHWND hwnd; + UnpackActivate(wParam, lParam, &state, &minimized, &hwnd); + + processed = HandleActivate(state, minimized != 0, hwnd); + } + break; + + case WM_COMMAND: + { + 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; + } + + // 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: m_clientWindow = OnCreateClient(); // Uses own style for client style @@ -369,25 +439,27 @@ long wxMDIParentFrame::MSWWindowProc(WXUINT message, case WM_MENUSELECT: { - WORD item = (WORD)wParam; -#ifdef __WIN32__ - WORD flags = HIWORD(wParam); - HMENU menu = (HMENU)lParam; -#else - WORD flags = LOWORD(lParam); - HMENU menu = (HMENU)HIWORD(lParam); -#endif + WXWORD item, flags; + WXHMENU hmenu; + UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu); + if ( m_parentFrameActive ) { - processed = HandleMenuSelect(item, flags, (WXHMENU)menu); + processed = HandleMenuSelect(item, flags, hmenu); } else if (m_currentChild) { processed = m_currentChild-> - HandleMenuSelect(item, flags, (WXHMENU)menu); + 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 + break; } if ( !processed ) @@ -396,11 +468,11 @@ long wxMDIParentFrame::MSWWindowProc(WXUINT message, return rc; } -bool wxMDIParentFrame::MSWOnActivate(int state, bool minimized, WXHWND activate) +bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate) { bool processed = FALSE; - if ( wxWindow::MSWOnActivate(state, minimized, activate) ) + if ( wxWindow::HandleActivate(state, minimized, activate) ) { // already processed processed = TRUE; @@ -408,7 +480,7 @@ bool wxMDIParentFrame::MSWOnActivate(int state, bool minimized, WXHWND activate) // If this window is an MDI parent, we must also send an OnActivate message // to the current child. - if ( (m_currentChild != NULL) && + if ( (m_currentChild != NULL) && ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) ) { wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_currentChild->GetId()); @@ -420,92 +492,110 @@ bool wxMDIParentFrame::MSWOnActivate(int state, bool minimized, WXHWND activate) return processed; } -bool wxMDIParentFrame::MSWOnCommand(WXWORD id, WXWORD cmd, WXHWND control) +bool wxMDIParentFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd) { -// if (cmd == 0) // Why did I do this test? - { // In case it's e.g. a toolbar. - wxWindow *win = wxFindWinFromHandle(control); - if (win) - return win->MSWCommand(cmd, id); - -/* - if (wxCurrentPopupMenu) + if ( hwnd ) { - wxMenu *popupMenu = wxCurrentPopupMenu; - wxCurrentPopupMenu = NULL; - if (!popupMenu->MSWCommand(cmd, id)) - return TRUE; + wxWindow *win = wxFindWinFromHandle(hwnd); + if ( win ) + return win->MSWCommand(cmd, id); } -*/ - switch (id) - { - case IDM_WINDOWCASCADE: - SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDICASCADE, MDITILE_SKIPDISABLED, 0); - return TRUE; - case IDM_WINDOWTILE: - SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDITILE, MDITILE_HORIZONTAL, 0); - return TRUE; - case IDM_WINDOWICONS: - SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDIICONARRANGE, 0, 0); - return TRUE; - case IDM_WINDOWNEXT: - SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDINEXT, 0, 0); - return TRUE; - default: - break; - } - if (id >= 0xF000) + // is it one of standard MDI commands? + WXWPARAM wParam = 0; + WXLPARAM lParam = 0; + int msg; + switch ( id ) { - return FALSE; // Get WndProc to call default proc + case IDM_WINDOWCASCADE: + msg = WM_MDICASCADE; + wParam = MDITILE_SKIPDISABLED; + break; + + case IDM_WINDOWTILEHOR: + wParam |= MDITILE_HORIZONTAL; + // fall through + + case IDM_WINDOWTILEVERT: + if ( !wParam ) + wParam = MDITILE_VERTICAL; + msg = WM_MDITILE; + wParam |= MDITILE_SKIPDISABLED; + break; + + case IDM_WINDOWICONS: + msg = WM_MDIICONARRANGE; + break; + + case IDM_WINDOWNEXT: + msg = WM_MDINEXT; + lParam = 0; // next child + break; + + case IDM_WINDOWPREV: + msg = WM_MDINEXT; + lParam = 1; // previous child + break; + + default: + msg = 0; } - if (m_parentFrameActive && (id < wxFIRST_MDI_CHILD || id > wxLAST_MDI_CHILD)) + if ( msg ) { - ProcessCommand(id); - return TRUE; + ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, lParam); + + return TRUE; } - else if (m_currentChild && (id < wxFIRST_MDI_CHILD || id > wxLAST_MDI_CHILD)) + + // FIXME VZ: what does this test do?? + if (id >= 0xF000) { - return m_currentChild->MSWOnCommand(id, cmd, control); + return FALSE; // Get WndProc to call default proc } - } - if (id >= wxFIRST_MDI_CHILD && id <= wxLAST_MDI_CHILD) - { - wxNode* node = GetChildren().First(); - while (node) + + if ( IsMdiCommandId(id) ) { - wxWindow* child = (wxWindow*) node->Data(); - if (child->GetHWND()) + wxWindowList::Node* node = GetChildren().GetFirst(); + while ( node ) { -#ifdef __WIN32__ - long childId = GetWindowLong((HWND) child->GetHWND(), GWL_ID); -#else - long childId = GetWindowWord((HWND) child->GetHWND(), GWW_ID); -#endif - if (childId == id) + wxWindow* child = node->GetData(); + if ( child->GetHWND() ) { - ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDIACTIVATE, (WPARAM) (HWND) child->GetHWND(), 0); - return TRUE; + long childId = wxGetWindowId(child->GetHWND()); + if (childId == (long)id) + { + ::SendMessage( GetWinHwnd(GetClientWindow()), + WM_MDIACTIVATE, + (WPARAM)child->GetHWND(), 0); + return TRUE; + } } + node = node->GetNext(); } - node = node->Next(); } -/* - wxWindow* child = FindItem(id); - if (child) + else if ( m_parentFrameActive ) { - ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDIACTIVATE, (WPARAM) (HWND) child->GetHWND(), 0); - return TRUE; + return ProcessCommand(id); + } + else if ( m_currentChild ) + { + return m_currentChild->HandleCommand(id, cmd, hwnd); + } + else + { + // 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?")); } -*/ - } - return wxWindow::MSWOnCommand(id, cmd, control); + return FALSE; } -long wxMDIParentFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) +long wxMDIParentFrame::MSWDefWindowProc(WXUINT message, + WXWPARAM wParam, + WXLPARAM lParam) { WXHWND clientWnd; if ( GetClientWindow() ) @@ -516,30 +606,24 @@ long wxMDIParentFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARA return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam); } -bool wxMDIParentFrame::MSWProcessMessage(WXMSG* msg) -{ - return m_currentChild && m_currentChild->GetHWND() && - m_currentChild->MSWProcessMessage(msg); -} - 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) ) { return TRUE; } - if ( m_acceleratorTable.Ok() && - ::TranslateAccelerator(GetHwnd(), - GetTableHaccel(&m_acceleratorTable), - pMsg) ) + // then try out accel table (will also check the menu accels) + if ( wxFrame::MSWTranslateMessage(msg) ) { return TRUE; } + // finally, check for MDI specific built in accel keys if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN ) { if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg)) @@ -549,13 +633,13 @@ bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg) return FALSE; } -// --------------------------------------------------------------------------- +// =========================================================================== // wxMDIChildFrame -// --------------------------------------------------------------------------- +// =========================================================================== -wxMDIChildFrame::wxMDIChildFrame() +void wxMDIChildFrame::Init() { -// m_active = FALSE; + m_needsResize = TRUE; } bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, @@ -566,18 +650,18 @@ bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, long style, const wxString& name) { - m_defaultIcon = (WXHICON) (wxSTD_MDICHILDFRAME_ICON ? wxSTD_MDICHILDFRAME_ICON : wxDEFAULT_MDICHILDFRAME_ICON); - SetName(name); + wxWindowBase::Show(TRUE); // MDI child frame starts off shown if ( id > -1 ) m_windowId = id; else m_windowId = (int)NewControlId(); - if (parent) parent->AddChild(this); - - wxWndHook = this; + if ( parent ) + { + parent->AddChild(this); + } int x = pos.x; int y = pos.y; @@ -586,22 +670,32 @@ bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, MDICREATESTRUCT mcs; - mcs.szClass = wxMDIChildFrameClassName; + mcs.szClass = style & wxNO_FULL_REPAINT_ON_RESIZE + ? wxMDIChildFrameClassNameNoRedraw + : wxMDIChildFrameClassName; mcs.szTitle = title; mcs.hOwner = wxGetInstance(); - if (x > -1) mcs.x = x; - else mcs.x = CW_USEDEFAULT; + if (x > -1) + mcs.x = x; + else + mcs.x = CW_USEDEFAULT; - if (y > -1) mcs.y = y; - else mcs.y = CW_USEDEFAULT; + if (y > -1) + mcs.y = y; + else + mcs.y = CW_USEDEFAULT; - if (width > -1) mcs.cx = width; - else mcs.cx = CW_USEDEFAULT; + if (width > -1) + mcs.cx = width; + else + mcs.cx = CW_USEDEFAULT; - if (height > -1) mcs.cy = height; - else mcs.cy = CW_USEDEFAULT; + if (height > -1) + mcs.cy = height; + else + mcs.cy = CW_USEDEFAULT; - DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN ; + DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN | WS_THICKFRAME | WS_VISIBLE ; if (style & wxMINIMIZE_BOX) msflags |= WS_MINIMIZEBOX; if (style & wxMAXIMIZE_BOX) @@ -621,37 +715,36 @@ bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, mcs.lParam = 0; - DWORD Return = SendMessage((HWND) parent->GetClientWindow()->GetHWND(), - WM_MDICREATE, 0, (LONG)(LPSTR)&mcs); - - //handle = (HWND)LOWORD(Return); - // Must be the DWORRD for WIN32. And in 16 bits, HIWORD=0 (says Microsoft) - m_hWnd = (WXHWND)Return; - - // This gets reassigned so can't be stored -// m_windowId = GetWindowLong((HWND) m_hWnd, GWL_ID); + wxWindowCreationHook hook(this); - wxWndHook = NULL; - wxWinHandleList->Append((long)GetHWND(), this); + m_hWnd = (WXHWND)::SendMessage(GetWinHwnd(parent->GetClientWindow()), + WM_MDICREATE, 0, (LONG)(LPSTR)&mcs); - SetWindowLong((HWND) GetHWND(), 0, (long)this); + wxAssociateWinWithHandle((HWND) GetHWND(), this); wxModelessWindows.Append(this); + return TRUE; } wxMDIChildFrame::~wxMDIChildFrame() { - MSWDestroyWindow(); + DestroyChildren(); + + // already deleted by DestroyChildren() + m_frameToolBar = NULL; + m_frameStatusBar = NULL; - ResetWindowStyle(NULL); + RemoveWindowMenu(NULL, m_hMenu); + + MSWDestroyWindow(); } // Set the client size (i.e. leave the calculation of borders etc. // to wxWindows) void wxMDIChildFrame::DoSetClientSize(int width, int height) { - HWND hWnd = (HWND) GetHWND(); + HWND hWnd = GetHwnd(); RECT rect; ::GetClientRect(hWnd, &rect); @@ -665,7 +758,7 @@ 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 (GetStatusBar()) + if (GetStatusBar() && GetStatusBar()->IsShown()) { int sx, sy; GetStatusBar()->GetSize(&sx, &sy); @@ -691,7 +784,7 @@ void wxMDIChildFrame::DoSetClientSize(int width, int height) void wxMDIChildFrame::DoGetPosition(int *x, int *y) const { RECT rect; - GetWindowRect((HWND) GetHWND(), &rect); + GetWindowRect(GetHwnd(), &rect); POINT point; point.x = rect.left; point.y = rect.top; @@ -705,139 +798,132 @@ void wxMDIChildFrame::DoGetPosition(int *x, int *y) const *y = point.y; } -void wxMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar) +void wxMDIChildFrame::InternalSetMenuBar() { - if (!menu_bar) - { - m_frameMenuBar = NULL; - return; - } - - if ( menu_bar->IsAttached() ) - return; - - m_hMenu = menu_bar->Create(); - - if (m_frameMenuBar) - delete m_frameMenuBar; - - wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); + wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); - parent->m_parentFrameActive = FALSE; - HMENU subMenu = GetSubMenu((HMENU) parent->GetWindowMenu(), 0); + InsertWindowMenu(parent->GetClientWindow(), + m_hMenu, GetMDIWindowMenu(parent)); - // Try to insert Window menu in front of Help, otherwise append it. - HMENU menu = (HMENU)m_hMenu; - int N = GetMenuItemCount(menu); - bool success = FALSE; - for (int i = 0; i < N; i++) - { - char buf[100]; - int chars = GetMenuString(menu, i, buf, 100, MF_BYPOSITION); - if ((chars > 0) && (strcmp(buf, "&Help") == 0 || - strcmp(buf, "Help") == 0)) - { - success = TRUE; - InsertMenu(menu, i, MF_BYPOSITION | MF_POPUP | MF_STRING, - (UINT)subMenu, "&Window"); - break; - } - } - if (!success) - AppendMenu(menu, MF_POPUP, - (UINT)subMenu, - "&Window"); -#ifdef __WIN32__ - SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDISETMENU, - (WPARAM)menu, - (LPARAM)subMenu); -#else - SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDISETMENU, 0, - MAKELPARAM(menu, subMenu)); -#endif + parent->m_parentFrameActive = FALSE; +} - DrawMenuBar((HWND) parent->GetHWND()); - m_frameMenuBar = menu_bar; - menu_bar->Attach(this); +WXHICON wxMDIChildFrame::GetDefaultIcon() const +{ + return (WXHICON)(wxSTD_MDICHILDFRAME_ICON ? wxSTD_MDICHILDFRAME_ICON + : wxDEFAULT_MDICHILDFRAME_ICON); } +// --------------------------------------------------------------------------- // MDI operations -void wxMDIChildFrame::Maximize() +// --------------------------------------------------------------------------- + +void wxMDIChildFrame::Maximize(bool maximize) { wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); if ( parent && parent->GetClientWindow() ) - ::SendMessage( (HWND) parent->GetClientWindow()->GetHWND(), WM_MDIMAXIMIZE, (WPARAM) (HWND) GetHWND(), 0); + { + ::SendMessage(GetWinHwnd(parent->GetClientWindow()), + maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE, + (WPARAM)GetHwnd(), 0); + } } void wxMDIChildFrame::Restore() { wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); if ( parent && parent->GetClientWindow() ) - ::SendMessage( (HWND) parent->GetClientWindow()->GetHWND(), WM_MDIRESTORE, (WPARAM) (HWND) GetHWND(), 0); + { + ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE, + (WPARAM) GetHwnd(), 0); + } } void wxMDIChildFrame::Activate() { wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); if ( parent && parent->GetClientWindow() ) - ::SendMessage( (HWND) parent->GetClientWindow()->GetHWND(), WM_MDIACTIVATE, (WPARAM) (HWND) GetHWND(), 0); + { + ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE, + (WPARAM) GetHwnd(), 0); + } } -static HWND invalidHandle = 0; -bool wxMDIChildFrame::MSWOnSize(int x, int y, WXUINT id) +// --------------------------------------------------------------------------- +// MDI window proc and message handlers +// --------------------------------------------------------------------------- + +long wxMDIChildFrame::MSWWindowProc(WXUINT message, + WXWPARAM wParam, + WXLPARAM lParam) { - HWND hwnd = GetHwnd(); - - if ( !hwnd || hwnd == invalidHandle ) - { - return FALSE; - } - - switch (id) + long rc = 0; + bool processed = FALSE; + + switch ( message ) { - case SIZEFULLSCREEN: - case SIZENORMAL: - m_iconized = FALSE; + case WM_COMMAND: + { + WORD id, cmd; + WXHWND hwnd; + UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam, + &id, &hwnd, &cmd); + + processed = HandleCommand(id, cmd, (WXHWND)hwnd); + } break; - case SIZEICONIC: - m_iconized = TRUE; + case WM_GETMINMAXINFO: + processed = HandleGetMinMaxInfo((MINMAXINFO *)lParam); + break; + + case WM_MDIACTIVATE: + { + WXWORD act; + WXHWND hwndAct, hwndDeact; + UnpackMDIActivate(wParam, lParam, &act, &hwndAct, &hwndDeact); + + processed = HandleMDIActivate(act, hwndAct, hwndDeact); + } + // fall through + + case WM_MOVE: + // must pass WM_MOVE to DefMDIChildProc() to recalculate MDI client + // scrollbars if necessary + + // fall through + + case WM_SIZE: + // must pass WM_SIZE to DefMDIChildProc(), otherwise many weird + // things happen + 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; } - - if (!m_iconized) - { - // forward WM_SIZE to status bar control -#if wxUSE_NATIVE_STATUSBAR - if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95))) - { - wxSizeEvent event(wxSize(x, y), m_frameStatusBar->GetId()); - event.SetEventObject( m_frameStatusBar ); - - ((wxStatusBar95 *)m_frameStatusBar)->OnSize(event); - } -#endif - - PositionStatusBar(); - PositionToolBar(); - - return wxWindow::MSWOnSize(x, y, id); - } - else - { - return FALSE; - } + + if ( !processed ) + rc = wxFrame::MSWWindowProc(message, wParam, lParam); + + return rc; } -bool wxMDIChildFrame::MSWOnCommand(WXWORD id, WXWORD cmd, WXHWND control) +bool wxMDIChildFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd) { -// if ((cmd == 0) && GetHWND()) - if (GetHWND()) - { // In case it's e.g. a toolbar. - wxWindow *win = wxFindWinFromHandle(control); - if (win) - return win->MSWCommand(cmd, id); + if ( hwnd ) + { + wxWindow *win = wxFindWinFromHandle(hwnd); + if (win) + return win->MSWCommand(cmd, id); + } if (wxCurrentPopupMenu) { @@ -847,137 +933,188 @@ bool wxMDIChildFrame::MSWOnCommand(WXWORD id, WXWORD cmd, WXHWND control) return TRUE; } - if (GetMenuBar() && GetMenuBar()->FindItemForId(id)) + bool processed; + if (GetMenuBar() && GetMenuBar()->FindItem(id)) { - ProcessCommand(id); - return TRUE; + processed = ProcessCommand(id); } else - return FALSE; - return TRUE; - } - else - return wxWindow::MSWOnCommand(id, cmd, control); -} + { + processed = FALSE; + } -long wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXUINT wParam, WXLPARAM lParam) -{ - if (GetHWND()) - return DefMDIChildProc((HWND) GetHWND(), (UINT) message, (WPARAM) wParam, (LPARAM) lParam); - else return 0; + return processed; } -bool wxMDIChildFrame::MSWProcessMessage(WXMSG *msg) +bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate), + WXHWND hwndAct, + WXHWND hwndDeact) { - return FALSE; + wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); + + HMENU menuToSet = 0; + + bool activated; + + if ( m_hWnd == hwndAct ) + { + activated = TRUE; + parent->m_currentChild = this; + + HMENU child_menu = (HMENU)GetWinMenu(); + if ( child_menu ) + { + parent->m_parentFrameActive = FALSE; + + menuToSet = child_menu; + } + } + else if ( m_hWnd == hwndDeact ) + { + wxASSERT_MSG( parent->m_currentChild == this, + wxT("can't deactivate MDI child which wasn't active!") ); + + activated = FALSE; + parent->m_currentChild = NULL; + + HMENU parent_menu = (HMENU)parent->GetWinMenu(); + + // activate the 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; + } + } + else + { + // we have nothing to do with it + return FALSE; + } + + if ( menuToSet ) + { + MDISetMenu(parent->GetClientWindow(), + menuToSet, GetMDIWindowMenu(parent)); + } + + wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId); + event.SetEventObject( this ); + + ResetWindowStyle((void *)NULL); + + return GetEventHandler()->ProcessEvent(event); } -bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg) +bool wxMDIChildFrame::HandleWindowPosChanging(void *pos) { - MSG *pMsg = (MSG *)msg; - if (m_acceleratorTable.Ok()) - { - wxFrame *parent = (wxFrame *)GetParent(); - HWND parent_hwnd = (HWND) parent->GetHWND(); - return (::TranslateAccelerator(parent_hwnd, (HACCEL) m_acceleratorTable.GetHACCEL(), pMsg) != 0); - } + WINDOWPOS *lpPos = (WINDOWPOS *)pos; +#if defined(__WIN95__) + if (!(lpPos->flags & SWP_NOSIZE)) + { + RECT rectClient; + DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE); + DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE); + if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE)) + { + ::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::MSWOnMDIActivate(long activate, WXHWND WXUNUSED(one), WXHWND WXUNUSED(two)) +bool wxMDIChildFrame::HandleGetMinMaxInfo(void *mmInfo) { - wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); - HMENU parent_menu = (HMENU) parent->GetWinMenu(); - HMENU child_menu = (HMENU) GetWinMenu(); + MINMAXINFO *info = (MINMAXINFO *)mmInfo; - if (activate) - { -// m_active = TRUE; - parent->m_currentChild = this; - if (child_menu) + // let the default window proc calculate the size of MDI children + // frames because it is based on the size of the MDI client window, + // not on the values specified in wxWindow m_max variables + bool processed = MSWDefWindowProc(WM_GETMINMAXINFO, 0, (LPARAM)mmInfo) != 0; + + int minWidth = GetMinWidth(), + minHeight = GetMinHeight(); + + // but allow GetSizeHints() to set the min size + if ( minWidth != -1 ) { - parent->m_parentFrameActive = FALSE; - HMENU subMenu = GetSubMenu((HMENU) parent->GetWindowMenu(), 0); -#ifdef __WIN32__ - ::SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDISETMENU, - (WPARAM)child_menu, - (LPARAM)subMenu); -#else - ::SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDISETMENU, 0, - MAKELONG(child_menu, subMenu)); -#endif + info->ptMinTrackSize.x = minWidth; - ::DrawMenuBar((HWND) parent->GetHWND()); + processed = TRUE; } - wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_windowId); - event.SetEventObject( this ); - return GetEventHandler()->ProcessEvent(event); - } - else - { - if (parent->m_currentChild == this) - parent->m_currentChild = NULL; - wxActivateEvent event(wxEVT_ACTIVATE, FALSE, m_windowId); - event.SetEventObject( this ); - if ( GetEventHandler()->ProcessEvent(event) ) - return TRUE; - -// m_active = FALSE; - if (parent_menu) + if ( minHeight != -1 ) { - parent->m_parentFrameActive = TRUE; - HMENU subMenu = GetSubMenu((HMENU) parent->GetWindowMenu(), 0); -#ifdef __WIN32__ - ::SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDISETMENU, - (WPARAM)parent_menu, - (LPARAM)subMenu); -#else - ::SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDISETMENU, 0, - MAKELONG(parent_menu, subMenu)); -#endif + info->ptMinTrackSize.y = minHeight; - ::DrawMenuBar((HWND) parent->GetHWND()); + processed = TRUE; } - } - bool flag = (activate != 0); - wxActivateEvent event(wxEVT_ACTIVATE, flag, m_windowId); - event.SetEventObject( this ); - return GetEventHandler()->ProcessEvent(event); + + return TRUE; } +// --------------------------------------------------------------------------- +// MDI specific message translation/preprocessing +// --------------------------------------------------------------------------- + +long wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXUINT wParam, WXLPARAM lParam) +{ + return DefMDIChildProc(GetHwnd(), + (UINT)message, (WPARAM)wParam, (LPARAM)lParam); +} + +bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg) +{ + return wxFrame::MSWTranslateMessage(msg); +} + +// --------------------------------------------------------------------------- +// misc +// --------------------------------------------------------------------------- + void wxMDIChildFrame::MSWDestroyWindow() { - MSWDetachWindowMenu(); - invalidHandle = (HWND) GetHWND(); + invalidHandle = GetHwnd(); + + wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); - wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); + // 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 + // the wxFrame is destroyed. - // 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 the wxFrame is - // destroyed. + HWND oldHandle = (HWND)GetHWND(); + SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY, + (WPARAM)oldHandle, 0); - HWND oldHandle = (HWND)GetHWND(); -#ifdef __WIN32__ - SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDIDESTROY, (WPARAM)oldHandle, (LPARAM)0); -#else - SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDIDESTROY, (HWND)oldHandle, 0); -#endif - invalidHandle = 0; + if (parent->GetActiveChild() == (wxMDIChildFrame*) NULL) + ResetWindowStyle((void*) NULL); - if (m_hMenu) - { - ::DestroyMenu((HMENU) m_hMenu); - m_hMenu = 0; - } - m_hWnd = 0; + invalidHandle = 0; + + if (m_hMenu) + { + ::DestroyMenu((HMENU) m_hMenu); + m_hMenu = 0; + } + wxRemoveHandleAssociation(this); + m_hWnd = 0; } -// Change the client window's extended style so we don't -// get a client edge style when a child is maximised (a double -// border looks silly.) +// Change the client window's extended style so we don't get a client edge +// style when a child is maximised (a double border looks silly.) bool wxMDIChildFrame::ResetWindowStyle(void *vrect) { #if defined(__WIN95__) @@ -986,131 +1123,278 @@ bool wxMDIChildFrame::ResetWindowStyle(void *vrect) wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild(); if (!pChild || (pChild == this)) { - DWORD dwStyle = ::GetWindowLong((HWND) pFrameWnd->GetClientWindow()->GetHWND(), GWL_EXSTYLE); - DWORD dwThisStyle = ::GetWindowLong((HWND) GetHWND(), GWL_STYLE); + HWND hwndClient = GetWinHwnd(pFrameWnd->GetClientWindow()); + DWORD dwStyle = ::GetWindowLong(hwndClient, GWL_EXSTYLE); + + // we want to test whether there is a maximized child, so just set + // dwThisStyle to 0 if there is no child at all + DWORD dwThisStyle = pChild + ? ::GetWindowLong(GetWinHwnd(pChild), GWL_STYLE) : 0; DWORD dwNewStyle = dwStyle; - if (pChild != NULL && (dwThisStyle & WS_MAXIMIZE)) + if ( dwThisStyle & WS_MAXIMIZE ) dwNewStyle &= ~(WS_EX_CLIENTEDGE); else dwNewStyle |= WS_EX_CLIENTEDGE; if (dwStyle != dwNewStyle) { - ::RedrawWindow((HWND) pFrameWnd->GetClientWindow()->GetHWND(), NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN); - ::SetWindowLong((HWND) pFrameWnd->GetClientWindow()->GetHWND(), GWL_EXSTYLE, dwNewStyle); - ::SetWindowPos((HWND) pFrameWnd->GetClientWindow()->GetHWND(), NULL, 0, 0, 0, 0, - SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOCOPYBITS); + // force update of everything + ::RedrawWindow(hwndClient, NULL, NULL, + RDW_INVALIDATE | RDW_ALLCHILDREN); + ::SetWindowLong(hwndClient, GWL_EXSTYLE, dwNewStyle); + ::SetWindowPos(hwndClient, NULL, 0, 0, 0, 0, + SWP_FRAMECHANGED | SWP_NOACTIVATE | + SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | + SWP_NOCOPYBITS); if (rect) - ::GetClientRect((HWND) pFrameWnd->GetClientWindow()->GetHWND(), rect); + ::GetClientRect(hwndClient, rect); + return TRUE; } } +#endif // Win95 + return FALSE; -#else - return FALSE; -#endif } -bool wxMDIChildFrame::MSWOnWindowPosChanging(void *pos) +// =========================================================================== +// wxMDIClientWindow: the window of predefined (by Windows) class which +// contains the child frames +// =========================================================================== + +bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style) { - WINDOWPOS *lpPos = (WINDOWPOS *)pos; + m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE); + + CLIENTCREATESTRUCT ccs; + m_windowStyle = style; + m_parent = parent; + + ccs.hWindowMenu = GetMDIWindowMenu(parent); + ccs.idFirstChild = wxFIRST_MDI_CHILD; + + DWORD msStyle = MDIS_ALLCHILDSTYLES | WS_VISIBLE | WS_CHILD | + WS_CLIPCHILDREN | WS_CLIPSIBLINGS; + + if ( style & wxHSCROLL ) + msStyle |= WS_HSCROLL; + if ( style & wxVSCROLL ) + msStyle |= WS_VSCROLL; + #if defined(__WIN95__) - if (!(lpPos->flags & SWP_NOSIZE)) + DWORD exStyle = WS_EX_CLIENTEDGE; +#else + DWORD exStyle = 0; +#endif + + wxWindowCreationHook hook(this); + m_hWnd = (WXHWND)::CreateWindowEx + ( + exStyle, + wxT("MDICLIENT"), + NULL, + msStyle, + 0, 0, 0, 0, + GetWinHwnd(parent), + NULL, + wxGetInstance(), + (LPSTR)(LPCLIENTCREATESTRUCT)&ccs); + if ( !m_hWnd ) { - RECT rectClient; - DWORD dwExStyle = ::GetWindowLong((HWND) GetHWND(), GWL_EXSTYLE); - DWORD dwStyle = ::GetWindowLong((HWND) GetHWND(), GWL_STYLE); - if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE)) - { - ::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()->Refresh(); - } + wxLogLastError(wxT("CreateWindowEx(MDI client)")); + + return FALSE; } -#endif - return FALSE; + SubclassWin(m_hWnd); + + return TRUE; } -// Client window -wxMDIClientWindow::wxMDIClientWindow() +// Explicitly call default scroll behaviour +void wxMDIClientWindow::OnScroll(wxScrollEvent& event) { - m_scrollX = 0; - m_scrollY = 0; + // Note: for client windows, the scroll position is not set in + // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what + // scroll position we're at. + // This makes it hard to paint patterns or bitmaps in the background, + // and have the client area scrollable as well. + + if ( event.GetOrientation() == wxHORIZONTAL ) + m_scrollX = event.GetPosition(); // Always returns zero! + else + m_scrollY = event.GetPosition(); // Always returns zero! + + event.Skip(); } -wxMDIClientWindow::~wxMDIClientWindow() +void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags) { + // Try to fix a problem whereby if you show an MDI child frame, then reposition the + // client area, you can end up with a non-refreshed portion in the client window + // (see OGL studio sample). So check if the position is changed and if so, + // redraw the MDI child frames. + + wxPoint oldPos = GetPosition(); + + wxWindow::DoSetSize(x, y, width, height, sizeFlags); + + wxPoint newPos = GetPosition(); + + if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y)) + { + if (GetParent()) + { + wxNode* node = GetParent()->GetChildren().First(); + while (node) + { + wxWindow* child = (wxWindow*) node->Data(); + if (child->IsKindOf(CLASSINFO(wxMDIChildFrame))) + { + HWND hWnd = (HWND) child->GetHWND(); + ::RedrawWindow(hWnd, NULL, NULL, RDW_FRAME|RDW_ALLCHILDREN|RDW_INVALIDATE ); + } + node = node->Next(); + } + } + } } -bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style) +void wxMDIChildFrame::OnIdle(wxIdleEvent& event) { - m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE); + // 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 - CLIENTCREATESTRUCT ccs; - m_windowStyle = style; - m_parent = parent; + SendSizeEvent(); + } - ccs.hWindowMenu = (HMENU) parent->GetWindowMenu(); - ccs.idFirstChild = wxFIRST_MDI_CHILD; + event.Skip(); +} - DWORD msStyle = WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN ; - if ( parent->GetWindowStyleFlag() & wxHSCROLL ) - msStyle |= WS_HSCROLL; - if ( parent->GetWindowStyleFlag() & wxVSCROLL ) - msStyle |= WS_VSCROLL ; +// --------------------------------------------------------------------------- +// non member functions +// --------------------------------------------------------------------------- -#if defined(__WIN95__) - DWORD exStyle = WS_EX_CLIENTEDGE; +static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow) +{ + ::SendMessage(GetWinHwnd(win), WM_MDISETMENU, +#ifdef __WIN32__ + (WPARAM)hmenuFrame, (LPARAM)hmenuWindow #else - DWORD exStyle = 0; + 0, MAKELPARAM(hmenuFrame, hmenuWindow) #endif + ); - wxWndHook = this; - m_hWnd = (WXHWND) ::CreateWindowEx(exStyle, "mdiclient", NULL, - msStyle, 0, 0, 0, 0, (HWND) parent->GetHWND(), NULL, - wxGetInstance(), (LPSTR)(LPCLIENTCREATESTRUCT)&ccs); - SubclassWin(m_hWnd); - wxWndHook = NULL; + // update menu bar of the parent window + wxWindow *parent = win->GetParent(); + wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") ); - return (m_hWnd != 0) ; +#ifndef __WIN16__ + ::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L); +#endif + + ::DrawMenuBar(GetWinHwnd(parent)); } -// Window procedure: here for debugging purposes -long wxMDIClientWindow::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) +static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu) { - return wxWindow::MSWWindowProc(nMsg, wParam, lParam); -// return MSWDefWindowProc(nMsg, wParam, lParam); + // Try to insert Window menu in front of Help, otherwise append it. + HMENU hmenu = (HMENU)menu; + + if (subMenu) + { + int N = GetMenuItemCount(hmenu); + bool success = FALSE; + for ( int i = 0; i < N; i++ ) + { + wxChar buf[256]; + int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION); + if ( chars == 0 ) + { + wxLogLastError(wxT("GetMenuString")); + + continue; + } + + if ( wxStripMenuCodes(wxString(buf)).IsSameAs(_("Help")) ) + { + success = TRUE; + ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING, + (UINT)subMenu, _("&Window")); + break; + } + } + + if ( !success ) + { + ::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, _("&Window")); + } + } + + MDISetMenu(win, hmenu, subMenu); } -long wxMDIClientWindow::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) +static void RemoveWindowMenu(wxWindow *win, WXHMENU menu) { - if ( MSWGetOldWndProc() != 0) - return ::CallWindowProc(CASTWNDPROC MSWGetOldWndProc(), (HWND) GetHWND(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam); - else - return ::DefWindowProc((HWND) m_hWnd, (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam); + HMENU hMenu = (HMENU)menu; + + if ( hMenu ) + { + wxChar buf[1024]; + + int N = ::GetMenuItemCount(hMenu); + for ( int i = 0; i < N; i++ ) + { + if ( !::GetMenuString(hMenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) ) + { + // Ignore successful read of menu string with length 0 which + // occurs, for example, for a maximized MDI childs system menu + if ( ::GetLastError() != 0 ) + { + wxLogLastError(wxT("GetMenuString")); + } + + continue; + } + + if ( wxStrcmp(buf, _("&Window")) == 0 ) + { + if ( !::RemoveMenu(hMenu, i, MF_BYPOSITION) ) + { + wxLogLastError(wxT("RemoveMenu")); + } + + break; + } + } + } + + if ( win ) + { + // we don't change the windows menu, but we update the main one + MDISetMenu(win, hMenu, NULL); + } } -// Explicitly call default scroll behaviour -void wxMDIClientWindow::OnScroll(wxScrollEvent& event) +static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam, + WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact) { - // Note: for client windows, the scroll position is not set in - // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what - // scroll position we're at. - // This makes it hard to paint patterns or bitmaps in the background, - // and have the client area scrollable as well. +#ifdef __WIN32__ + *activate = TRUE; + *hwndAct = (WXHWND)lParam; + *hwndDeact = (WXHWND)wParam; +#else // Win16 + *activate = (WXWORD)wParam; + *hwndAct = (WXHWND)LOWORD(lParam); + *hwndDeact = (WXHWND)HIWORD(lParam); +#endif // Win32/Win16 +} - if ( event.GetOrientation() == wxHORIZONTAL ) - m_scrollX = event.GetPosition(); // Always returns zero! - else - m_scrollY = event.GetPosition(); // Always returns zero! +#endif +// wxUSE_MDI_ARCHITECTURE && !defined(__WXUNIVERSAL__) - Default(); -}