Files
wxWidgets/src/aui/tabmdi.cpp
Benjamin Williams f39fddcd9e accessor functions for wxAuiMDIParentFrame
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@43190 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
2006-11-08 10:31:52 +00:00

708 lines
19 KiB
C++

/////////////////////////////////////////////////////////////////////////////
// Name: src/aui/tabmdi.cpp
// Purpose: Generic MDI (Multiple Document Interface) classes
// Author: Hans Van Leemputten
// Modified by: Benjamin I. Williams / Kirix Corporation
// Created: 29/07/2002
// RCS-ID: $Id$
// Copyright: (c) Hans Van Leemputten
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ===========================================================================
// declarations
// ===========================================================================
// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#if wxUSE_AUI
#if wxUSE_MDI
#include "wx/aui/tabmdi.h"
#ifndef WX_PRECOMP
#include "wx/panel.h"
#include "wx/menu.h"
#include "wx/intl.h"
#include "wx/log.h"
#include "wx/settings.h"
#endif //WX_PRECOMP
#include "wx/stockitem.h"
enum MDI_MENU_ID
{
wxWINDOWCLOSE = 4001,
wxWINDOWCLOSEALL,
wxWINDOWNEXT,
wxWINDOWPREV
};
//-----------------------------------------------------------------------------
// wxAuiMDIParentFrame
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIParentFrame, wxFrame)
BEGIN_EVENT_TABLE(wxAuiMDIParentFrame, wxFrame)
#if wxUSE_MENUS
EVT_MENU (wxID_ANY, wxAuiMDIParentFrame::DoHandleMenu)
#endif
END_EVENT_TABLE()
wxAuiMDIParentFrame::wxAuiMDIParentFrame()
{
Init();
}
wxAuiMDIParentFrame::wxAuiMDIParentFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
Init();
(void)Create(parent, id, title, pos, size, style, name);
}
wxAuiMDIParentFrame::~wxAuiMDIParentFrame()
{
// Make sure the client window is destructed before the menu bars are!
wxDELETE(m_pClientWindow);
#if wxUSE_MENUS
RemoveWindowMenu(GetMenuBar());
delete m_pWindowMenu;
#endif // wxUSE_MENUS
}
bool wxAuiMDIParentFrame::Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
#if wxUSE_MENUS
// this style can be used to prevent a window from having the standard MDI
// "Window" menu
if (!(style & wxFRAME_NO_WINDOW_MENU))
{
m_pWindowMenu = new wxMenu;
m_pWindowMenu->Append(wxWINDOWCLOSE, _("Cl&ose"));
m_pWindowMenu->Append(wxWINDOWCLOSEALL, _("Close All"));
m_pWindowMenu->AppendSeparator();
m_pWindowMenu->Append(wxWINDOWNEXT, _("&Next"));
m_pWindowMenu->Append(wxWINDOWPREV, _("&Previous"));
}
#endif // wxUSE_MENUS
wxFrame::Create(parent, id, title, pos, size, style, name);
OnCreateClient();
return true;
}
void wxAuiMDIParentFrame::SetArtProvider(wxAuiTabArt* provider)
{
if (m_pClientWindow)
{
m_pClientWindow->SetArtProvider(provider);
}
}
wxAuiTabArt* wxAuiMDIParentFrame::GetArtProvider()
{
if (!m_pClientWindow)
return NULL;
return m_pClientWindow->GetArtProvider();
}
wxAuiNotebook* wxAuiMDIParentFrame::GetNotebook() const
{
return static_cast<wxAuiNotebook*>(m_pClientWindow);
}
#if wxUSE_MENUS
void wxAuiMDIParentFrame::SetWindowMenu(wxMenu* pMenu)
{
// Replace the window menu from the currently loaded menu bar.
wxMenuBar *pMenuBar = GetMenuBar();
if (m_pWindowMenu)
{
RemoveWindowMenu(pMenuBar);
wxDELETE(m_pWindowMenu);
}
if (pMenu)
{
m_pWindowMenu = pMenu;
AddWindowMenu(pMenuBar);
}
}
void wxAuiMDIParentFrame::SetMenuBar(wxMenuBar* pMenuBar)
{
// Remove the Window menu from the old menu bar
RemoveWindowMenu(GetMenuBar());
// Add the Window menu to the new menu bar.
AddWindowMenu(pMenuBar);
wxFrame::SetMenuBar(pMenuBar);
m_pMyMenuBar = GetMenuBar();
}
#endif // wxUSE_MENUS
void wxAuiMDIParentFrame::SetChildMenuBar(wxAuiMDIChildFrame* pChild)
{
#if wxUSE_MENUS
if (!pChild)
{
// No Child, set Our menu bar back.
SetMenuBar(m_pMyMenuBar);
// Make sure we know our menu bar is in use
//m_pMyMenuBar = NULL;
}
else
{
if (pChild->GetMenuBar() == NULL)
return;
// Do we need to save the current bar?
if (m_pMyMenuBar == NULL)
m_pMyMenuBar = GetMenuBar();
SetMenuBar(pChild->GetMenuBar());
}
#endif // wxUSE_MENUS
}
bool wxAuiMDIParentFrame::ProcessEvent(wxEvent& event)
{
// stops the same event being processed repeatedly
if (m_pLastEvt == &event)
return false;
m_pLastEvt = &event;
// let the active child (if any) process the event first.
bool res = false;
if (m_pActiveChild &&
event.IsCommandEvent() &&
event.GetEventObject() != m_pClientWindow &&
!(event.GetEventType() == wxEVT_ACTIVATE ||
event.GetEventType() == wxEVT_SET_FOCUS ||
event.GetEventType() == wxEVT_KILL_FOCUS ||
event.GetEventType() == wxEVT_CHILD_FOCUS ||
event.GetEventType() == wxEVT_COMMAND_SET_FOCUS ||
event.GetEventType() == wxEVT_COMMAND_KILL_FOCUS )
)
{
res = m_pActiveChild->GetEventHandler()->ProcessEvent(event);
}
if (!res)
{
// if the event was not handled this frame will handle it,
// which is why we need the protection code at the beginning
// of this method
res = wxEvtHandler::ProcessEvent(event);
}
m_pLastEvt = NULL;
return res;
}
wxAuiMDIChildFrame *wxAuiMDIParentFrame::GetActiveChild() const
{
return m_pActiveChild;
}
void wxAuiMDIParentFrame::SetActiveChild(wxAuiMDIChildFrame* pChildFrame)
{
m_pActiveChild = pChildFrame;
}
wxAuiMDIClientWindow *wxAuiMDIParentFrame::GetClientWindow() const
{
return m_pClientWindow;
}
wxAuiMDIClientWindow *wxAuiMDIParentFrame::OnCreateClient()
{
m_pClientWindow = new wxAuiMDIClientWindow( this );
return m_pClientWindow;
}
void wxAuiMDIParentFrame::ActivateNext()
{
if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
{
size_t active = m_pClientWindow->GetSelection() + 1;
if (active >= m_pClientWindow->GetPageCount())
active = 0;
m_pClientWindow->SetSelection(active);
}
}
void wxAuiMDIParentFrame::ActivatePrevious()
{
if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
{
int active = m_pClientWindow->GetSelection() - 1;
if (active < 0)
active = m_pClientWindow->GetPageCount() - 1;
m_pClientWindow->SetSelection(active);
}
}
void wxAuiMDIParentFrame::Init()
{
m_pLastEvt = NULL;
m_pClientWindow = NULL;
m_pActiveChild = NULL;
#if wxUSE_MENUS
m_pWindowMenu = NULL;
m_pMyMenuBar = NULL;
#endif // wxUSE_MENUS
}
#if wxUSE_MENUS
void wxAuiMDIParentFrame::RemoveWindowMenu(wxMenuBar* pMenuBar)
{
if (pMenuBar && m_pWindowMenu)
{
// Remove old window menu
int pos = pMenuBar->FindMenu(_("&Window"));
if (pos != wxNOT_FOUND)
{
// DBG:: We're going to delete the wrong menu!!!
wxASSERT(m_pWindowMenu == pMenuBar->GetMenu(pos));
pMenuBar->Remove(pos);
}
}
}
void wxAuiMDIParentFrame::AddWindowMenu(wxMenuBar *pMenuBar)
{
if (pMenuBar && m_pWindowMenu)
{
int pos = pMenuBar->FindMenu(wxGetStockLabel(wxID_HELP,wxSTOCK_NOFLAGS));
if (pos == wxNOT_FOUND)
pMenuBar->Append(m_pWindowMenu, _("&Window"));
else
pMenuBar->Insert(pos, m_pWindowMenu, _("&Window"));
}
}
void wxAuiMDIParentFrame::DoHandleMenu(wxCommandEvent& event)
{
switch (event.GetId())
{
case wxWINDOWCLOSE:
if (m_pActiveChild)
m_pActiveChild->Close();
break;
case wxWINDOWCLOSEALL:
while (m_pActiveChild)
{
if (!m_pActiveChild->Close())
{
return; // failure
}
else
{
delete m_pActiveChild;
m_pActiveChild = NULL;
}
}
break;
case wxWINDOWNEXT:
ActivateNext();
break;
case wxWINDOWPREV:
ActivatePrevious();
break;
default:
event.Skip();
}
}
#endif // wxUSE_MENUS
void wxAuiMDIParentFrame::DoGetClientSize(int* width, int* height) const
{
wxFrame::DoGetClientSize(width, height);
}
//-----------------------------------------------------------------------------
// wxAuiMDIChildFrame
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIChildFrame, wxPanel)
BEGIN_EVENT_TABLE(wxAuiMDIChildFrame, wxPanel)
EVT_MENU_HIGHLIGHT_ALL(wxAuiMDIChildFrame::OnMenuHighlight)
EVT_ACTIVATE(wxAuiMDIChildFrame::OnActivate)
EVT_CLOSE(wxAuiMDIChildFrame::OnCloseWindow)
END_EVENT_TABLE()
wxAuiMDIChildFrame::wxAuiMDIChildFrame()
{
Init();
}
wxAuiMDIChildFrame::wxAuiMDIChildFrame(wxAuiMDIParentFrame *parent,
wxWindowID id,
const wxString& title,
const wxPoint& WXUNUSED(pos),
const wxSize& size,
long style,
const wxString& name)
{
Init();
Create(parent, id, title, wxDefaultPosition, size, style, name);
}
wxAuiMDIChildFrame::~wxAuiMDIChildFrame()
{
#if wxUSE_MENUS
wxDELETE(m_pMenuBar);
#endif // wxUSE_MENUS
}
bool wxAuiMDIChildFrame::Create(wxAuiMDIParentFrame* parent,
wxWindowID id,
const wxString& title,
const wxPoint& WXUNUSED(pos),
const wxSize& size,
long style,
const wxString& name)
{
wxAuiMDIClientWindow* pClientWindow = parent->GetClientWindow();
wxASSERT_MSG((pClientWindow != (wxWindow*) NULL), wxT("Missing MDI client window."));
wxPanel::Create(pClientWindow, id, wxDefaultPosition, size, style|wxNO_BORDER, name);
SetMDIParentFrame(parent);
// this is the currently active child
parent->SetActiveChild(this);
m_title = title;
pClientWindow->AddPage(this, title, true);
pClientWindow->Refresh();
return true;
}
bool wxAuiMDIChildFrame::Destroy()
{
wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
wxASSERT_MSG(pClientWindow, wxT("Missing MDI Client Window"));
if (pParentFrame->GetActiveChild() == this)
{
pParentFrame->SetActiveChild(NULL);
pParentFrame->SetChildMenuBar(NULL);
}
const size_t page_count = pClientWindow->GetPageCount();
for (size_t pos = 0; pos < page_count; pos++)
{
if (pClientWindow->GetPage(pos) == this)
return pClientWindow->DeletePage(pos);
}
return false;
}
#if wxUSE_MENUS
void wxAuiMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
{
wxMenuBar *pOldMenuBar = m_pMenuBar;
m_pMenuBar = menu_bar;
if (m_pMenuBar)
{
wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
m_pMenuBar->SetParent(pParentFrame);
if (pParentFrame->GetActiveChild() == this)
{
// replace current menu bars
if (pOldMenuBar)
pParentFrame->SetChildMenuBar(NULL);
pParentFrame->SetChildMenuBar(this);
}
}
}
wxMenuBar *wxAuiMDIChildFrame::GetMenuBar() const
{
return m_pMenuBar;
}
#endif // wxUSE_MENUS
void wxAuiMDIChildFrame::SetTitle(const wxString& title)
{
m_title = title;
wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
if (pClientWindow != NULL)
{
size_t pos;
for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
{
if (pClientWindow->GetPage(pos) == this)
{
pClientWindow->SetPageText(pos, m_title);
break;
}
}
}
}
wxString wxAuiMDIChildFrame::GetTitle() const
{
return m_title;
}
void wxAuiMDIChildFrame::Activate()
{
wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
if (pClientWindow != NULL)
{
size_t pos;
for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
{
if (pClientWindow->GetPage(pos) == this)
{
pClientWindow->SetSelection(pos);
break;
}
}
}
}
void wxAuiMDIChildFrame::OnMenuHighlight(wxMenuEvent& event)
{
#if wxUSE_STATUSBAR
if (m_pMDIParentFrame)
{
// we don't have any help text for this item,
// but may be the MDI frame does?
m_pMDIParentFrame->OnMenuHighlight(event);
}
#else
wxUnusedVar(event);
#endif // wxUSE_STATUSBAR
}
void wxAuiMDIChildFrame::OnActivate(wxActivateEvent& WXUNUSED(event))
{
// do nothing
}
void wxAuiMDIChildFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
{
Destroy();
}
void wxAuiMDIChildFrame::SetMDIParentFrame(wxAuiMDIParentFrame* parentFrame)
{
m_pMDIParentFrame = parentFrame;
}
wxAuiMDIParentFrame* wxAuiMDIChildFrame::GetMDIParentFrame() const
{
return m_pMDIParentFrame;
}
void wxAuiMDIChildFrame::Init()
{
m_pMDIParentFrame = NULL;
#if wxUSE_MENUS
m_pMenuBar = NULL;
#endif // wxUSE_MENUS
}
bool wxAuiMDIChildFrame::Show(bool WXUNUSED(show))
{
// do nothing
return true;
}
void wxAuiMDIChildFrame::DoShow(bool show)
{
wxWindow::Show(show);
}
void wxAuiMDIChildFrame::DoSetSize(int x, int y, int width, int height, int sizeFlags)
{
m_mdi_newrect = wxRect(x, y, width, height);
#ifdef __WXGTK__
wxPanel::DoSetSize(x,y,width, height, sizeFlags);
#else
wxUnusedVar(sizeFlags);
#endif
}
void wxAuiMDIChildFrame::DoMoveWindow(int x, int y, int width, int height)
{
m_mdi_newrect = wxRect(x, y, width, height);
}
void wxAuiMDIChildFrame::ApplyMDIChildFrameRect()
{
if (m_mdi_currect != m_mdi_newrect)
{
wxPanel::DoMoveWindow(m_mdi_newrect.x, m_mdi_newrect.y,
m_mdi_newrect.width, m_mdi_newrect.height);
m_mdi_currect = m_mdi_newrect;
}
}
//-----------------------------------------------------------------------------
// wxAuiMDIClientWindow
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIClientWindow, wxAuiNotebook)
BEGIN_EVENT_TABLE(wxAuiMDIClientWindow, wxAuiNotebook)
EVT_AUINOTEBOOK_PAGE_CHANGED(wxID_ANY, wxAuiMDIClientWindow::OnPageChanged)
EVT_SIZE(wxAuiMDIClientWindow::OnSize)
END_EVENT_TABLE()
wxAuiMDIClientWindow::wxAuiMDIClientWindow()
{
}
wxAuiMDIClientWindow::wxAuiMDIClientWindow(wxAuiMDIParentFrame* parent, long style)
{
CreateClient(parent, style);
}
wxAuiMDIClientWindow::~wxAuiMDIClientWindow()
{
DestroyChildren();
}
bool wxAuiMDIClientWindow::CreateClient(wxAuiMDIParentFrame* parent, long style)
{
SetWindowStyleFlag(style);
if (!wxAuiNotebook::Create(parent,
wxID_ANY,
wxPoint(0,0),
wxSize(100, 100),
wxAUI_NB_DEFAULT_STYLE | wxNO_BORDER))
{
return false;
}
wxColour bkcolour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
SetBackgroundColour(bkcolour);
m_mgr.GetArtProvider()->SetColour(wxAUI_ART_BACKGROUND_COLOUR, bkcolour);
return true;
}
int wxAuiMDIClientWindow::SetSelection(size_t nPage)
{
return wxAuiNotebook::SetSelection(nPage);
}
void wxAuiMDIClientWindow::PageChanged(int old_selection, int new_selection)
{
// don't do anything if the page doesn't actually change
if (old_selection == new_selection)
return;
// don't do anything if the new page is already active
if (new_selection != -1)
{
wxAuiMDIChildFrame* child = (wxAuiMDIChildFrame*)GetPage(new_selection);
if (child->GetMDIParentFrame()->GetActiveChild() == child)
return;
}
// notify old active child that it has been deactivated
if (old_selection != -1)
{
wxAuiMDIChildFrame* old_child = (wxAuiMDIChildFrame*)GetPage(old_selection);
wxASSERT_MSG(old_child, wxT("wxAuiMDIClientWindow::PageChanged - null page pointer"));
wxActivateEvent event(wxEVT_ACTIVATE, false, old_child->GetId());
event.SetEventObject(old_child);
old_child->GetEventHandler()->ProcessEvent(event);
}
// notify new active child that it has been activated
if (new_selection != -1)
{
wxAuiMDIChildFrame* active_child = (wxAuiMDIChildFrame*)GetPage(new_selection);
wxASSERT_MSG(active_child, wxT("wxAuiMDIClientWindow::PageChanged - null page pointer"));
wxActivateEvent event(wxEVT_ACTIVATE, true, active_child->GetId());
event.SetEventObject(active_child);
active_child->GetEventHandler()->ProcessEvent(event);
if (active_child->GetMDIParentFrame())
{
active_child->GetMDIParentFrame()->SetActiveChild(active_child);
active_child->GetMDIParentFrame()->SetChildMenuBar(active_child);
}
}
}
void wxAuiMDIClientWindow::OnPageChanged(wxAuiNotebookEvent& evt)
{
PageChanged(evt.GetOldSelection(), evt.GetSelection());
evt.Skip();
}
void wxAuiMDIClientWindow::OnSize(wxSizeEvent& evt)
{
wxAuiNotebook::OnSize(evt);
for (size_t pos = 0; pos < GetPageCount(); pos++)
((wxAuiMDIChildFrame *)GetPage(pos))->ApplyMDIChildFrameRect();
}
#endif //wxUSE_AUI
#endif // wxUSE_MDI