/////////////////////////////////////////////////////////////////////////////
-// Name: src/generic/tabmdi.cpp
+// Name: src/aui/tabmdi.cpp
// Purpose: Generic MDI (Multiple Document Interface) classes
// Author: Hans Van Leemputten
// Modified by: Benjamin I. Williams / Kirix Corporation
#pragma hdrstop
#endif
+#if wxUSE_AUI
#if wxUSE_MDI
#include "wx/aui/tabmdi.h"
#endif //WX_PRECOMP
#include "wx/stockitem.h"
+#include "wx/aui/dockart.h"
enum MDI_MENU_ID
{
};
//-----------------------------------------------------------------------------
-// wxTabMDIParentFrame
+// wxAuiMDIParentFrame
//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxTabMDIParentFrame, wxFrame)
+IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIParentFrame, wxFrame)
-BEGIN_EVENT_TABLE(wxTabMDIParentFrame, wxFrame)
+BEGIN_EVENT_TABLE(wxAuiMDIParentFrame, wxFrame)
#if wxUSE_MENUS
- EVT_MENU (wxID_ANY, wxTabMDIParentFrame::DoHandleMenu)
+ EVT_MENU (wxID_ANY, wxAuiMDIParentFrame::DoHandleMenu)
+ EVT_UPDATE_UI (wxID_ANY, wxAuiMDIParentFrame::DoHandleUpdateUI)
#endif
END_EVENT_TABLE()
-wxTabMDIParentFrame::wxTabMDIParentFrame()
+wxAuiMDIParentFrame::wxAuiMDIParentFrame()
{
Init();
}
-wxTabMDIParentFrame::wxTabMDIParentFrame(wxWindow *parent,
+wxAuiMDIParentFrame::wxAuiMDIParentFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
(void)Create(parent, id, title, pos, size, style, name);
}
-wxTabMDIParentFrame::~wxTabMDIParentFrame()
+wxAuiMDIParentFrame::~wxAuiMDIParentFrame()
{
+ // Avoid having GetActiveChild() called after m_pClientWindow is destroyed
+ SendDestroyEvent();
// Make sure the client window is destructed before the menu bars are!
wxDELETE(m_pClientWindow);
#if wxUSE_MENUS
+ wxDELETE(m_pMyMenuBar);
RemoveWindowMenu(GetMenuBar());
- delete m_pWindowMenu;
+ wxDELETE(m_pWindowMenu);
#endif // wxUSE_MENUS
}
-bool wxTabMDIParentFrame::Create(wxWindow *parent,
+bool wxAuiMDIParentFrame::Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
}
#endif // wxUSE_MENUS
- wxFrame::Create(parent, id, title, pos, size, style, name);
- OnCreateClient();
- return true;
+ if ( !wxFrame::Create(parent, id, title, pos, size, style, name) )
+ return false;
+
+ m_pClientWindow = OnCreateClient();
+ return m_pClientWindow != NULL;
+}
+
+
+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 wxTabMDIParentFrame::SetWindowMenu(wxMenu* pMenu)
+void wxAuiMDIParentFrame::SetWindowMenu(wxMenu* pMenu)
{
// Replace the window menu from the currently loaded menu bar.
wxMenuBar *pMenuBar = GetMenuBar();
}
}
-void wxTabMDIParentFrame::SetMenuBar(wxMenuBar* pMenuBar)
+void wxAuiMDIParentFrame::SetMenuBar(wxMenuBar* pMenuBar)
{
// Remove the Window menu from the old menu bar
RemoveWindowMenu(GetMenuBar());
AddWindowMenu(pMenuBar);
wxFrame::SetMenuBar(pMenuBar);
- m_pMyMenuBar = GetMenuBar();
+ //m_pMyMenuBar = GetMenuBar();
}
#endif // wxUSE_MENUS
-void wxTabMDIParentFrame::SetChildMenuBar(wxTabMDIChildFrame* pChild)
+void wxAuiMDIParentFrame::SetChildMenuBar(wxAuiMDIChildFrame* pChild)
{
#if wxUSE_MENUS
if (!pChild)
{
// No Child, set Our menu bar back.
- SetMenuBar(m_pMyMenuBar);
+ if (m_pMyMenuBar)
+ SetMenuBar(m_pMyMenuBar);
+ else
+ SetMenuBar(GetMenuBar());
// Make sure we know our menu bar is in use
- //m_pMyMenuBar = NULL;
+ m_pMyMenuBar = NULL;
}
- else
+ else
{
if (pChild->GetMenuBar() == NULL)
return;
-
+
// Do we need to save the current bar?
if (m_pMyMenuBar == NULL)
m_pMyMenuBar = GetMenuBar();
#endif // wxUSE_MENUS
}
-bool wxTabMDIParentFrame::ProcessEvent(wxEvent& event)
+bool wxAuiMDIParentFrame::ProcessEvent(wxEvent& event)
{
- // Stops the same event being processed repeatedly
- static wxEventType inEvent = wxEVT_NULL;
- if (inEvent == event.GetEventType())
+ // stops the same event being processed repeatedly
+ if (m_pLastEvt == &event)
return false;
+ m_pLastEvt = &event;
- inEvent = event.GetEventType();
-
- // Let the active child (if any) process the event first.
+ // let the active child (if any) process the event first.
bool res = false;
- if (m_pActiveChild &&
+ wxAuiMDIChildFrame* pActiveChild = GetActiveChild();
+ if (pActiveChild &&
event.IsCommandEvent() &&
event.GetEventObject() != m_pClientWindow &&
!(event.GetEventType() == wxEVT_ACTIVATE ||
event.GetEventType() == wxEVT_COMMAND_KILL_FOCUS )
)
{
- res = m_pActiveChild->GetEventHandler()->ProcessEvent(event);
+ res = pActiveChild->GetEventHandler()->ProcessEvent(event);
}
- // If the event was not handled this frame will handle it!
if (!res)
{
- //res = GetEventHandler()->ProcessEvent(event);
+ // 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);
}
- inEvent = wxEVT_NULL;
+ m_pLastEvt = NULL;
return res;
}
-wxTabMDIChildFrame *wxTabMDIParentFrame::GetActiveChild() const
+wxAuiMDIChildFrame *wxAuiMDIParentFrame::GetActiveChild() const
{
- return m_pActiveChild;
+ // We can be called before the client window is created, so check for its
+ // existence.
+ wxAuiMDIClientWindow* const client = GetClientWindow();
+ return client ? client->GetActiveChild() : NULL;
}
-void wxTabMDIParentFrame::SetActiveChild(wxTabMDIChildFrame* pChildFrame)
+void wxAuiMDIParentFrame::SetActiveChild(wxAuiMDIChildFrame* pChildFrame)
{
- m_pActiveChild = pChildFrame;
+ wxAuiMDIClientWindow* const client = GetClientWindow();
+ if (client && client->GetActiveChild() != pChildFrame)
+ {
+ client->SetActiveChild(pChildFrame);
+ }
}
-wxTabMDIClientWindow *wxTabMDIParentFrame::GetClientWindow() const
+wxAuiMDIClientWindow *wxAuiMDIParentFrame::GetClientWindow() const
{
return m_pClientWindow;
}
-wxTabMDIClientWindow *wxTabMDIParentFrame::OnCreateClient()
+wxAuiMDIClientWindow *wxAuiMDIParentFrame::OnCreateClient()
{
- m_pClientWindow = new wxTabMDIClientWindow( this );
- return m_pClientWindow;
+ return new wxAuiMDIClientWindow( this );
}
-void wxTabMDIParentFrame::ActivateNext()
+void wxAuiMDIParentFrame::ActivateNext()
{
if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
{
}
}
-void wxTabMDIParentFrame::ActivatePrevious()
+void wxAuiMDIParentFrame::ActivatePrevious()
{
if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
{
}
}
-void wxTabMDIParentFrame::Init()
+void wxAuiMDIParentFrame::Init()
{
+ m_pLastEvt = NULL;
m_pClientWindow = NULL;
- m_pActiveChild = NULL;
#if wxUSE_MENUS
m_pWindowMenu = NULL;
m_pMyMenuBar = NULL;
}
#if wxUSE_MENUS
-void wxTabMDIParentFrame::RemoveWindowMenu(wxMenuBar* pMenuBar)
+void wxAuiMDIParentFrame::RemoveWindowMenu(wxMenuBar* pMenuBar)
{
if (pMenuBar && m_pWindowMenu)
{
}
}
-void wxTabMDIParentFrame::AddWindowMenu(wxMenuBar *pMenuBar)
+void wxAuiMDIParentFrame::AddWindowMenu(wxMenuBar *pMenuBar)
{
if (pMenuBar && m_pWindowMenu)
{
- int pos = pMenuBar->FindMenu(wxGetStockLabel(wxID_HELP,false));
+ int pos = pMenuBar->FindMenu(wxGetStockLabel(wxID_HELP,wxSTOCK_NOFLAGS));
if (pos == wxNOT_FOUND)
pMenuBar->Append(m_pWindowMenu, _("&Window"));
- else
+ else
pMenuBar->Insert(pos, m_pWindowMenu, _("&Window"));
}
}
-void wxTabMDIParentFrame::DoHandleMenu(wxCommandEvent& event)
+void wxAuiMDIParentFrame::DoHandleMenu(wxCommandEvent& event)
{
switch (event.GetId())
{
case wxWINDOWCLOSE:
- if (m_pActiveChild)
- m_pActiveChild->Close();
+ {
+ wxAuiMDIChildFrame* pActiveChild = GetActiveChild();
+ if (pActiveChild)
+ pActiveChild->Close();
break;
+ }
case wxWINDOWCLOSEALL:
- while (m_pActiveChild)
+ {
+ wxAuiMDIChildFrame* pActiveChild;
+ while ((pActiveChild = GetActiveChild()) != NULL)
{
- if (!m_pActiveChild->Close())
+ if (!pActiveChild->Close())
{
return; // failure
}
- else
- {
- delete m_pActiveChild;
- m_pActiveChild = NULL;
- }
}
break;
+ }
case wxWINDOWNEXT:
ActivateNext();
break;
event.Skip();
}
}
+
+void wxAuiMDIParentFrame::DoHandleUpdateUI(wxUpdateUIEvent& event)
+{
+ switch (event.GetId())
+ {
+ case wxWINDOWCLOSE:
+ case wxWINDOWCLOSEALL:
+ {
+ wxAuiMDIClientWindow* client_window = GetClientWindow();
+ wxCHECK_RET(client_window, wxS("Missing MDI Client Window"));
+ size_t pages = client_window->GetPageCount();
+ event.Enable(pages >= 1);
+ break;
+ }
+
+ case wxWINDOWNEXT:
+ case wxWINDOWPREV:
+ {
+ wxAuiMDIClientWindow* client_window = GetClientWindow();
+ wxCHECK_RET(client_window, wxS("Missing MDI Client Window"));
+ size_t pages = client_window->GetPageCount();
+ event.Enable(pages >= 2);
+ break;
+ }
+
+ default:
+ event.Skip();
+ }
+}
#endif // wxUSE_MENUS
-void wxTabMDIParentFrame::DoGetClientSize(int* width, int* height) const
+void wxAuiMDIParentFrame::DoGetClientSize(int* width, int* height) const
{
wxFrame::DoGetClientSize(width, height);
}
+void wxAuiMDIParentFrame::Tile(wxOrientation orient)
+{
+ wxAuiMDIClientWindow* client_window = GetClientWindow();
+ wxASSERT_MSG(client_window, wxT("Missing MDI Client Window"));
+
+ int cur_idx = client_window->GetSelection();
+ if (cur_idx == -1)
+ return;
+
+ if (orient == wxVERTICAL)
+ {
+ client_window->Split(cur_idx, wxLEFT);
+ }
+ else if (orient == wxHORIZONTAL)
+ {
+ client_window->Split(cur_idx, wxTOP);
+ }
+}
+
+
//-----------------------------------------------------------------------------
-// wxTabMDIChildFrame
+// wxAuiMDIChildFrame
//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxTabMDIChildFrame, wxPanel)
+IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIChildFrame, wxPanel)
-BEGIN_EVENT_TABLE(wxTabMDIChildFrame, wxPanel)
- EVT_MENU_HIGHLIGHT_ALL(wxTabMDIChildFrame::OnMenuHighlight)
- EVT_ACTIVATE(wxTabMDIChildFrame::OnActivate)
- EVT_CLOSE(wxTabMDIChildFrame::OnCloseWindow)
+BEGIN_EVENT_TABLE(wxAuiMDIChildFrame, wxPanel)
+ EVT_MENU_HIGHLIGHT_ALL(wxAuiMDIChildFrame::OnMenuHighlight)
+ EVT_ACTIVATE(wxAuiMDIChildFrame::OnActivate)
+ EVT_CLOSE(wxAuiMDIChildFrame::OnCloseWindow)
END_EVENT_TABLE()
-wxTabMDIChildFrame::wxTabMDIChildFrame()
+wxAuiMDIChildFrame::wxAuiMDIChildFrame()
{
Init();
}
-wxTabMDIChildFrame::wxTabMDIChildFrame(wxTabMDIParentFrame *parent,
+wxAuiMDIChildFrame::wxAuiMDIChildFrame(wxAuiMDIParentFrame *parent,
wxWindowID id,
const wxString& title,
const wxPoint& WXUNUSED(pos),
const wxString& name)
{
Init();
- Create(parent, id, title, wxDefaultPosition, size, style, name);
+
+ // There are two ways to create an tabbed mdi child fram without
+ // making it the active document. Either Show(false) can be called
+ // before Create() (as is customary on some ports with wxFrame-type
+ // windows), or wxMINIMIZE can be passed in the style flags. Note that
+ // wxAuiMDIChildFrame is not really derived from wxFrame, as wxMDIChildFrame
+ // is, but those are the expected symantics. No style flag is passed
+ // onto the panel underneath.
+ if (style & wxMINIMIZE)
+ m_activateOnCreate = false;
+
+ Create(parent, id, title, wxDefaultPosition, size, 0, name);
}
-wxTabMDIChildFrame::~wxTabMDIChildFrame()
+wxAuiMDIChildFrame::~wxAuiMDIChildFrame()
{
+ wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
+ if (pParentFrame)
+ {
+ if (pParentFrame->GetActiveChild() == this)
+ {
+ pParentFrame->SetActiveChild(NULL);
+ pParentFrame->SetChildMenuBar(NULL);
+ }
+ wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
+ wxASSERT(pClientWindow);
+ int idx = pClientWindow->GetPageIndex(this);
+ if (idx != wxNOT_FOUND)
+ {
+ pClientWindow->RemovePage(idx);
+ }
+ }
+
#if wxUSE_MENUS
wxDELETE(m_pMenuBar);
#endif // wxUSE_MENUS
}
-bool wxTabMDIChildFrame::Create(wxTabMDIParentFrame* parent,
+bool wxAuiMDIChildFrame::Create(wxAuiMDIParentFrame* parent,
wxWindowID id,
const wxString& title,
const wxPoint& WXUNUSED(pos),
long style,
const wxString& name)
{
- wxTabMDIClientWindow* pClientWindow = parent->GetClientWindow();
- wxASSERT_MSG((pClientWindow != (wxWindow*) NULL), wxT("Missing MDI client window."));
+ wxAuiMDIClientWindow* pClientWindow = parent->GetClientWindow();
+ wxASSERT_MSG((pClientWindow != NULL), wxT("Missing MDI client window."));
- wxPanel::Create(pClientWindow, id, wxDefaultPosition, size, style|wxNO_BORDER, name);
+ // see comment in constructor
+ if (style & wxMINIMIZE)
+ m_activateOnCreate = false;
- SetMDIParentFrame(parent);
+ wxSize cli_size = pClientWindow->GetClientSize();
+
+ // create the window off-screen to prevent flicker
+ wxPanel::Create(pClientWindow,
+ id,
+ wxPoint(cli_size.x+1, cli_size.y+1),
+ size,
+ wxNO_BORDER, name);
- // this is the currently active child
- parent->SetActiveChild(this);
+ DoShow(false);
+
+ SetMDIParentFrame(parent);
m_title = title;
- pClientWindow->AddPage(this, title, true);
+ pClientWindow->AddPage(this, title, m_activateOnCreate);
+
+ // Check that the parent notion of the active child coincides with our one.
+ // This is less obvious that it seems because we must honour
+ // m_activateOnCreate flag but only if it's not the first child because
+ // this one becomes active unconditionally.
+ wxASSERT_MSG
+ (
+ (m_activateOnCreate || pClientWindow->GetPageCount() == 1)
+ == (parent->GetActiveChild() == this),
+ wxS("Logic error: child [not] activated when it should [not] have been.")
+ );
+
pClientWindow->Refresh();
return true;
}
-bool wxTabMDIChildFrame::Destroy()
+bool wxAuiMDIChildFrame::Destroy()
{
- wxTabMDIParentFrame* pParentFrame = GetMDIParentFrame();
+ wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
- wxTabMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
+ wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
wxASSERT_MSG(pClientWindow, wxT("Missing MDI Client Window"));
- bool bActive = false;
if (pParentFrame->GetActiveChild() == this)
{
- pParentFrame->SetActiveChild(NULL);
+ // deactivate ourself
+ wxActivateEvent event(wxEVT_ACTIVATE, false, GetId());
+ event.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(event);
+
pParentFrame->SetChildMenuBar(NULL);
- bActive = true;
}
- size_t pos, page_count = pClientWindow->GetPageCount();
- for (pos = 0; pos < page_count; pos++)
+ size_t page_count = pClientWindow->GetPageCount();
+ for (size_t pos = 0; pos < page_count; pos++)
{
if (pClientWindow->GetPage(pos) == this)
return pClientWindow->DeletePage(pos);
}
#if wxUSE_MENUS
-void wxTabMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
+void wxAuiMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
{
wxMenuBar *pOldMenuBar = m_pMenuBar;
m_pMenuBar = menu_bar;
if (m_pMenuBar)
{
- wxTabMDIParentFrame* pParentFrame = GetMDIParentFrame();
+ wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
m_pMenuBar->SetParent(pParentFrame);
}
}
-wxMenuBar *wxTabMDIChildFrame::GetMenuBar() const
+wxMenuBar *wxAuiMDIChildFrame::GetMenuBar() const
{
return m_pMenuBar;
}
#endif // wxUSE_MENUS
-void wxTabMDIChildFrame::SetTitle(const wxString& title)
+void wxAuiMDIChildFrame::SetTitle(const wxString& title)
{
m_title = title;
- wxTabMDIParentFrame* pParentFrame = GetMDIParentFrame();
+ wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
- wxTabMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
+ wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
if (pClientWindow != NULL)
{
size_t pos;
}
}
-wxString wxTabMDIChildFrame::GetTitle() const
+wxString wxAuiMDIChildFrame::GetTitle() const
{
return m_title;
}
-void wxTabMDIChildFrame::Activate()
+void wxAuiMDIChildFrame::SetIcons(const wxIconBundle& icons)
+{
+ // get icon with the system icon size
+ SetIcon(icons.GetIcon(-1));
+ m_iconBundle = icons;
+}
+
+const wxIconBundle& wxAuiMDIChildFrame::GetIcons() const
+{
+ return m_iconBundle;
+}
+
+void wxAuiMDIChildFrame::SetIcon(const wxIcon& icon)
{
- wxTabMDIParentFrame* pParentFrame = GetMDIParentFrame();
+ wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
- wxTabMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
+ m_icon = icon;
+
+ wxBitmap bmp;
+ bmp.CopyFromIcon(m_icon);
+
+ wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
+ if (pClientWindow != NULL)
+ {
+ int idx = pClientWindow->GetPageIndex(this);
+
+ if (idx != -1)
+ {
+ pClientWindow->SetPageBitmap((size_t)idx, bmp);
+ }
+ }
+}
+
+const wxIcon& wxAuiMDIChildFrame::GetIcon() const
+{
+ return m_icon;
+}
+
+
+void wxAuiMDIChildFrame::Activate()
+{
+ wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
+ wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
+
+ wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
if (pClientWindow != NULL)
{
}
}
-void wxTabMDIChildFrame::OnMenuHighlight(wxMenuEvent& event)
+void wxAuiMDIChildFrame::OnMenuHighlight(wxMenuEvent& event)
{
#if wxUSE_STATUSBAR
if (m_pMDIParentFrame)
#endif // wxUSE_STATUSBAR
}
-void wxTabMDIChildFrame::OnActivate(wxActivateEvent& WXUNUSED(event))
+void wxAuiMDIChildFrame::OnActivate(wxActivateEvent& WXUNUSED(event))
{
// do nothing
}
-void wxTabMDIChildFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
+void wxAuiMDIChildFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
{
Destroy();
}
-void wxTabMDIChildFrame::SetMDIParentFrame(wxTabMDIParentFrame* parentFrame)
+void wxAuiMDIChildFrame::SetMDIParentFrame(wxAuiMDIParentFrame* parentFrame)
{
m_pMDIParentFrame = parentFrame;
}
-wxTabMDIParentFrame* wxTabMDIChildFrame::GetMDIParentFrame() const
+wxAuiMDIParentFrame* wxAuiMDIChildFrame::GetMDIParentFrame() const
{
return m_pMDIParentFrame;
}
-void wxTabMDIChildFrame::Init()
+void wxAuiMDIChildFrame::Init()
{
+ m_activateOnCreate = true;
m_pMDIParentFrame = NULL;
#if wxUSE_MENUS
m_pMenuBar = NULL;
#endif // wxUSE_MENUS
}
-bool wxTabMDIChildFrame::Show(bool WXUNUSED(show))
+bool wxAuiMDIChildFrame::Show(bool show)
{
+ // wxAuiMDIChildFrame uses m_activateOnCreate only to decide whether to
+ // activate the frame when it is created. After Create() is called,
+ // m_activateOnCreate will never be read again. Therefore, calling this
+ // function after Create() is pointless and you probably want to call
+ // Activate() instead.
+ wxCHECK_MSG( !GetHandle(), false,
+ wxS("Show() has no effect after Create(). Do you mean Activate()?") );
+
+ m_activateOnCreate = show;
+
// do nothing
return true;
}
-void wxTabMDIChildFrame::DoShow(bool show)
+void wxAuiMDIChildFrame::DoShow(bool show)
{
wxWindow::Show(show);
}
-void wxTabMDIChildFrame::DoSetSize(int x, int y, int width, int height, int sizeFlags)
+void wxAuiMDIChildFrame::DoSetSize(int x, int y, int width, int height, int sizeFlags)
{
- m_mdi_newrect = wxRect(x, y, width, height);
+ m_mdiNewRect = wxRect(x, y, width, height);
#ifdef __WXGTK__
wxPanel::DoSetSize(x,y,width, height, sizeFlags);
#else
#endif
}
-void wxTabMDIChildFrame::DoMoveWindow(int x, int y, int width, int height)
+void wxAuiMDIChildFrame::DoMoveWindow(int x, int y, int width, int height)
{
- m_mdi_newrect = wxRect(x, y, width, height);
+ m_mdiNewRect = wxRect(x, y, width, height);
}
-void wxTabMDIChildFrame::ApplyMDIChildFrameRect()
+void wxAuiMDIChildFrame::ApplyMDIChildFrameRect()
{
- if (m_mdi_currect != m_mdi_newrect)
+ if (m_mdiCurRect != m_mdiNewRect)
{
- wxPanel::DoMoveWindow(m_mdi_newrect.x, m_mdi_newrect.y,
- m_mdi_newrect.width, m_mdi_newrect.height);
- m_mdi_currect = m_mdi_newrect;
+ wxPanel::DoMoveWindow(m_mdiNewRect.x, m_mdiNewRect.y,
+ m_mdiNewRect.width, m_mdiNewRect.height);
+ m_mdiCurRect = m_mdiNewRect;
}
}
//-----------------------------------------------------------------------------
-// wxTabMDIClientWindow
+// wxAuiMDIClientWindow
//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxTabMDIClientWindow, wxAuiMultiNotebook)
+IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIClientWindow, wxAuiNotebook)
-BEGIN_EVENT_TABLE(wxTabMDIClientWindow, wxAuiMultiNotebook)
- EVT_AUINOTEBOOK_PAGE_CHANGED(wxID_ANY, wxTabMDIClientWindow::OnPageChanged)
- EVT_SIZE(wxTabMDIClientWindow::OnSize)
+BEGIN_EVENT_TABLE(wxAuiMDIClientWindow, wxAuiNotebook)
+ EVT_AUINOTEBOOK_PAGE_CHANGED(wxID_ANY, wxAuiMDIClientWindow::OnPageChanged)
+ EVT_AUINOTEBOOK_PAGE_CLOSE(wxID_ANY, wxAuiMDIClientWindow::OnPageClose)
+ EVT_SIZE(wxAuiMDIClientWindow::OnSize)
END_EVENT_TABLE()
-wxTabMDIClientWindow::wxTabMDIClientWindow()
+wxAuiMDIClientWindow::wxAuiMDIClientWindow()
{
}
-wxTabMDIClientWindow::wxTabMDIClientWindow(wxTabMDIParentFrame* parent, long style)
+wxAuiMDIClientWindow::wxAuiMDIClientWindow(wxAuiMDIParentFrame* parent, long style)
{
CreateClient(parent, style);
}
-wxTabMDIClientWindow::~wxTabMDIClientWindow()
-{
- DestroyChildren();
-}
-
-bool wxTabMDIClientWindow::CreateClient(wxTabMDIParentFrame* parent, long style)
+bool wxAuiMDIClientWindow::CreateClient(wxAuiMDIParentFrame* parent, long style)
{
SetWindowStyleFlag(style);
- if (!wxAuiMultiNotebook::Create(parent,
- wxID_ANY,
- wxPoint(0,0),
- wxSize(100, 100),
- wxNO_BORDER))
+ wxSize caption_icon_size =
+ wxSize(wxSystemSettings::GetMetric(wxSYS_SMALLICON_X),
+ wxSystemSettings::GetMetric(wxSYS_SMALLICON_Y));
+ SetUniformBitmapSize(caption_icon_size);
+
+ 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);
+ SetOwnBackgroundColour(bkcolour);
- m_mgr.GetArtProvider()->SetColour(wxAUI_ART_BACKGROUND_COLOUR, bkcolour);
+ m_mgr.GetArtProvider()->SetColour(wxAUI_DOCKART_BACKGROUND_COLOUR, bkcolour);
return true;
}
-int wxTabMDIClientWindow::SetSelection(size_t nPage)
+int wxAuiMDIClientWindow::SetSelection(size_t nPage)
{
- return wxAuiMultiNotebook::SetSelection(nPage);
+ return wxAuiNotebook::SetSelection(nPage);
}
-void wxTabMDIClientWindow::PageChanged(int old_selection, int new_selection)
+wxAuiMDIChildFrame* wxAuiMDIClientWindow::GetActiveChild()
+{
+ const int sel = GetSelection();
+ if ( sel == wxNOT_FOUND )
+ return NULL;
+
+ return wxStaticCast(GetPage(sel), wxAuiMDIChildFrame);
+}
+
+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)
{
- wxTabMDIChildFrame* child = (wxTabMDIChildFrame*)GetPage(new_selection);
+ 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)
+ if ((old_selection != -1) && (old_selection < (int)GetPageCount()))
{
- wxTabMDIChildFrame* old_child = (wxTabMDIChildFrame*)GetPage(old_selection);
- wxASSERT_MSG(old_child, wxT("wxTabMDIClientWindow::PageChanged - null page pointer"));
+ 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);
// notify new active child that it has been activated
if (new_selection != -1)
{
- wxTabMDIChildFrame* active_child = (wxTabMDIChildFrame*)GetPage(new_selection);
- wxASSERT_MSG(active_child, wxT("wxTabMDIClientWindow::PageChanged - null page pointer"));
+ 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->GetMDIParentFrame()->SetChildMenuBar(active_child);
}
}
+
+
+}
+
+void wxAuiMDIClientWindow::OnPageClose(wxAuiNotebookEvent& evt)
+{
+ wxAuiMDIChildFrame* wnd;
+ wnd = static_cast<wxAuiMDIChildFrame*>(GetPage(evt.GetSelection()));
+
+ wnd->Close();
+
+ // regardless of the result of wnd->Close(), we've
+ // already taken care of the close operations, so
+ // suppress further processing
+ evt.Veto();
}
-void wxTabMDIClientWindow::OnPageChanged(wxAuiNotebookEvent& evt)
+void wxAuiMDIClientWindow::OnPageChanged(wxAuiNotebookEvent& evt)
{
PageChanged(evt.GetOldSelection(), evt.GetSelection());
- evt.Skip();
}
-void wxTabMDIClientWindow::OnSize(wxSizeEvent& evt)
+void wxAuiMDIClientWindow::OnSize(wxSizeEvent& evt)
{
- wxAuiMultiNotebook::OnSize(evt);
+ wxAuiNotebook::OnSize(evt);
for (size_t pos = 0; pos < GetPageCount(); pos++)
- ((wxTabMDIChildFrame *)GetPage(pos))->ApplyMDIChildFrameRect();
+ ((wxAuiMDIChildFrame *)GetPage(pos))->ApplyMDIChildFrameRect();
}
+#endif //wxUSE_AUI
#endif // wxUSE_MDI
projects / wxWidgets.git / blobdiff