/////////////////////////////////////////////////////////////////////////////
-// 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
// RCS-ID: $Id$
-// Copyright: (c) Julian Smart and Markus Holzem
-// Licence: wxWindows license
+// Copyright: (c) Julian Smart
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
-#pragma implementation "mdi.h"
-#endif
+// ===========================================================================
+// declarations
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// headers
+// ---------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
-#pragma hdrstop
+ #pragma hdrstop
#endif
-#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"
-#include "wx/statusbr.h"
-#include "wx/settings.h"
-#endif
+#if wxUSE_MDI && !defined(__WXUNIVERSAL__)
#include "wx/mdi.h"
-#include "wx/msw/private.h"
-#if wxUSE_NATIVE_STATUSBAR
-#include <wx/msw/statbr95.h>
+#ifndef WX_PRECOMP
+ #include "wx/frame.h"
+ #include "wx/menu.h"
+ #include "wx/app.h"
+ #include "wx/utils.h"
+ #include "wx/dialog.h"
+ #include "wx/statusbr.h"
+ #include "wx/settings.h"
+ #include "wx/intl.h"
+ #include "wx/log.h"
+ #include "wx/toolbar.h"
#endif
+#include "wx/stockitem.h"
+#include "wx/msw/private.h"
+
#include <string.h>
-extern wxList wxModelessWindows;
+// ---------------------------------------------------------------------------
+// global variables
+// ---------------------------------------------------------------------------
+
extern wxMenu *wxCurrentPopupMenu;
-#define IDM_WINDOWTILE 4001
-#define IDM_WINDOWCASCADE 4002
-#define IDM_WINDOWICONS 4003
-#define IDM_WINDOWNEXT 4004
-// This range gives a maximum of 500
-// MDI children. Should be enough :-)
-#define wxFIRST_MDI_CHILD 4100
-#define wxLAST_MDI_CHILD 4600
+extern void wxRemoveHandleAssociation(wxWindow *win);
+
+// ---------------------------------------------------------------------------
+// constants
+// ---------------------------------------------------------------------------
+
+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;
+
+// ---------------------------------------------------------------------------
+// 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);
-// Status border dimensions
-#define wxTHICK_LINE_BORDER 3
-#define wxTHICK_LINE_WIDTH 1
+// insert the window menu (subMenu) into menu just before "Help" submenu or at
+// the very end if not found
+static void MDIInsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu);
-extern char wxMDIFrameClassName[];
-extern char wxMDIChildFrameClassName[];
-extern wxWindow *wxWndHook;
+// Remove the window menu
+static void MDIRemoveWindowMenu(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
+//
+// this function works correctly even when we don't have a window menu and just
+// returns 0 then
+static inline HMENU GetMDIWindowMenu(wxMDIParentFrame *frame)
+{
+ wxMenu *menu = frame->GetWindowMenu();
+ return menu ? GetHmenuOf(menu) : 0;
+}
+
+// ===========================================================================
+// implementation
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// wxWin macros
+// ---------------------------------------------------------------------------
-#if !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)
+ EVT_SIZE(wxMDIParentFrame::OnSize)
+ EVT_ICONIZE(wxMDIParentFrame::OnIconized)
+ 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)
+ EVT_SCROLL(wxMDIClientWindow::OnScroll)
END_EVENT_TABLE()
-#endif
+// ===========================================================================
+// wxMDIParentFrame: the frame which contains the client window which manages
+// the children
+// ===========================================================================
wxMDIParentFrame::wxMDIParentFrame()
{
- m_clientWindow = NULL;
- m_currentChild = NULL;
- m_windowMenu = 0;
- m_parentFrameActive = TRUE;
+ m_parentFrameActive = true;
}
bool wxMDIParentFrame::Create(wxWindow *parent,
- wxWindowID id,
- const wxString& title,
- const wxPoint& pos,
- const wxSize& size,
- long style,
- const wxString& name)
+ wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
- m_defaultIcon = (WXHICON) (wxSTD_MDIPARENTFRAME_ICON ? wxSTD_MDIPARENTFRAME_ICON : wxDEFAULT_MDIPARENTFRAME_ICON);
+ // this style can be used to prevent a window from having the standard MDI
+ // "Window" menu
+ 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->AppendSeparator();
+ m_windowMenu->Append(IDM_WINDOWICONS, _("&Arrange Icons"));
+ m_windowMenu->Append(IDM_WINDOWNEXT, _("&Next"));
+ m_windowMenu->Append(IDM_WINDOWPREV, _("&Previous"));
+ }
- m_clientWindow = NULL;
- m_currentChild = NULL;
- m_windowMenu = 0;
- m_parentFrameActive = TRUE;
+ m_parentFrameActive = true;
if (!parent)
wxTopLevelWindows.Append(this);
SetName(name);
m_windowStyle = style;
- if (parent) parent->AddChild(this);
+ if ( parent )
+ parent->AddChild(this);
- if ( id > -1 )
+ if ( id != wxID_ANY )
m_windowId = id;
else
- m_windowId = (int)NewControlId();
+ m_windowId = NewControlId();
+
+ WXDWORD exflags;
+ WXDWORD msflags = MSWGetCreateWindowFlags(&exflags);
+ msflags &= ~WS_VSCROLL;
+ msflags &= ~WS_HSCROLL;
+
+ if ( !wxWindow::MSWCreate(wxApp::GetRegisteredClassName(_T("wxMDIFrame")),
+ title.wx_str(),
+ pos, size,
+ msflags,
+ exflags) )
+ {
+ return false;
+ }
- int x = pos.x;
- int y = pos.y;
- int width = size.x;
- int height = size.y;
+ SetOwnBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
- m_windowMenu = (WXHMENU) ::LoadMenu(wxGetInstance(), "wxWindowMenu");
+ // unlike (almost?) all other windows, frames are created hidden
+ m_isShown = false;
- 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;
+ return true;
+}
+
+wxMDIParentFrame::~wxMDIParentFrame()
+{
+ // see comment in ~wxMDIChildFrame
+#if wxUSE_TOOLBAR
+ m_frameToolBar = NULL;
+#endif
+#if wxUSE_STATUSBAR
+ m_frameStatusBar = NULL;
+#endif // wxUSE_STATUSBAR
- // Adding WS_CLIPCHILDREN causes children not to be properly
- // drawn when first displaying them.
-// if (style & wxCLIP_CHILDREN)
-// msflags |= WS_CLIPCHILDREN;
+ DestroyChildren();
- wxWindow::MSWCreate(m_windowId, parent, wxMDIFrameClassName, this, title, x, y, width, height,
- msflags);
+ // the MDI frame menubar is not automatically deleted by Windows unlike for
+ // the normal frames
+ if ( m_hMenu )
+ ::DestroyMenu((HMENU)m_hMenu);
- wxModelessWindows.Append(this);
+ if ( m_clientWindow )
+ {
+ if ( m_clientWindow->MSWGetOldWndProc() )
+ m_clientWindow->UnsubclassWin();
- return TRUE;
+ m_clientWindow->SetHWND(0);
+ delete m_clientWindow;
+ }
}
-wxMDIParentFrame::~wxMDIParentFrame()
+// ----------------------------------------------------------------------------
+// wxMDIParentFrame child management
+// ----------------------------------------------------------------------------
+
+int wxMDIParentFrame::GetChildFramesCount() const
{
- DestroyChildren();
+ int count = 0;
+ for ( wxWindowList::const_iterator i = GetChildren().begin();
+ i != GetChildren().end();
+ ++i )
+ {
+ if ( wxDynamicCast(*i, wxMDIChildFrame) )
+ count++;
+ }
- DestroyMenu((HMENU) m_windowMenu); // Destroy dummy "Window" menu
- m_windowMenu = 0;
+ return count;
+}
- if (m_clientWindow->MSWGetOldWndProc())
- m_clientWindow->UnsubclassWin();
+void wxMDIParentFrame::AddMDIChild(wxMDIChildFrame * WXUNUSED(child))
+{
+ if ( GetChildFramesCount() == 1 )
+ {
+ // first MDI child added, we need to insert the window menu now if we
+ // have it
+ AddWindowMenu();
+ }
+}
- m_clientWindow->m_hWnd = 0;
- delete m_clientWindow;
+void wxMDIParentFrame::RemoveMDIChild(wxMDIChildFrame * WXUNUSED(child))
+{
+ if ( GetChildFramesCount() == 1 )
+ {
+ // last MDI child is being removed, remove the now unnecessary window
+ // menu too
+ RemoveWindowMenu();
+ }
}
-// Get size *available for subwindows* i.e. excluding menu bar.
-void wxMDIParentFrame::GetClientSize(int *x, int *y) const
+// ----------------------------------------------------------------------------
+// wxMDIParentFrame window menu handling
+// ----------------------------------------------------------------------------
+
+void wxMDIParentFrame::AddWindowMenu()
{
- RECT rect;
- ::GetClientRect((HWND) GetHWND(), &rect);
+ if ( m_windowMenu )
+ MDIInsertWindowMenu(GetClientWindow(), m_hMenu, GetMDIWindowMenu(this));
+}
- int cwidth = rect.right;
- int cheight = rect.bottom;
+void wxMDIParentFrame::RemoveWindowMenu()
+{
+ if ( m_windowMenu )
+ MDIRemoveWindowMenu(GetClientWindow(), m_hMenu);
+}
- if ( GetStatusBar() )
- {
- int sw, sh;
- GetStatusBar()->GetSize(&sw, &sh);
- cheight -= sh;
- }
+#if wxUSE_MENUS_NATIVE
- wxPoint pt(GetClientAreaOrigin());
- cheight -= pt.y;
- cwidth -= pt.x;
+void wxMDIParentFrame::InternalSetMenuBar()
+{
+ m_parentFrameActive = true;
- *x = cwidth;
- *y = cheight;
+ 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);
+ }
}
-void wxMDIParentFrame::SetMenuBar(wxMenuBar *menu_bar)
-{
- if (!menu_bar)
- {
- m_frameMenuBar = NULL;
- return;
- }
+#endif // wxUSE_MENUS_NATIVE
- if ( menu_bar->IsAttached() )
- return;
+void wxMDIParentFrame::SetWindowMenu(wxMenu* menu)
+{
+ // notice that Remove/AddWindowMenu() are safe to call even when
+ // m_windowMenu is NULL
+ RemoveWindowMenu();
- m_hMenu = menu_bar->Create();
+ delete m_windowMenu;
- if (m_frameMenuBar)
- delete m_frameMenuBar;
+ m_windowMenu = menu;
- // MDI parent-specific code follows
+ AddWindowMenu();
+}
- HMENU subMenu = GetSubMenu((HMENU) m_windowMenu, 0);
+void wxMDIParentFrame::DoMenuUpdates(wxMenu* menu)
+{
+ wxMDIChildFrame *child = GetActiveChild();
+ if ( child )
+ {
+ wxEvtHandler* source = child->GetEventHandler();
+ wxMenuBar* bar = child->GetMenuBar();
- // 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))
+ if (menu)
{
- success = TRUE;
- InsertMenu(menu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
- (UINT)subMenu, "&Window");
- break;
+ menu->UpdateUI(source);
}
- }
- 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);
+ else
+ {
+ if ( bar != NULL )
+ {
+ int nCount = bar->GetMenuCount();
+ for (int n = 0; n < nCount; n++)
+ bar->GetMenu(n)->UpdateUI(source);
+ }
+ }
+ }
+ else
+ {
+ wxFrameBase::DoMenuUpdates(menu);
+ }
}
-void wxMDIParentFrame::OnSize(wxSizeEvent& event)
+const wxMenuItem *wxMDIParentFrame::FindItemInMenuBar(int menuId) const
{
-#if wxUSE_CONSTRAINTS
- if (GetAutoLayout())
- Layout();
-#endif
- int x = 0;
- int y = 0;
- int width, height;
- GetClientSize(&width, &height);
+ const wxMenuItem *item = wxFrame::FindItemInMenuBar(menuId);
+ if ( !item && m_currentChild )
+ {
+ item = m_currentChild->FindItemInMenuBar(menuId);
+ }
+ return item;
+}
+
+void wxMDIParentFrame::UpdateClientSize()
+{
if ( GetClientWindow() )
- GetClientWindow()->SetSize(x, y, width, height);
+ {
+ int width, height;
+ GetClientSize(&width, &height);
-/* Already done in MSWOnSize
- // forward WM_SIZE to status bar control
-#if wxUSE_NATIVE_STATUSBAR
- if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
- ((wxStatusBar95 *)m_frameStatusBar)->OnSize(event);
-#endif
-*/
+ GetClientWindow()->SetSize(0, 0, width, height);
+ }
+}
+void wxMDIParentFrame::OnSize(wxSizeEvent& WXUNUSED(event))
+{
+ UpdateClientSize();
+
+ // do not call event.Skip() here, it somehow messes up MDI client window
}
-void wxMDIParentFrame::OnActivate(wxActivateEvent& event)
+void wxMDIParentFrame::OnIconized(wxIconizeEvent& event)
{
- // Do nothing
+ event.Skip();
+
+ if ( !event.IsIconized() )
+ UpdateClientSize();
}
// Returns the active MDI child window
wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
{
-// HWND hWnd = (HWND)LOWORD(SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDIGETACTIVE, 0, 0L));
- HWND hWnd = (HWND)SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDIGETACTIVE, 0, 0L);
- if (hWnd == 0)
- return NULL;
- else
- return (wxMDIChildFrame *)wxFindWinFromHandle((WXHWND) hWnd);
-}
+ HWND hWnd = (HWND)::SendMessage(GetWinHwnd(GetClientWindow()),
+ WM_MDIGETACTIVE, 0, 0L);
+ if ( hWnd == 0 )
+ return NULL;
-// Create the client window class (don't Create the window,
-// just return a new class)
-wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
-{
- return new wxMDIClientWindow ;
+ return (wxMDIChildFrame *)wxFindWinFromHandle(hWnd);
}
// Responds to colour changes, and passes event on to children.
{
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
+{
+ // we don't have any standard icons (any more)
+ return (WXHICON)0;
}
+// ---------------------------------------------------------------------------
// MDI operations
+// ---------------------------------------------------------------------------
+
void wxMDIParentFrame::Cascade()
{
- ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDICASCADE, 0, 0);
+ ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0);
}
-void wxMDIParentFrame::Tile()
+void wxMDIParentFrame::Tile(wxOrientation orient)
{
- ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDITILE, MDITILE_HORIZONTAL, 0);
+ wxASSERT_MSG( orient == wxHORIZONTAL || orient == wxVERTICAL,
+ _T("invalid orientation value") );
+
+ ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE,
+ orient == wxHORIZONTAL ? MDITILE_HORIZONTAL
+ : MDITILE_VERTICAL, 0);
}
void wxMDIParentFrame::ArrangeIcons()
{
- ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDIICONARRANGE, 0, 0);
+ ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDIICONARRANGE, 0, 0);
}
void wxMDIParentFrame::ActivateNext()
{
- ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDINEXT, 0, 0);
+ ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 0);
}
void wxMDIParentFrame::ActivatePrevious()
{
- ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDINEXT, 0, 1);
+ ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 1);
}
+// ---------------------------------------------------------------------------
+// the MDI parent frame window proc
+// ---------------------------------------------------------------------------
-/*
-// Returns a style for the client window - usually 0
-// or, for example, wxHSCROLL | wxVSCROLL
-long wxMDIParentFrame::GetClientStyle() const
+WXLRESULT wxMDIParentFrame::MSWWindowProc(WXUINT message,
+ WXWPARAM wParam,
+ WXLPARAM lParam)
{
- return wxHSCROLL | wxVSCROLL ;
-}
-*/
+ WXLRESULT rc = 0;
+ bool processed = false;
-bool wxMDIParentFrame::MSWOnDestroy()
-{
- return FALSE;
-}
+ switch ( message )
+ {
+ case WM_ACTIVATE:
+ {
+ WXWORD state, minimized;
+ WXHWND hwnd;
+ UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
-void wxMDIParentFrame::MSWOnCreate(WXLPCREATESTRUCT WXUNUSED(cs))
-{
- m_clientWindow = OnCreateClient();
- // Uses own style for client style
- m_clientWindow->CreateClient(this, GetWindowStyleFlag());
-}
+ processed = HandleActivate(state, minimized != 0, hwnd);
+ }
+ break;
-void wxMDIParentFrame::MSWOnSize(int x, int y, WXUINT id)
-{
- switch (id)
- {
- case SIZEFULLSCREEN:
- case SIZENORMAL:
- m_iconized = FALSE;
- break;
- case SIZEICONIC:
- m_iconized = TRUE;
- break;
- }
+ case WM_COMMAND:
+ {
+ WXWORD id, cmd;
+ WXHWND hwnd;
+ UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
- 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 );
+ (void)HandleCommand(id, cmd, hwnd);
- ((wxStatusBar95 *)m_frameStatusBar)->OnSize(event);
- }
-#endif
+ // even if the frame didn't process it, there is no need to try it
+ // once again (i.e. call wxFrame::HandleCommand()) - we just did it,
+ // so pretend we processed the message anyhow
+ processed = true;
+ }
- PositionStatusBar();
- PositionToolBar();
+ // always pass this message DefFrameProc(), otherwise MDI menu
+ // commands (and sys commands - more surprisingly!) won't work
+ MSWDefWindowProc(message, wParam, lParam);
+ break;
- wxSizeEvent event(wxSize(x, y), m_windowId);
- event.SetEventObject( this );
- if (!GetEventHandler()->ProcessEvent(event))
- Default();
- }
+ case WM_CREATE:
+ m_clientWindow = OnCreateClient();
+ // Uses own style for client style
+ if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
+ {
+ wxLogMessage(_("Failed to create MDI parent frame."));
+
+ rc = -1;
+ }
+
+ processed = true;
+ break;
+
+ case WM_ERASEBKGND:
+ processed = true;
+
+ // we erase background ourselves
+ rc = true;
+ break;
+
+ case WM_SIZE:
+ // though we don't (usually) resize the MDI client to exactly fit the
+ // client area we need to pass this one to DefFrameProc to allow the children to show
+ break;
+ }
+
+ if ( !processed )
+ rc = wxFrame::MSWWindowProc(message, wParam, lParam);
+
+ return rc;
}
-bool wxMDIParentFrame::MSWOnActivate(int state, bool minimized, WXHWND activate)
+bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate)
{
- wxWindow::MSWOnActivate(state, minimized, activate);
+ bool processed = false;
+
+ if ( wxWindow::HandleActivate(state, minimized, activate) )
+ {
+ // already processed
+ processed = true;
+ }
// If this window is an MDI parent, we must also send an OnActivate message
// to the current child.
- if ((m_currentChild != NULL) && ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)))
+ if ( (m_currentChild != NULL) &&
+ ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) )
{
- wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_currentChild->GetId());
+ wxActivateEvent event(wxEVT_ACTIVATE, true, m_currentChild->GetId());
event.SetEventObject( m_currentChild );
- m_currentChild->GetEventHandler()->ProcessEvent(event);
+ if ( m_currentChild->HandleWindowEvent(event) )
+ processed = true;
}
- return 0;
+
+ 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?
- {
+ // sign extend to int from short before comparing with the other int ids
+ int id = (signed short)id_;
+
// 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)
{
wxMenu *popupMenu = wxCurrentPopupMenu;
wxCurrentPopupMenu = NULL;
- if (!popupMenu->MSWCommand(cmd, id))
- return TRUE;
+ if (popupMenu->MSWCommand(cmd, id))
+ return true;
}
-*/
- 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::compatibility_iterator 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;
+ int childId = wxGetWindowId(child->GetHWND());
+ if ( childId == (signed short)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);
}
-*/
- }
-
- return FALSE;
-}
-
-void wxMDIParentFrame::MSWOnMenuHighlight(WXWORD nItem, WXWORD nFlags, WXHMENU hSysMenu)
-{
- if (m_parentFrameActive)
- {
- if (nFlags == 0xFFFF && hSysMenu == (WXHMENU) NULL)
+ else if ( m_currentChild )
{
- wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, -1);
- event.SetEventObject( this );
- GetEventHandler()->ProcessEvent(event);
+ return m_currentChild->HandleCommand(id, cmd, hwnd);
}
- else if (nFlags != MF_SEPARATOR)
+ else
{
- wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, nItem);
- event.SetEventObject( this );
- GetEventHandler()->ProcessEvent(event);
+ // 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?"));
}
- }
- else if (m_currentChild)
- {
- m_currentChild->MSWOnMenuHighlight(nItem, nFlags, hSysMenu);
- }
+
+ return false;
}
-long wxMDIParentFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
+WXLRESULT wxMDIParentFrame::MSWDefWindowProc(WXUINT message,
+ WXWPARAM wParam,
+ WXLPARAM lParam)
{
WXHWND clientWnd;
if ( GetClientWindow() )
else
clientWnd = 0;
- return DefFrameProc((HWND) GetHWND(), (HWND) clientWnd, message, wParam, lParam);
-}
-
-bool wxMDIParentFrame::MSWProcessMessage(WXMSG* msg)
-{
- if ((m_currentChild != (wxWindow *)NULL) && (m_currentChild->GetHWND() != (WXHWND) NULL) && m_currentChild->MSWProcessMessage(msg))
- return TRUE;
-
- return FALSE;
+ return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam);
}
bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg)
{
- MSG *pMsg = (MSG *)msg;
-
- if ((m_currentChild != (wxWindow *)NULL) && (m_currentChild->GetHWND() != (WXHWND) NULL) && m_currentChild->MSWTranslateMessage(msg))
- return TRUE;
+ MSG *pMsg = (MSG *)msg;
- if (m_acceleratorTable.Ok() &&
- ::TranslateAccelerator((HWND) GetHWND(), (HACCEL) m_acceleratorTable.GetHACCEL(), pMsg))
- return TRUE;
-
- if (pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN)
- {
- if (::TranslateMDISysAccel((HWND) GetClientWindow()->GetHWND(), pMsg))
- return TRUE;
- }
+ // first let the current child get it
+ if ( m_currentChild && m_currentChild->GetHWND() &&
+ m_currentChild->MSWTranslateMessage(msg) )
+ {
+ return true;
+ }
- return FALSE;
-}
+ // 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))
+ return true;
+ }
-bool wxMDIParentFrame::MSWOnEraseBkgnd(WXHDC WXUNUSED(pDC))
-{
- return TRUE;
+ return false;
}
-extern wxWindow *wxWndHook;
-extern wxList *wxWinHandleList;
+// ===========================================================================
+// wxMDIChildFrame
+// ===========================================================================
-wxMDIChildFrame::wxMDIChildFrame()
+void wxMDIChildFrame::Init()
{
-// m_active = FALSE;
+ m_needsResize = true;
+ m_needsInitialShow = true;
}
bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
- wxWindowID id,
- const wxString& title,
- const wxPoint& pos,
- const wxSize& size,
- long style,
- const wxString& name)
+ wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
- m_defaultIcon = (WXHICON) (wxSTD_MDICHILDFRAME_ICON ? wxSTD_MDICHILDFRAME_ICON : wxDEFAULT_MDICHILDFRAME_ICON);
+ m_mdiParent = parent;
SetName(name);
- if ( id > -1 )
+ if ( id != wxID_ANY )
m_windowId = id;
else
- m_windowId = (int)NewControlId();
-
- if (parent) parent->AddChild(this);
+ m_windowId = NewControlId();
- wxWndHook = this;
+ if ( parent )
+ {
+ parent->AddChild(this);
+ }
int x = pos.x;
int y = pos.y;
MDICREATESTRUCT mcs;
- mcs.szClass = wxMDIChildFrameClassName;
- mcs.szTitle = title;
+ wxString className =
+ wxApp::GetRegisteredClassName(_T("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) mcs.x = x;
- else mcs.x = CW_USEDEFAULT;
+ if (x != wxDefaultCoord)
+ mcs.x = x;
+ else
+ mcs.x = CW_USEDEFAULT;
- if (y > -1) mcs.y = y;
- else mcs.y = CW_USEDEFAULT;
+ if (y != wxDefaultCoord)
+ mcs.y = y;
+ else
+ mcs.y = CW_USEDEFAULT;
- if (width > -1) mcs.cx = width;
- else mcs.cx = CW_USEDEFAULT;
+ if (width != wxDefaultCoord)
+ mcs.cx = width;
+ else
+ mcs.cx = CW_USEDEFAULT;
- if (height > -1) mcs.cy = height;
- else mcs.cy = CW_USEDEFAULT;
+ if (height != wxDefaultCoord)
+ mcs.cy = height;
+ else
+ mcs.cy = CW_USEDEFAULT;
- DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN ;
+ 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;
mcs.lParam = 0;
- DWORD Return = SendMessage((HWND) parent->GetClientWindow()->GetHWND(),
- WM_MDICREATE, 0, (LONG)(LPSTR)&mcs);
+ wxWindowCreationHook hook(this);
- //handle = (HWND)LOWORD(Return);
- // Must be the DWORRD for WIN32. And in 16 bits, HIWORD=0 (says Microsoft)
- m_hWnd = (WXHWND)Return;
+ m_hWnd = (WXHWND)::SendMessage(GetWinHwnd(parent->GetClientWindow()),
+ WM_MDICREATE, 0, (LPARAM)&mcs);
- // This gets reassigned so can't be stored
-// m_windowId = GetWindowLong((HWND) m_hWnd, GWL_ID);
+ if ( !m_hWnd )
+ {
+ wxLogLastError(_T("WM_MDICREATE"));
+ return false;
+ }
- wxWndHook = NULL;
- wxWinHandleList->Append((long)GetHWND(), this);
+ SubclassWin(m_hWnd);
- SetWindowLong((HWND) GetHWND(), 0, (long)this);
+ parent->AddMDIChild(this);
- wxModelessWindows.Append(this);
- return TRUE;
+ return true;
}
wxMDIChildFrame::~wxMDIChildFrame()
{
+ // if we hadn't been created, there is nothing to destroy
+ if ( !m_hWnd )
+ return;
+
+ 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
+
+ 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());
- ResetWindowStyle(NULL);
+ // 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;
}
// Set the client size (i.e. leave the calculation of borders etc.
-// to wxWindows)
-void wxMDIChildFrame::SetClientSize(int width, int height)
+// to wxWidgets)
+void wxMDIChildFrame::DoSetClientSize(int width, int height)
{
- HWND hWnd = (HWND) GetHWND();
+ HWND hWnd = GetHwnd();
RECT rect;
::GetClientRect(hWnd, &rect);
int actual_width = rect2.right - rect2.left - rect.right + width;
int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
- if (GetStatusBar())
+#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;
// 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::GetPosition(int *x, int *y) const
+
+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;
// 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::SetMenuBar(wxMenuBar *menu_bar)
+void wxMDIChildFrame::InternalSetMenuBar()
{
- if (!menu_bar)
- {
- m_frameMenuBar = NULL;
- return;
- }
-
- if ( menu_bar->IsAttached() )
- return;
+ wxMDIParentFrame * const parent = GetMDIParent();
- m_hMenu = menu_bar->Create();
+ MDIInsertWindowMenu(parent->GetClientWindow(),
+ m_hMenu, GetMDIWindowMenu(parent));
- if (m_frameMenuBar)
- delete m_frameMenuBar;
-
- wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
-
- parent->m_parentFrameActive = FALSE;
- HMENU subMenu = GetSubMenu((HMENU) parent->GetWindowMenu(), 0);
+ parent->m_parentFrameActive = false;
+}
- // 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
+void wxMDIChildFrame::DetachMenuBar()
+{
+ MDIRemoveWindowMenu(NULL, m_hMenu);
+ wxFrame::DetachMenuBar();
+}
- DrawMenuBar((HWND) parent->GetHWND());
- m_frameMenuBar = menu_bar;
- menu_bar->Attach(this);
+WXHICON wxMDIChildFrame::GetDefaultIcon() const
+{
+ // we don't have any standard icons (any more)
+ return (WXHICON)0;
}
+// ---------------------------------------------------------------------------
// MDI operations
-void wxMDIChildFrame::Maximize()
+// ---------------------------------------------------------------------------
+
+void wxMDIChildFrame::Maximize(bool maximize)
{
- wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
+ wxMDIParentFrame * const parent = GetMDIParent();
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();
+ wxMDIParentFrame * const parent = GetMDIParent();
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();
+ wxMDIParentFrame * const parent = GetMDIParent();
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;
-void wxMDIChildFrame::MSWOnSize(int x, int y, WXUINT id)
+// ---------------------------------------------------------------------------
+// MDI window proc and message handlers
+// ---------------------------------------------------------------------------
+
+WXLRESULT wxMDIChildFrame::MSWWindowProc(WXUINT message,
+ WXWPARAM wParam,
+ WXLPARAM lParam)
{
- if (!GetHWND()) return;
+ WXLRESULT rc = 0;
+ bool processed = false;
- if (invalidHandle == (HWND) GetHWND())
- {
- return;
- }
+ switch ( message )
+ {
+ case WM_COMMAND:
+ {
+ WORD id, cmd;
+ WXHWND hwnd;
+ UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam,
+ &id, &hwnd, &cmd);
- (void)MSWDefWindowProc(m_lastMsg, m_lastWParam, m_lastLParam);
+ processed = HandleCommand(id, cmd, (WXHWND)hwnd);
+ }
+ break;
- switch (id)
- {
- case SIZEFULLSCREEN:
- case SIZENORMAL:
- m_iconized = FALSE;
- break;
- case SIZEICONIC:
- m_iconized = TRUE;
- break;
- }
+ case WM_GETMINMAXINFO:
+ processed = HandleGetMinMaxInfo((MINMAXINFO *)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 );
+ 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
- ((wxStatusBar95 *)m_frameStatusBar)->OnSize(event);
+ 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;
}
-#endif
- PositionStatusBar();
- PositionToolBar();
+ if ( !processed )
+ rc = wxFrame::MSWWindowProc(message, wParam, lParam);
- wxWindow::MSWOnSize(x, y, id);
- }
+ 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())
- {
+ // sign extend to int from short before comparing with the other int ids
+ int id = (signed short)id_;
+
// 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)
{
wxMenu *popupMenu = wxCurrentPopupMenu;
wxCurrentPopupMenu = NULL;
if (popupMenu->MSWCommand(cmd, id))
- return TRUE;
+ 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 FALSE;
-}
+ {
+ 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 * const parent = GetMDIParent();
+
+ 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 HandleWindowEvent(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 (!(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;
+ }
+ }
- return FALSE;
+ return false;
}
-long 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 != wxDefaultCoord )
{
- 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 );
- GetEventHandler()->ProcessEvent(event);
- }
- else
- {
- if (parent->m_currentChild == this)
- parent->m_currentChild = NULL;
-
- wxActivateEvent event(wxEVT_ACTIVATE, FALSE, m_windowId);
- event.SetEventObject( this );
- GetEventHandler()->ProcessEvent(event);
-// m_active = FALSE;
- if (parent_menu)
+ if ( minHeight != wxDefaultCoord )
{
- 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 );
- GetEventHandler()->ProcessEvent(event);
- return 0;
+
+ return processed;
}
+// ---------------------------------------------------------------------------
+// MDI specific message translation/preprocessing
+// ---------------------------------------------------------------------------
+
+WXLRESULT wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
+{
+ return DefMDIChildProc(GetHwnd(),
+ (UINT)message, (WPARAM)wParam, (LPARAM)lParam);
+}
+
+bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* 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);
+}
+
+// ---------------------------------------------------------------------------
+// misc
+// ---------------------------------------------------------------------------
+
void wxMDIChildFrame::MSWDestroyWindow()
{
- MSWDetachWindowMenu();
- invalidHandle = (HWND) GetHWND();
+ wxMDIParentFrame * const parent = GetMDIParent();
- 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() == NULL)
+ ResetWindowStyle(NULL);
- if (m_hMenu)
- {
- ::DestroyMenu((HMENU) m_hMenu);
- m_hMenu = 0;
- }
- m_hWnd = 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__)
RECT *rect = (RECT *)vrect;
- wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
+ wxMDIParentFrame * const pFrameWnd = GetMDIParent();
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);
- return TRUE;
+ ::GetClientRect(hwndClient, rect);
+
+ return true;
}
}
- return FALSE;
-#else
- return FALSE;
-#endif
+
+ return false;
}
-void 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;
-#if defined(__WIN95__)
- if (!(lpPos->flags & SWP_NOSIZE))
+ 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;
+
+ DWORD exStyle = WS_EX_CLIENTEDGE;
+
+ 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
- Default();
-}
-// Client window
-wxMDIClientWindow::wxMDIClientWindow()
-{
- m_scrollX = 0;
- m_scrollY = 0;
+ SubclassWin(m_hWnd);
+
+ return true;
}
-wxMDIClientWindow::~wxMDIClientWindow()
+// Explicitly call default scroll behaviour
+void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
{
+ // 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();
}
-bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
+void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
{
- m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE);
+ // 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.
- CLIENTCREATESTRUCT ccs;
- m_windowStyle = style;
- m_windowParent = parent;
+ const wxPoint oldPos = GetPosition();
- ccs.hWindowMenu = (HMENU) parent->GetWindowMenu();
- ccs.idFirstChild = wxFIRST_MDI_CHILD;
+ wxWindow::DoSetSize(x, y, width, height, sizeFlags | wxSIZE_FORCE);
- DWORD msStyle = WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN ;
- if ( parent->GetWindowStyleFlag() & wxHSCROLL )
- msStyle |= WS_HSCROLL;
- if ( parent->GetWindowStyleFlag() & wxVSCROLL )
- msStyle |= WS_VSCROLL ;
+ const wxPoint newPos = GetPosition();
-#if defined(__WIN95__)
- DWORD exStyle = WS_EX_CLIENTEDGE;
-#else
- DWORD exStyle = 0;
-#endif
+ if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y))
+ {
+ if (GetParent())
+ {
+ wxWindowList::compatibility_iterator node = GetParent()->GetChildren().GetFirst();
+ while (node)
+ {
+ wxWindow *child = node->GetData();
+ if (child->IsKindOf(CLASSINFO(wxMDIChildFrame)))
+ {
+ ::RedrawWindow(GetHwndOf(child),
+ NULL,
+ NULL,
+ RDW_FRAME |
+ RDW_ALLCHILDREN |
+ RDW_INVALIDATE);
+ }
+ node = node->GetNext();
+ }
+ }
+ }
+}
- 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;
+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
+
+ SendSizeEvent();
+ }
- return (m_hWnd != 0) ;
+ event.Skip();
}
-// Window procedure: here for debugging purposes
-long wxMDIClientWindow::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
+// ---------------------------------------------------------------------------
+// non member functions
+// ---------------------------------------------------------------------------
+
+static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow)
{
- return wxWindow::MSWWindowProc(nMsg, wParam, lParam);
-// return MSWDefWindowProc(nMsg, wParam, lParam);
+ if ( hmenuFrame || hmenuWindow )
+ {
+ if ( !::SendMessage(GetWinHwnd(win),
+ WM_MDISETMENU,
+ (WPARAM)hmenuFrame,
+ (LPARAM)hmenuWindow) )
+ {
+#ifdef __WXDEBUG__
+ DWORD err = ::GetLastError();
+ if ( err )
+ wxLogApiError(_T("SendMessage(WM_MDISETMENU)"), err);
+#endif // __WXDEBUG__
+ }
+ }
+
+ // update menu bar of the parent window
+ wxWindow *parent = win->GetParent();
+ wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") );
+
+ ::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L);
+
+ ::DrawMenuBar(GetWinHwnd(parent));
}
-long wxMDIClientWindow::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
+static void MDIInsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu)
{
- 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);
+ // 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;
+ }
+
+ wxString strBuf(buf);
+ if ( wxStripMenuCodes(strBuf) == wxGetStockLabel(wxID_HELP,false) )
+ {
+ success = true;
+ ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
+ (UINT_PTR)subMenu, _("&Window").wx_str());
+ break;
+ }
+ }
+
+ if ( !success )
+ {
+ ::AppendMenu(hmenu, MF_POPUP,
+ (UINT_PTR)subMenu, _("&Window").wx_str());
+ }
+ }
+
+ MDISetMenu(win, hmenu, subMenu);
}
-// Explicitly call default scroll behaviour
-void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
+static void MDIRemoveWindowMenu(wxWindow *win, WXHMENU menu)
{
- // 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.
+ HMENU hMenu = (HMENU)menu;
- if ( event.GetOrientation() == wxHORIZONTAL )
- m_scrollX = event.GetPosition(); // Always returns zero!
- else
- m_scrollY = event.GetPosition(); // Always returns zero!
+ 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"));
+ }
- Default();
+ break;
+ }
+ }
+ }
+
+ if ( win )
+ {
+ // we don't change the windows menu, but we update the main one
+ MDISetMenu(win, hMenu, NULL);
+ }
}
-// Should hand the message to the default proc
-long wxMDIClientWindow::MSWOnMDIActivate(long bActivate, WXHWND, WXHWND)
+static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
+ WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact)
{
- return Default();
+ *activate = true;
+ *hwndAct = (WXHWND)lParam;
+ *hwndDeact = (WXHWND)wParam;
}
+#endif // wxUSE_MDI && !defined(__WXUNIVERSAL__)
projects / wxWidgets.git / blobdiff