// headers
// ---------------------------------------------------------------------------
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
- #pragma implementation "mdi.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#pragma hdrstop
#endif
-#if wxUSE_MDI_ARCHITECTURE && !defined(__WXUNIVERSAL__)
+#if wxUSE_MDI && !defined(__WXUNIVERSAL__)
+
+#include "wx/mdi.h"
#ifndef WX_PRECOMP
- #include "wx/setup.h"
#include "wx/frame.h"
#include "wx/menu.h"
#include "wx/app.h"
#include "wx/utils.h"
#include "wx/dialog.h"
- #if wxUSE_STATUSBAR
- #include "wx/statusbr.h"
- #endif
+ #include "wx/statusbr.h"
#include "wx/settings.h"
#include "wx/intl.h"
#include "wx/log.h"
+ #include "wx/toolbar.h"
#endif
-#include "wx/mdi.h"
+#include "wx/stockitem.h"
#include "wx/msw/private.h"
#if wxUSE_STATUSBAR && wxUSE_NATIVE_STATUSBAR
#include "wx/msw/statbr95.h"
#endif
-#if wxUSE_TOOLBAR
- #include "wx/toolbar.h"
-#endif // wxUSE_TOOLBAR
-
#include <string.h>
// ---------------------------------------------------------------------------
// global variables
// ---------------------------------------------------------------------------
-extern wxWindowList wxModelessWindows; // from dialog.cpp
extern wxMenu *wxCurrentPopupMenu;
extern const wxChar *wxMDIFrameClassName; // from app.cpp
extern const wxChar *wxMDIChildFrameClassName;
extern const wxChar *wxMDIChildFrameClassNameNoRedraw;
-extern void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win);
extern void wxRemoveHandleAssociation(wxWindow *win);
-static HWND invalidHandle = 0;
-
// ---------------------------------------------------------------------------
// 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 wxFIRST_MDI_CHILD = 4100;
static const int wxLAST_MDI_CHILD = 4600;
-// Status border dimensions
-static const int wxTHICK_LINE_BORDER = 3;
-static const int wxTHICK_LINE_WIDTH = 1;
-
// ---------------------------------------------------------------------------
// private functions
// ---------------------------------------------------------------------------
BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
EVT_SIZE(wxMDIParentFrame::OnSize)
+ EVT_ICONIZE(wxMDIParentFrame::OnIconized)
EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
END_EVENT_TABLE()
if ( parent )
parent->AddChild(this);
- if ( id > -1 )
+ if ( id != wxID_ANY )
m_windowId = id;
else
m_windowId = NewControlId();
return false;
}
- wxModelessWindows.Append(this);
+ SetOwnBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
// unlike (almost?) all other windows, frames are created hidden
m_isShown = false;
wxMDIParentFrame::~wxMDIParentFrame()
{
- DestroyChildren();
-
- // already delete by DestroyChildren()
+ // see comment in ~wxMDIChildFrame
+#if wxUSE_TOOLBAR
m_frameToolBar = NULL;
+#endif
+#if wxUSE_STATUSBAR
m_frameStatusBar = NULL;
+#endif // wxUSE_STATUSBAR
+
+ DestroyChildren();
if (m_windowMenu)
{
}
}
-void wxMDIParentFrame::OnSize(wxSizeEvent&)
+void wxMDIParentFrame::DoMenuUpdates(wxMenu* menu)
+{
+ wxMDIChildFrame *child = GetActiveChild();
+ if ( child )
+ {
+ wxEvtHandler* source = child->GetEventHandler();
+ wxMenuBar* bar = child->GetMenuBar();
+
+ if (menu)
+ {
+ menu->UpdateUI(source);
+ }
+ else
+ {
+ if ( bar != NULL )
+ {
+ int nCount = bar->GetMenuCount();
+ for (int n = 0; n < nCount; n++)
+ bar->GetMenu(n)->UpdateUI(source);
+ }
+ }
+ }
+ else
+ {
+ wxFrameBase::DoMenuUpdates(menu);
+ }
+}
+
+void wxMDIParentFrame::UpdateClientSize()
{
if ( GetClientWindow() )
{
}
}
+void wxMDIParentFrame::OnSize(wxSizeEvent& WXUNUSED(event))
+{
+ UpdateClientSize();
+
+ // do not call event.Skip() here, it somehow messes up MDI client window
+}
+
+void wxMDIParentFrame::OnIconized(wxIconizeEvent& event)
+{
+ event.Skip();
+
+ if ( !event.Iconized() )
+ {
+ UpdateClientSize();
+ }
+}
+
// Returns the active MDI child window
wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
{
::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0);
}
-// TODO: add a direction argument (hor/vert)
-void wxMDIParentFrame::Tile()
+void wxMDIParentFrame::Tile(wxOrientation orient)
{
- ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE, MDITILE_HORIZONTAL, 0);
+ wxASSERT_MSG( orient == wxHORIZONTAL || orient == wxVERTICAL,
+ _T("invalid orientation value") );
+
+ ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE,
+ orient == wxHORIZONTAL ? MDITILE_HORIZONTAL
+ : MDITILE_VERTICAL, 0);
}
void wxMDIParentFrame::ArrangeIcons()
// the MDI parent frame window proc
// ---------------------------------------------------------------------------
-long wxMDIParentFrame::MSWWindowProc(WXUINT message,
+WXLRESULT wxMDIParentFrame::MSWWindowProc(WXUINT message,
WXWPARAM wParam,
WXLPARAM lParam)
{
- long rc = 0;
+ WXLRESULT rc = 0;
bool processed = false;
switch ( message )
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
+ // 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;
}
return win->MSWCommand(cmd, id);
}
+ if (wxCurrentPopupMenu)
+ {
+ wxMenu *popupMenu = wxCurrentPopupMenu;
+ wxCurrentPopupMenu = NULL;
+ if (popupMenu->MSWCommand(cmd, id))
+ return true;
+ }
+
// is it one of standard MDI commands?
WXWPARAM wParam = 0;
WXLPARAM lParam = 0;
return false;
}
-long wxMDIParentFrame::MSWDefWindowProc(WXUINT message,
+WXLRESULT wxMDIParentFrame::MSWDefWindowProc(WXUINT message,
WXWPARAM wParam,
WXLPARAM lParam)
{
void wxMDIChildFrame::Init()
{
m_needsResize = true;
+ m_needsInitialShow = true;
}
bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
const wxString& name)
{
SetName(name);
- wxWindowBase::Show(true); // MDI child frame starts off shown
- if ( id > -1 )
+ if ( id != wxID_ANY )
m_windowId = id;
else
m_windowId = (int)NewControlId();
: wxMDIChildFrameClassNameNoRedraw;
mcs.szTitle = title;
mcs.hOwner = wxGetInstance();
- if (x > -1)
+ if (x != wxDefaultCoord)
mcs.x = x;
else
mcs.x = CW_USEDEFAULT;
- if (y > -1)
+ if (y != wxDefaultCoord)
mcs.y = y;
else
mcs.y = CW_USEDEFAULT;
- if (width > -1)
+ if (width != wxDefaultCoord)
mcs.cx = width;
else
mcs.cx = CW_USEDEFAULT;
- if (height > -1)
+ if (height != wxDefaultCoord)
mcs.cy = height;
else
mcs.cy = CW_USEDEFAULT;
- DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN | WS_THICKFRAME | WS_VISIBLE ;
+ DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN;
if (style & wxMINIMIZE_BOX)
msflags |= WS_MINIMIZEBOX;
if (style & wxMAXIMIZE_BOX)
msflags |= WS_MAXIMIZEBOX;
- if (style & wxTHICK_FRAME)
+ if (style & wxRESIZE_BORDER)
msflags |= WS_THICKFRAME;
if (style & wxSYSTEM_MENU)
msflags |= WS_SYSMENU;
m_hWnd = (WXHWND)::SendMessage(GetWinHwnd(parent->GetClientWindow()),
WM_MDICREATE, 0, (LONG)(LPSTR)&mcs);
- wxAssociateWinWithHandle((HWND) GetHWND(), this);
+ if ( !m_hWnd )
+ {
+ wxLogLastError(_T("WM_MDICREATE"));
+ return false;
+ }
- wxModelessWindows.Append(this);
+ SubclassWin(m_hWnd);
return true;
}
wxMDIChildFrame::~wxMDIChildFrame()
{
- DestroyChildren();
-
- // already deleted by DestroyChildren()
+ // 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();
RemoveWindowMenu(NULL, m_hMenu);
MSWDestroyWindow();
}
+bool wxMDIChildFrame::Show(bool show)
+{
+ m_needsInitialShow = false;
+
+ if (!wxFrame::Show(show))
+ return false;
+
+ // KH: Without this call, new MDI children do not become active.
+ // This was added here after the same BringWindowToTop call was
+ // removed from wxTopLevelWindow::Show (November 2005)
+ if ( show )
+ ::BringWindowToTop(GetHwnd());
+
+ // we need to refresh the MDI frame window menu to include (or exclude if
+ // we've been hidden) this frame
+ wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
+ MDISetMenu(parent->GetClientWindow(), NULL, NULL);
+
+ return true;
+}
+
// Set the client size (i.e. leave the calculation of borders etc.
-// to wxWindows)
+// to wxWidgets)
void wxMDIChildFrame::DoSetClientSize(int width, int height)
{
HWND hWnd = GetHwnd();
int actual_width = rect2.right - rect2.left - rect.right + width;
int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
+#if wxUSE_STATUSBAR
if (GetStatusBar() && GetStatusBar()->IsShown())
{
int sx, sy;
GetStatusBar()->GetSize(&sx, &sy);
actual_height += sy;
}
+#endif // wxUSE_STATUSBAR
POINT point;
point.x = rect2.left;
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);
}
+// Unlike other wxTopLevelWindowBase, the mdi child's "GetPosition" is not the
+// same as its GetScreenPosition
+void wxMDIChildFrame::DoGetScreenPosition(int *x, int *y) const
+{
+ HWND hWnd = GetHwnd();
+
+ RECT rect;
+ ::GetWindowRect(hWnd, &rect);
+ if (x)
+ *x = rect.left;
+ if (y)
+ *y = rect.top;
+}
+
+
void wxMDIChildFrame::DoGetPosition(int *x, int *y) const
{
RECT rect;
wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent();
::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &point);
- *x = point.x;
- *y = point.y;
+ if (x)
+ *x = point.x;
+ if (y)
+ *y = point.y;
}
void wxMDIChildFrame::InternalSetMenuBar()
parent->m_parentFrameActive = false;
}
+void wxMDIChildFrame::DetachMenuBar()
+{
+ RemoveWindowMenu(NULL, m_hMenu);
+ wxFrame::DetachMenuBar();
+}
+
WXHICON wxMDIChildFrame::GetDefaultIcon() const
{
// we don't have any standard icons (any more)
// MDI window proc and message handlers
// ---------------------------------------------------------------------------
-long wxMDIChildFrame::MSWWindowProc(WXUINT message,
+WXLRESULT wxMDIChildFrame::MSWWindowProc(WXUINT message,
WXWPARAM wParam,
WXLPARAM lParam)
{
- long rc = 0;
+ WXLRESULT rc = 0;
bool processed = false;
switch ( message )
bool wxMDIChildFrame::HandleWindowPosChanging(void *pos)
{
WINDOWPOS *lpPos = (WINDOWPOS *)pos;
-#if defined(__WIN95__)
+
if (!(lpPos->flags & SWP_NOSIZE))
{
RECT rectClient;
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;
}
minHeight = GetMinHeight();
// but allow GetSizeHints() to set the min size
- if ( minWidth != -1 )
+ if ( minWidth != wxDefaultCoord )
{
info->ptMinTrackSize.x = minWidth;
processed = true;
}
- if ( minHeight != -1 )
+ if ( minHeight != wxDefaultCoord )
{
info->ptMinTrackSize.y = minHeight;
// MDI specific message translation/preprocessing
// ---------------------------------------------------------------------------
-long wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXUINT wParam, WXLPARAM lParam)
+WXLRESULT wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
{
return DefMDIChildProc(GetHwnd(),
(UINT)message, (WPARAM)wParam, (LPARAM)lParam);
bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg)
{
- return wxFrame::MSWTranslateMessage(msg);
+ // we must pass the parent frame to ::TranslateAccelerator(), otherwise it
+ // doesn't do its job correctly for MDI child menus
+ return MSWDoTranslateMessage((wxMDIChildFrame *)GetParent(), msg);
}
// ---------------------------------------------------------------------------
void wxMDIChildFrame::MSWDestroyWindow()
{
- invalidHandle = GetHwnd();
-
wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
// Must make sure this handle is invalidated (set to NULL) since all sorts
if (parent->GetActiveChild() == (wxMDIChildFrame*) NULL)
ResetWindowStyle((void*) NULL);
- invalidHandle = 0;
-
if (m_hMenu)
{
::DestroyMenu((HMENU) m_hMenu);
// 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();
wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild();
+
if (!pChild || (pChild == this))
{
HWND hwndClient = GetWinHwnd(pFrameWnd->GetClientWindow());
return true;
}
}
-#endif // Win95
return false;
}
if ( style & wxVSCROLL )
msStyle |= WS_VSCROLL;
-#if defined(__WIN95__)
DWORD exStyle = WS_EX_CLIENTEDGE;
-#else
- DWORD exStyle = 0;
-#endif
wxWindowCreationHook hook(this);
m_hWnd = (WXHWND)::CreateWindowEx
// (see OGL studio sample). So check if the position is changed and if so,
// redraw the MDI child frames.
- wxPoint oldPos = GetPosition();
+ const wxPoint oldPos = GetPosition();
- wxWindow::DoSetSize(x, y, width, height, sizeFlags);
+ wxWindow::DoSetSize(x, y, width, height, sizeFlags | wxSIZE_FORCE);
- wxPoint newPos = GetPosition();
+ const wxPoint newPos = GetPosition();
if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y))
{
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
static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow)
{
- ::SendMessage(GetWinHwnd(win), WM_MDISETMENU,
-#ifdef __WIN32__
- (WPARAM)hmenuFrame, (LPARAM)hmenuWindow
-#else
- 0, MAKELPARAM(hmenuFrame, hmenuWindow)
-#endif
- );
+ if ( hmenuFrame || hmenuWindow )
+ {
+ if ( !::SendMessage(GetWinHwnd(win),
+ WM_MDISETMENU,
+ (WPARAM)hmenuFrame,
+ (LPARAM)hmenuWindow) )
+ {
+ wxLogLastError(_T("SendMessage(WM_MDISETMENU)"));
+ }
+ }
// update menu bar of the parent window
wxWindow *parent = win->GetParent();
wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") );
-#ifndef __WIN16__
::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L);
-#endif
::DrawMenuBar(GetWinHwnd(parent));
}
continue;
}
- if ( wxStripMenuCodes(wxString(buf)).IsSameAs(_("Help")) )
+ wxString strBuf(buf);
+ if ( wxStripMenuCodes(strBuf) == wxGetStockLabel(wxID_HELP,false) )
{
success = true;
::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact)
{
-#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
}
-#endif
-// wxUSE_MDI_ARCHITECTURE && !defined(__WXUNIVERSAL__)
-
+#endif // wxUSE_MDI && !defined(__WXUNIVERSAL__)
projects / wxWidgets.git / blobdiff