check that the version of __sync_sub_and_fetch that returns a value is supported...

[wxWidgets.git] / src / aui / tabmdi.cpp

diff --git a/src/aui/tabmdi.cpp b/src/aui/tabmdi.cpp
index 78f618e0a459465f0e04f810df200d892d4c8df9..ccf9e885f51d37b9f06b80ef977b4d3af9a695a1 100644 (file)
--- a/src/aui/tabmdi.cpp
+++ b/src/aui/tabmdi.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// 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
 // Purpose:     Generic MDI (Multiple Document Interface) classes
 // Author:      Hans Van Leemputten
 // Modified by: Benjamin I. Williams / Kirix Corporation


@@ -24,6 +24,7 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#if wxUSE_AUI

 #if wxUSE_MDI
 
 #include "wx/aui/tabmdi.h"
 #if wxUSE_MDI
 
 #include "wx/aui/tabmdi.h"


@@ -47,23 +48,23 @@ 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
 #if wxUSE_MENUS

-    EVT_MENU (wxID_ANY, wxTabMDIParentFrame::DoHandleMenu)
+    EVT_MENU (wxID_ANY, wxAuiMDIParentFrame::DoHandleMenu)

 #endif
 END_EVENT_TABLE()
 
 #endif
 END_EVENT_TABLE()
 

-wxTabMDIParentFrame::wxTabMDIParentFrame()
+wxAuiMDIParentFrame::wxAuiMDIParentFrame()

 {
     Init();
 }
 
 {
     Init();
 }
 

-wxTabMDIParentFrame::wxTabMDIParentFrame(wxWindow *parent,
+wxAuiMDIParentFrame::wxAuiMDIParentFrame(wxWindow *parent,

                                          wxWindowID id,
                                          const wxString& title,
                                          const wxPoint& pos,
                                          wxWindowID id,
                                          const wxString& title,
                                          const wxPoint& pos,


@@ -75,18 +76,19 @@ wxTabMDIParentFrame::wxTabMDIParentFrame(wxWindow *parent,
     (void)Create(parent, id, title, pos, size, style, name);
 }
 
     (void)Create(parent, id, title, pos, size, style, name);
 }
 

-wxTabMDIParentFrame::~wxTabMDIParentFrame()
+wxAuiMDIParentFrame::~wxAuiMDIParentFrame()

 {
     // Make sure the client window is destructed before the menu bars are!
     wxDELETE(m_pClientWindow);
 
 #if wxUSE_MENUS
 {
     // Make sure the client window is destructed before the menu bars are!
     wxDELETE(m_pClientWindow);
 
 #if wxUSE_MENUS

+    wxDELETE(m_pMyMenuBar);

     RemoveWindowMenu(GetMenuBar());
     RemoveWindowMenu(GetMenuBar());

-    delete m_pWindowMenu;
+    wxDELETE(m_pWindowMenu);

 #endif // wxUSE_MENUS
 }
 
 #endif // wxUSE_MENUS
 }
 

-bool wxTabMDIParentFrame::Create(wxWindow *parent,
+bool wxAuiMDIParentFrame::Create(wxWindow *parent,

                                  wxWindowID id,
                                  const wxString& title,
                                  const wxPoint& pos,
                                  wxWindowID id,
                                  const wxString& title,
                                  const wxPoint& pos,


@@ -113,8 +115,32 @@ bool wxTabMDIParentFrame::Create(wxWindow *parent,
     return true;
 }
 
     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
 #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();
 {
     // Replace the window menu from the currently loaded menu bar.
     wxMenuBar *pMenuBar = GetMenuBar();


@@ -132,7 +158,7 @@ void wxTabMDIParentFrame::SetWindowMenu(wxMenu* pMenu)
     }
 }
 
     }
 }
 

-void wxTabMDIParentFrame::SetMenuBar(wxMenuBar *pMenuBar)
+void wxAuiMDIParentFrame::SetMenuBar(wxMenuBar* pMenuBar)

 {
     // Remove the Window menu from the old menu bar
     RemoveWindowMenu(GetMenuBar());
 {
     // Remove the Window menu from the old menu bar
     RemoveWindowMenu(GetMenuBar());


@@ -141,22 +167,25 @@ void wxTabMDIParentFrame::SetMenuBar(wxMenuBar *pMenuBar)
     AddWindowMenu(pMenuBar);
 
     wxFrame::SetMenuBar(pMenuBar);
     AddWindowMenu(pMenuBar);
 
     wxFrame::SetMenuBar(pMenuBar);

-    m_pMyMenuBar = GetMenuBar();
+    //m_pMyMenuBar = GetMenuBar();

 }
 #endif // wxUSE_MENUS
 
 }
 #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.
 {
 #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;
     }
 
         // Make sure we know our menu bar is in use
         m_pMyMenuBar = NULL;
     }

-     else
+    else

     {
         if (pChild->GetMenuBar() == NULL)
             return;
     {
         if (pChild->GetMenuBar() == NULL)
             return;


@@ -170,16 +199,14 @@ void wxTabMDIParentFrame::SetChildMenuBar(wxTabMDIChildFrame* pChild)
 #endif // wxUSE_MENUS
 }
 
 #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;
         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 &&
         event.IsCommandEvent() &&
     bool res = false;
     if (m_pActiveChild &&
         event.IsCommandEvent() &&


@@ -195,40 +222,41 @@ bool wxTabMDIParentFrame::ProcessEvent(wxEvent& event)
         res = m_pActiveChild->GetEventHandler()->ProcessEvent(event);
     }
 
         res = m_pActiveChild->GetEventHandler()->ProcessEvent(event);
     }
 

-    // If the event was not handled this frame will handle it!

     if (!res)
     {
     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);
     }
 
         res = wxEvtHandler::ProcessEvent(event);
     }
 

-    inEvent = wxEVT_NULL;
+    m_pLastEvt = NULL;

 
     return res;
 }
 
 
     return res;
 }
 

-wxTabMDIChildFrame *wxTabMDIParentFrame::GetActiveChild() const
+wxAuiMDIChildFrame *wxAuiMDIParentFrame::GetActiveChild() const

 {
     return m_pActiveChild;
 }
 
 {
     return m_pActiveChild;
 }
 

-void wxTabMDIParentFrame::SetActiveChild(wxTabMDIChildFrame* pChildFrame)
+void wxAuiMDIParentFrame::SetActiveChild(wxAuiMDIChildFrame* pChildFrame)

 {
     m_pActiveChild = pChildFrame;
 }
 
 {
     m_pActiveChild = pChildFrame;
 }
 

-wxTabMDIClientWindow *wxTabMDIParentFrame::GetClientWindow() const
+wxAuiMDIClientWindow *wxAuiMDIParentFrame::GetClientWindow() const

 {
     return m_pClientWindow;
 }
 
 {
     return m_pClientWindow;
 }
 

-wxTabMDIClientWindow *wxTabMDIParentFrame::OnCreateClient()
+wxAuiMDIClientWindow *wxAuiMDIParentFrame::OnCreateClient()

 {
 {

-    m_pClientWindow = new wxTabMDIClientWindow( this );
+    m_pClientWindow = new wxAuiMDIClientWindow( this );

     return m_pClientWindow;
 }
 
     return m_pClientWindow;
 }
 

-void wxTabMDIParentFrame::ActivateNext()
+void wxAuiMDIParentFrame::ActivateNext()

 {
     if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
     {
 {
     if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
     {


@@ -240,7 +268,7 @@ void wxTabMDIParentFrame::ActivateNext()
     }
 }
 
     }
 }
 

-void wxTabMDIParentFrame::ActivatePrevious()
+void wxAuiMDIParentFrame::ActivatePrevious()

 {
     if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
     {
 {
     if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
     {


@@ -252,8 +280,9 @@ void wxTabMDIParentFrame::ActivatePrevious()
     }
 }
 
     }
 }
 

-void wxTabMDIParentFrame::Init()
+void wxAuiMDIParentFrame::Init()

 {
 {

+    m_pLastEvt = NULL;

     m_pClientWindow = NULL;
     m_pActiveChild = NULL;
 #if wxUSE_MENUS
     m_pClientWindow = NULL;
     m_pActiveChild = NULL;
 #if wxUSE_MENUS


@@ -263,7 +292,7 @@ void wxTabMDIParentFrame::Init()
 }
 
 #if wxUSE_MENUS
 }
 
 #if wxUSE_MENUS

-void wxTabMDIParentFrame::RemoveWindowMenu(wxMenuBar* pMenuBar)
+void wxAuiMDIParentFrame::RemoveWindowMenu(wxMenuBar* pMenuBar)

 {
     if (pMenuBar && m_pWindowMenu)
     {
 {
     if (pMenuBar && m_pWindowMenu)
     {


@@ -278,19 +307,19 @@ void wxTabMDIParentFrame::RemoveWindowMenu(wxMenuBar* pMenuBar)
     }
 }
 
     }
 }
 

-void wxTabMDIParentFrame::AddWindowMenu(wxMenuBar *pMenuBar)
+void wxAuiMDIParentFrame::AddWindowMenu(wxMenuBar *pMenuBar)

 {
     if (pMenuBar && m_pWindowMenu)
     {
 {
     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"));
         if (pos == wxNOT_FOUND)
             pMenuBar->Append(m_pWindowMenu, _("&Window"));

-             else
+        else

             pMenuBar->Insert(pos, m_pWindowMenu, _("&Window"));
     }
 }
 
             pMenuBar->Insert(pos, m_pWindowMenu, _("&Window"));
     }
 }
 

-void wxTabMDIParentFrame::DoHandleMenu(wxCommandEvent& event)
+void wxAuiMDIParentFrame::DoHandleMenu(wxCommandEvent& event)

 {
     switch (event.GetId())
     {
 {
     switch (event.GetId())
     {


@@ -305,11 +334,6 @@ void wxTabMDIParentFrame::DoHandleMenu(wxCommandEvent& event)
                 {
                     return; // failure
                 }
                 {
                     return; // failure
                 }

-                 else
-                {
-                    delete m_pActiveChild;
-                    m_pActiveChild = NULL;
-                }

             }
             break;
         case wxWINDOWNEXT:
             }
             break;
         case wxWINDOWNEXT:


@@ -324,29 +348,49 @@ void wxTabMDIParentFrame::DoHandleMenu(wxCommandEvent& event)
 }
 #endif // wxUSE_MENUS
 
 }
 #endif // wxUSE_MENUS
 

-void wxTabMDIParentFrame::DoGetClientSize(int* width, int* height) const
+void wxAuiMDIParentFrame::DoGetClientSize(int* width, int* height) const

 {
     wxFrame::DoGetClientSize(width, height);
 }
 
 {
     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()
 
 END_EVENT_TABLE()
 

-wxTabMDIChildFrame::wxTabMDIChildFrame()
+wxAuiMDIChildFrame::wxAuiMDIChildFrame()

 {
     Init();
 }
 
 {
     Init();
 }
 

-wxTabMDIChildFrame::wxTabMDIChildFrame(wxTabMDIParentFrame *parent,
+wxAuiMDIChildFrame::wxAuiMDIChildFrame(wxAuiMDIParentFrame *parent,

                                        wxWindowID id,
                                        const wxString& title,
                                        const wxPoint& WXUNUSED(pos),
                                        wxWindowID id,
                                        const wxString& title,
                                        const wxPoint& WXUNUSED(pos),


@@ -355,17 +399,35 @@ wxTabMDIChildFrame::wxTabMDIChildFrame(wxTabMDIParentFrame *parent,
                                        const wxString& name)
 {
     Init();
                                        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_activate_on_create = false;
+
+    Create(parent, id, title, wxDefaultPosition, size, 0, name);

 }
 
 }
 

-wxTabMDIChildFrame::~wxTabMDIChildFrame()
+wxAuiMDIChildFrame::~wxAuiMDIChildFrame()

 {
 {

+    wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
+    if (pParentFrame && pParentFrame->GetActiveChild() == this)
+    {
+        pParentFrame->SetActiveChild(NULL);
+        pParentFrame->SetChildMenuBar(NULL);
+    }
+

 #if wxUSE_MENUS
     wxDELETE(m_pMenuBar);
 #endif // wxUSE_MENUS
 }
 
 #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),
                                 wxWindowID id,
                                 const wxString& title,
                                 const wxPoint& WXUNUSED(pos),


@@ -373,10 +435,23 @@ bool wxTabMDIChildFrame::Create(wxTabMDIParentFrame* parent,
                                 long style,
                                 const wxString& name)
 {
                                 long style,
                                 const wxString& name)
 {

-    wxTabMDIClientWindow* pClientWindow = parent->GetClientWindow();
+    wxAuiMDIClientWindow* pClientWindow = parent->GetClientWindow();

     wxASSERT_MSG((pClientWindow != (wxWindow*) NULL), wxT("Missing MDI client window."));
 
     wxASSERT_MSG((pClientWindow != (wxWindow*) NULL), wxT("Missing MDI client window."));
 

-    wxPanel::Create(pClientWindow, id, wxDefaultPosition, size, style|wxNO_BORDER, name);
+    // see comment in constructor
+    if (style & wxMINIMIZE)
+        m_activate_on_create = false;
+
+    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);
+
+    DoShow(false);

 
     SetMDIParentFrame(parent);
 
 
     SetMDIParentFrame(parent);
 


@@ -385,30 +460,33 @@ bool wxTabMDIChildFrame::Create(wxTabMDIParentFrame* parent,
 
     m_title = title;
 
 
     m_title = title;
 

-    pClientWindow->AddPage(this, title, true);
+    pClientWindow->AddPage(this, title, m_activate_on_create);

     pClientWindow->Refresh();
 
     return true;
 }
 
     pClientWindow->Refresh();
 
     return true;
 }
 

-bool wxTabMDIChildFrame::Destroy()
+bool wxAuiMDIChildFrame::Destroy()

 {
 {

-    wxTabMDIParentFrame* pParentFrame = GetMDIParentFrame();
+    wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();

     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 
     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 

-    wxTabMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
+    wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();

     wxASSERT_MSG(pClientWindow, wxT("Missing MDI Client Window"));
 
     wxASSERT_MSG(pClientWindow, wxT("Missing MDI Client Window"));
 

-    bool bActive = false;

     if (pParentFrame->GetActiveChild() == this)
     {
     if (pParentFrame->GetActiveChild() == this)
     {

+        // deactivate ourself
+        wxActivateEvent event(wxEVT_ACTIVATE, false, GetId());
+        event.SetEventObject(this);
+        GetEventHandler()->ProcessEvent(event);
+

         pParentFrame->SetActiveChild(NULL);
         pParentFrame->SetChildMenuBar(NULL);
         pParentFrame->SetActiveChild(NULL);
         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 (pClientWindow->GetPage(pos) == this)
             return pClientWindow->DeletePage(pos);


@@ -418,14 +496,14 @@ bool wxTabMDIChildFrame::Destroy()
 }
 
 #if wxUSE_MENUS
 }
 
 #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)
     {
 {
     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);
         wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 
         m_pMenuBar->SetParent(pParentFrame);


@@ -439,20 +517,20 @@ void wxTabMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
     }
 }
 
     }
 }
 

-wxMenuBar *wxTabMDIChildFrame::GetMenuBar() const
+wxMenuBar *wxAuiMDIChildFrame::GetMenuBar() const

 {
     return m_pMenuBar;
 }
 #endif // wxUSE_MENUS
 
 {
     return m_pMenuBar;
 }
 #endif // wxUSE_MENUS
 

-void wxTabMDIChildFrame::SetTitle(const wxString& title)
+void wxAuiMDIChildFrame::SetTitle(const wxString& title)

 {
     m_title = title;
 
 {
     m_title = title;
 

-    wxTabMDIParentFrame* pParentFrame = GetMDIParentFrame();
+    wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();

     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 
     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 

-    wxTabMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
+    wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();

     if (pClientWindow != NULL)
     {
         size_t pos;
     if (pClientWindow != NULL)
     {
         size_t pos;


@@ -467,17 +545,57 @@ void wxTabMDIChildFrame::SetTitle(const wxString& title)
     }
 }
 
     }
 }
 

-wxString wxTabMDIChildFrame::GetTitle() const
+wxString wxAuiMDIChildFrame::GetTitle() const

 {
     return m_title;
 }
 
 {
     return m_title;
 }
 

-void wxTabMDIChildFrame::Activate()
+void wxAuiMDIChildFrame::SetIcons(const wxIconBundle& icons)
+{
+    // get icon with the system icon size
+    SetIcon(icons.GetIcon(-1));
+    m_icon_bundle = icons;
+}
+
+const wxIconBundle& wxAuiMDIChildFrame::GetIcons() const
+{
+    return m_icon_bundle;
+}
+
+void wxAuiMDIChildFrame::SetIcon(const wxIcon& icon)
+{
+    wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
+    wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
+
+    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()

 {
 {

-    wxTabMDIParentFrame* pParentFrame = GetMDIParentFrame();
+    wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();

     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 
     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 

-    wxTabMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
+    wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();

 
     if (pClientWindow != NULL)
     {
 
     if (pClientWindow != NULL)
     {


@@ -493,7 +611,7 @@ void wxTabMDIChildFrame::Activate()
     }
 }
 
     }
 }
 

-void wxTabMDIChildFrame::OnMenuHighlight(wxMenuEvent& event)
+void wxAuiMDIChildFrame::OnMenuHighlight(wxMenuEvent& event)

 {
 #if wxUSE_STATUSBAR
     if (m_pMDIParentFrame)
 {
 #if wxUSE_STATUSBAR
     if (m_pMDIParentFrame)


@@ -507,56 +625,64 @@ void wxTabMDIChildFrame::OnMenuHighlight(wxMenuEvent& event)
 #endif // wxUSE_STATUSBAR
 }
 
 #endif // wxUSE_STATUSBAR
 }
 

-void wxTabMDIChildFrame::OnActivate(wxActivateEvent& WXUNUSED(event))
+void wxAuiMDIChildFrame::OnActivate(wxActivateEvent& WXUNUSED(event))

 {
     // do nothing
 }
 
 {
     // do nothing
 }
 

-void wxTabMDIChildFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
+void wxAuiMDIChildFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))

 {
     Destroy();
 }
 
 {
     Destroy();
 }
 

-void wxTabMDIChildFrame::SetMDIParentFrame(wxTabMDIParentFrame* parentFrame)
+void wxAuiMDIChildFrame::SetMDIParentFrame(wxAuiMDIParentFrame* parentFrame)

 {
     m_pMDIParentFrame = parentFrame;
 }
 
 {
     m_pMDIParentFrame = parentFrame;
 }
 

-wxTabMDIParentFrame* wxTabMDIChildFrame::GetMDIParentFrame() const
+wxAuiMDIParentFrame* wxAuiMDIChildFrame::GetMDIParentFrame() const

 {
     return m_pMDIParentFrame;
 }
 
 {
     return m_pMDIParentFrame;
 }
 

-void wxTabMDIChildFrame::Init()
+void wxAuiMDIChildFrame::Init()

 {
 {

+    m_activate_on_create = true;

     m_pMDIParentFrame = NULL;
 #if wxUSE_MENUS
     m_pMenuBar = NULL;
 #endif // wxUSE_MENUS
 }
 
     m_pMDIParentFrame = NULL;
 #if wxUSE_MENUS
     m_pMenuBar = NULL;
 #endif // wxUSE_MENUS
 }
 

-bool wxTabMDIChildFrame::Show(bool WXUNUSED(show))
+bool wxAuiMDIChildFrame::Show(bool show)

 {
 {

+    m_activate_on_create = show;
+

     // do nothing
     return true;
 }
 
     // do nothing
     return true;
 }
 

-void wxTabMDIChildFrame::DoShow(bool show)
+void wxAuiMDIChildFrame::DoShow(bool show)

 {
     wxWindow::Show(show);
 }
 
 {
     wxWindow::Show(show);
 }
 

-void wxTabMDIChildFrame::DoSetSize(int x, int y, int width, int height, int WXUNUSED(sizeFlags))
+void wxAuiMDIChildFrame::DoSetSize(int x, int y, int width, int height, int sizeFlags)

 {
     m_mdi_newrect = wxRect(x, y, width, height);
 {
     m_mdi_newrect = wxRect(x, y, width, height);

+#ifdef __WXGTK__
+    wxPanel::DoSetSize(x,y,width, height, sizeFlags);
+#else
+    wxUnusedVar(sizeFlags);
+#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_mdi_newrect = wxRect(x, y, width, height);
 }
 

-void wxTabMDIChildFrame::ApplyMDIChildFrameRect()
+void wxAuiMDIChildFrame::ApplyMDIChildFrameRect()

 {
     if (m_mdi_currect != m_mdi_newrect)
     {
 {
     if (m_mdi_currect != m_mdi_newrect)
     {


@@ -568,75 +694,83 @@ void wxTabMDIChildFrame::ApplyMDIChildFrameRect()
 
 
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------

-// 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()
 
 END_EVENT_TABLE()
 

-wxTabMDIClientWindow::wxTabMDIClientWindow()
+wxAuiMDIClientWindow::wxAuiMDIClientWindow()

 {
 }
 
 {
 }
 

-wxTabMDIClientWindow::wxTabMDIClientWindow(wxTabMDIParentFrame* parent, long style)
+wxAuiMDIClientWindow::wxAuiMDIClientWindow(wxAuiMDIParentFrame* parent, long style)

 {
     CreateClient(parent, style);
 }
 
 {
     CreateClient(parent, style);
 }
 

-wxTabMDIClientWindow::~wxTabMDIClientWindow()
+wxAuiMDIClientWindow::~wxAuiMDIClientWindow()

 {
     DestroyChildren();
 }
 
 {
     DestroyChildren();
 }
 

-bool wxTabMDIClientWindow::CreateClient(wxTabMDIParentFrame* parent, long style)
+bool wxAuiMDIClientWindow::CreateClient(wxAuiMDIParentFrame* parent, long style)

 {
     SetWindowStyleFlag(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);
     {
         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;
 }
 
 
     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)
+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 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)
     {
     // 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;
         if (child->GetMDIParentFrame()->GetActiveChild() == child)
             return;

-    }
+    }*/
+

 
     // notify old active child that it has been deactivated
     if (old_selection != -1)
     {
 
     // notify old active child that it has been deactivated
     if (old_selection != -1)
     {

-        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);
 
         wxActivateEvent event(wxEVT_ACTIVATE, false, old_child->GetId());
         event.SetEventObject(old_child);


@@ -646,8 +780,8 @@ void wxTabMDIClientWindow::PageChanged(int old_selection, int new_selection)
     // notify new active child that it has been activated
     if (new_selection != -1)
     {
     // 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);
 
         wxActivateEvent event(wxEVT_ACTIVATE, true, active_child->GetId());
         event.SetEventObject(active_child);


@@ -659,20 +793,35 @@ void wxTabMDIClientWindow::PageChanged(int old_selection, int new_selection)
             active_child->GetMDIParentFrame()->SetChildMenuBar(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());
 {
     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++)
 
     for (size_t pos = 0; pos < GetPageCount(); pos++)

-        ((wxTabMDIChildFrame *)GetPage(pos))->ApplyMDIChildFrameRect();
+        ((wxAuiMDIChildFrame *)GetPage(pos))->ApplyMDIChildFrameRect();

 }
 
 }
 

+#endif //wxUSE_AUI

 #endif // wxUSE_MDI
 #endif // wxUSE_MDI