void wxMDIChildFrame::InternalSetMenuBar()
{
wxMDIParentFrame * const parent = GetMDIParent();
MDIInsertWindowMenu(parent->GetClientWindow(),
m_hMenu, GetMDIWindowMenu(parent));
}
void wxMDIChildFrame::Maximize(bool maximize)
{
wxMDIParentFrame * const parent = GetMDIParent();
if ( parent && parent->GetClientWindow() )
{
if ( !IsShown() )
{
// Turn off redrawing in the MDI client window because otherwise
// maximizing it would also show it and we don't want this for
// hidden windows.
::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_SETREDRAW,
FALSE, 0L);
}
::SendMessage(GetWinHwnd(parent->GetClientWindow()),
maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE,
(WPARAM)GetHwnd(), 0);
if ( !IsShown() )
{
// Hide back the child window shown by maximizing it.
::ShowWindow(GetHwnd(), SW_HIDE);
// Turn redrawing in the MDI client back on.
::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_SETREDRAW,
TRUE, 0L);
}
}
}
void wxMDIChildFrame::Activate()
{
wxMDIParentFrame * const parent = GetMDIParent();
if ( parent && parent->GetClientWindow() )
{
::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE,
(WPARAM) GetHwnd(), 0);
}
}
void wxMDIChildFrame::Restore()
{
wxMDIParentFrame * const parent = GetMDIParent();
if ( parent && parent->GetClientWindow() )
{
::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE,
(WPARAM) GetHwnd(), 0);
}
}
void wxMDIChildFrame::Maximize(bool maximize)
{
wxMDIParentFrame * const parent = GetMDIParent();
if ( parent && parent->GetClientWindow() )
{
::SendMessage(GetWinHwnd(parent->GetClientWindow()),
maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE,
(WPARAM)GetHwnd(), 0);
}
}
bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate),
WXHWND hwndAct,
WXHWND hwndDeact)
{
wxMDIParentFrame * const parent = GetMDIParent();
WXHMENU hMenuToSet = 0;
bool activated;
if ( m_hWnd == hwndAct )
{
activated = true;
parent->SetActiveChild(this);
WXHMENU hMenuChild = m_hMenu;
if ( hMenuChild )
hMenuToSet = hMenuChild;
}
else if ( m_hWnd == hwndDeact )
{
wxASSERT_MSG( parent->GetActiveChild() == this,
wxT("can't deactivate MDI child which wasn't active!") );
activated = false;
parent->SetActiveChild(NULL);
WXHMENU hMenuParent = parent->m_hMenu;
// activate the the parent menu only when there is no other child
// that has been activated
if ( hMenuParent && !hwndAct )
hMenuToSet = hMenuParent;
}
else
{
// we have nothing to do with it
return false;
}
if ( hMenuToSet )
{
MDISetMenu(parent->GetClientWindow(),
(HMENU)hMenuToSet, GetMDIWindowMenu(parent));
}
wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId);
event.SetEventObject( this );
ResetWindowStyle(NULL);
return HandleWindowEvent(event);
}
void wxMDIChildFrame::Activate()
{
wxMDIParentFrame * const parent = GetMDIParent();
if ( parent && parent->GetClientWindow() )
{
// Activating an iconized MDI frame doesn't do anything, so restore it
// first to really present it to the user.
if ( IsIconized() )
Restore();
::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE,
(WPARAM) GetHwnd(), 0);
}
}
void wxMDIChildFrame::DoGetPosition(int *x, int *y) const
{
RECT 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 * const mdiParent = GetMDIParent();
::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point);
if (x)
*x = point.x;
if (y)
*y = point.y;
}
bool wxMDIChildFrame::Show(bool show)
{
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 * const parent = GetMDIParent();
MDISetMenu(parent->GetClientWindow(), NULL, NULL);
return true;
}
// Set the client size (i.e. leave the calculation of borders etc.
// to wxWidgets)
void wxMDIChildFrame::DoSetClientSize(int width, int height)
{
HWND hWnd = GetHwnd();
RECT rect;
::GetClientRect(hWnd, &rect);
RECT rect2;
GetWindowRect(hWnd, &rect2);
// Find the difference between the entire window (title bar and all)
// and the client area; add this to the new client size to move the
// window
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;
point.y = rect2.top;
// If there's an MDI parent, must subtract the parent's top left corner
// since MoveWindow moves relative to the parent
wxMDIParentFrame * const mdiParent = GetMDIParent();
::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point);
MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)true);
wxSize size(width, height);
wxSizeEvent event(size, m_windowId);
event.SetEventObject( this );
HandleWindowEvent(event);
}
// 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)
{
RECT *rect = (RECT *)vrect;
wxMDIParentFrame * const pFrameWnd = GetMDIParent();
wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild();
if (!pChild || (pChild == this))
{
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 ( dwThisStyle & WS_MAXIMIZE )
dwNewStyle &= ~(WS_EX_CLIENTEDGE);
else
dwNewStyle |= WS_EX_CLIENTEDGE;
if (dwStyle != dwNewStyle)
{
// 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(hwndClient, rect);
return true;
}
}
return false;
}
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();
}
void wxMDIChildFrame::MSWDestroyWindow()
{
wxMDIParentFrame * const parent = GetMDIParent();
// 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);
if (parent->GetActiveChild() == NULL)
ResetWindowStyle(NULL);
if (m_hMenu)
{
::DestroyMenu((HMENU) m_hMenu);
m_hMenu = 0;
}
wxRemoveHandleAssociation(this);
m_hWnd = 0;
}
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);
}