Undid completely wrong patch 1438117: other platforms do _not_ count

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

diff --git a/src/aui/framemanager.cpp b/src/aui/framemanager.cpp
index 3ae027d0545f2b1a3d78f9df3469070175a24dfb..e1b0ee6797fa0c76d07b803eda87bec114a3d650 100644 (file)
--- a/src/aui/framemanager.cpp
+++ b/src/aui/framemanager.cpp
@@ -45,15 +45,17 @@ WX_CHECK_BUILD_OPTIONS("wxAUI")
 #include "wx/arrimpl.cpp"
 WX_DECLARE_OBJARRAY(wxRect, wxAuiRectArray);
 WX_DEFINE_OBJARRAY(wxAuiRectArray)
 #include "wx/arrimpl.cpp"
 WX_DECLARE_OBJARRAY(wxRect, wxAuiRectArray);
 WX_DEFINE_OBJARRAY(wxAuiRectArray)

-WX_DEFINE_OBJARRAY(wxDockUIPartArray)
-WX_DEFINE_OBJARRAY(wxDockInfoArray)
-WX_DEFINE_OBJARRAY(wxPaneButtonArray)
-WX_DEFINE_OBJARRAY(wxPaneInfoArray)
+WX_DEFINE_OBJARRAY(wxAuiDockUIPartArray)
+WX_DEFINE_OBJARRAY(wxAuiDockInfoArray)
+WX_DEFINE_OBJARRAY(wxAuiPaneButtonArray)
+WX_DEFINE_OBJARRAY(wxAuiPaneInfoArray)

 
 

-wxPaneInfo wxNullPaneInfo;
-wxDockInfo wxNullDockInfo;
+wxAuiPaneInfo wxAuiNullPaneInfo;
+wxAuiDockInfo wxAuiNullDockInfo;

 DEFINE_EVENT_TYPE(wxEVT_AUI_PANEBUTTON)
 DEFINE_EVENT_TYPE(wxEVT_AUI_PANECLOSE)
 DEFINE_EVENT_TYPE(wxEVT_AUI_PANEBUTTON)
 DEFINE_EVENT_TYPE(wxEVT_AUI_PANECLOSE)

+DEFINE_EVENT_TYPE(wxEVT_AUI_PANEMAXIMIZE)
+DEFINE_EVENT_TYPE(wxEVT_AUI_PANERESTORE)

 DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER)
 
 #ifdef __WXMAC__
 DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER)
 
 #ifdef __WXMAC__


@@ -63,7 +65,7 @@ DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER)
     #include "wx/mac/private.h"
 #endif
 
     #include "wx/mac/private.h"
 #endif
 

-IMPLEMENT_DYNAMIC_CLASS(wxFrameManagerEvent, wxEvent)
+IMPLEMENT_DYNAMIC_CLASS(wxAuiManagerEvent, wxEvent)

 
 class wxPseudoTransparentFrame : public wxFrame
 {
 
 class wxPseudoTransparentFrame : public wxFrame
 {


@@ -222,21 +224,21 @@ static void DrawResizeHint(wxDC& dc, const wxRect& rect)
 
 
 // CopyDocksAndPanes() - this utility function creates copies of
 
 
 // CopyDocksAndPanes() - this utility function creates copies of

-// the dock and pane info.  wxDockInfo's usually contain pointers
-// to wxPaneInfo classes, thus this function is necessary to reliably
+// the dock and pane info.  wxAuiDockInfo's usually contain pointers
+// to wxAuiPaneInfo classes, thus this function is necessary to reliably

 // reconstruct that relationship in the new dock info and pane info arrays
 
 // reconstruct that relationship in the new dock info and pane info arrays
 

-static void CopyDocksAndPanes(wxDockInfoArray& dest_docks,
-                              wxPaneInfoArray& dest_panes,
-                              const wxDockInfoArray& src_docks,
-                              const wxPaneInfoArray& src_panes)
+static void CopyDocksAndPanes(wxAuiDockInfoArray& dest_docks,
+                              wxAuiPaneInfoArray& dest_panes,
+                              const wxAuiDockInfoArray& src_docks,
+                              const wxAuiPaneInfoArray& src_panes)

 {
     dest_docks = src_docks;
     dest_panes = src_panes;
     int i, j, k, dock_count, pc1, pc2;
     for (i = 0, dock_count = dest_docks.GetCount(); i < dock_count; ++i)
     {
 {
     dest_docks = src_docks;
     dest_panes = src_panes;
     int i, j, k, dock_count, pc1, pc2;
     for (i = 0, dock_count = dest_docks.GetCount(); i < dock_count; ++i)
     {

-        wxDockInfo& dock = dest_docks.Item(i);
+        wxAuiDockInfo& dock = dest_docks.Item(i);

         for (j = 0, pc1 = dock.panes.GetCount(); j < pc1; ++j)
             for (k = 0, pc2 = src_panes.GetCount(); k < pc2; ++k)
                 if (dock.panes.Item(j) == &src_panes.Item(k))
         for (j = 0, pc1 = dock.panes.GetCount(); j < pc1; ++j)
             for (k = 0, pc2 = src_panes.GetCount(); k < pc2; ++k)
                 if (dock.panes.Item(j) == &src_panes.Item(k))


@@ -246,12 +248,12 @@ static void CopyDocksAndPanes(wxDockInfoArray& dest_docks,
 
 // GetMaxLayer() is an internal function which returns
 // the highest layer inside the specified dock
 
 // GetMaxLayer() is an internal function which returns
 // the highest layer inside the specified dock

-static int GetMaxLayer(const wxDockInfoArray& docks, int dock_direction)
+static int GetMaxLayer(const wxAuiDockInfoArray& docks, int dock_direction)

 {
     int i, dock_count, max_layer = 0;
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {
 {
     int i, dock_count, max_layer = 0;
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {

-        wxDockInfo& dock = docks.Item(i);
+        wxAuiDockInfo& dock = docks.Item(i);

         if (dock.dock_direction == dock_direction &&
             dock.dock_layer > max_layer && !dock.fixed)
                 max_layer = dock.dock_layer;
         if (dock.dock_direction == dock_direction &&
             dock.dock_layer > max_layer && !dock.fixed)
                 max_layer = dock.dock_layer;


@@ -262,12 +264,12 @@ static int GetMaxLayer(const wxDockInfoArray& docks, int dock_direction)
 
 // GetMaxRow() is an internal function which returns
 // the highest layer inside the specified dock
 
 // GetMaxRow() is an internal function which returns
 // the highest layer inside the specified dock

-static int GetMaxRow(const wxPaneInfoArray& panes, int direction, int layer)
+static int GetMaxRow(const wxAuiPaneInfoArray& panes, int direction, int layer)

 {
     int i, pane_count, max_row = 0;
     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
     {
 {
     int i, pane_count, max_row = 0;
     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
     {

-        wxPaneInfo& pane = panes.Item(i);
+        wxAuiPaneInfo& pane = panes.Item(i);

         if (pane.dock_direction == direction &&
             pane.dock_layer == layer &&
             pane.dock_row > max_row)
         if (pane.dock_direction == direction &&
             pane.dock_layer == layer &&
             pane.dock_row > max_row)


@@ -280,14 +282,14 @@ static int GetMaxRow(const wxPaneInfoArray& panes, int direction, int layer)
 
 // DoInsertDockLayer() is an internal function that inserts a new dock
 // layer by incrementing all existing dock layer values by one
 
 // DoInsertDockLayer() is an internal function that inserts a new dock
 // layer by incrementing all existing dock layer values by one

-static void DoInsertDockLayer(wxPaneInfoArray& panes,
+static void DoInsertDockLayer(wxAuiPaneInfoArray& panes,

                               int dock_direction,
                               int dock_layer)
 {
     int i, pane_count;
     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
     {
                               int dock_direction,
                               int dock_layer)
 {
     int i, pane_count;
     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
     {

-        wxPaneInfo& pane = panes.Item(i);
+        wxAuiPaneInfo& pane = panes.Item(i);

         if (!pane.IsFloating() &&
             pane.dock_direction == dock_direction &&
             pane.dock_layer >= dock_layer)
         if (!pane.IsFloating() &&
             pane.dock_direction == dock_direction &&
             pane.dock_layer >= dock_layer)


@@ -297,7 +299,7 @@ static void DoInsertDockLayer(wxPaneInfoArray& panes,
 
 // DoInsertDockLayer() is an internal function that inserts a new dock
 // row by incrementing all existing dock row values by one
 
 // DoInsertDockLayer() is an internal function that inserts a new dock
 // row by incrementing all existing dock row values by one

-static void DoInsertDockRow(wxPaneInfoArray& panes,
+static void DoInsertDockRow(wxAuiPaneInfoArray& panes,

                             int dock_direction,
                             int dock_layer,
                             int dock_row)
                             int dock_direction,
                             int dock_layer,
                             int dock_row)


@@ -305,7 +307,7 @@ static void DoInsertDockRow(wxPaneInfoArray& panes,
     int i, pane_count;
     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
     {
     int i, pane_count;
     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
     {

-        wxPaneInfo& pane = panes.Item(i);
+        wxAuiPaneInfo& pane = panes.Item(i);

         if (!pane.IsFloating() &&
             pane.dock_direction == dock_direction &&
             pane.dock_layer == dock_layer &&
         if (!pane.IsFloating() &&
             pane.dock_direction == dock_direction &&
             pane.dock_layer == dock_layer &&


@@ -316,7 +318,7 @@ static void DoInsertDockRow(wxPaneInfoArray& panes,
 
 // DoInsertDockLayer() is an internal function that inserts a space for
 // another dock pane by incrementing all existing dock row values by one
 
 // DoInsertDockLayer() is an internal function that inserts a space for
 // another dock pane by incrementing all existing dock row values by one

-static void DoInsertPane(wxPaneInfoArray& panes,
+static void DoInsertPane(wxAuiPaneInfoArray& panes,

                          int dock_direction,
                          int dock_layer,
                          int dock_row,
                          int dock_direction,
                          int dock_layer,
                          int dock_row,


@@ -325,7 +327,7 @@ static void DoInsertPane(wxPaneInfoArray& panes,
     int i, pane_count;
     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
     {
     int i, pane_count;
     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
     {

-        wxPaneInfo& pane = panes.Item(i);
+        wxAuiPaneInfo& pane = panes.Item(i);

         if (!pane.IsFloating() &&
             pane.dock_direction == dock_direction &&
             pane.dock_layer == dock_layer &&
         if (!pane.IsFloating() &&
             pane.dock_direction == dock_direction &&
             pane.dock_layer == dock_layer &&


@@ -338,11 +340,11 @@ static void DoInsertPane(wxPaneInfoArray& panes,
 // FindDocks() is an internal function that returns a list of docks which meet
 // the specified conditions in the parameters and returns a sorted array
 // (sorted by layer and then row)
 // FindDocks() is an internal function that returns a list of docks which meet
 // the specified conditions in the parameters and returns a sorted array
 // (sorted by layer and then row)

-static void FindDocks(wxDockInfoArray& docks,
+static void FindDocks(wxAuiDockInfoArray& docks,

                       int dock_direction,
                       int dock_layer,
                       int dock_row,
                       int dock_direction,
                       int dock_layer,
                       int dock_row,

-                      wxDockInfoPtrArray& arr)
+                      wxAuiDockInfoPtrArray& arr)

 {
     int begin_layer = dock_layer;
     int end_layer = dock_layer;
 {
     int begin_layer = dock_layer;
     int end_layer = dock_layer;


@@ -378,7 +380,7 @@ static void FindDocks(wxDockInfoArray& docks,
         for (row = begin_row; row <= end_row; ++row)
             for (i = 0; i < dock_count; ++i)
             {
         for (row = begin_row; row <= end_row; ++row)
             for (i = 0; i < dock_count; ++i)
             {

-                wxDockInfo& d = docks.Item(i);
+                wxAuiDockInfo& d = docks.Item(i);

                 if (dock_direction == -1 || dock_direction == d.dock_direction)
                 {
                     if (d.dock_layer == layer && d.dock_row == row)
                 if (dock_direction == -1 || dock_direction == d.dock_direction)
                 {
                     if (d.dock_layer == layer && d.dock_row == row)


@@ -388,13 +390,13 @@ static void FindDocks(wxDockInfoArray& docks,
 }
 
 // FindPaneInDock() looks up a specified window pointer inside a dock.
 }
 
 // FindPaneInDock() looks up a specified window pointer inside a dock.

-// If found, the corresponding wxPaneInfo pointer is returned, otherwise NULL.
-static wxPaneInfo* FindPaneInDock(const wxDockInfo& dock, wxWindow* window)
+// If found, the corresponding wxAuiPaneInfo pointer is returned, otherwise NULL.
+static wxAuiPaneInfo* FindPaneInDock(const wxAuiDockInfo& dock, wxWindow* window)

 {
     int i, count = dock.panes.GetCount();
     for (i = 0; i < count; ++i)
     {
 {
     int i, count = dock.panes.GetCount();
     for (i = 0; i < count; ++i)
     {

-        wxPaneInfo* p = dock.panes.Item(i);
+        wxAuiPaneInfo* p = dock.panes.Item(i);

         if (p->window == window)
             return p;
     }
         if (p->window == window)
             return p;
     }


@@ -403,17 +405,17 @@ static wxPaneInfo* FindPaneInDock(const wxDockInfo& dock, wxWindow* window)
 
 // RemovePaneFromDocks() removes a pane window from all docks
 // with a possible exception specified by parameter "ex_cept"
 
 // RemovePaneFromDocks() removes a pane window from all docks
 // with a possible exception specified by parameter "ex_cept"

-static void RemovePaneFromDocks(wxDockInfoArray& docks,
-                                wxPaneInfo& pane,
-                                wxDockInfo* ex_cept  = NULL  )
+static void RemovePaneFromDocks(wxAuiDockInfoArray& docks,
+                                wxAuiPaneInfo& pane,
+                                wxAuiDockInfo* ex_cept  = NULL  )

 {
     int i, dock_count;
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {
 {
     int i, dock_count;
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {

-        wxDockInfo& d = docks.Item(i);
+        wxAuiDockInfo& d = docks.Item(i);

         if (&d == ex_cept)
             continue;
         if (&d == ex_cept)
             continue;

-        wxPaneInfo* pi = FindPaneInDock(d, pane.window);
+        wxAuiPaneInfo* pi = FindPaneInDock(d, pane.window);

         if (pi)
             d.panes.Remove(pi);
     }
         if (pi)
             d.panes.Remove(pi);
     }


@@ -422,12 +424,12 @@ static void RemovePaneFromDocks(wxDockInfoArray& docks,
 // RenumberDockRows() takes a dock and assigns sequential numbers
 // to existing rows.  Basically it takes out the gaps; so if a
 // dock has rows with numbers 0,2,5, they will become 0,1,2
 // RenumberDockRows() takes a dock and assigns sequential numbers
 // to existing rows.  Basically it takes out the gaps; so if a
 // dock has rows with numbers 0,2,5, they will become 0,1,2

-static void RenumberDockRows(wxDockInfoPtrArray& docks)
+static void RenumberDockRows(wxAuiDockInfoPtrArray& docks)

 {
     int i, dock_count, j, pane_count;
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {
 {
     int i, dock_count, j, pane_count;
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {

-        wxDockInfo& dock = *docks.Item(i);
+        wxAuiDockInfo& dock = *docks.Item(i);

         dock.dock_row = i;
         for (j = 0, pane_count = dock.panes.GetCount(); j < pane_count; ++j)
             dock.panes.Item(j)->dock_row = i;
         dock.dock_row = i;
         for (j = 0, pane_count = dock.panes.GetCount(); j < pane_count; ++j)
             dock.panes.Item(j)->dock_row = i;


@@ -438,109 +440,111 @@ static void RenumberDockRows(wxDockInfoPtrArray& docks)
 // SetActivePane() sets the active pane, as well as cycles through
 // every other pane and makes sure that all others' active flags
 // are turned off
 // SetActivePane() sets the active pane, as well as cycles through
 // every other pane and makes sure that all others' active flags
 // are turned off

-static void SetActivePane(wxPaneInfoArray& panes, wxWindow* active_pane)
+static void SetActivePane(wxAuiPaneInfoArray& panes, wxWindow* active_pane)

 {
     int i, pane_count;
     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
     {
 {
     int i, pane_count;
     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
     {

-        wxPaneInfo& pane = panes.Item(i);
-        pane.state &= ~wxPaneInfo::optionActive;
+        wxAuiPaneInfo& pane = panes.Item(i);
+        pane.state &= ~wxAuiPaneInfo::optionActive;

         if (pane.window == active_pane)
         if (pane.window == active_pane)

-            pane.state |= wxPaneInfo::optionActive;
+            pane.state |= wxAuiPaneInfo::optionActive;

     }
 }
 
 
 // this function is used to sort panes by dock position
     }
 }
 
 
 // this function is used to sort panes by dock position

-static int PaneSortFunc(wxPaneInfo** p1, wxPaneInfo** p2)
+static int PaneSortFunc(wxAuiPaneInfo** p1, wxAuiPaneInfo** p2)

 {
     return ((*p1)->dock_pos < (*p2)->dock_pos) ? -1 : 1;
 }
 
 
 {
     return ((*p1)->dock_pos < (*p2)->dock_pos) ? -1 : 1;
 }
 
 

-// -- wxFrameManager class implementation --
+// -- wxAuiManager class implementation --

 
 
 
 

-BEGIN_EVENT_TABLE(wxFrameManager, wxEvtHandler)
-    EVT_AUI_PANEBUTTON(wxFrameManager::OnPaneButton)
-    EVT_AUI_RENDER(wxFrameManager::OnRender)
-    EVT_PAINT(wxFrameManager::OnPaint)
-    EVT_ERASE_BACKGROUND(wxFrameManager::OnEraseBackground)
-    EVT_SIZE(wxFrameManager::OnSize)
-    EVT_SET_CURSOR(wxFrameManager::OnSetCursor)
-    EVT_LEFT_DOWN(wxFrameManager::OnLeftDown)
-    EVT_LEFT_UP(wxFrameManager::OnLeftUp)
-    EVT_MOTION(wxFrameManager::OnMotion)
-    EVT_LEAVE_WINDOW(wxFrameManager::OnLeaveWindow)
-    EVT_CHILD_FOCUS(wxFrameManager::OnChildFocus)
-    EVT_TIMER(101, wxFrameManager::OnHintFadeTimer)
+BEGIN_EVENT_TABLE(wxAuiManager, wxEvtHandler)
+    EVT_AUI_PANEBUTTON(wxAuiManager::OnPaneButton)
+    EVT_AUI_RENDER(wxAuiManager::OnRender)
+    EVT_PAINT(wxAuiManager::OnPaint)
+    EVT_ERASE_BACKGROUND(wxAuiManager::OnEraseBackground)
+    EVT_SIZE(wxAuiManager::OnSize)
+    EVT_SET_CURSOR(wxAuiManager::OnSetCursor)
+    EVT_LEFT_DOWN(wxAuiManager::OnLeftDown)
+    EVT_LEFT_UP(wxAuiManager::OnLeftUp)
+    EVT_MOTION(wxAuiManager::OnMotion)
+    EVT_LEAVE_WINDOW(wxAuiManager::OnLeaveWindow)
+    EVT_CHILD_FOCUS(wxAuiManager::OnChildFocus)
+    EVT_TIMER(101, wxAuiManager::OnHintFadeTimer)

 END_EVENT_TABLE()
 
 
 END_EVENT_TABLE()
 
 

-wxFrameManager::wxFrameManager(wxWindow* managed_wnd, unsigned int flags)
+wxAuiManager::wxAuiManager(wxWindow* managed_wnd, unsigned int flags)

 {
     m_action = actionNone;
     m_last_mouse_move = wxPoint();
     m_hover_button = NULL;
 {
     m_action = actionNone;
     m_last_mouse_move = wxPoint();
     m_hover_button = NULL;

-    m_art = new wxDefaultDockArt;
+    m_art = new wxAuiDefaultDockArt;

     m_hint_wnd = NULL;
     m_flags = flags;
     m_skipping = false;
     m_hint_wnd = NULL;
     m_flags = flags;
     m_skipping = false;

-
+    m_has_maximized = false;
+    m_frame = NULL;
+    

     if (managed_wnd)
     {
         SetManagedWindow(managed_wnd);
     }
 }
 
     if (managed_wnd)
     {
         SetManagedWindow(managed_wnd);
     }
 }
 

-wxFrameManager::~wxFrameManager()
+wxAuiManager::~wxAuiManager()

 {
     delete m_art;
 }
 
 // Creates a floating frame for the windows
 {
     delete m_art;
 }
 
 // Creates a floating frame for the windows

-wxFloatingPane * wxFrameManager::CreateFloatingFrame(wxWindow* parent, const wxPaneInfo& p)
+wxAuiFloatingFrame * wxAuiManager::CreateFloatingFrame(wxWindow* parent, const wxAuiPaneInfo& p)

 {
 {

-    return new wxFloatingPane(parent, this, p);
+    return new wxAuiFloatingFrame(parent, this, p);

 }
 
 }
 

-// GetPane() looks up a wxPaneInfo structure based
+// GetPane() looks up a wxAuiPaneInfo structure based

 // on the supplied window pointer.  Upon failure, GetPane()
 // on the supplied window pointer.  Upon failure, GetPane()

-// returns an empty wxPaneInfo, a condition which can be checked
-// by calling wxPaneInfo::IsOk().
+// returns an empty wxAuiPaneInfo, a condition which can be checked
+// by calling wxAuiPaneInfo::IsOk().

 //
 // The pane info's structure may then be modified.  Once a pane's
 //
 // The pane info's structure may then be modified.  Once a pane's

-// info is modified, wxFrameManager::Update() must be called to
+// info is modified, wxAuiManager::Update() must be called to

 // realize the changes in the UI.
 
 // realize the changes in the UI.
 

-wxPaneInfo& wxFrameManager::GetPane(wxWindow* window)
+wxAuiPaneInfo& wxAuiManager::GetPane(wxWindow* window)

 {
     int i, pane_count;
     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
     {
 {
     int i, pane_count;
     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
     {

-        wxPaneInfo& p = m_panes.Item(i);
+        wxAuiPaneInfo& p = m_panes.Item(i);

         if (p.window == window)
             return p;
     }
         if (p.window == window)
             return p;
     }

-    return wxNullPaneInfo;
+    return wxAuiNullPaneInfo;

 }
 
 // this version of GetPane() looks up a pane based on a
 // 'pane name', see above comment for more info
 }
 
 // this version of GetPane() looks up a pane based on a
 // 'pane name', see above comment for more info

-wxPaneInfo& wxFrameManager::GetPane(const wxString& name)
+wxAuiPaneInfo& wxAuiManager::GetPane(const wxString& name)

 {
     int i, pane_count;
     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
     {
 {
     int i, pane_count;
     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
     {

-        wxPaneInfo& p = m_panes.Item(i);
+        wxAuiPaneInfo& p = m_panes.Item(i);

         if (p.name == name)
             return p;
     }
         if (p.name == name)
             return p;
     }

-    return wxNullPaneInfo;
+    return wxAuiNullPaneInfo;

 }
 
 // GetAllPanes() returns a reference to all the pane info structures
 }
 
 // GetAllPanes() returns a reference to all the pane info structures

-wxPaneInfoArray& wxFrameManager::GetAllPanes()
+wxAuiPaneInfoArray& wxAuiManager::GetAllPanes()

 {
     return m_panes;
 }
 {
     return m_panes;
 }


@@ -548,27 +552,27 @@ wxPaneInfoArray& wxFrameManager::GetAllPanes()
 // HitTest() is an internal function which determines
 // which UI item the specified coordinates are over
 // (x,y) specify a position in client coordinates
 // HitTest() is an internal function which determines
 // which UI item the specified coordinates are over
 // (x,y) specify a position in client coordinates

-wxDockUIPart* wxFrameManager::HitTest(int x, int y)
+wxAuiDockUIPart* wxAuiManager::HitTest(int x, int y)

 {
 {

-    wxDockUIPart* result = NULL;
+    wxAuiDockUIPart* result = NULL;

 
     int i, part_count;
     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
     {
 
     int i, part_count;
     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
     {

-        wxDockUIPart* item = &m_uiparts.Item(i);
+        wxAuiDockUIPart* item = &m_uiparts.Item(i);

 
         // we are not interested in typeDock, because this space
         // isn't used to draw anything, just for measurements;
         // besides, the entire dock area is covered with other
         // rectangles, which we are interested in.
 
         // we are not interested in typeDock, because this space
         // isn't used to draw anything, just for measurements;
         // besides, the entire dock area is covered with other
         // rectangles, which we are interested in.

-        if (item->type == wxDockUIPart::typeDock)
+        if (item->type == wxAuiDockUIPart::typeDock)

             continue;
 
         // if we already have a hit on a more specific item, we are not
         // interested in a pane hit.  If, however, we don't already have
         // a hit, returning a pane hit is necessary for some operations
             continue;
 
         // if we already have a hit on a more specific item, we are not
         // interested in a pane hit.  If, however, we don't already have
         // a hit, returning a pane hit is necessary for some operations

-        if ((item->type == wxDockUIPart::typePane ||
-            item->type == wxDockUIPart::typePaneBorder) && result)
+        if ((item->type == wxAuiDockUIPart::typePane ||
+            item->type == wxAuiDockUIPart::typePaneBorder) && result)

             continue;
 
         // if the point is inside the rectangle, we have a hit
             continue;
 
         // if the point is inside the rectangle, we have a hit


@@ -581,8 +585,8 @@ wxDockUIPart* wxFrameManager::HitTest(int x, int y)
 
 
 // SetFlags() and GetFlags() allow the owner to set various
 
 
 // SetFlags() and GetFlags() allow the owner to set various

-// options which are global to wxFrameManager
-void wxFrameManager::SetFlags(unsigned int flags)
+// options which are global to wxAuiManager
+void wxAuiManager::SetFlags(unsigned int flags)

 {
     // find out if we have to call UpdateHintWindowConfig()
     bool update_hint_wnd = false;
 {
     // find out if we have to call UpdateHintWindowConfig()
     bool update_hint_wnd = false;


@@ -602,7 +606,7 @@ void wxFrameManager::SetFlags(unsigned int flags)
     }
 }
 
     }
 }
 

-unsigned int wxFrameManager::GetFlags() const
+unsigned int wxAuiManager::GetFlags() const

 {
     return m_flags;
 }
 {
     return m_flags;
 }


@@ -610,18 +614,18 @@ unsigned int wxFrameManager::GetFlags() const
 
 // don't use these anymore as they are deprecated
 // use Set/GetManagedFrame() instead
 
 // don't use these anymore as they are deprecated
 // use Set/GetManagedFrame() instead

-void wxFrameManager::SetFrame(wxFrame* frame)
+void wxAuiManager::SetFrame(wxFrame* frame)

 {
     SetManagedWindow((wxWindow*)frame);
 }
 
 {
     SetManagedWindow((wxWindow*)frame);
 }
 

-wxFrame* wxFrameManager::GetFrame() const
+wxFrame* wxAuiManager::GetFrame() const

 {
     return (wxFrame*)m_frame;
 }
 
 
 {
     return (wxFrame*)m_frame;
 }
 
 

-void wxFrameManager::UpdateHintWindowConfig()
+void wxAuiManager::UpdateHintWindowConfig()

 {
     // find out if the the system can do transparent frames
     bool can_do_transparent = false;
 {
     // find out if the the system can do transparent frames
     bool can_do_transparent = false;


@@ -707,7 +711,7 @@ void wxFrameManager::UpdateHintWindowConfig()
 // SetManagedWindow() is usually called once when the frame
 // manager class is being initialized.  "frame" specifies
 // the frame which should be managed by the frame mananger
 // SetManagedWindow() is usually called once when the frame
 // manager class is being initialized.  "frame" specifies
 // the frame which should be managed by the frame mananger

-void wxFrameManager::SetManagedWindow(wxWindow* wnd)
+void wxAuiManager::SetManagedWindow(wxWindow* wnd)

 {
     wxASSERT_MSG(wnd, wxT("specified window must be non-NULL"));
 
 {
     wxASSERT_MSG(wnd, wxT("specified window must be non-NULL"));
 


@@ -727,7 +731,7 @@ void wxFrameManager::SetManagedWindow(wxWindow* wnd)
         wxASSERT_MSG(client_window, wxT("Client window is NULL!"));
 
         AddPane(client_window,
         wxASSERT_MSG(client_window, wxT("Client window is NULL!"));
 
         AddPane(client_window,

-                wxPaneInfo().Name(wxT("mdiclient")).
+                wxAuiPaneInfo().Name(wxT("mdiclient")).

                 CenterPane().PaneBorder(false));
     }
 #endif
                 CenterPane().PaneBorder(false));
     }
 #endif


@@ -739,23 +743,26 @@ void wxFrameManager::SetManagedWindow(wxWindow* wnd)
 // UnInit() must be called, usually in the destructor
 // of the frame class.   If it is not called, usually this
 // will result in a crash upon program exit
 // UnInit() must be called, usually in the destructor
 // of the frame class.   If it is not called, usually this
 // will result in a crash upon program exit

-void wxFrameManager::UnInit()
+void wxAuiManager::UnInit()

 {
 {

-    m_frame->RemoveEventHandler(this);
+    if (m_frame)
+    {
+        m_frame->RemoveEventHandler(this);
+    }

 }
 
 // GetManagedWindow() returns the window pointer being managed
 }
 
 // GetManagedWindow() returns the window pointer being managed

-wxWindow* wxFrameManager::GetManagedWindow() const
+wxWindow* wxAuiManager::GetManagedWindow() const

 {
     return m_frame;
 }
 
 {
     return m_frame;
 }
 

-wxDockArt* wxFrameManager::GetArtProvider() const
+wxAuiDockArt* wxAuiManager::GetArtProvider() const

 {
     return m_art;
 }
 
 {
     return m_art;
 }
 

-void wxFrameManager::ProcessMgrEvent(wxFrameManagerEvent& event)
+void wxAuiManager::ProcessMgrEvent(wxAuiManagerEvent& event)

 {
     // first, give the owner frame a chance to override
     if (m_frame)
 {
     // first, give the owner frame a chance to override
     if (m_frame)


@@ -767,12 +774,12 @@ void wxFrameManager::ProcessMgrEvent(wxFrameManagerEvent& event)
     ProcessEvent(event);
 }
 
     ProcessEvent(event);
 }
 

-// SetArtProvider() instructs wxFrameManager to use the
+// SetArtProvider() instructs wxAuiManager to use the

 // specified art provider for all drawing calls.  This allows
 // plugable look-and-feel features.  The pointer that is
 // specified art provider for all drawing calls.  This allows
 // plugable look-and-feel features.  The pointer that is

-// passed to this method subsequently belongs to wxFrameManager,
+// passed to this method subsequently belongs to wxAuiManager,

 // and is deleted in the frame manager destructor
 // and is deleted in the frame manager destructor

-void wxFrameManager::SetArtProvider(wxDockArt* art_provider)
+void wxAuiManager::SetArtProvider(wxAuiDockArt* art_provider)

 {
     // delete the last art provider, if any
     delete m_art;
 {
     // delete the last art provider, if any
     delete m_art;


@@ -782,7 +789,7 @@ void wxFrameManager::SetArtProvider(wxDockArt* art_provider)
 }
 
 
 }
 
 

-bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info)
+bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)

 {
     // check if the pane has a valid window
     if (!window)
 {
     // check if the pane has a valid window
     if (!window)


@@ -792,9 +799,13 @@ bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info)
     if (GetPane(pane_info.window).IsOk())
         return false;
 
     if (GetPane(pane_info.window).IsOk())
         return false;
 

+    // if the new pane is docked then we should undo maximize
+    if(pane_info.IsDocked())
+        RestoreMaximizedPane();
+

     m_panes.Add(pane_info);
 
     m_panes.Add(pane_info);
 

-    wxPaneInfo& pinfo = m_panes.Last();
+    wxAuiPaneInfo& pinfo = m_panes.Last();

 
     // set the pane window
     pinfo.window = window;
 
     // set the pane window
     pinfo.window = window;


@@ -817,10 +828,16 @@ bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info)
     if (pinfo.dock_proportion == 0)
         pinfo.dock_proportion = 100000;
 
     if (pinfo.dock_proportion == 0)
         pinfo.dock_proportion = 100000;
 

-    if (pinfo.HasCloseButton() &&
-        pinfo.buttons.size() == 0)
+    if (pinfo.HasMaximizeButton())

     {
     {

-        wxPaneButton button;
+        wxAuiPaneButton button;
+        button.button_id = wxAUI_BUTTON_MAXIMIZE_RESTORE;
+        pinfo.buttons.Add(button);
+    }
+
+    if (pinfo.HasCloseButton())
+    {
+        wxAuiPaneButton button;

         button.button_id = wxAUI_BUTTON_CLOSE;
         pinfo.buttons.Add(button);
     }
         button.button_id = wxAUI_BUTTON_CLOSE;
         pinfo.buttons.Add(button);
     }


@@ -857,11 +874,11 @@ bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info)
     return true;
 }
 
     return true;
 }
 

-bool wxFrameManager::AddPane(wxWindow* window,
+bool wxAuiManager::AddPane(wxWindow* window,

                              int direction,
                              const wxString& caption)
 {
                              int direction,
                              const wxString& caption)
 {

-    wxPaneInfo pinfo;
+    wxAuiPaneInfo pinfo;

     pinfo.Caption(caption);
     switch (direction)
     {
     pinfo.Caption(caption);
     switch (direction)
     {


@@ -874,21 +891,21 @@ bool wxFrameManager::AddPane(wxWindow* window,
     return AddPane(window, pinfo);
 }
 
     return AddPane(window, pinfo);
 }
 

-bool wxFrameManager::AddPane(wxWindow* window,
-                             const wxPaneInfo& pane_info,
+bool wxAuiManager::AddPane(wxWindow* window,
+                             const wxAuiPaneInfo& pane_info,

                              const wxPoint& drop_pos)
 {
     if (!AddPane(window, pane_info))
         return false;
 
                              const wxPoint& drop_pos)
 {
     if (!AddPane(window, pane_info))
         return false;
 

-    wxPaneInfo& pane = GetPane(window);
+    wxAuiPaneInfo& pane = GetPane(window);

 
     DoDrop(m_docks, m_panes, pane, drop_pos, wxPoint(0,0));
 
     return true;
 }
 
 
     DoDrop(m_docks, m_panes, pane, drop_pos, wxPoint(0,0));
 
     return true;
 }
 

-bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info,
+bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info,

                                 int insert_level)
 {
     // shift the panes around, depending on the insert level
                                 int insert_level)
 {
     // shift the panes around, depending on the insert level


@@ -916,7 +933,7 @@ bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info,
 
     // if the window already exists, we are basically just moving/inserting the
     // existing window.  If it doesn't exist, we need to add it and insert it
 
     // if the window already exists, we are basically just moving/inserting the
     // existing window.  If it doesn't exist, we need to add it and insert it

-    wxPaneInfo& existing_pane = GetPane(window);
+    wxAuiPaneInfo& existing_pane = GetPane(window);

     if (!existing_pane.IsOk())
     {
         return AddPane(window, pane_info);
     if (!existing_pane.IsOk())
     {
         return AddPane(window, pane_info);


@@ -933,6 +950,9 @@ bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info,
         }
          else
         {
         }
          else
         {

+            // if the new pane is docked then we should undo maximize
+            RestoreMaximizedPane();
+

             existing_pane.Direction(pane_info.dock_direction);
             existing_pane.Layer(pane_info.dock_layer);
             existing_pane.Row(pane_info.dock_row);
             existing_pane.Direction(pane_info.dock_direction);
             existing_pane.Layer(pane_info.dock_layer);
             existing_pane.Row(pane_info.dock_row);


@@ -946,12 +966,12 @@ bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info,
 
 // DetachPane() removes a pane from the frame manager.  This
 // method will not destroy the window that is removed.
 
 // DetachPane() removes a pane from the frame manager.  This
 // method will not destroy the window that is removed.

-bool wxFrameManager::DetachPane(wxWindow* window)
+bool wxAuiManager::DetachPane(wxWindow* window)

 {
     int i, count;
     for (i = 0, count = m_panes.GetCount(); i < count; ++i)
     {
 {
     int i, count;
     for (i = 0, count = m_panes.GetCount(); i < count; ++i)
     {

-        wxPaneInfo& p = m_panes.Item(i);
+        wxAuiPaneInfo& p = m_panes.Item(i);

         if (p.window == window)
         {
             if (p.frame)
         if (p.window == window)
         {
             if (p.frame)


@@ -966,6 +986,9 @@ bool wxFrameManager::DetachPane(wxWindow* window)
                     p.frame->Show(false);
 
                 // reparent to m_frame and destroy the pane
                     p.frame->Show(false);
 
                 // reparent to m_frame and destroy the pane

+                if(m_action_window == p.frame) {
+                    m_action_window = NULL;
+                }

                 p.window->Reparent(m_frame);
                 p.frame->SetSizer(NULL);
                 p.frame->Destroy();
                 p.window->Reparent(m_frame);
                 p.frame->SetSizer(NULL);
                 p.frame->Destroy();


@@ -979,7 +1002,7 @@ bool wxFrameManager::DetachPane(wxWindow* window)
             int pi, part_count;
             for (pi = 0, part_count = (int)m_uiparts.GetCount(); pi < part_count; ++pi)
             {
             int pi, part_count;
             for (pi = 0, part_count = (int)m_uiparts.GetCount(); pi < part_count; ++pi)
             {

-                wxDockUIPart& part = m_uiparts.Item(pi);
+                wxAuiDockUIPart& part = m_uiparts.Item(pi);

                 if (part.pane == &p)
                 {
                     m_uiparts.RemoveAt(pi);
                 if (part.pane == &p)
                 {
                     m_uiparts.RemoveAt(pi);


@@ -998,8 +1021,13 @@ bool wxFrameManager::DetachPane(wxWindow* window)
 
 // ClosePane() destroys or hides the pane depending on its
 // flags
 
 // ClosePane() destroys or hides the pane depending on its
 // flags

-void wxFrameManager::ClosePane(wxPaneInfo& pane_info)
+void wxAuiManager::ClosePane(wxAuiPaneInfo& pane_info)

 {
 {

+    // if we were maximized, restore
+    if(pane_info.IsMaximized()) {
+        RestorePane(pane_info);
+    }
+

     // first, hide the window
     if (pane_info.window && pane_info.window->IsShown()) {
         pane_info.window->Show(false);
     // first, hide the window
     if (pane_info.window && pane_info.window->IsShown()) {
         pane_info.window->Show(false);


@@ -1031,6 +1059,70 @@ void wxFrameManager::ClosePane(wxPaneInfo& pane_info)
     }
 }
 
     }
 }
 

+void wxAuiManager::MaximizePane(wxAuiPaneInfo& pane_info)
+{
+    int i, pane_count;
+
+    // un-maximize and hide all other panes
+    for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
+    {
+        wxAuiPaneInfo& p = m_panes.Item(i);
+        if(!p.IsToolbar()) {
+            p.Restore();
+            p.SaveHidden();
+            p.Hide();
+        }
+    }
+
+    // mark ourselves maximized
+    pane_info.Maximize();
+    pane_info.Show();
+    m_has_maximized = true;
+
+    // last, show the window
+    if (pane_info.window && !pane_info.window->IsShown()) {
+        pane_info.window->Show(true);
+    }
+}
+
+void wxAuiManager::RestorePane(wxAuiPaneInfo& pane_info)
+{
+    int i, pane_count;
+
+    // restore all the panes
+    for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
+    {
+        wxAuiPaneInfo& p = m_panes.Item(i);
+        if(!p.IsToolbar()) {
+            p.RestoreHidden();
+        }
+    }
+
+    // mark ourselves non-maximized
+    pane_info.Restore();
+    m_has_maximized = false;
+
+    // last, show the window
+    if (pane_info.window && !pane_info.window->IsShown()) {
+        pane_info.window->Show(true);
+    }
+}
+
+void wxAuiManager::RestoreMaximizedPane()
+{
+    int i, pane_count;
+
+    // restore all the panes
+    for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
+    {
+        wxAuiPaneInfo& p = m_panes.Item(i);
+        if(p.IsMaximized()) {
+            RestorePane(p);
+            break;
+        }
+    }
+}
+

 // EscapeDelimiters() changes ";" into "\;" and "|" into "\|"
 // in the input string.  This is an internal functions which is
 // used for saving perspectives
 // EscapeDelimiters() changes ";" into "\;" and "|" into "\|"
 // in the input string.  This is an internal functions which is
 // used for saving perspectives


@@ -1049,7 +1141,7 @@ static wxString EscapeDelimiters(const wxString& s)
     return result;
 }
 
     return result;
 }
 

-wxString wxFrameManager::SavePaneInfo(wxPaneInfo& pane)
+wxString wxAuiManager::SavePaneInfo(wxAuiPaneInfo& pane)

 {
     wxString result = wxT("name=");
     result += EscapeDelimiters(pane.name);
 {
     wxString result = wxT("name=");
     result += EscapeDelimiters(pane.name);


@@ -1080,7 +1172,7 @@ wxString wxFrameManager::SavePaneInfo(wxPaneInfo& pane)
 }
 
 // Load a "pane" with the pane infor settings in pane_part
 }
 
 // Load a "pane" with the pane infor settings in pane_part

-void wxFrameManager::LoadPaneInfo(wxString pane_part, wxPaneInfo &pane)
+void wxAuiManager::LoadPaneInfo(wxString pane_part, wxAuiPaneInfo &pane)

 {
     // replace escaped characters so we can
     // split up the string easily
 {
     // replace escaped characters so we can
     // split up the string easily


@@ -1161,7 +1253,7 @@ void wxFrameManager::LoadPaneInfo(wxString pane_part, wxPaneInfo &pane)
 // all pane settings.  This save and load mechanism allows an
 // exact pane configuration to be saved and restored at a later time
 
 // all pane settings.  This save and load mechanism allows an
 // exact pane configuration to be saved and restored at a later time
 

-wxString wxFrameManager::SavePerspective()
+wxString wxAuiManager::SavePerspective()

 {
     wxString result;
     result.Alloc(500);
 {
     wxString result;
     result.Alloc(500);


@@ -1170,14 +1262,14 @@ wxString wxFrameManager::SavePerspective()
     int pane_i, pane_count = m_panes.GetCount();
     for (pane_i = 0; pane_i < pane_count; ++pane_i)
     {
     int pane_i, pane_count = m_panes.GetCount();
     for (pane_i = 0; pane_i < pane_count; ++pane_i)
     {

-        wxPaneInfo& pane = m_panes.Item(pane_i);
+        wxAuiPaneInfo& pane = m_panes.Item(pane_i);

         result += SavePaneInfo(pane)+wxT("|");
     }
 
     int dock_i, dock_count = m_docks.GetCount();
     for (dock_i = 0; dock_i < dock_count; ++dock_i)
     {
         result += SavePaneInfo(pane)+wxT("|");
     }
 
     int dock_i, dock_count = m_docks.GetCount();
     for (dock_i = 0; dock_i < dock_count; ++dock_i)
     {

-        wxDockInfo& dock = m_docks.Item(dock_i);
+        wxAuiDockInfo& dock = m_docks.Item(dock_i);

 
         result += wxString::Format(wxT("dock_size(%d,%d,%d)=%d|"),
                                    dock.dock_direction, dock.dock_layer,
 
         result += wxString::Format(wxT("dock_size(%d,%d,%d)=%d|"),
                                    dock.dock_direction, dock.dock_layer,


@@ -1190,7 +1282,7 @@ wxString wxFrameManager::SavePerspective()
 // LoadPerspective() loads a layout which was saved with SavePerspective()
 // If the "update" flag parameter is true, the GUI will immediately be updated
 
 // LoadPerspective() loads a layout which was saved with SavePerspective()
 // If the "update" flag parameter is true, the GUI will immediately be updated
 

-bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
+bool wxAuiManager::LoadPerspective(const wxString& layout, bool update)

 {
     wxString input = layout;
     wxString part;
 {
     wxString input = layout;
     wxString part;


@@ -1218,7 +1310,7 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
 
     while (1)
     {
 
     while (1)
     {

-        wxPaneInfo pane;
+        wxAuiPaneInfo pane;

 
         wxString pane_part = input.BeforeFirst(wxT('|'));
         input = input.AfterFirst(wxT('|'));
 
         wxString pane_part = input.BeforeFirst(wxT('|'));
         input = input.AfterFirst(wxT('|'));


@@ -1242,7 +1334,7 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
             piece.AfterFirst(wxT(',')).ToLong(&row);
             value.ToLong(&size);
 
             piece.AfterFirst(wxT(',')).ToLong(&row);
             value.ToLong(&size);
 

-            wxDockInfo dock;
+            wxAuiDockInfo dock;

             dock.dock_direction = dir;
             dock.dock_layer = layer;
             dock.dock_row = row;
             dock.dock_direction = dir;
             dock.dock_layer = layer;
             dock.dock_row = row;


@@ -1258,7 +1350,7 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
 
         LoadPaneInfo(pane_part, pane);
 
 
         LoadPaneInfo(pane_part, pane);
 

-        wxPaneInfo& p = GetPane(pane.name);
+        wxAuiPaneInfo& p = GetPane(pane.name);

         if (!p.IsOk())
         {
             // the pane window couldn't be found
         if (!p.IsOk())
         {
             // the pane window couldn't be found


@@ -1276,7 +1368,7 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
     return true;
 }
 
     return true;
 }
 

-void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock,
+void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,

                                               wxArrayInt& positions,
                                               wxArrayInt& sizes)
 {
                                               wxArrayInt& positions,
                                               wxArrayInt& sizes)
 {


@@ -1293,9 +1385,9 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock,
     // find the pane marked as our action pane
     for (pane_i = 0; pane_i < pane_count; ++pane_i)
     {
     // find the pane marked as our action pane
     for (pane_i = 0; pane_i < pane_count; ++pane_i)
     {

-        wxPaneInfo& pane = *(dock.panes.Item(pane_i));
+        wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));

 
 

-        if (pane.state & wxPaneInfo::actionPane)
+        if (pane.state & wxAuiPaneInfo::actionPane)

         {
             wxASSERT_MSG(action_pane==-1, wxT("Too many fixed action panes"));
             action_pane = pane_i;
         {
             wxASSERT_MSG(action_pane==-1, wxT("Too many fixed action panes"));
             action_pane = pane_i;


@@ -1307,7 +1399,7 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock,
     // on the dock's orientation) of each pane
     for (pane_i = 0; pane_i < pane_count; ++pane_i)
     {
     // on the dock's orientation) of each pane
     for (pane_i = 0; pane_i < pane_count; ++pane_i)
     {

-        wxPaneInfo& pane = *(dock.panes.Item(pane_i));
+        wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));

         positions.Add(pane.dock_pos);
         int size = 0;
 
         positions.Add(pane.dock_pos);
         int size = 0;
 


@@ -1367,13 +1459,13 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock,
 }
 
 
 }
 
 

-void wxFrameManager::LayoutAddPane(wxSizer* cont,
-                                   wxDockInfo& dock,
-                                   wxPaneInfo& pane,
-                                   wxDockUIPartArray& uiparts,
+void wxAuiManager::LayoutAddPane(wxSizer* cont,
+                                   wxAuiDockInfo& dock,
+                                   wxAuiPaneInfo& pane,
+                                   wxAuiDockUIPartArray& uiparts,

                                    bool spacer_only)
 {
                                    bool spacer_only)
 {

-    wxDockUIPart part;
+    wxAuiDockUIPart part;

     wxSizerItem* sizer_item;
 
     int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);
     wxSizerItem* sizer_item;
 
     int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);


@@ -1403,7 +1495,7 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont,
         else
             sizer_item = horz_pane_sizer ->Add(gripper_size, 1, 0, wxEXPAND);
 
         else
             sizer_item = horz_pane_sizer ->Add(gripper_size, 1, 0, wxEXPAND);
 

-        part.type = wxDockUIPart::typeGripper;
+        part.type = wxAuiDockUIPart::typeGripper;

         part.dock = &dock;
         part.pane = &pane;
         part.button = NULL;
         part.dock = &dock;
         part.pane = &pane;
         part.button = NULL;


@@ -1420,7 +1512,7 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont,
 
         sizer_item = caption_sizer->Add(1, caption_size, 1, wxEXPAND);
 
 
         sizer_item = caption_sizer->Add(1, caption_size, 1, wxEXPAND);
 

-        part.type = wxDockUIPart::typeCaption;
+        part.type = wxAuiDockUIPart::typeCaption;

         part.dock = &dock;
         part.pane = &pane;
         part.button = NULL;
         part.dock = &dock;
         part.pane = &pane;
         part.button = NULL;


@@ -1435,13 +1527,13 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont,
         for (i = 0, button_count = pane.buttons.GetCount();
              i < button_count; ++i)
         {
         for (i = 0, button_count = pane.buttons.GetCount();
              i < button_count; ++i)
         {

-            wxPaneButton& button = pane.buttons.Item(i);
+            wxAuiPaneButton& button = pane.buttons.Item(i);

 
             sizer_item = caption_sizer->Add(pane_button_size,
                                             caption_size,
                                             0, wxEXPAND);
 
 
             sizer_item = caption_sizer->Add(pane_button_size,
                                             caption_size,
                                             0, wxEXPAND);
 

-            part.type = wxDockUIPart::typePaneButton;
+            part.type = wxAuiDockUIPart::typePaneButton;

             part.dock = &dock;
             part.pane = &pane;
             part.button = &button;
             part.dock = &dock;
             part.pane = &pane;
             part.button = &button;


@@ -1471,7 +1563,7 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont,
         vert_pane_sizer->SetItemMinSize(pane.window, 1, 1);
     }
 
         vert_pane_sizer->SetItemMinSize(pane.window, 1, 1);
     }
 

-    part.type = wxDockUIPart::typePane;
+    part.type = wxAuiDockUIPart::typePane;

     part.dock = &dock;
     part.pane = &pane;
     part.button = NULL;
     part.dock = &dock;
     part.pane = &pane;
     part.button = NULL;


@@ -1515,7 +1607,7 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont,
         sizer_item = cont->Add(horz_pane_sizer, pane_proportion,
                                wxEXPAND | wxALL, pane_border_size);
 
         sizer_item = cont->Add(horz_pane_sizer, pane_proportion,
                                wxEXPAND | wxALL, pane_border_size);
 

-        part.type = wxDockUIPart::typePaneBorder;
+        part.type = wxAuiDockUIPart::typePaneBorder;

         part.dock = &dock;
         part.pane = &pane;
         part.button = NULL;
         part.dock = &dock;
         part.pane = &pane;
         part.button = NULL;


@@ -1530,24 +1622,24 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont,
     }
 }
 
     }
 }
 

-void wxFrameManager::LayoutAddDock(wxSizer* cont,
-                                   wxDockInfo& dock,
-                                   wxDockUIPartArray& uiparts,
+void wxAuiManager::LayoutAddDock(wxSizer* cont,
+                                   wxAuiDockInfo& dock,
+                                   wxAuiDockUIPartArray& uiparts,

                                    bool spacer_only)
 {
     wxSizerItem* sizer_item;
                                    bool spacer_only)
 {
     wxSizerItem* sizer_item;

-    wxDockUIPart part;
+    wxAuiDockUIPart part;

 
     int sash_size = m_art->GetMetric(wxAUI_ART_SASH_SIZE);
     int orientation = dock.IsHorizontal() ? wxHORIZONTAL : wxVERTICAL;
 
     // resizable bottom and right docks have a sash before them
 
     int sash_size = m_art->GetMetric(wxAUI_ART_SASH_SIZE);
     int orientation = dock.IsHorizontal() ? wxHORIZONTAL : wxVERTICAL;
 
     // resizable bottom and right docks have a sash before them

-    if (!dock.fixed && (dock.dock_direction == wxAUI_DOCK_BOTTOM ||
+    if (!m_has_maximized && !dock.fixed && (dock.dock_direction == wxAUI_DOCK_BOTTOM ||

                         dock.dock_direction == wxAUI_DOCK_RIGHT))
     {
         sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND);
 
                         dock.dock_direction == wxAUI_DOCK_RIGHT))
     {
         sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND);
 

-        part.type = wxDockUIPart::typeDockSizer;
+        part.type = wxAuiDockUIPart::typeDockSizer;

         part.orientation = orientation;
         part.dock = &dock;
         part.pane = NULL;
         part.orientation = orientation;
         part.dock = &dock;
         part.pane = NULL;


@@ -1561,6 +1653,7 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont,
     wxSizer* dock_sizer = new wxBoxSizer(orientation);
 
     // add each pane to the dock
     wxSizer* dock_sizer = new wxBoxSizer(orientation);
 
     // add each pane to the dock

+    bool has_maximized_pane = false;

     int pane_i, pane_count = dock.panes.GetCount();
 
     if (dock.fixed)
     int pane_i, pane_count = dock.panes.GetCount();
 
     if (dock.fixed)


@@ -1574,8 +1667,11 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont,
         int offset = 0;
         for (pane_i = 0; pane_i < pane_count; ++pane_i)
         {
         int offset = 0;
         for (pane_i = 0; pane_i < pane_count; ++pane_i)
         {

-            wxPaneInfo& pane = *(dock.panes.Item(pane_i));
+            wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));

             int pane_pos = pane_positions.Item(pane_i);
             int pane_pos = pane_positions.Item(pane_i);

+            if(pane.IsMaximized()) {
+                has_maximized_pane = true;
+            }

 
             int amount = pane_pos - offset;
             if (amount > 0)
 
             int amount = pane_pos - offset;
             if (amount > 0)


@@ -1585,7 +1681,7 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont,
                      else
                     sizer_item = dock_sizer->Add(amount, 1, 0, wxEXPAND);
 
                      else
                     sizer_item = dock_sizer->Add(amount, 1, 0, wxEXPAND);
 

-                part.type = wxDockUIPart::typeBackground;
+                part.type = wxAuiDockUIPart::typeBackground;

                 part.dock = &dock;
                 part.pane = NULL;
                 part.button = NULL;
                 part.dock = &dock;
                 part.pane = NULL;
                 part.button = NULL;


@@ -1605,7 +1701,7 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont,
         // at the end add a very small stretchable background area
         sizer_item = dock_sizer->Add(1,1, 1, wxEXPAND);
 
         // at the end add a very small stretchable background area
         sizer_item = dock_sizer->Add(1,1, 1, wxEXPAND);
 

-        part.type = wxDockUIPart::typeBackground;
+        part.type = wxAuiDockUIPart::typeBackground;

         part.dock = &dock;
         part.pane = NULL;
         part.button = NULL;
         part.dock = &dock;
         part.pane = NULL;
         part.button = NULL;


@@ -1618,15 +1714,18 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont,
     {
         for (pane_i = 0; pane_i < pane_count; ++pane_i)
         {
     {
         for (pane_i = 0; pane_i < pane_count; ++pane_i)
         {

-            wxPaneInfo& pane = *(dock.panes.Item(pane_i));
+            wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
+            if(pane.IsMaximized()) {
+                has_maximized_pane = true;
+            }

 
             // if this is not the first pane being added,
             // we need to add a pane sizer
 
             // if this is not the first pane being added,
             // we need to add a pane sizer

-            if (pane_i > 0)
+            if (!m_has_maximized && pane_i > 0)

             {
                 sizer_item = dock_sizer->Add(sash_size, sash_size, 0, wxEXPAND);
 
             {
                 sizer_item = dock_sizer->Add(sash_size, sash_size, 0, wxEXPAND);
 

-                part.type = wxDockUIPart::typePaneSizer;
+                part.type = wxAuiDockUIPart::typePaneSizer;

                 part.dock = &dock;
                 part.pane = dock.panes.Item(pane_i-1);
                 part.button = NULL;
                 part.dock = &dock;
                 part.pane = dock.panes.Item(pane_i-1);
                 part.button = NULL;


@@ -1640,12 +1739,12 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont,
         }
     }
 
         }
     }
 

-    if (dock.dock_direction == wxAUI_DOCK_CENTER)
+    if (dock.dock_direction == wxAUI_DOCK_CENTER || has_maximized_pane)

         sizer_item = cont->Add(dock_sizer, 1, wxEXPAND);
          else
         sizer_item = cont->Add(dock_sizer, 0, wxEXPAND);
 
         sizer_item = cont->Add(dock_sizer, 1, wxEXPAND);
          else
         sizer_item = cont->Add(dock_sizer, 0, wxEXPAND);
 

-    part.type = wxDockUIPart::typeDock;
+    part.type = wxAuiDockUIPart::typeDock;

     part.dock = &dock;
     part.pane = NULL;
     part.button = NULL;
     part.dock = &dock;
     part.pane = NULL;
     part.button = NULL;


@@ -1660,12 +1759,12 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont,
         cont->SetItemMinSize(dock_sizer, dock.size, 0);
 
     //  top and left docks have a sash after them
         cont->SetItemMinSize(dock_sizer, dock.size, 0);
 
     //  top and left docks have a sash after them

-    if (!dock.fixed && (dock.dock_direction == wxAUI_DOCK_TOP ||
+    if (!m_has_maximized && !dock.fixed && (dock.dock_direction == wxAUI_DOCK_TOP ||

                         dock.dock_direction == wxAUI_DOCK_LEFT))
     {
         sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND);
 
                         dock.dock_direction == wxAUI_DOCK_LEFT))
     {
         sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND);
 

-        part.type = wxDockUIPart::typeDockSizer;
+        part.type = wxAuiDockUIPart::typeDockSizer;

         part.dock = &dock;
         part.pane = NULL;
         part.button = NULL;
         part.dock = &dock;
         part.pane = NULL;
         part.button = NULL;


@@ -1676,9 +1775,9 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont,
     }
 }
 
     }
 }
 

-wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
-                                   wxDockInfoArray& docks,
-                                   wxDockUIPartArray& uiparts,
+wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
+                                   wxAuiDockInfoArray& docks,
+                                   wxAuiDockUIPartArray& uiparts,

                                    bool spacer_only)
 {
     wxBoxSizer* container = new wxBoxSizer(wxVERTICAL);
                                    bool spacer_only)
 {
     wxBoxSizer* container = new wxBoxSizer(wxVERTICAL);


@@ -1693,16 +1792,17 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
         docks.Item(i).panes.Empty();
 
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
         docks.Item(i).panes.Empty();
 

+

     // iterate through all known panes, filing each
     // of them into the appropriate dock. If the
     // pane does not exist in the dock, add it
     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
     {
     // iterate through all known panes, filing each
     // of them into the appropriate dock. If the
     // pane does not exist in the dock, add it
     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
     {

-        wxPaneInfo& p = panes.Item(i);
+        wxAuiPaneInfo& p = panes.Item(i);

 
         // find any docks in this layer
 
         // find any docks in this layer

-        wxDockInfo* dock;
-        wxDockInfoPtrArray arr;
+        wxAuiDockInfo* dock;
+        wxAuiDockInfoPtrArray arr;

         FindDocks(docks, p.dock_direction, p.dock_layer, p.dock_row, arr);
 
         if (arr.GetCount() > 0)
         FindDocks(docks, p.dock_direction, p.dock_layer, p.dock_row, arr);
 
         if (arr.GetCount() > 0)


@@ -1712,7 +1812,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
          else
         {
             // dock was not found, so we need to create a new one
          else
         {
             // dock was not found, so we need to create a new one

-            wxDockInfo d;
+            wxAuiDockInfo d;

             d.dock_direction = p.dock_direction;
             d.dock_layer = p.dock_layer;
             d.dock_row = p.dock_row;
             d.dock_direction = p.dock_direction;
             d.dock_layer = p.dock_layer;
             d.dock_row = p.dock_row;


@@ -1749,7 +1849,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
     // configure the docks further
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {
     // configure the docks further
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {

-        wxDockInfo& dock = docks.Item(i);
+        wxAuiDockInfo& dock = docks.Item(i);

         int j, dock_pane_count = dock.panes.GetCount();
 
         // sort the dock pane array by the pane's
         int j, dock_pane_count = dock.panes.GetCount();
 
         // sort the dock pane array by the pane's


@@ -1763,7 +1863,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
 
             for (j = 0; j < dock_pane_count; ++j)
             {
 
             for (j = 0; j < dock_pane_count; ++j)
             {

-                wxPaneInfo& pane = *dock.panes.Item(j);
+                wxAuiPaneInfo& pane = *dock.panes.Item(j);

                 wxSize pane_size = pane.best_size;
                 if (pane_size == wxDefaultSize)
                     pane_size = pane.min_size;
                 wxSize pane_size = pane.best_size;
                 if (pane_size == wxDefaultSize)
                     pane_size = pane.min_size;


@@ -1819,7 +1919,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
         int dock_min_size = 0;
         for (j = 0; j < dock_pane_count; ++j)
         {
         int dock_min_size = 0;
         for (j = 0; j < dock_pane_count; ++j)
         {

-            wxPaneInfo& pane = *dock.panes.Item(j);
+            wxAuiPaneInfo& pane = *dock.panes.Item(j);

             if (pane.min_size != wxDefaultSize)
             {
                 if (pane.HasBorder())
             if (pane.min_size != wxDefaultSize)
             {
                 if (pane.HasBorder())


@@ -1860,12 +1960,12 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
         dock.toolbar = true;
         for (j = 0; j < dock_pane_count; ++j)
         {
         dock.toolbar = true;
         for (j = 0; j < dock_pane_count; ++j)
         {

-            wxPaneInfo& pane = *dock.panes.Item(j);
+            wxAuiPaneInfo& pane = *dock.panes.Item(j);

             if (!pane.IsFixed())
                 dock.fixed = false;
             if (!pane.IsToolbar())
                 dock.toolbar = false;
             if (!pane.IsFixed())
                 dock.fixed = false;
             if (!pane.IsToolbar())
                 dock.toolbar = false;

-            if (pane.state & wxPaneInfo::actionPane)
+            if (pane.state & wxAuiPaneInfo::actionPane)

                 action_pane_marked = true;
         }
 
                 action_pane_marked = true;
         }
 


@@ -1877,7 +1977,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
         {
             for (j = 0; j < dock_pane_count; ++j)
             {
         {
             for (j = 0; j < dock_pane_count; ++j)
             {

-                wxPaneInfo& pane = *dock.panes.Item(j);
+                wxAuiPaneInfo& pane = *dock.panes.Item(j);

                 pane.dock_pos = j;
             }
         }
                 pane.dock_pos = j;
             }
         }


@@ -1894,7 +1994,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
             int offset = 0;
             for (j = 0; j < dock_pane_count; ++j)
             {
             int offset = 0;
             for (j = 0; j < dock_pane_count; ++j)
             {

-                wxPaneInfo& pane = *(dock.panes.Item(j));
+                wxAuiPaneInfo& pane = *(dock.panes.Item(j));

                 pane.dock_pos = pane_positions[j];
 
                 int amount = pane.dock_pos - offset;
                 pane.dock_pos = pane_positions[j];
 
                 int amount = pane.dock_pos - offset;


@@ -1926,7 +2026,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
 
     for (layer = 0; layer <= max_layer; ++layer)
     {
 
     for (layer = 0; layer <= max_layer; ++layer)
     {

-        wxDockInfoPtrArray arr;
+        wxAuiDockInfoPtrArray arr;

 
         // find any docks in this layer
         FindDocks(docks, -1, layer, -1, arr);
 
         // find any docks in this layer
         FindDocks(docks, -1, layer, -1, arr);


@@ -1977,12 +2077,12 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
                 for (row = 0,row_count = arr.GetCount(); row<row_count; ++row)
                    LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only);
             }
                 for (row = 0,row_count = arr.GetCount(); row<row_count; ++row)
                    LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only);
             }

-             else
+             else if (!m_has_maximized)

             {
                 // there are no center docks, add a background area
                 wxSizerItem* sizer_item = middle->Add(1,1, 1, wxEXPAND);
             {
                 // there are no center docks, add a background area
                 wxSizerItem* sizer_item = middle->Add(1,1, 1, wxEXPAND);

-                wxDockUIPart part;
-                part.type = wxDockUIPart::typeBackground;
+                wxAuiDockUIPart part;
+                part.type = wxAuiDockUIPart::typeBackground;

                 part.pane = NULL;
                 part.dock = NULL;
                 part.button = NULL;
                 part.pane = NULL;
                 part.dock = NULL;
                 part.button = NULL;


@@ -2026,8 +2126,8 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
         // therefore we will create a simple background area
         cont = new wxBoxSizer(wxVERTICAL);
         wxSizerItem* sizer_item = cont->Add(1,1, 1, wxEXPAND);
         // therefore we will create a simple background area
         cont = new wxBoxSizer(wxVERTICAL);
         wxSizerItem* sizer_item = cont->Add(1,1, 1, wxEXPAND);

-        wxDockUIPart part;
-        part.type = wxDockUIPart::typeBackground;
+        wxAuiDockUIPart part;
+        part.type = wxAuiDockUIPart::typeBackground;

         part.pane = NULL;
         part.dock = NULL;
         part.button = NULL;
         part.pane = NULL;
         part.dock = NULL;
         part.button = NULL;


@@ -2045,7 +2145,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
 // one or more panes, this function should be called.  It is the
 // external entry point for running the layout engine.
 
 // one or more panes, this function should be called.  It is the
 // external entry point for running the layout engine.
 

-void wxFrameManager::Update()
+void wxAuiManager::Update()

 {
     wxSizer* sizer;
     int i, pane_count = m_panes.GetCount();
 {
     wxSizer* sizer;
     int i, pane_count = m_panes.GetCount();


@@ -2057,7 +2157,7 @@ void wxFrameManager::Update()
     // redocked or are becoming non-floating
     for (i = 0; i < pane_count; ++i)
     {
     // redocked or are becoming non-floating
     for (i = 0; i < pane_count; ++i)
     {

-        wxPaneInfo& p = m_panes.Item(i);
+        wxAuiPaneInfo& p = m_panes.Item(i);

 
         if (!p.IsFloating() && p.frame)
         {
 
         if (!p.IsFloating() && p.frame)
         {


@@ -2068,25 +2168,30 @@ void wxFrameManager::Update()
             p.window->SetSize(1,1);
 
 
             p.window->SetSize(1,1);
 
 

-           // the following block is a workaround for bug #1531361
-           // (see wxWidgets sourceforge page).  On wxGTK (only), when
-           // a frame is shown/hidden, a move event unfortunately
-           // also gets fired.  Because we may be dragging around
-           // a pane, we need to cancel that action here to prevent
-           // a spurious crash.
-           if (m_action_window == p.frame)
-           {
-               if (wxWindow::GetCapture() == m_frame)
+               // the following block is a workaround for bug #1531361
+               // (see wxWidgets sourceforge page).  On wxGTK (only), when
+               // a frame is shown/hidden, a move event unfortunately
+               // also gets fired.  Because we may be dragging around
+               // a pane, we need to cancel that action here to prevent
+               // a spurious crash.
+               if (m_action_window == p.frame)
+               {
+                       if (wxWindow::GetCapture() == m_frame)

                     m_frame->ReleaseMouse();
                 m_action = actionNone;
                     m_frame->ReleaseMouse();
                 m_action = actionNone;

-               m_action_window = NULL;
-           }
+                       m_action_window = NULL;
+               }

 
 

-           // hide the frame
+               // hide the frame

             if (p.frame->IsShown())
                 p.frame->Show(false);
 
             // reparent to m_frame and destroy the pane
             if (p.frame->IsShown())
                 p.frame->Show(false);
 
             // reparent to m_frame and destroy the pane

+            if(m_action_window == p.frame)
+            {
+                m_action_window = NULL;
+            }
+            

             p.window->Reparent(m_frame);
             p.frame->SetSizer(NULL);
             p.frame->Destroy();
             p.window->Reparent(m_frame);
             p.frame->SetSizer(NULL);
             p.frame->Destroy();


@@ -2102,7 +2207,7 @@ void wxFrameManager::Update()
     // and float panes as necessary
     for (i = 0; i < pane_count; ++i)
     {
     // and float panes as necessary
     for (i = 0; i < pane_count; ++i)
     {

-        wxPaneInfo& p = m_panes.Item(i);
+        wxAuiPaneInfo& p = m_panes.Item(i);

 
         if (p.IsFloating())
         {
 
         if (p.IsFloating())
         {


@@ -2110,7 +2215,7 @@ void wxFrameManager::Update()
             {
                 // we need to create a frame for this
                 // pane, which has recently been floated
             {
                 // we need to create a frame for this
                 // pane, which has recently been floated

-                wxFloatingPane* frame = CreateFloatingFrame(m_frame, p);
+                wxAuiFloatingFrame* frame = CreateFloatingFrame(m_frame, p);

 
 #if wxCHECK_VERSION(2,7,0)
                 // on MSW and Mac, if the owner desires transparent dragging, and
 
 #if wxCHECK_VERSION(2,7,0)
                 // on MSW and Mac, if the owner desires transparent dragging, and


@@ -2130,7 +2235,7 @@ void wxFrameManager::Update()
              else
             {
                 // frame already exists, make sure it's position
              else
             {
                 // frame already exists, make sure it's position

-                // and size reflect the information in wxPaneInfo
+                // and size reflect the information in wxAuiPaneInfo

                 if (p.frame->GetPosition() != p.floating_pos)
                 {
                     p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,
                 if (p.frame->GetPosition() != p.floating_pos)
                 {
                     p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,


@@ -2153,7 +2258,7 @@ void wxFrameManager::Update()
         // any optionActive values from the pane states
         if ((m_flags & wxAUI_MGR_ALLOW_ACTIVE_PANE) == 0)
         {
         // any optionActive values from the pane states
         if ((m_flags & wxAUI_MGR_ALLOW_ACTIVE_PANE) == 0)
         {

-            p.state &= ~wxPaneInfo::optionActive;
+            p.state &= ~wxAuiPaneInfo::optionActive;

         }
     }
 
         }
     }
 


@@ -2164,7 +2269,7 @@ void wxFrameManager::Update()
     for (i = 0; i < pane_count; ++i)
     {
         wxRect r;
     for (i = 0; i < pane_count; ++i)
     {
         wxRect r;

-        wxPaneInfo& p = m_panes.Item(i);
+        wxAuiPaneInfo& p = m_panes.Item(i);

 
         if (p.window && p.IsShown() && p.IsDocked())
             r = p.rect;
 
         if (p.window && p.IsShown() && p.IsDocked())
             r = p.rect;


@@ -2188,7 +2293,7 @@ void wxFrameManager::Update()
     // changed, the corresponding panes must also be updated
     for (i = 0; i < pane_count; ++i)
     {
     // changed, the corresponding panes must also be updated
     for (i = 0; i < pane_count; ++i)
     {

-        wxPaneInfo& p = m_panes.Item(i);
+        wxAuiPaneInfo& p = m_panes.Item(i);

         if (p.window && p.window->IsShown() && p.IsDocked())
         {
             if (p.rect != old_pane_rects[i])
         if (p.window && p.window->IsShown() && p.IsDocked())
         {
             if (p.rect != old_pane_rects[i])


@@ -2230,14 +2335,14 @@ void wxFrameManager::Update()
 // and updates their internal rectangles.  This should always be called
 // instead of calling m_frame->Layout() directly
 
 // and updates their internal rectangles.  This should always be called
 // instead of calling m_frame->Layout() directly
 

-void wxFrameManager::DoFrameLayout()
+void wxAuiManager::DoFrameLayout()

 {
     m_frame->Layout();
 
     int i, part_count;
     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
     {
 {
     m_frame->Layout();
 
     int i, part_count;
     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
     {

-        wxDockUIPart& part = m_uiparts.Item(i);
+        wxAuiDockUIPart& part = m_uiparts.Item(i);

 
         // get the rectangle of the UI part
         // originally, this code looked like this:
 
         // get the rectangle of the UI part
         // originally, this code looked like this:


@@ -2270,9 +2375,9 @@ void wxFrameManager::DoFrameLayout()
             part.rect.width += border;
 
 
             part.rect.width += border;
 
 

-        if (part.type == wxDockUIPart::typeDock)
+        if (part.type == wxAuiDockUIPart::typeDock)

             part.dock->rect = part.rect;
             part.dock->rect = part.rect;

-        if (part.type == wxDockUIPart::typePane)
+        if (part.type == wxAuiDockUIPart::typePane)

             part.pane->rect = part.rect;
     }
 }
             part.pane->rect = part.rect;
     }
 }


@@ -2282,20 +2387,20 @@ void wxFrameManager::DoFrameLayout()
 // rectangle of the pane in question, including decorations like
 // caption and border (if any).
 
 // rectangle of the pane in question, including decorations like
 // caption and border (if any).
 

-wxDockUIPart* wxFrameManager::GetPanePart(wxWindow* wnd)
+wxAuiDockUIPart* wxAuiManager::GetPanePart(wxWindow* wnd)

 {
     int i, part_count;
     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
     {
 {
     int i, part_count;
     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
     {

-        wxDockUIPart& part = m_uiparts.Item(i);
-        if (part.type == wxDockUIPart::typePaneBorder &&
+        wxAuiDockUIPart& part = m_uiparts.Item(i);
+        if (part.type == wxAuiDockUIPart::typePaneBorder &&

             part.pane && part.pane->window == wnd)
                 return &part;
     }
     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
     {
             part.pane && part.pane->window == wnd)
                 return &part;
     }
     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
     {

-        wxDockUIPart& part = m_uiparts.Item(i);
-        if (part.type == wxDockUIPart::typePane &&
+        wxAuiDockUIPart& part = m_uiparts.Item(i);
+        if (part.type == wxAuiDockUIPart::typePane &&

             part.pane && part.pane->window == wnd)
                 return &part;
     }
             part.pane && part.pane->window == wnd)
                 return &part;
     }


@@ -2310,15 +2415,15 @@ wxDockUIPart* wxFrameManager::GetPanePart(wxWindow* wnd)
 // vertical docks).  This value is necessary for calculating
 // fixel-pane/toolbar offsets when they are dragged.
 
 // vertical docks).  This value is necessary for calculating
 // fixel-pane/toolbar offsets when they are dragged.
 

-int wxFrameManager::GetDockPixelOffset(wxPaneInfo& test)
+int wxAuiManager::GetDockPixelOffset(wxAuiPaneInfo& test)

 {
     // the only way to accurately calculate the dock's
     // offset is to actually run a theoretical layout
 
     int i, part_count, dock_count;
 {
     // the only way to accurately calculate the dock's
     // offset is to actually run a theoretical layout
 
     int i, part_count, dock_count;

-    wxDockInfoArray docks;
-    wxPaneInfoArray panes;
-    wxDockUIPartArray uiparts;
+    wxAuiDockInfoArray docks;
+    wxAuiPaneInfoArray panes;
+    wxAuiDockUIPartArray uiparts;

     CopyDocksAndPanes(docks, panes, m_docks, m_panes);
     panes.Add(test);
 
     CopyDocksAndPanes(docks, panes, m_docks, m_panes);
     panes.Add(test);
 


@@ -2329,10 +2434,10 @@ int wxFrameManager::GetDockPixelOffset(wxPaneInfo& test)
 
     for (i = 0, part_count = uiparts.GetCount(); i < part_count; ++i)
     {
 
     for (i = 0, part_count = uiparts.GetCount(); i < part_count; ++i)
     {

-        wxDockUIPart& part = uiparts.Item(i);
+        wxAuiDockUIPart& part = uiparts.Item(i);

         part.rect = wxRect(part.sizer_item->GetPosition(),
                            part.sizer_item->GetSize());
         part.rect = wxRect(part.sizer_item->GetPosition(),
                            part.sizer_item->GetSize());

-        if (part.type == wxDockUIPart::typeDock)
+        if (part.type == wxAuiDockUIPart::typeDock)

             part.dock->rect = part.rect;
     }
 
             part.dock->rect = part.rect;
     }
 


@@ -2340,7 +2445,7 @@ int wxFrameManager::GetDockPixelOffset(wxPaneInfo& test)
 
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {
 
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {

-        wxDockInfo& dock = docks.Item(i);
+        wxAuiDockInfo& dock = docks.Item(i);

         if (test.dock_direction == dock.dock_direction &&
             test.dock_layer==dock.dock_layer && test.dock_row==dock.dock_row)
         {
         if (test.dock_direction == dock.dock_direction &&
             test.dock_layer==dock.dock_layer && test.dock_row==dock.dock_row)
         {


@@ -2360,8 +2465,8 @@ int wxFrameManager::GetDockPixelOffset(wxPaneInfo& test)
 // if a dock operation is allowed, the new dock position is copied into
 // the target info.  If the operation was allowed, the function returns true.
 
 // if a dock operation is allowed, the new dock position is copied into
 // the target info.  If the operation was allowed, the function returns true.
 

-bool wxFrameManager::ProcessDockResult(wxPaneInfo& target,
-                              const wxPaneInfo& new_pos)
+bool wxAuiManager::ProcessDockResult(wxAuiPaneInfo& target,
+                              const wxAuiPaneInfo& new_pos)

 {
     bool allowed = false;
     switch (new_pos.dock_direction)
 {
     bool allowed = false;
     switch (new_pos.dock_direction)


@@ -2384,7 +2489,7 @@ bool wxFrameManager::ProcessDockResult(wxPaneInfo& target,
 // dropped, it performs the drop operation using the specified dock and pane
 // arrays.  By specifying copied dock and pane arrays when calling, a "what-if"
 // scenario can be performed, giving precise coordinates for drop hints.
 // dropped, it performs the drop operation using the specified dock and pane
 // arrays.  By specifying copied dock and pane arrays when calling, a "what-if"
 // scenario can be performed, giving precise coordinates for drop hints.

-// If, however, wxFrameManager:m_docks and wxFrameManager::m_panes are specified
+// If, however, wxAuiManager:m_docks and wxAuiManager::m_panes are specified

 // as parameters, the changes will be made to the main state arrays
 
 const int auiInsertRowPixels = 10;
 // as parameters, the changes will be made to the main state arrays
 
 const int auiInsertRowPixels = 10;


@@ -2392,15 +2497,15 @@ const int auiNewRowPixels = 40;
 const int auiLayerInsertPixels = 40;
 const int auiLayerInsertOffset = 5;
 
 const int auiLayerInsertPixels = 40;
 const int auiLayerInsertOffset = 5;
 

-bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
-                            wxPaneInfoArray& panes,
-                            wxPaneInfo& target,
+bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
+                            wxAuiPaneInfoArray& panes,
+                            wxAuiPaneInfo& target,

                             const wxPoint& pt,
                             const wxPoint& offset)
 {
     wxSize cli_size = m_frame->GetClientSize();
 
                             const wxPoint& pt,
                             const wxPoint& offset)
 {
     wxSize cli_size = m_frame->GetClientSize();
 

-    wxPaneInfo drop = target;
+    wxAuiPaneInfo drop = target;

 
 
     // The result should always be shown
 
 
     // The result should always be shown


@@ -2453,7 +2558,7 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
         return ProcessDockResult(target, drop);
     }
 
         return ProcessDockResult(target, drop);
     }
 

-    wxDockUIPart* part = HitTest(pt.x, pt.y);
+    wxAuiDockUIPart* part = HitTest(pt.x, pt.y);

 
 
     if (drop.IsToolbar())
 
 
     if (drop.IsToolbar())


@@ -2570,16 +2675,16 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
     if (!part)
         return false;
 
     if (!part)
         return false;
 

-    if (part->type == wxDockUIPart::typePaneBorder ||
-        part->type == wxDockUIPart::typeCaption ||
-        part->type == wxDockUIPart::typeGripper ||
-        part->type == wxDockUIPart::typePaneButton ||
-        part->type == wxDockUIPart::typePane ||
-        part->type == wxDockUIPart::typePaneSizer ||
-        part->type == wxDockUIPart::typeDockSizer ||
-        part->type == wxDockUIPart::typeBackground)
+    if (part->type == wxAuiDockUIPart::typePaneBorder ||
+        part->type == wxAuiDockUIPart::typeCaption ||
+        part->type == wxAuiDockUIPart::typeGripper ||
+        part->type == wxAuiDockUIPart::typePaneButton ||
+        part->type == wxAuiDockUIPart::typePane ||
+        part->type == wxAuiDockUIPart::typePaneSizer ||
+        part->type == wxAuiDockUIPart::typeDockSizer ||
+        part->type == wxAuiDockUIPart::typeBackground)

     {
     {

-        if (part->type == wxDockUIPart::typeDockSizer)
+        if (part->type == wxAuiDockUIPart::typeDockSizer)

         {
             if (part->dock->panes.GetCount() != 1)
                 return false;
         {
             if (part->dock->panes.GetCount() != 1)
                 return false;


@@ -2771,7 +2876,7 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
 }
 
 
 }
 
 

-void wxFrameManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event))
+void wxAuiManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event))

 {
     if (!m_hint_wnd || m_hint_fadeamt >= m_hint_fademax)
     {
 {
     if (!m_hint_wnd || m_hint_fadeamt >= m_hint_fademax)
     {


@@ -2788,7 +2893,7 @@ void wxFrameManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event))
 #endif
 }
 
 #endif
 }
 

-void wxFrameManager::ShowHint(const wxRect& rect)
+void wxAuiManager::ShowHint(const wxRect& rect)

 {
     if (m_hint_wnd)
     {
 {
     if (m_hint_wnd)
     {


@@ -2851,7 +2956,7 @@ void wxFrameManager::ShowHint(const wxRect& rect)
         int i, pane_count;
         for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
         {
         int i, pane_count;
         for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
         {

-            wxPaneInfo& pane = m_panes.Item(i);
+            wxAuiPaneInfo& pane = m_panes.Item(i);

 
             if (pane.IsFloating() &&
                 pane.frame->IsShown())
 
             if (pane.IsFloating() &&
                 pane.frame->IsShown())


@@ -2887,7 +2992,7 @@ void wxFrameManager::ShowHint(const wxRect& rect)
     }
 }
 
     }
 }
 

-void wxFrameManager::HideHint()
+void wxAuiManager::HideHint()

 {
     // hides a transparent window hint, if there is one
     if (m_hint_wnd)
 {
     // hides a transparent window hint, if there is one
     if (m_hint_wnd)


@@ -2922,7 +3027,7 @@ void wxFrameManager::HideHint()
 // DrawHintRect() then calls ShowHint() to indicate this drop rectangle.
 // "pane_window" is the window pointer of the pane being dragged, pt is
 // the mouse position, in client coordinates
 // DrawHintRect() then calls ShowHint() to indicate this drop rectangle.
 // "pane_window" is the window pointer of the pane being dragged, pt is
 // the mouse position, in client coordinates

-void wxFrameManager::DrawHintRect(wxWindow* pane_window,
+void wxAuiManager::DrawHintRect(wxWindow* pane_window,

                                   const wxPoint& pt,
                                   const wxPoint& offset)
 {
                                   const wxPoint& pt,
                                   const wxPoint& offset)
 {


@@ -2934,10 +3039,10 @@ void wxFrameManager::DrawHintRect(wxWindow* pane_window,
     // so that we don't modify the real thing on screen
 
     int i, pane_count, part_count;
     // so that we don't modify the real thing on screen
 
     int i, pane_count, part_count;

-    wxDockInfoArray docks;
-    wxPaneInfoArray panes;
-    wxDockUIPartArray uiparts;
-    wxPaneInfo hint = GetPane(pane_window);
+    wxAuiDockInfoArray docks;
+    wxAuiPaneInfoArray panes;
+    wxAuiDockUIPartArray uiparts;
+    wxAuiPaneInfo hint = GetPane(pane_window);

     hint.name = wxT("__HINT__");
     hint.Show();
 
     hint.name = wxT("__HINT__");
     hint.Show();
 


@@ -2975,9 +3080,9 @@ void wxFrameManager::DrawHintRect(wxWindow* pane_window,
     for (i = 0, part_count = uiparts.GetCount();
          i < part_count; ++i)
     {
     for (i = 0, part_count = uiparts.GetCount();
          i < part_count; ++i)
     {

-        wxDockUIPart& part = uiparts.Item(i);
+        wxAuiDockUIPart& part = uiparts.Item(i);

 
 

-        if (part.type == wxDockUIPart::typePaneBorder &&
+        if (part.type == wxAuiDockUIPart::typePaneBorder &&

             part.pane && part.pane->name == wxT("__HINT__"))
         {
             rect = wxRect(part.sizer_item->GetPosition(),
             part.pane && part.pane->name == wxT("__HINT__"))
         {
             rect = wxRect(part.sizer_item->GetPosition(),


@@ -2999,10 +3104,10 @@ void wxFrameManager::DrawHintRect(wxWindow* pane_window,
     ShowHint(rect);
 }
 
     ShowHint(rect);
 }
 

-void wxFrameManager::OnFloatingPaneMoveStart(wxWindow* wnd)
+void wxAuiManager::OnFloatingPaneMoveStart(wxWindow* wnd)

 {
     // try to find the pane
 {
     // try to find the pane

-    wxPaneInfo& pane = GetPane(wnd);
+    wxAuiPaneInfo& pane = GetPane(wnd);

     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
 #if wxCHECK_VERSION(2,7,0)
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
 #if wxCHECK_VERSION(2,7,0)


@@ -3011,10 +3116,10 @@ void wxFrameManager::OnFloatingPaneMoveStart(wxWindow* wnd)
 #endif
 }
 
 #endif
 }
 

-void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)
+void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)

 {
     // try to find the pane
 {
     // try to find the pane

-    wxPaneInfo& pane = GetPane(wnd);
+    wxAuiPaneInfo& pane = GetPane(wnd);

     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
     wxPoint pt = ::wxGetMousePosition();
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
     wxPoint pt = ::wxGetMousePosition();


@@ -3067,10 +3172,10 @@ void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)
     {
         if (m_action == actionDragFloatingPane)
         {
     {
         if (m_action == actionDragFloatingPane)
         {

-            wxDockInfoArray docks;
-            wxPaneInfoArray panes;
-            wxDockUIPartArray uiparts;
-            wxPaneInfo hint = pane;
+            wxAuiDockInfoArray docks;
+            wxAuiPaneInfoArray panes;
+            wxAuiDockUIPartArray uiparts;
+            wxAuiPaneInfo hint = pane;

 
             CopyDocksAndPanes(docks, panes, m_docks, m_panes);
 
 
             CopyDocksAndPanes(docks, panes, m_docks, m_panes);
 


@@ -3114,10 +3219,10 @@ void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)
     m_frame->Update();
 }
 
     m_frame->Update();
 }
 

-void wxFrameManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir)
+void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir)

 {
     // try to find the pane
 {
     // try to find the pane

-    wxPaneInfo& pane = GetPane(wnd);
+    wxAuiPaneInfo& pane = GetPane(wnd);

     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
     wxPoint pt = ::wxGetMousePosition();
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
     wxPoint pt = ::wxGetMousePosition();


@@ -3184,6 +3289,8 @@ void wxFrameManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir)
         if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
             pane.frame->SetTransparent(255);
 #endif
         if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
             pane.frame->SetTransparent(255);
 #endif

+    } else if(m_has_maximized) {
+        RestoreMaximizedPane();

     }
 
     Update();
     }
 
     Update();


@@ -3191,25 +3298,25 @@ void wxFrameManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir)
     HideHint();
 }
 
     HideHint();
 }
 

-void wxFrameManager::OnFloatingPaneResized(wxWindow* wnd, const wxSize& size)
+void wxAuiManager::OnFloatingPaneResized(wxWindow* wnd, const wxSize& size)

 {
     // try to find the pane
 {
     // try to find the pane

-    wxPaneInfo& pane = GetPane(wnd);
+    wxAuiPaneInfo& pane = GetPane(wnd);

     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
     pane.floating_size = size;
 }
 
 
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
     pane.floating_size = size;
 }
 
 

-void wxFrameManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt)
+void wxAuiManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt)

 {
     // try to find the pane
 {
     // try to find the pane

-    wxPaneInfo& pane = GetPane(wnd);
+    wxAuiPaneInfo& pane = GetPane(wnd);

     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
 
     // fire pane close event
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
 
     // fire pane close event

-    wxFrameManagerEvent e(wxEVT_AUI_PANECLOSE);
+    wxAuiManagerEvent e(wxEVT_AUI_PANECLOSE);

     e.SetPane(&pane);
     e.SetCanVeto(evt.CanVeto());
     ProcessMgrEvent(e);
     e.SetPane(&pane);
     e.SetCanVeto(evt.CanVeto());
     ProcessMgrEvent(e);


@@ -3227,7 +3334,7 @@ void wxFrameManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt)
 
 
 
 
 
 

-void wxFrameManager::OnFloatingPaneActivated(wxWindow* wnd)
+void wxAuiManager::OnFloatingPaneActivated(wxWindow* wnd)

 {
     if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
     {
 {
     if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
     {


@@ -3243,7 +3350,7 @@ void wxFrameManager::OnFloatingPaneActivated(wxWindow* wnd)
 // backgrounds, captions, grippers, pane borders and buttons.
 // It renders the entire user interface.
 
 // backgrounds, captions, grippers, pane borders and buttons.
 // It renders the entire user interface.
 

-void wxFrameManager::OnRender(wxFrameManagerEvent& evt)
+void wxAuiManager::OnRender(wxAuiManagerEvent& evt)

 {
     wxDC* dc = evt.GetDC();
 
 {
     wxDC* dc = evt.GetDC();
 


@@ -3254,7 +3361,7 @@ void wxFrameManager::OnRender(wxFrameManagerEvent& evt)
     for (i = 0, part_count = m_uiparts.GetCount();
          i < part_count; ++i)
     {
     for (i = 0, part_count = m_uiparts.GetCount();
          i < part_count; ++i)
     {

-        wxDockUIPart& part = m_uiparts.Item(i);
+        wxAuiDockUIPart& part = m_uiparts.Item(i);

 
         // don't draw hidden pane items
         if (part.sizer_item && !part.sizer_item->IsShown())
 
         // don't draw hidden pane items
         if (part.sizer_item && !part.sizer_item->IsShown())


@@ -3262,23 +3369,23 @@ void wxFrameManager::OnRender(wxFrameManagerEvent& evt)
 
         switch (part.type)
         {
 
         switch (part.type)
         {

-            case wxDockUIPart::typeDockSizer:
-            case wxDockUIPart::typePaneSizer:
+            case wxAuiDockUIPart::typeDockSizer:
+            case wxAuiDockUIPart::typePaneSizer:

                 m_art->DrawSash(*dc, m_frame, part.orientation, part.rect);
                 break;
                 m_art->DrawSash(*dc, m_frame, part.orientation, part.rect);
                 break;

-            case wxDockUIPart::typeBackground:
+            case wxAuiDockUIPart::typeBackground:

                 m_art->DrawBackground(*dc, m_frame, part.orientation, part.rect);
                 break;
                 m_art->DrawBackground(*dc, m_frame, part.orientation, part.rect);
                 break;

-            case wxDockUIPart::typeCaption:
+            case wxAuiDockUIPart::typeCaption:

                 m_art->DrawCaption(*dc, m_frame, part.pane->caption, part.rect, *part.pane);
                 break;
                 m_art->DrawCaption(*dc, m_frame, part.pane->caption, part.rect, *part.pane);
                 break;

-            case wxDockUIPart::typeGripper:
+            case wxAuiDockUIPart::typeGripper:

                 m_art->DrawGripper(*dc, m_frame, part.rect, *part.pane);
                 break;
                 m_art->DrawGripper(*dc, m_frame, part.rect, *part.pane);
                 break;

-            case wxDockUIPart::typePaneBorder:
+            case wxAuiDockUIPart::typePaneBorder:

                 m_art->DrawBorder(*dc, m_frame, part.rect, *part.pane);
                 break;
                 m_art->DrawBorder(*dc, m_frame, part.rect, *part.pane);
                 break;

-            case wxDockUIPart::typePaneButton:
+            case wxAuiDockUIPart::typePaneButton:

                 m_art->DrawPaneButton(*dc, m_frame, part.button->button_id,
                         wxAUI_BUTTON_STATE_NORMAL, part.rect, *part.pane);
                 break;
                 m_art->DrawPaneButton(*dc, m_frame, part.button->button_id,
                         wxAUI_BUTTON_STATE_NORMAL, part.rect, *part.pane);
                 break;


@@ -3288,19 +3395,19 @@ void wxFrameManager::OnRender(wxFrameManagerEvent& evt)
 
 
 // Render() fire a render event, which is normally handled by
 
 
 // Render() fire a render event, which is normally handled by

-// wxFrameManager::OnRender().  This allows the render function to
+// wxAuiManager::OnRender().  This allows the render function to

 // be overridden via the render event.  This can be useful for paintin
 // custom graphics in the main window. Default behavior can be
 // invoked in the overridden function by calling OnRender()
 
 // be overridden via the render event.  This can be useful for paintin
 // custom graphics in the main window. Default behavior can be
 // invoked in the overridden function by calling OnRender()
 

-void wxFrameManager::Render(wxDC* dc)
+void wxAuiManager::Render(wxDC* dc)

 {
 {

-    wxFrameManagerEvent e(wxEVT_AUI_RENDER);
+    wxAuiManagerEvent e(wxEVT_AUI_RENDER);

     e.SetDC(dc);
     ProcessMgrEvent(e);
 }
 
     e.SetDC(dc);
     ProcessMgrEvent(e);
 }
 

-void wxFrameManager::Repaint(wxDC* dc)
+void wxAuiManager::Repaint(wxDC* dc)

 {
 #ifdef __WXMAC__
     if ( dc == NULL )
 {
 #ifdef __WXMAC__
     if ( dc == NULL )


@@ -3337,13 +3444,13 @@ void wxFrameManager::Repaint(wxDC* dc)
         delete client_dc;
 }
 
         delete client_dc;
 }
 

-void wxFrameManager::OnPaint(wxPaintEvent& WXUNUSED(event))
+void wxAuiManager::OnPaint(wxPaintEvent& WXUNUSED(event))

 {
     wxPaintDC dc(m_frame);
     Repaint(&dc);
 }
 
 {
     wxPaintDC dc(m_frame);
     Repaint(&dc);
 }
 

-void wxFrameManager::OnEraseBackground(wxEraseEvent& event)
+void wxAuiManager::OnEraseBackground(wxEraseEvent& event)

 {
 #ifdef __WXMAC__
     event.Skip() ;
 {
 #ifdef __WXMAC__
     event.Skip() ;


@@ -3352,7 +3459,7 @@ void wxFrameManager::OnEraseBackground(wxEraseEvent& event)
 #endif
 }
 
 #endif
 }
 

-void wxFrameManager::OnSize(wxSizeEvent& event)
+void wxAuiManager::OnSize(wxSizeEvent& event)

 {
     if (m_frame)
     {
 {
     if (m_frame)
     {


@@ -3363,20 +3470,20 @@ void wxFrameManager::OnSize(wxSizeEvent& event)
 }
 
 
 }
 
 

-void wxFrameManager::OnSetCursor(wxSetCursorEvent& event)
+void wxAuiManager::OnSetCursor(wxSetCursorEvent& event)

 {
     // determine cursor
 {
     // determine cursor

-    wxDockUIPart* part = HitTest(event.GetX(), event.GetY());
+    wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY());

     wxCursor cursor = wxNullCursor;
 
     if (part)
     {
     wxCursor cursor = wxNullCursor;
 
     if (part)
     {

-        if (part->type == wxDockUIPart::typeDockSizer ||
-            part->type == wxDockUIPart::typePaneSizer)
+        if (part->type == wxAuiDockUIPart::typeDockSizer ||
+            part->type == wxAuiDockUIPart::typePaneSizer)

         {
             // a dock may not be resized if it has a single
             // pane which is not resizable
         {
             // a dock may not be resized if it has a single
             // pane which is not resizable

-            if (part->type == wxDockUIPart::typeDockSizer && part->dock &&
+            if (part->type == wxAuiDockUIPart::typeDockSizer && part->dock &&

                 part->dock->panes.GetCount() == 1 &&
                 part->dock->panes.Item(0)->IsFixed())
                     return;
                 part->dock->panes.GetCount() == 1 &&
                 part->dock->panes.Item(0)->IsFixed())
                     return;


@@ -3390,7 +3497,7 @@ void wxFrameManager::OnSetCursor(wxSetCursorEvent& event)
                  else
                 cursor = wxCursor(wxCURSOR_SIZENS);
         }
                  else
                 cursor = wxCursor(wxCURSOR_SIZENS);
         }

-         else if (part->type == wxDockUIPart::typeGripper)
+         else if (part->type == wxAuiDockUIPart::typeGripper)

         {
             cursor = wxCursor(wxCURSOR_SIZING);
         }
         {
             cursor = wxCursor(wxCURSOR_SIZING);
         }


@@ -3401,10 +3508,10 @@ void wxFrameManager::OnSetCursor(wxSetCursorEvent& event)
 
 
 
 
 
 

-void wxFrameManager::UpdateButtonOnScreen(wxDockUIPart* button_ui_part,
+void wxAuiManager::UpdateButtonOnScreen(wxAuiDockUIPart* button_ui_part,

                                           const wxMouseEvent& event)
 {
                                           const wxMouseEvent& event)
 {

-    wxDockUIPart* hit_test = HitTest(event.GetX(), event.GetY());
+    wxAuiDockUIPart* hit_test = HitTest(event.GetX(), event.GetY());

 
     int state = wxAUI_BUTTON_STATE_NORMAL;
 
 
     int state = wxAUI_BUTTON_STATE_NORMAL;
 


@@ -3415,7 +3522,7 @@ void wxFrameManager::UpdateButtonOnScreen(wxDockUIPart* button_ui_part,
              else
             state = wxAUI_BUTTON_STATE_HOVER;
     }
              else
             state = wxAUI_BUTTON_STATE_HOVER;
     }

-    else
+     else

     {
         if (event.LeftDown())
             state = wxAUI_BUTTON_STATE_HOVER;
     {
         if (event.LeftDown())
             state = wxAUI_BUTTON_STATE_HOVER;


@@ -3430,27 +3537,30 @@ void wxFrameManager::UpdateButtonOnScreen(wxDockUIPart* button_ui_part,
     if (pt.x != 0 || pt.y != 0)
         cdc.SetDeviceOrigin(pt.x, pt.y);
 
     if (pt.x != 0 || pt.y != 0)
         cdc.SetDeviceOrigin(pt.x, pt.y);
 

-    m_art->DrawPaneButton(cdc, m_frame,
-              button_ui_part->button->button_id,
-              state,
-              button_ui_part->rect,
-              *hit_test->pane);
+    if (hit_test->pane)
+    {
+        m_art->DrawPaneButton(cdc, m_frame,
+                  button_ui_part->button->button_id,
+                  state,
+                  button_ui_part->rect,
+                  *hit_test->pane);
+    }

 }
 
 }
 

-void wxFrameManager::OnLeftDown(wxMouseEvent& event)
+void wxAuiManager::OnLeftDown(wxMouseEvent& event)

 {
 {

-    wxDockUIPart* part = HitTest(event.GetX(), event.GetY());
+    wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY());

     if (part)
     {
     if (part)
     {

-        if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER)
-            return;
-
-        if (part->type == wxDockUIPart::typeDockSizer ||
-            part->type == wxDockUIPart::typePaneSizer)
+        if (part->type == wxAuiDockUIPart::typeDockSizer ||
+            part->type == wxAuiDockUIPart::typePaneSizer)

         {
         {

+            if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER)
+                return;
+        

             // a dock may not be resized if it has a single
             // pane which is not resizable
             // a dock may not be resized if it has a single
             // pane which is not resizable

-            if (part->type == wxDockUIPart::typeDockSizer && part->dock &&
+            if (part->type == wxAuiDockUIPart::typeDockSizer && part->dock &&

                 part->dock->panes.GetCount() == 1 &&
                 part->dock->panes.Item(0)->IsFixed())
                     return;
                 part->dock->panes.GetCount() == 1 &&
                 part->dock->panes.Item(0)->IsFixed())
                     return;


@@ -3467,7 +3577,7 @@ void wxFrameManager::OnLeftDown(wxMouseEvent& event)
                                       event.m_y - part->rect.y);
             m_frame->CaptureMouse();
         }
                                       event.m_y - part->rect.y);
             m_frame->CaptureMouse();
         }

-         else if (part->type == wxDockUIPart::typePaneButton)
+         else if (part->type == wxAuiDockUIPart::typePaneButton)

         {
             m_action = actionClickButton;
             m_action_part = part;
         {
             m_action = actionClickButton;
             m_action_part = part;


@@ -3476,9 +3586,12 @@ void wxFrameManager::OnLeftDown(wxMouseEvent& event)
 
             UpdateButtonOnScreen(part, event);
         }
 
             UpdateButtonOnScreen(part, event);
         }

-         else if (part->type == wxDockUIPart::typeCaption ||
-                  part->type == wxDockUIPart::typeGripper)
+         else if (part->type == wxAuiDockUIPart::typeCaption ||
+                  part->type == wxAuiDockUIPart::typeGripper)

         {
         {

+            if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER)
+                return;
+

             if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
             {
                 // set the caption as active
             if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
             {
                 // set the caption as active


@@ -3511,7 +3624,7 @@ void wxFrameManager::OnLeftDown(wxMouseEvent& event)
 }
 
 
 }
 
 

-void wxFrameManager::OnLeftUp(wxMouseEvent& event)
+void wxAuiManager::OnLeftUp(wxMouseEvent& event)

 {
     if (m_action == actionResize)
     {
 {
     if (m_action == actionResize)
     {


@@ -3522,7 +3635,7 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
         DrawResizeHint(dc, m_action_hintrect);
 
         // resize the dock or the pane
         DrawResizeHint(dc, m_action_hintrect);
 
         // resize the dock or the pane

-        if (m_action_part && m_action_part->type==wxDockUIPart::typeDockSizer)
+        if (m_action_part && m_action_part->type==wxAuiDockUIPart::typeDockSizer)

         {
             wxRect& rect = m_action_part->dock->rect;
 
         {
             wxRect& rect = m_action_part->dock->rect;
 


@@ -3551,10 +3664,10 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
             Repaint(NULL);
         }
          else if (m_action_part &&
             Repaint(NULL);
         }
          else if (m_action_part &&

-                  m_action_part->type == wxDockUIPart::typePaneSizer)
+                  m_action_part->type == wxAuiDockUIPart::typePaneSizer)

         {
         {

-            wxDockInfo& dock = *m_action_part->dock;
-            wxPaneInfo& pane = *m_action_part->pane;
+            wxAuiDockInfo& dock = *m_action_part->dock;
+            wxAuiPaneInfo& pane = *m_action_part->pane;

 
             int total_proportion = 0;
             int dock_pixels = 0;
 
             int total_proportion = 0;
             int dock_pixels = 0;


@@ -3568,7 +3681,7 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
                             event.m_y - m_action_offset.y);
 
             // determine the pane rectangle by getting the pane part
                             event.m_y - m_action_offset.y);
 
             // determine the pane rectangle by getting the pane part

-            wxDockUIPart* pane_part = GetPanePart(pane.window);
+            wxAuiDockUIPart* pane_part = GetPanePart(pane.window);

             wxASSERT_MSG(pane_part,
                        wxT("Pane border part not found -- shouldn't happen"));
 
             wxASSERT_MSG(pane_part,
                        wxT("Pane border part not found -- shouldn't happen"));
 


@@ -3592,7 +3705,7 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
             int pane_position = -1;
             for (i = 0; i < dock_pane_count; ++i)
             {
             int pane_position = -1;
             for (i = 0; i < dock_pane_count; ++i)
             {

-                wxPaneInfo& p = *dock.panes.Item(i);
+                wxAuiPaneInfo& p = *dock.panes.Item(i);

                 if (p.window == pane.window)
                     pane_position = i;
 
                 if (p.window == pane.window)
                     pane_position = i;
 


@@ -3625,7 +3738,7 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
             int borrow_pane = -1;
             for (i = pane_position+1; i < dock_pane_count; ++i)
             {
             int borrow_pane = -1;
             for (i = pane_position+1; i < dock_pane_count; ++i)
             {

-                wxPaneInfo& p = *dock.panes.Item(i);
+                wxAuiPaneInfo& p = *dock.panes.Item(i);

                 if (!p.IsFixed())
                 {
                     borrow_pane = i;
                 if (!p.IsFixed())
                 {
                     borrow_pane = i;


@@ -3711,7 +3824,7 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
         if (m_action_part == HitTest(event.GetX(), event.GetY()))
         {
             // fire button-click event
         if (m_action_part == HitTest(event.GetX(), event.GetY()))
         {
             // fire button-click event

-            wxFrameManagerEvent e(wxEVT_AUI_PANEBUTTON);
+            wxAuiManagerEvent e(wxEVT_AUI_PANEBUTTON);

             e.SetPane(m_action_part->pane);
             e.SetButton(m_action_part->button->button_id);
             ProcessMgrEvent(e);
             e.SetPane(m_action_part->pane);
             e.SetButton(m_action_part->button->button_id);
             ProcessMgrEvent(e);


@@ -3729,16 +3842,16 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
     {
         m_frame->ReleaseMouse();
 
     {
         m_frame->ReleaseMouse();
 

-        wxPaneInfo& pane = GetPane(m_action_window);
+        wxAuiPaneInfo& pane = GetPane(m_action_window);

         wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
         // save the new positions
         wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
         // save the new positions

-        wxDockInfoPtrArray docks;
+        wxAuiDockInfoPtrArray docks;

         FindDocks(m_docks, pane.dock_direction,
                   pane.dock_layer, pane.dock_row, docks);
         if (docks.GetCount() == 1)
         {
         FindDocks(m_docks, pane.dock_direction,
                   pane.dock_layer, pane.dock_row, docks);
         if (docks.GetCount() == 1)
         {

-            wxDockInfo& dock = *docks.Item(0);
+            wxAuiDockInfo& dock = *docks.Item(0);

 
             wxArrayInt pane_positions, pane_sizes;
             GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
 
             wxArrayInt pane_positions, pane_sizes;
             GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);


@@ -3748,7 +3861,7 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
                 dock.panes.Item(i)->dock_pos = pane_positions[i];
         }
 
                 dock.panes.Item(i)->dock_pos = pane_positions[i];
         }
 

-        pane.state &= ~wxPaneInfo::actionPane;
+        pane.state &= ~wxAuiPaneInfo::actionPane;

         Update();
     }
     else
         Update();
     }
     else


@@ -3761,7 +3874,7 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
 }
 
 
 }
 
 

-void wxFrameManager::OnMotion(wxMouseEvent& event)
+void wxAuiManager::OnMotion(wxMouseEvent& event)

 {
     // sometimes when Update() is called from inside this method,
     // a spurious mouse move event is generated; this check will make
 {
     // sometimes when Update() is called from inside this method,
     // a spurious mouse move event is generated; this check will make


@@ -3803,7 +3916,7 @@ void wxFrameManager::OnMotion(wxMouseEvent& event)
         if (abs(event.m_x - m_action_start.x) > drag_x_threshold ||
             abs(event.m_y - m_action_start.y) > drag_y_threshold)
         {
         if (abs(event.m_x - m_action_start.x) > drag_x_threshold ||
             abs(event.m_y - m_action_start.y) > drag_y_threshold)
         {

-            wxPaneInfo* pane_info = m_action_part->pane;
+            wxAuiPaneInfo* pane_info = m_action_part->pane;

 
             if (!pane_info->IsToolbar())
             {
 
             if (!pane_info->IsToolbar())
             {


@@ -3816,7 +3929,11 @@ void wxFrameManager::OnMotion(wxMouseEvent& event)
                     wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
                     pane_info->floating_pos = wxPoint(pt.x - m_action_offset.x,
                                                       pt.y - m_action_offset.y);
                     wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
                     pane_info->floating_pos = wxPoint(pt.x - m_action_offset.x,
                                                       pt.y - m_action_offset.y);

+

                     // float the window
                     // float the window

+                    if(pane_info->IsMaximized()) {
+                        RestorePane(*pane_info);
+                    }

                     pane_info->Float();
                     Update();
 
                     pane_info->Float();
                     Update();
 


@@ -3841,16 +3958,18 @@ void wxFrameManager::OnMotion(wxMouseEvent& event)
     }
     else if (m_action == actionDragFloatingPane)
     {
     }
     else if (m_action == actionDragFloatingPane)
     {

-        wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
-        m_action_window->Move(pt.x - m_action_offset.x,
-                             pt.y - m_action_offset.y);
+        if(m_action_window) {
+            wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
+            m_action_window->Move(pt.x - m_action_offset.x,
+                                pt.y - m_action_offset.y);
+        }

     }
     else if (m_action == actionDragToolbarPane)
     {
     }
     else if (m_action == actionDragToolbarPane)
     {

-        wxPaneInfo& pane = GetPane(m_action_window);
+        wxAuiPaneInfo& pane = GetPane(m_action_window);

         wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
         wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 

-        pane.state |= wxPaneInfo::actionPane;
+        pane.state |= wxAuiPaneInfo::actionPane;

 
         wxPoint pt = event.GetPosition();
         DoDrop(m_docks, m_panes, pane, pt, m_action_offset);
 
         wxPoint pt = event.GetPosition();
         DoDrop(m_docks, m_panes, pane, pt, m_action_offset);


@@ -3875,26 +3994,30 @@ void wxFrameManager::OnMotion(wxMouseEvent& event)
         // EVT_MOTION() events will move the floating pane
         if (pane.IsFloating())
         {
         // EVT_MOTION() events will move the floating pane
         if (pane.IsFloating())
         {

-            pane.state &= ~wxPaneInfo::actionPane;
+            pane.state &= ~wxAuiPaneInfo::actionPane;

             m_action = actionDragFloatingPane;
             m_action_window = pane.frame;
         }
     }
     else
     {
             m_action = actionDragFloatingPane;
             m_action_window = pane.frame;
         }
     }
     else
     {

-        wxDockUIPart* part = HitTest(event.GetX(), event.GetY());
-        if (part && part->type == wxDockUIPart::typePaneButton)
+        wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY());
+        if (part && part->type == wxAuiDockUIPart::typePaneButton)

         {
             if (part != m_hover_button)
             {
                 // make the old button normal
                 if (m_hover_button)
         {
             if (part != m_hover_button)
             {
                 // make the old button normal
                 if (m_hover_button)

+                {

                     UpdateButtonOnScreen(m_hover_button, event);
                     UpdateButtonOnScreen(m_hover_button, event);

-
+                    Repaint();
+                }
+                

                 // mouse is over a button, so repaint the
                 // button in hover mode
                 UpdateButtonOnScreen(part, event);
                 m_hover_button = part;
                 // mouse is over a button, so repaint the
                 // button in hover mode
                 UpdateButtonOnScreen(part, event);
                 m_hover_button = part;

+                

             }
         }
          else
             }
         }
          else


@@ -3912,7 +4035,7 @@ void wxFrameManager::OnMotion(wxMouseEvent& event)
     }
 }
 
     }
 }
 

-void wxFrameManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
+void wxAuiManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))

 {
     if (m_hover_button)
     {
 {
     if (m_hover_button)
     {


@@ -3921,7 +4044,7 @@ void wxFrameManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
     }
 }
 
     }
 }
 

-void wxFrameManager::OnChildFocus(wxChildFocusEvent& event)
+void wxAuiManager::OnChildFocus(wxChildFocusEvent& event)

 {
     // when a child pane has it's focus set, we should change the
     // pane's active state to reflect this. (this is only true if
 {
     // when a child pane has it's focus set, we should change the
     // pane's active state to reflect this. (this is only true if


@@ -3941,16 +4064,16 @@ void wxFrameManager::OnChildFocus(wxChildFocusEvent& event)
 
 // OnPaneButton() is an event handler that is called
 // when a pane button has been pressed.
 
 // OnPaneButton() is an event handler that is called
 // when a pane button has been pressed.

-void wxFrameManager::OnPaneButton(wxFrameManagerEvent& evt)
+void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt)

 {
 {

-    wxASSERT_MSG(evt.pane, wxT("Pane Info passed to wxFrameManager::OnPaneButton must be non-null"));
+    wxASSERT_MSG(evt.pane, wxT("Pane Info passed to wxAuiManager::OnPaneButton must be non-null"));

 
 

-    wxPaneInfo& pane = *(evt.pane);
+    wxAuiPaneInfo& pane = *(evt.pane);

 
     if (evt.button == wxAUI_BUTTON_CLOSE)
     {
         // fire pane close event
 
     if (evt.button == wxAUI_BUTTON_CLOSE)
     {
         // fire pane close event

-        wxFrameManagerEvent e(wxEVT_AUI_PANECLOSE);
+        wxAuiManagerEvent e(wxEVT_AUI_PANECLOSE);

         e.SetPane(evt.pane);
         ProcessMgrEvent(e);
 
         e.SetPane(evt.pane);
         ProcessMgrEvent(e);
 


@@ -3960,7 +4083,33 @@ void wxFrameManager::OnPaneButton(wxFrameManagerEvent& evt)
             Update();
         }
     }
             Update();
         }
     }

-     else if (evt.button == wxPaneInfo::buttonPin)
+    else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && !pane.IsMaximized())
+    {
+        // fire pane close event
+        wxAuiManagerEvent e(wxEVT_AUI_PANEMAXIMIZE);
+        e.SetPane(evt.pane);
+        ProcessMgrEvent(e);
+
+        if (!e.GetVeto())
+        {
+            MaximizePane(pane);
+            Update();
+        }
+    }
+    else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && pane.IsMaximized())
+    {
+        // fire pane close event
+        wxAuiManagerEvent e(wxEVT_AUI_PANERESTORE);
+        e.SetPane(evt.pane);
+        ProcessMgrEvent(e);
+
+        if (!e.GetVeto())
+        {
+            RestorePane(pane);
+            Update();
+        }
+    }
+     else if (evt.button == wxAUI_BUTTON_PIN)

     {
         if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
             pane.IsFloatable())
     {
         if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
             pane.IsFloatable())