/////////////////////////////////////////////////////////////////////////////
-// 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
/////////////////////////////////////////////////////////////////////////////
// ===========================================================================
// headers
// ---------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "mdi.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#pragma hdrstop
#endif
+#if wxUSE_MDI && !defined(__WXUNIVERSAL__)
+
#ifndef WX_PRECOMP
#include "wx/setup.h"
#include "wx/frame.h"
#include "wx/log.h"
#endif
+#include "wx/stockitem.h"
#include "wx/mdi.h"
#include "wx/msw/private.h"
// global variables
// ---------------------------------------------------------------------------
-extern wxWindowList wxModelessWindows; // from dialog.cpp
extern wxMenu *wxCurrentPopupMenu;
-extern wxChar wxMDIFrameClassName[];
-extern wxChar wxMDIChildFrameClassName[];
-extern wxWindow *wxWndHook; // from window.cpp
-
+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 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;
-// Status border dimensions
-static const int wxTHICK_LINE_BORDER = 3;
-static const int wxTHICK_LINE_WIDTH = 1;
-
// ---------------------------------------------------------------------------
// private functions
// ---------------------------------------------------------------------------
// 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
// ===========================================================================
// wxWin macros
// ---------------------------------------------------------------------------
- IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
- IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
- IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
+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_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)
END_EVENT_TABLE()
{
m_clientWindow = NULL;
m_currentChild = NULL;
- m_windowMenu = 0;
- m_parentFrameActive = TRUE;
+ m_windowMenu = (wxMenu*) NULL;
+ m_parentFrameActive = true;
}
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;
- m_parentFrameActive = TRUE;
+
+ // 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)
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();
-
- int x = pos.x;
- int y = pos.y;
- int width = size.x;
- int height = size.y;
-
- m_windowMenu = (WXHMENU) ::LoadMenu(wxGetInstance(), wxT("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;
-
- if (style & wxCLIP_CHILDREN)
- msflags |= WS_CLIPCHILDREN;
-
- wxWindow::MSWCreate(m_windowId, parent, wxMDIFrameClassName, this, title, x, y, width, height,
- msflags);
+ m_windowId = NewControlId();
+
+ WXDWORD exflags;
+ WXDWORD msflags = MSWGetCreateWindowFlags(&exflags);
+ msflags &= ~WS_VSCROLL;
+ msflags &= ~WS_HSCROLL;
+
+ 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;
+ return true;
}
wxMDIParentFrame::~wxMDIParentFrame()
{
- DestroyChildren();
- // already delete by DestroyChildren()
+ // see comment in ~wxMDIChildFrame
+#if wxUSE_TOOLBAR
m_frameToolBar = NULL;
+#endif
+#if wxUSE_STATUSBAR
+ m_frameStatusBar = NULL;
+#endif // wxUSE_STATUSBAR
+
+ DestroyChildren();
+
+ if (m_windowMenu)
+ {
+ delete m_windowMenu;
+ m_windowMenu = (wxMenu*) NULL;
+ }
- ::DestroyMenu((HMENU)m_windowMenu);
- m_windowMenu = 0;
+ // the MDI frame menubar is not automatically deleted by Windows unlike for
+ // the normal frames
+ if ( m_hMenu )
+ {
+ ::DestroyMenu((HMENU)m_hMenu);
+ m_hMenu = (WXHMENU)NULL;
+ }
if ( m_clientWindow )
{
}
}
+#if wxUSE_MENUS_NATIVE
+
void wxMDIParentFrame::InternalSetMenuBar()
{
- HMENU subMenu = GetSubMenu((HMENU) m_windowMenu, 0);
+ m_parentFrameActive = true;
+
+ InsertWindowMenu(GetClientWindow(), m_hMenu, GetMDIWindowMenu(this));
+}
+
+#endif // wxUSE_MENUS_NATIVE
+
+void wxMDIParentFrame::SetWindowMenu(wxMenu* menu)
+{
+ if (m_windowMenu)
+ {
+ if (GetMenuBar())
+ {
+ // Remove old window menu
+ RemoveWindowMenu(GetClientWindow(), m_hMenu);
+ }
+
+ delete m_windowMenu;
+ m_windowMenu = (wxMenu*) NULL;
+ }
+
+ if (menu)
+ {
+ m_windowMenu = menu;
+ if (GetMenuBar())
+ {
+ InsertWindowMenu(GetClientWindow(), m_hMenu,
+ GetHmenuOf(m_windowMenu));
+ }
+ }
+}
- m_parentFrameActive = TRUE;
+void wxMDIParentFrame::DoMenuUpdates(wxMenu* menu)
+{
+ wxMDIChildFrame *child = GetActiveChild();
+ if ( child )
+ {
+ wxEvtHandler* source = child->GetEventHandler();
+ wxMenuBar* bar = child->GetMenuBar();
- InsertWindowMenu(GetClientWindow(), m_hMenu, subMenu);
+ 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::OnSize(wxSizeEvent& event)
+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
{
{
if ( m_clientWindow )
{
- m_clientWindow->SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
+ m_clientWindow->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
m_clientWindow->Refresh();
}
event.Skip();
}
+WXHICON wxMDIParentFrame::GetDefaultIcon() const
+{
+ // we don't have any standard icons (any more)
+ return (WXHICON)0;
+}
+
// ---------------------------------------------------------------------------
// MDI operations
// ---------------------------------------------------------------------------
::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;
- bool processed = FALSE;
+ WXLRESULT rc = 0;
+ bool processed = false;
switch ( message )
{
(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,
+ // once again (i.e. call wxFrame::HandleCommand()) - we just did it,
// so pretend we processed the message anyhow
- processed = TRUE;
+ processed = true;
}
// always pass this message DefFrameProc(), otherwise MDI menu
- // commands (and sys commands - more surprizingly!) won't work
+ // commands (and sys commands - more surprisingly!) won't work
MSWDefWindowProc(message, wParam, lParam);
break;
rc = -1;
}
- processed = TRUE;
+ processed = true;
break;
case WM_ERASEBKGND:
- processed = TRUE;
+ processed = true;
// we erase background ourselves
- rc = TRUE;
+ rc = true;
break;
case WM_MENUSELECT:
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;
}
bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate)
{
- bool processed = FALSE;
+ bool processed = false;
if ( wxWindow::HandleActivate(state, minimized, activate) )
{
// already processed
- processed = TRUE;
+ processed = true;
}
// If this window is an MDI parent, we must also send an OnActivate message
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 );
if ( m_currentChild->GetEventHandler()->ProcessEvent(event) )
- processed = TRUE;
+ processed = true;
}
return processed;
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;
int msg;
switch ( id )
{
case IDM_WINDOWNEXT:
msg = WM_MDINEXT;
+ lParam = 0; // next child
+ break;
+
+ case IDM_WINDOWPREV:
+ msg = WM_MDINEXT;
+ lParam = 1; // previous child
break;
default:
if ( msg )
{
- ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, 0);
+ ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, lParam);
- return TRUE;
+ return true;
}
// FIXME VZ: what does this test do??
if (id >= 0xF000)
{
- return FALSE; // Get WndProc to call default proc
+ return false; // Get WndProc to call default proc
}
if ( IsMdiCommandId(id) )
{
- wxWindowList::Node* node = GetChildren().GetFirst();
+ wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
while ( node )
{
- wxWindow* child = node->GetData();
+ wxWindow *child = node->GetData();
if ( child->GetHWND() )
{
long childId = wxGetWindowId(child->GetHWND());
::SendMessage( GetWinHwnd(GetClientWindow()),
WM_MDIACTIVATE,
(WPARAM)child->GetHWND(), 0);
- return TRUE;
+ return true;
}
}
node = node->GetNext();
{
// 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?"));
+ wxFAIL_MSG(wxT("MDI parent frame is not active, yet there is no active MDI child?"));
}
- return FALSE;
+ return false;
}
-long wxMDIParentFrame::MSWDefWindowProc(WXUINT message,
+WXLRESULT wxMDIParentFrame::MSWDefWindowProc(WXUINT message,
WXWPARAM wParam,
WXLPARAM lParam)
{
{
MSG *pMsg = (MSG *)msg;
+ // first let the current child get it
if ( m_currentChild && m_currentChild->GetHWND() &&
m_currentChild->MSWTranslateMessage(msg) )
{
- return TRUE;
+ return true;
}
- if ( m_acceleratorTable.Translate(this, msg) )
+ // then try out accel table (will also check the menu accels)
+ if ( wxFrame::MSWTranslateMessage(msg) )
{
- return TRUE;
+ 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;
+ return true;
}
- return FALSE;
+ return false;
}
// ===========================================================================
// wxMDIChildFrame
// ===========================================================================
-wxMDIChildFrame::wxMDIChildFrame()
+void wxMDIChildFrame::Init()
{
+ m_needsResize = true;
+ m_needsInitialShow = true;
}
bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
long style,
const wxString& name)
{
- m_defaultIcon = (WXHICON)(wxSTD_MDICHILDFRAME_ICON ? wxSTD_MDICHILDFRAME_ICON
- : wxDEFAULT_MDICHILDFRAME_ICON);
-
SetName(name);
- if ( id > -1 )
+ if ( id != wxID_ANY )
m_windowId = id;
else
m_windowId = (int)NewControlId();
parent->AddChild(this);
}
- wxWndHook = this;
-
int x = pos.x;
int y = pos.y;
int width = size.x;
MDICREATESTRUCT mcs;
- mcs.szClass = wxMDIChildFrameClassName;
+ mcs.szClass = style & wxFULL_REPAINT_ON_RESIZE
+ ? wxMDIChildFrameClassName
+ : 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;
mcs.lParam = 0;
- DWORD Return = SendMessage(GetWinHwnd(parent->GetClientWindow()),
- 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, (LONG)(LPSTR)&mcs);
- wxWndHook = NULL;
wxAssociateWinWithHandle((HWND) GetHWND(), this);
- // VZ: what's this? an act of piracy?
- //SetWindowLong(GetHwnd(), 0, (long)this);
-
- wxModelessWindows.Append(this);
- return TRUE;
+ return true;
}
wxMDIChildFrame::~wxMDIChildFrame()
{
+ // 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 (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;
wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent();
::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &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);
}
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()
{
wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
- HMENU subMenu = GetSubMenu((HMENU)parent->GetWindowMenu(), 0);
+ InsertWindowMenu(parent->GetClientWindow(),
+ m_hMenu, GetMDIWindowMenu(parent));
+
+ parent->m_parentFrameActive = false;
+}
- InsertWindowMenu(parent->GetClientWindow(), m_hMenu, subMenu);
+void wxMDIChildFrame::DetachMenuBar()
+{
+ RemoveWindowMenu(NULL, m_hMenu);
+ wxFrame::DetachMenuBar();
+}
- parent->m_parentFrameActive = FALSE;
+WXHICON wxMDIChildFrame::GetDefaultIcon() const
+{
+ // we don't have any standard icons (any more)
+ return (WXHICON)0;
}
// ---------------------------------------------------------------------------
// MDI window proc and message handlers
// ---------------------------------------------------------------------------
-long wxMDIChildFrame::MSWWindowProc(WXUINT message,
+WXLRESULT wxMDIChildFrame::MSWWindowProc(WXUINT message,
WXWPARAM wParam,
WXLPARAM lParam)
{
- long rc = 0;
- bool processed = FALSE;
+ WXLRESULT rc = 0;
+ bool processed = false;
switch ( message )
{
break;
case WM_GETMINMAXINFO:
- // 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_min/max variables
- return MSWDefWindowProc(message, wParam, lParam);
+ processed = HandleGetMinMaxInfo((MINMAXINFO *)lParam);
+ break;
case WM_MDIACTIVATE:
{
return rc;
}
-bool wxMDIChildFrame::HandleSize(int x, int y, WXUINT id)
-{
- HWND hwnd = GetHwnd();
-
- if ( !hwnd || hwnd == invalidHandle )
- {
- return FALSE;
- }
-
- switch (id)
- {
- case SIZEFULLSCREEN:
- case SIZENORMAL:
- m_iconized = FALSE;
- break;
-
- case SIZEICONIC:
- m_iconized = TRUE;
- 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 // wxUSE_NATIVE_STATUSBAR
-
- PositionStatusBar();
- PositionToolBar();
-
- return wxWindow::HandleSize(x, y, id);
- }
- else
- {
- return FALSE;
- }
-}
-
bool wxMDIChildFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd)
{
// In case it's e.g. a toolbar.
wxMenu *popupMenu = wxCurrentPopupMenu;
wxCurrentPopupMenu = NULL;
if (popupMenu->MSWCommand(cmd, id))
- return TRUE;
+ return true;
}
+ bool processed;
if (GetMenuBar() && GetMenuBar()->FindItem(id))
{
- ProcessCommand(id);
- return TRUE;
+ processed = ProcessCommand(id);
}
else
- return FALSE;
+ {
+ processed = false;
+ }
- return TRUE;
+ return processed;
}
bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate),
if ( m_hWnd == hwndAct )
{
- activated = TRUE;
+ activated = true;
parent->m_currentChild = this;
HMENU child_menu = (HMENU)GetWinMenu();
if ( child_menu )
{
- parent->m_parentFrameActive = FALSE;
+ parent->m_parentFrameActive = false;
menuToSet = child_menu;
}
wxASSERT_MSG( parent->m_currentChild == this,
wxT("can't deactivate MDI child which wasn't active!") );
- activated = FALSE;
+ activated = false;
parent->m_currentChild = NULL;
HMENU parent_menu = (HMENU)parent->GetWinMenu();
- if ( parent_menu )
+
+ // activate the the parent menu only when there is no other child
+ // that has been activated
+ if ( parent_menu && !hwndAct )
{
- parent->m_parentFrameActive = TRUE;
+ parent->m_parentFrameActive = true;
menuToSet = parent_menu;
}
}
else
{
- // we have nothing to with it
- return FALSE;
+ // we have nothing to do with it
+ return false;
}
if ( menuToSet )
{
- HMENU subMenu = GetSubMenu((HMENU) parent->GetWindowMenu(), 0);
-
- MDISetMenu(parent->GetClientWindow(), menuToSet, subMenu);
+ 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::HandleWindowPosChanging(void *pos)
{
WINDOWPOS *lpPos = (WINDOWPOS *)pos;
-#if defined(__WIN95__)
+
if (!(lpPos->flags & SWP_NOSIZE))
{
RECT rectClient;
DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE))
{
- ::AdjustWindowRectEx(&rectClient, dwStyle, FALSE, dwExStyle);
+ ::AdjustWindowRectEx(&rectClient, dwStyle, false, dwExStyle);
lpPos->x = rectClient.left;
lpPos->y = rectClient.top;
lpPos->cx = rectClient.right - rectClient.left;
lpPos->cy = rectClient.bottom - rectClient.top;
}
+#if wxUSE_TOOLBAR
wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
- if (pFrameWnd && pFrameWnd->GetToolBar())
+ if (pFrameWnd && pFrameWnd->GetToolBar() && pFrameWnd->GetToolBar()->IsShown())
{
pFrameWnd->GetToolBar()->Refresh();
}
+#endif
}
-#endif // Win95
- return FALSE;
+ return false;
+}
+
+bool wxMDIChildFrame::HandleGetMinMaxInfo(void *mmInfo)
+{
+ MINMAXINFO *info = (MINMAXINFO *)mmInfo;
+
+ // 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 )
+ {
+ info->ptMinTrackSize.x = minWidth;
+
+ processed = true;
+ }
+
+ if ( minHeight != wxDefaultCoord )
+ {
+ info->ptMinTrackSize.y = minHeight;
+
+ processed = true;
+ }
+
+ return processed;
}
// ---------------------------------------------------------------------------
// MDI specific message translation/preprocessing
// ---------------------------------------------------------------------------
-long wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXUINT wParam, WXLPARAM lParam)
+WXLRESULT wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
{
return DefMDIChildProc(GetHwnd(),
(UINT)message, (WPARAM)wParam, (LPARAM)lParam);
bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg)
{
- return m_acceleratorTable.Translate(GetParent(), msg);
+ return wxFrame::MSWTranslateMessage(msg);
}
// ---------------------------------------------------------------------------
void wxMDIChildFrame::MSWDestroyWindow()
{
- MSWDetachWindowMenu();
invalidHandle = GetHwnd();
wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
HWND oldHandle = (HWND)GetHWND();
SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY,
(WPARAM)oldHandle, 0);
+
+ if (parent->GetActiveChild() == (wxMDIChildFrame*) NULL)
+ ResetWindowStyle((void*) NULL);
+
invalidHandle = 0;
if (m_hMenu)
::DestroyMenu((HMENU) m_hMenu);
m_hMenu = 0;
}
+ wxRemoveHandleAssociation(this);
m_hWnd = 0;
}
// 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))
{
- DWORD dwStyle = ::GetWindowLong(GetWinHwnd(pFrameWnd->GetClientWindow()), GWL_EXSTYLE);
- DWORD dwThisStyle = ::GetWindowLong(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)
{
- HWND hwnd = GetWinHwnd(pFrameWnd->GetClientWindow());
- ::RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
- ::SetWindowLong(hwnd, GWL_EXSTYLE, dwNewStyle);
- ::SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
+ // 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, rect);
+ ::GetClientRect(hwndClient, rect);
- return TRUE;
+ return true;
}
}
-#endif // Win95
- return FALSE;
+ return false;
}
// ===========================================================================
bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
{
- m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE);
+ m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
CLIENTCREATESTRUCT ccs;
m_windowStyle = style;
m_parent = parent;
- ccs.hWindowMenu = (HMENU)parent->GetWindowMenu();
+ ccs.hWindowMenu = GetMDIWindowMenu(parent);
ccs.idFirstChild = wxFIRST_MDI_CHILD;
- DWORD msStyle = WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN;
+ 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__)
DWORD exStyle = WS_EX_CLIENTEDGE;
-#else
- DWORD exStyle = 0;
-#endif
- wxWndHook = this;
+ wxWindowCreationHook hook(this);
m_hWnd = (WXHWND)::CreateWindowEx
(
exStyle,
(LPSTR)(LPCLIENTCREATESTRUCT)&ccs);
if ( !m_hWnd )
{
- wxLogLastError("CreateWindowEx(MDI client)");
+ wxLogLastError(wxT("CreateWindowEx(MDI client)"));
- return FALSE;
+ return false;
}
SubclassWin(m_hWnd);
- wxWndHook = NULL;
- return TRUE;
+ return true;
}
// Explicitly call default scroll behaviour
event.Skip();
}
+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.
+
+ const wxPoint oldPos = GetPosition();
+
+ wxWindow::DoSetSize(x, y, width, height, sizeFlags | wxSIZE_FORCE);
+
+ const wxPoint newPos = GetPosition();
+
+ 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();
+ }
+ }
+ }
+}
+
+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();
+ }
+
+ event.Skip();
+}
+
// ---------------------------------------------------------------------------
// non member functions
// ---------------------------------------------------------------------------
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...") );
+ ::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L);
+
::DrawMenuBar(GetWinHwnd(parent));
}
{
// Try to insert Window menu in front of Help, otherwise append it.
HMENU hmenu = (HMENU)menu;
- int N = GetMenuItemCount(hmenu);
- bool success = FALSE;
- for ( int i = 0; i < N; i++ )
+
+ if (subMenu)
{
- wxChar buf[256];
- int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION);
- if ( chars == 0 )
+ int N = GetMenuItemCount(hmenu);
+ bool success = false;
+ for ( int i = 0; i < N; i++ )
{
- wxLogLastError(wxT("GetMenuString"));
+ wxChar buf[256];
+ int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION);
+ if ( chars == 0 )
+ {
+ wxLogLastError(wxT("GetMenuString"));
+
+ continue;
+ }
- continue;
+ wxString strBuf(buf);
+ if ( wxStripMenuCodes(strBuf) == wxGetStockLabel(wxID_HELP,false) )
+ {
+ success = true;
+ ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
+ (UINT)subMenu, _("&Window"));
+ break;
+ }
}
- if ( wxStripMenuCodes(wxString(buf)).IsSameAs(wxT("Help")) )
+ if ( !success )
{
- success = TRUE;
- ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
- (UINT)subMenu, wxT("&Window"));
- break;
+ ::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, _("&Window"));
}
}
- if ( !success )
+ MDISetMenu(win, hmenu, subMenu);
+}
+
+static void RemoveWindowMenu(wxWindow *win, WXHMENU menu)
+{
+ HMENU hMenu = (HMENU)menu;
+
+ if ( hMenu )
{
- ::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, wxT("&Window"));
+ 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;
+ }
+ }
}
- MDISetMenu(win, hmenu, subMenu);
+ if ( win )
+ {
+ // we don't change the windows menu, but we update the main one
+ MDISetMenu(win, hMenu, NULL);
+ }
}
static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact)
{
-#ifdef __WIN32__
- *activate = TRUE;
+ *activate = true;
*hwndAct = (WXHWND)lParam;
*hwndDeact = (WXHWND)wParam;
-#else // Win16
- *activate = (WXWORD)wParam;
- *hwndAct = (WXHWND)LOWORD(lParam);
- *hwndDeact = (WXHWND)HIWORD(lParam);
-#endif // Win32/Win16
}
+
+#endif // wxUSE_MDI && !defined(__WXUNIVERSAL__)
projects / wxWidgets.git / blobdiff