/////////////////////////////////////////////////////////////////////////////
-// 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
extern wxWindowList wxModelessWindows; // from dialog.cpp
extern wxMenu *wxCurrentPopupMenu;
-extern const wxChar *wxMDIFrameClassName;
+extern const wxChar *wxMDIFrameClassName; // from app.cpp
extern const wxChar *wxMDIChildFrameClassName;
-extern wxWindow *wxWndHook; // from window.cpp
+extern const wxChar *wxMDIChildFrameClassNameNoRedraw;
extern void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win);
+extern void wxRemoveHandleAssociation(wxWindow *win);
static HWND invalidHandle = 0;
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()
long style,
const wxString& name)
{
- m_defaultIcon = (WXHICON) (wxSTD_MDIPARENTFRAME_ICON ? wxSTD_MDIPARENTFRAME_ICON : wxDEFAULT_MDIPARENTFRAME_ICON);
-
m_clientWindow = NULL;
m_currentChild = NULL;
- if (style & wxFRAME_NO_WINDOW_MENU)
- m_windowMenu = (wxMenu*) NULL;
- else
+ // 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 = (WXHMENU) ::LoadMenu(wxGetInstance(), wxT("wxWindowMenu"));
m_windowMenu = new wxMenu;
-
- m_windowMenu->Append(4002, wxT("&Cascade"));
- m_windowMenu->Append(4001, wxT("Tile &Horizontally"));
- m_windowMenu->Append(4005, wxT("Tile &Vertically"));
+ 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(4003, wxT("&Arrange Icons"));
- m_windowMenu->Append(4004, wxT("&Next"));
+ m_windowMenu->Append(IDM_WINDOWICONS, _("&Arrange Icons"));
+ m_windowMenu->Append(IDM_WINDOWNEXT, _("&Next"));
}
m_parentFrameActive = TRUE;
SetName(name);
m_windowStyle = style;
- if (parent) parent->AddChild(this);
+ if ( parent )
+ parent->AddChild(this);
if ( id > -1 )
m_windowId = id;
else
- m_windowId = (int)NewControlId();
+ m_windowId = NewControlId();
- int x = pos.x;
- int y = pos.y;
- int width = size.x;
- int height = size.y;
+ long exflags;
+ long msflags = MSWGetCreateWindowFlags(&exflags);
- 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);
+ 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;
}
DestroyChildren();
// already delete by DestroyChildren()
m_frameToolBar = NULL;
+ m_frameStatusBar = NULL;
// ::DestroyMenu((HMENU)m_windowMenu);
if (m_windowMenu)
}
}
+#if wxUSE_MENUS_NATIVE
+
void wxMDIParentFrame::InternalSetMenuBar()
{
-// HMENU subMenu = GetSubMenu((HMENU) m_windowMenu, 0);
-
m_parentFrameActive = TRUE;
- HMENU subMenu = (HMENU) 0;
- if (GetWindowMenu())
- subMenu = (HMENU) GetWindowMenu()->GetHMenu();
+ wxMenu *menu = GetWindowMenu();
+ HMENU subMenu = menu ? GetHmenuOf(menu) : 0;
InsertWindowMenu(GetClientWindow(), m_hMenu, subMenu);
}
+#endif // wxUSE_MENUS_NATIVE
+
void wxMDIParentFrame::SetWindowMenu(wxMenu* menu)
{
if (m_windowMenu)
{
m_windowMenu = menu;
if (GetMenuBar())
- InsertWindowMenu(GetClientWindow(), m_hMenu, (HMENU) m_windowMenu->GetHMenu());
+ {
+ InsertWindowMenu(GetClientWindow(), m_hMenu,
+ GetHmenuOf(m_windowMenu));
+ }
}
}
-void wxMDIParentFrame::OnSize(wxSizeEvent& event)
+void wxMDIParentFrame::OnSize(wxSizeEvent&)
{
if ( GetClientWindow() )
{
event.Skip();
}
+WXHICON wxMDIParentFrame::GetDefaultIcon() const
+{
+ return (WXHICON)(wxSTD_MDIPARENTFRAME_ICON ? wxSTD_MDIPARENTFRAME_ICON
+ : wxDEFAULT_MDIPARENTFRAME_ICON);
+}
+
// ---------------------------------------------------------------------------
// MDI operations
// ---------------------------------------------------------------------------
{
// 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;
{
MSG *pMsg = (MSG *)msg;
+ // first let the current child get it
if ( m_currentChild && m_currentChild->GetHWND() &&
m_currentChild->MSWTranslateMessage(msg) )
{
return TRUE;
}
- if ( m_acceleratorTable.Translate(this, msg) )
+ // 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))
// wxMDIChildFrame
// ===========================================================================
-wxMDIChildFrame::wxMDIChildFrame()
+void wxMDIChildFrame::Init()
{
+ m_needsResize = 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);
+ wxWindowBase::Show(TRUE); // MDI child frame starts off shown
if ( id > -1 )
m_windowId = id;
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 & wxNO_FULL_REPAINT_ON_RESIZE
+ ? wxMDIChildFrameClassNameNoRedraw
+ : wxMDIChildFrameClassName;
mcs.szTitle = title;
mcs.hOwner = wxGetInstance();
if (x > -1)
else
mcs.cy = CW_USEDEFAULT;
- DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN;
+ DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN | WS_THICKFRAME | WS_VISIBLE ;
if (style & wxMINIMIZE_BOX)
msflags |= WS_MINIMIZEBOX;
if (style & wxMAXIMIZE_BOX)
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;
}
wxMDIChildFrame::~wxMDIChildFrame()
{
+ DestroyChildren();
+
+ // already delete by DestroyChildren()
+ m_frameToolBar = NULL;
+ m_frameStatusBar = NULL;
+
MSWDestroyWindow();
}
parent->m_parentFrameActive = FALSE;
}
+WXHICON wxMDIChildFrame::GetDefaultIcon() const
+{
+ return (WXHICON)(wxSTD_MDICHILDFRAME_ICON ? wxSTD_MDICHILDFRAME_ICON
+ : wxDEFAULT_MDICHILDFRAME_ICON);
+}
+
// ---------------------------------------------------------------------------
// MDI operations
// ---------------------------------------------------------------------------
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 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),
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;
wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId);
event.SetEventObject( this );
+ ResetWindowStyle((void *)NULL);
+
return GetEventHandler()->ProcessEvent(event);
}
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;
+
+ // but allow GetSizeHints() to set the min size
+ if ( m_minWidth != -1 )
+ {
+ info->ptMinTrackSize.x = m_minWidth;
+
+ processed = TRUE;
+ }
+
+ if ( m_minHeight != -1 )
+ {
+ info->ptMinTrackSize.y = m_minHeight;
+
+ processed = TRUE;
+ }
+
+ return TRUE;
+}
+
// ---------------------------------------------------------------------------
// MDI specific message translation/preprocessing
// ---------------------------------------------------------------------------
bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg)
{
- return m_acceleratorTable.Translate(GetParent(), msg);
+ return wxFrame::MSWTranslateMessage(msg);
}
// ---------------------------------------------------------------------------
::DestroyMenu((HMENU) m_hMenu);
m_hMenu = 0;
}
+ wxRemoveHandleAssociation(this);
m_hWnd = 0;
}
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;
}
ccs.hWindowMenu = (HMENU) parent->GetWindowMenu()->GetHMenu();
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 )
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;
}
SubclassWin(m_hWnd);
- wxWndHook = NULL;
return TRUE;
}
}
}
+void wxMDIChildFrame::OnIdle(wxIdleEvent& event)
+{
+ // 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
// ---------------------------------------------------------------------------
{
::SendMessage(GetWinHwnd(win), WM_MDISETMENU,
#ifdef __WIN32__
- (WPARAM)hmenuFrame, (LPARAM)hmenuWindow);
+ (WPARAM)hmenuFrame, (LPARAM)hmenuWindow
#else
- 0, MAKELPARAM(hmenuFrame, hmenuWindow));
+ 0, MAKELPARAM(hmenuFrame, hmenuWindow)
#endif
+ );
// 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(wxT("Help")) )
+ if ( wxStripMenuCodes(wxString(buf)).IsSameAs(_("Help")) )
{
success = TRUE;
::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
- (UINT)subMenu, wxT("&Window"));
+ (UINT)subMenu, _("&Window"));
break;
}
}
if ( !success )
{
- ::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, wxT("&Window"));
+ ::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, _("&Window"));
}
}
// 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++ )
{
wxChar buf[256];
continue;
}
- if ( wxStripMenuCodes(wxString(buf)).IsSameAs(wxT("Window")) )
+ if ( wxStripMenuCodes(wxString(buf)).IsSameAs(_("Window")) )
{
- success = TRUE;
::RemoveMenu(hmenu, i, MF_BYPOSITION);
break;
}
projects / wxWidgets.git / blobdiff