//---------------------------------------------------------
void CSAGA_Frame::On_Frame_Close_All(wxCommandEvent &WXUNUSED(event))
{
while( GetActiveChild() != NULL )
{
delete(GetActiveChild());
}
}
//---------------------------------------------------------
void CSAGA_Frame::On_Frame_Close(wxCommandEvent &WXUNUSED(event))
{
if( GetActiveChild() != NULL )
{
GetActiveChild()->Close();
}
}
bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate)
{
bool processed = false;
// Set the flag before testing it to ensure the only way for it to be true
// is to be set in our OnActivate() -- and not just remain set from the
// last time.
m_activationNotHandled = false;
if ( wxWindow::HandleActivate(state, minimized, activate) )
{
// already processed, unless we artificially marked the event as
// handled in our own handler without really processing it
processed = !m_activationNotHandled;
}
// If this window is an MDI parent, we must also send an OnActivate message
// to the current child.
if ( GetActiveChild() &&
((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) )
{
wxActivateEvent event(wxEVT_ACTIVATE, true, GetActiveChild()->GetId());
event.SetEventObject( GetActiveChild() );
if ( GetActiveChild()->HandleWindowEvent(event) )
processed = true;
}
return processed;
}
// Make sure the correct toolbars are showing for the active view
void csFrame::OnIdle(wxIdleEvent& event)
{
wxSashLayoutWindow* paletteWin = wxGetApp().GetDiagramPaletteSashWindow();
wxSashLayoutWindow* diagramToolBarWin = wxGetApp().GetDiagramToolBarSashWindow();
if (!paletteWin || !diagramToolBarWin)
return;
bool doLayout = false;
if (GetActiveChild())
{
if (!paletteWin->IsShown() || !diagramToolBarWin->IsShown())
{
paletteWin->Show(true);
diagramToolBarWin->Show(true);
doLayout = true;
}
}
else
{
if (paletteWin->IsShown() || diagramToolBarWin->IsShown())
{
paletteWin->Show(false);
diagramToolBarWin->Show(false);
doLayout = true;
}
}
if (doLayout)
{
wxLayoutAlgorithm layout;
layout.LayoutMDIFrame(this);
#if defined(__WXMSW__)
// Need to do something else to get it to refresh properly
// when a client frame is first displayed; moving the client
// window doesn't cause the proper refresh. Just refreshing the
// client doesn't work (presumably because it's clipping the
// children).
// FIXED in wxWidgets, by intercepting wxMDIClientWindow::DoSetSize
// and checking if the position has changed, before redrawing the
// child windows.
#if 0
wxMDIChildFrame* childFrame = GetActiveChild();
if (childFrame)
{
HWND hWnd = (HWND) childFrame->GetHWND();
::RedrawWindow(hWnd, NULL, NULL, RDW_FRAME|RDW_ALLCHILDREN|RDW_INVALIDATE );
}
#endif
#endif // __WXMSW__
}
event.Skip();
}
wxMenuItem *wxMDIParentFrame::FindItemInMenuBar(int menuId) const
{
wxMenuItem *item = wxFrame::FindItemInMenuBar(menuId);
if ( !item && GetActiveChild() )
{
item = GetActiveChild()->FindItemInMenuBar(menuId);
}
if ( !item && m_windowMenu )
item = m_windowMenu->FindItem(menuId);
return item;
}
wxMenu* wxMDIParentFrame::MSWFindMenuFromHMENU(WXHMENU hMenu)
{
wxMenu* menu = GetActiveChild()
? GetActiveChild()->MSWFindMenuFromHMENU(hMenu)
: NULL;
if ( !menu )
menu = wxFrame::MSWFindMenuFromHMENU(hMenu);
if ( !menu && m_windowMenu && GetHmenuOf(m_windowMenu) == hMenu )
menu = m_windowMenu;
return menu;
}
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);
}
}
wxMenuItem *wxMDIParentFrame::FindItemInMenuBar(int menuId) const
{
// We must look in the child menu first: if it has an item with the same ID
// as in our own menu bar, the child item should be used to determine
// whether it's currently enabled.
wxMenuItem *item = GetActiveChild()
? GetActiveChild()->FindItemInMenuBar(menuId)
: NULL;
if ( !item )
item = wxFrame::FindItemInMenuBar(menuId);
if ( !item && m_windowMenu )
item = m_windowMenu->FindItem(menuId);
return item;
}
void wxMDIParentFrame::SetWindowMenu(wxMenu* menu)
{
if ( menu != m_windowMenu )
{
// We may not be showing the window menu currently if we don't have any
// children, and in this case we shouldn't remove/add it back right now.
const bool hasWindowMenu = GetActiveChild() != NULL;
if ( hasWindowMenu )
RemoveWindowMenu();
delete m_windowMenu;
m_windowMenu = menu;
if ( hasWindowMenu )
AddWindowMenu();
}
#if wxUSE_ACCEL
wxDELETE(m_accelWindowMenu);
if ( menu && menu->HasAccels() )
m_accelWindowMenu = menu->CreateAccelTable();
#endif // wxUSE_ACCEL
}
bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg)
{
MSG *pMsg = (MSG *)msg;
// first let the current child get it
wxMDIChildFrame * const child = GetActiveChild();
if ( child && child->MSWTranslateMessage(msg) )
{
return true;
}
// then try out accelerator table (will also check the accelerators for the
// normal menu items)
if ( wxFrame::MSWTranslateMessage(msg) )
{
return true;
}
#if wxUSE_MENUS && wxUSE_ACCEL
// but it doesn't check for the (custom) accelerators of the window menu
// items as it's not part of the menu bar as it's handled by Windows itself
// so we need to do this explicitly
if ( m_accelWindowMenu && m_accelWindowMenu->Translate(this, msg) )
return true;
#endif // wxUSE_MENUS && wxUSE_ACCEL
// finally, check for MDI specific built-in accelerators
if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN )
{
if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg))
return true;
}
return false;
}
void CSAGA_Frame::On_Command_Child_UI(wxUpdateUIEvent &event)
{
CVIEW_Base *pChild;
if( (pChild = wxDynamicCast(GetActiveChild(), CVIEW_Base)) != NULL )
{
pChild->On_Command_UI(event);
}
}
//---------------------------------------------------------
void CSAGA_Frame::On_Command_Child(wxCommandEvent &event)
{
wxMDIChildFrame *pChild;
if( (pChild = GetActiveChild()) != NULL )
{
pChild->GetEventHandler()->AddPendingEvent(event);
}
}
WXHMENU wxMDIParentFrame::MSWGetActiveMenu() const
{
wxMDIChildFrame * const child = GetActiveChild();
if ( child )
{
const WXHMENU hmenu = child->MSWGetActiveMenu();
if ( hmenu )
return hmenu;
}
return wxFrame::MSWGetActiveMenu();
}
// Default menu selection behaviour - display a help string
void wxMDIParentFrame::OnMenuHighlight(wxMenuEvent& event)
{
if (GetStatusBar())
{
if (event.GetMenuId() == -1)
SetStatusText("");
else
{
wxMenuBar *menuBar = (wxMenuBar*) NULL;
if (GetActiveChild())
menuBar = GetActiveChild()->GetMenuBar();
else
menuBar = GetMenuBar();
if (menuBar)
{
wxString helpString(menuBar->GetHelpString(event.GetMenuId()));
if (helpString != "")
SetStatusText(helpString);
}
}
}
}
bool wxMDIParentFrame::TryBefore(wxEvent& event)
{
// menu (and toolbar) events should be sent to the active child frame
// first, if any
if ( event.GetEventType() == wxEVT_COMMAND_MENU_SELECTED )
{
wxMDIChildFrame * const child = GetActiveChild();
if ( child && child->ProcessEventHere(event) )
return true;
}
return wxMDIParentFrameBase::TryBefore(event);
}
void wxMDIParentFrame::InternalSetMenuBar()
{
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);
}
}
bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND 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 ( GetActiveChild() &&
((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) )
{
wxActivateEvent event(wxEVT_ACTIVATE, true, GetActiveChild()->GetId());
event.SetEventObject( GetActiveChild() );
if ( GetActiveChild()->HandleWindowEvent(event) )
processed = true;
}
return processed;
}
void wxMDIParentFrame::GtkOnSize( int x, int y, int width, int height )
{
wxFrame::GtkOnSize( x, y, width, height );
wxMDIChildFrame *child_frame = GetActiveChild();
if (!child_frame) return;
wxMenuBar *menu_bar = child_frame->m_menuBar;
if (!menu_bar) return;
if (!menu_bar->m_widget) return;
menu_bar->m_x = 0;
menu_bar->m_y = 0;
menu_bar->m_width = m_width;
menu_bar->m_height = wxMENU_HEIGHT;
gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
menu_bar->m_widget,
0, 0, m_width, wxMENU_HEIGHT );
}
void wxMDIParentFrame::DoGetClientSize(int* width, int* height) const
{
wxFrame::DoGetClientSize(width, height);
if (height)
{
wxMDIChildFrame* active_child_frame = GetActiveChild();
if (active_child_frame)
{
wxMenuBar* menubar = active_child_frame->m_menuBar;
if (menubar && menubar->IsShown())
{
GtkRequisition req;
gtk_widget_size_request(menubar->m_widget, &req);
*height -= req.height;
if (*height < 0) *height = 0;
}
}
}
}
void MyFrame::FileSavePicture (wxCommandEvent & WXUNUSED(event) )
{
#if wxUSE_FILEDLG
MyChild * pChild = (MyChild *)GetActiveChild();
if (pChild == NULL)
{
return;
}
wxFileDialog dialog(this, wxT("Save Picture as"), wxEmptyString, pChild->GetTitle(),
wxT("SVG vector picture files (*.svg)|*.svg"),
wxFD_SAVE|wxFD_OVERWRITE_PROMPT);
if (dialog.ShowModal() == wxID_OK)
{
if (!pChild->OnSave ( dialog.GetPath() ))
{
return;
}
}
return;
#endif // wxUSE_FILEDLG
}
void CSAGA_Frame::On_Frame_Previous_UI(wxUpdateUIEvent &event)
{
event.Enable(GetActiveChild() != NULL);
}
bool
wxGenericMDIParentFrame::WXIsActiveChild(wxGenericMDIChildFrame *child) const
{
return static_cast<wxMDIChildFrameBase *>(GetActiveChild()) == child;
}
void CSAGA_Frame::On_Frame_ArrangeIcons_UI(wxUpdateUIEvent &event)
{
event.Enable(GetActiveChild() != NULL);
}
void wxMDIParentFrame::OnInternalIdle()
{
/* if a an MDI child window has just been inserted
it has to be brought to the top in idle time. we
simply set the last notebook page active as new
pages can only be appended at the end */
if (m_justInserted)
{
GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
gtk_notebook_set_page( notebook, g_list_length( notebook->children ) - 1 );
/* need to set the menubar of the child */
wxMDIChildFrame *active_child_frame = GetActiveChild();
if (active_child_frame != NULL)
{
wxMenuBar *menu_bar = active_child_frame->m_menuBar;
if (menu_bar)
{
menu_bar->m_width = m_width;
menu_bar->m_height = wxMENU_HEIGHT;
gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
menu_bar->m_widget,
0, 0, m_width, wxMENU_HEIGHT );
menu_bar->SetInvokingWindow(active_child_frame);
}
}
m_justInserted = false;
return;
}
wxFrame::OnInternalIdle();
wxMDIChildFrame *active_child_frame = GetActiveChild();
bool visible_child_menu = false;
wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
while (node)
{
wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
if ( child_frame )
{
wxMenuBar *menu_bar = child_frame->m_menuBar;
if ( menu_bar )
{
if (child_frame == active_child_frame)
{
if (menu_bar->Show(true))
{
menu_bar->m_width = m_width;
menu_bar->m_height = wxMENU_HEIGHT;
gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
menu_bar->m_widget,
0, 0, m_width, wxMENU_HEIGHT );
menu_bar->SetInvokingWindow( child_frame );
}
visible_child_menu = true;
}
else
{
if (menu_bar->Show(false))
{
menu_bar->UnsetInvokingWindow( child_frame );
}
}
}
}
node = node->GetNext();
}
/* show/hide parent menu bar as required */
if ((m_frameMenuBar) &&
(m_frameMenuBar->IsShown() == visible_child_menu))
{
if (visible_child_menu)
{
m_frameMenuBar->Show( false );
m_frameMenuBar->UnsetInvokingWindow( this );
}
else
{
m_frameMenuBar->Show( true );
m_frameMenuBar->SetInvokingWindow( this );
m_frameMenuBar->m_width = m_width;
m_frameMenuBar->m_height = wxMENU_HEIGHT;
gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
m_frameMenuBar->m_widget,
0, 0, m_width, wxMENU_HEIGHT );
}
}
}
void csFrame::OnSaveUpdate(wxUpdateUIEvent& event)
{
event.Enable( (GetActiveChild() != NULL) );
}
void DeviceFrame::OnDeviceCloseCurrentWindow(wxCommandEvent&) {
wxMDIChildFrame* frame = GetActiveChild();
if (frame) {
frame->Close();
}
}
void wxMDIParentFrame::OnInternalIdle()
{
/* if a MDI child window has just been inserted
it has to be brought to the top in idle time. we
simply set the last notebook page active as new
pages can only be appended at the end */
if (m_justInserted)
{
GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
gtk_notebook_set_current_page(notebook, -1);
/* need to set the menubar of the child */
wxMDIChildFrame *active_child_frame = GetActiveChild();
if (active_child_frame != NULL)
{
wxMenuBar *menu_bar = active_child_frame->m_menuBar;
if (menu_bar)
{
menu_bar->Attach(active_child_frame);
}
}
m_justInserted = false;
return;
}
wxFrame::OnInternalIdle();
wxMDIChildFrame *active_child_frame = GetActiveChild();
bool visible_child_menu = false;
wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
while (node)
{
wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
if ( child_frame )
{
wxMenuBar *menu_bar = child_frame->m_menuBar;
if ( menu_bar )
{
if (child_frame == active_child_frame)
{
if (menu_bar->Show(true))
{
// Attach() asserts if we call it for an already
// attached menu bar so don't do it if we're already
// associated with this frame (it would be nice to get
// rid of this check and ensure that this doesn't
// happen...)
if ( menu_bar->GetFrame() != child_frame )
menu_bar->Attach( child_frame );
}
visible_child_menu = true;
}
else
{
if (menu_bar->Show(false))
{
menu_bar->Detach();
}
}
}
}
node = node->GetNext();
}
/* show/hide parent menu bar as required */
if ((m_frameMenuBar) &&
(m_frameMenuBar->IsShown() == visible_child_menu))
{
if (visible_child_menu)
{
m_frameMenuBar->Show( false );
m_frameMenuBar->Detach();
}
else
{
m_frameMenuBar->Show( true );
m_frameMenuBar->Attach( this );
}
}
}
void CSAGA_Frame::On_Frame_Close_All_UI(wxUpdateUIEvent &event)
{
event.Enable(GetActiveChild() != NULL);
}