enter wxPendingEventLocker critical section in ProcessPendingEvents() (fixes 1720352)

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

diff --git a/src/aui/framemanager.cpp b/src/aui/framemanager.cpp
index dbeeb975e9b71ac80abdf6708732e62760a121fd..fb40bea51d32a989046785758f630fc870346c67 100644 (file)
--- a/src/aui/framemanager.cpp
+++ b/src/aui/framemanager.cpp
@@ -52,11 +52,12 @@ WX_DEFINE_OBJARRAY(wxAuiPaneInfoArray)
 
 wxAuiPaneInfo wxAuiNullPaneInfo;
 wxAuiDockInfo wxAuiNullDockInfo;
 
 wxAuiPaneInfo wxAuiNullPaneInfo;
 wxAuiDockInfo wxAuiNullDockInfo;

-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_PANE_BUTTON)
+DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_CLOSE)
+DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_MAXIMIZE)
+DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_RESTORE)

 DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER)
 DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER)

+DEFINE_EVENT_TYPE(wxEVT_AUI_FIND_MANAGER)

 
 #ifdef __WXMAC__
     // a few defines to avoid nameclashes
 
 #ifdef __WXMAC__
     // a few defines to avoid nameclashes


@@ -66,6 +67,12 @@ DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER)
 #endif
 
 IMPLEMENT_DYNAMIC_CLASS(wxAuiManagerEvent, wxEvent)
 #endif
 
 IMPLEMENT_DYNAMIC_CLASS(wxAuiManagerEvent, wxEvent)

+IMPLEMENT_CLASS(wxAuiManager, wxEvtHandler)
+
+
+
+const int auiToolBarLayer = 10;
+

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


@@ -248,7 +255,8 @@ static void CopyDocksAndPanes(wxAuiDockInfoArray& 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 wxAuiDockInfoArray& 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)


@@ -464,7 +472,7 @@ static int PaneSortFunc(wxAuiPaneInfo** p1, wxAuiPaneInfo** p2)
 
 
 BEGIN_EVENT_TABLE(wxAuiManager, wxEvtHandler)
 
 
 BEGIN_EVENT_TABLE(wxAuiManager, wxEvtHandler)

-    EVT_AUI_PANEBUTTON(wxAuiManager::OnPaneButton)
+    EVT_AUI_PANE_BUTTON(wxAuiManager::OnPaneButton)

     EVT_AUI_RENDER(wxAuiManager::OnRender)
     EVT_PAINT(wxAuiManager::OnPaint)
     EVT_ERASE_BACKGROUND(wxAuiManager::OnEraseBackground)
     EVT_AUI_RENDER(wxAuiManager::OnRender)
     EVT_PAINT(wxAuiManager::OnPaint)
     EVT_ERASE_BACKGROUND(wxAuiManager::OnEraseBackground)


@@ -475,6 +483,7 @@ BEGIN_EVENT_TABLE(wxAuiManager, wxEvtHandler)
     EVT_MOTION(wxAuiManager::OnMotion)
     EVT_LEAVE_WINDOW(wxAuiManager::OnLeaveWindow)
     EVT_CHILD_FOCUS(wxAuiManager::OnChildFocus)
     EVT_MOTION(wxAuiManager::OnMotion)
     EVT_LEAVE_WINDOW(wxAuiManager::OnLeaveWindow)
     EVT_CHILD_FOCUS(wxAuiManager::OnChildFocus)

+    EVT_AUI_FIND_MANAGER(wxAuiManager::OnFindManager)

     EVT_TIMER(101, wxAuiManager::OnHintFadeTimer)
 END_EVENT_TABLE()
 
     EVT_TIMER(101, wxAuiManager::OnHintFadeTimer)
 END_EVENT_TABLE()
 


@@ -490,7 +499,10 @@ wxAuiManager::wxAuiManager(wxWindow* managed_wnd, unsigned int flags)
     m_skipping = false;
     m_has_maximized = false;
     m_frame = NULL;
     m_skipping = false;
     m_has_maximized = false;
     m_frame = NULL;

-    
+    m_dock_constraint_x = 0.3;
+    m_dock_constraint_y = 0.3;
+    m_reserved = NULL;
+

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


@@ -499,13 +511,21 @@ wxAuiManager::wxAuiManager(wxWindow* managed_wnd, unsigned int flags)
 
 wxAuiManager::~wxAuiManager()
 {
 
 wxAuiManager::~wxAuiManager()
 {

+    for ( size_t i = 0; i < m_panes.size(); i++ )
+    {
+        wxAuiPaneInfo& pinfo = m_panes[i];
+        if (pinfo.window && !pinfo.window->GetParent())
+            delete pinfo.window;
+    }
+

     delete m_art;
 }
 
     delete m_art;
 }
 

-// Creates a floating frame for the windows
-wxAuiFloatingFrame * wxAuiManager::CreateFloatingFrame(wxWindow* parent, const wxAuiPaneInfo& p)
+// creates a floating frame for the windows
+wxAuiFloatingFrame* wxAuiManager::CreateFloatingFrame(wxWindow* parent,
+                                                      const wxAuiPaneInfo& pane_info)

 {
 {

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

 }
 
 // GetPane() looks up a wxAuiPaneInfo structure based
 }
 
 // GetPane() looks up a wxAuiPaneInfo structure based


@@ -599,7 +619,7 @@ void wxAuiManager::SetFlags(unsigned int flags)
 
     // set the new flags
     m_flags = flags;
 
     // set the new flags
     m_flags = flags;

-    
+

     if (update_hint_wnd)
     {
         UpdateHintWindowConfig();
     if (update_hint_wnd)
     {
         UpdateHintWindowConfig();


@@ -625,26 +645,41 @@ wxFrame* wxAuiManager::GetFrame() const
 }
 
 
 }
 
 

+// this function will return the aui manager for a given
+// window.  The |window| parameter should be any child window
+// or grand-child window (and so on) of the frame/window
+// managed by wxAuiManager.  The |window| parameter does not
+// need to be managed by the manager itself.
+wxAuiManager* wxAuiManager::GetManager(wxWindow* window)
+{
+    wxAuiManagerEvent evt(wxEVT_AUI_FIND_MANAGER);
+    evt.SetManager(NULL);
+    evt.ResumePropagation(wxEVENT_PROPAGATE_MAX);
+    if (!window->ProcessEvent(evt))
+        return NULL;
+
+    return evt.GetManager();
+}
+
+

 void wxAuiManager::UpdateHintWindowConfig()
 {
     // find out if the the system can do transparent frames
     bool can_do_transparent = false;
 void wxAuiManager::UpdateHintWindowConfig()
 {
     // find out if the the system can do transparent frames
     bool can_do_transparent = false;

-    
+

     wxWindow* w = m_frame;
     while (w)
     {
         if (w->IsKindOf(CLASSINFO(wxFrame)))
         {
             wxFrame* f = static_cast<wxFrame*>(w);
     wxWindow* w = m_frame;
     while (w)
     {
         if (w->IsKindOf(CLASSINFO(wxFrame)))
         {
             wxFrame* f = static_cast<wxFrame*>(w);

-            #if wxCHECK_VERSION(2,7,0)

             can_do_transparent = f->CanSetTransparent();
             can_do_transparent = f->CanSetTransparent();

-            #endif

             break;
         }
             break;
         }

-        
+

         w = w->GetParent();
     }
         w = w->GetParent();
     }

-    
+

     // if there is an existing hint window, delete it
     if (m_hint_wnd)
     {
     // if there is an existing hint window, delete it
     if (m_hint_wnd)
     {


@@ -654,9 +689,9 @@ void wxAuiManager::UpdateHintWindowConfig()
 
     m_hint_fademax = 50;
     m_hint_wnd = NULL;
 
     m_hint_fademax = 50;
     m_hint_wnd = NULL;

-    
+

     if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) && can_do_transparent)
     if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) && can_do_transparent)

-    { 
+    {

         // Make a window to use for a transparent hint
         #if defined(__WXMSW__) || defined(__WXGTK__)
             m_hint_wnd = new wxFrame(m_frame, wxID_ANY, wxEmptyString,
         // Make a window to use for a transparent hint
         #if defined(__WXMSW__) || defined(__WXGTK__)
             m_hint_wnd = new wxFrame(m_frame, wxID_ANY, wxEmptyString,


@@ -684,9 +719,9 @@ void wxAuiManager::UpdateHintWindowConfig()
             // blue.
             p->SetBackgroundColour(*wxBLUE);
         #endif
             // blue.
             p->SetBackgroundColour(*wxBLUE);
         #endif

-        
+

     }
     }

-     else
+    else

     {
         if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0 ||
             (m_flags & wxAUI_MGR_VENETIAN_BLINDS_HINT) != 0)
     {
         if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0 ||
             (m_flags & wxAUI_MGR_VENETIAN_BLINDS_HINT) != 0)


@@ -795,12 +830,21 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)
     if (!window)
         return false;
 
     if (!window)
         return false;
 

-    // check if the pane already exists
+    // check if the window is already managed by us

     if (GetPane(pane_info.window).IsOk())
         return false;
 
     if (GetPane(pane_info.window).IsOk())
         return false;
 

+    // check if the pane name already exists, this could reveal a
+    // bug in the library user's application
+    bool already_exists = false;
+    if (!pane_info.name.empty() && GetPane(pane_info.name).IsOk())
+    {
+        wxFAIL_MSG(wxT("A pane with that name already exists in the manager!"));
+        already_exists = true;
+    }
+

     // if the new pane is docked then we should undo maximize
     // if the new pane is docked then we should undo maximize

-    if(pane_info.IsDocked())
+    if (pane_info.IsDocked())

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


@@ -810,8 +854,9 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)
     // set the pane window
     pinfo.window = window;
 
     // set the pane window
     pinfo.window = window;
 

+

     // if the pane's name identifier is blank, create a random string
     // if the pane's name identifier is blank, create a random string

-    if (pinfo.name.empty())
+    if (pinfo.name.empty() || already_exists)

     {
         pinfo.name.Printf(wxT("%08lx%08x%08x%08lx"),
              ((unsigned long)pinfo.window) & 0xffffffff,
     {
         pinfo.name.Printf(wxT("%08lx%08x%08x%08lx"),
              ((unsigned long)pinfo.window) & 0xffffffff,


@@ -835,6 +880,13 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)
         pinfo.buttons.Add(button);
     }
 
         pinfo.buttons.Add(button);
     }
 

+    if (pinfo.HasPinButton())
+    {
+        wxAuiPaneButton button;
+        button.button_id = wxAUI_BUTTON_PIN;
+        pinfo.buttons.Add(button);
+    }
+

     if (pinfo.HasCloseButton())
     {
         wxAuiPaneButton button;
     if (pinfo.HasCloseButton())
     {
         wxAuiPaneButton button;


@@ -875,8 +927,8 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)
 }
 
 bool wxAuiManager::AddPane(wxWindow* window,
 }
 
 bool wxAuiManager::AddPane(wxWindow* window,

-                             int direction,
-                             const wxString& caption)
+                           int direction,
+                           const wxString& caption)

 {
     wxAuiPaneInfo pinfo;
     pinfo.Caption(caption);
 {
     wxAuiPaneInfo pinfo;
     pinfo.Caption(caption);


@@ -892,8 +944,8 @@ bool wxAuiManager::AddPane(wxWindow* window,
 }
 
 bool wxAuiManager::AddPane(wxWindow* window,
 }
 
 bool wxAuiManager::AddPane(wxWindow* window,

-                             const wxAuiPaneInfo& pane_info,
-                             const wxPoint& drop_pos)
+                           const wxAuiPaneInfo& pane_info,
+                           const wxPoint& drop_pos)

 {
     if (!AddPane(window, pane_info))
         return false;
 {
     if (!AddPane(window, pane_info))
         return false;


@@ -938,7 +990,7 @@ bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info,
     {
         return AddPane(window, pane_info);
     }
     {
         return AddPane(window, pane_info);
     }

-     else
+    else

     {
         if (pane_info.IsFloating())
         {
     {
         if (pane_info.IsFloating())
         {


@@ -948,7 +1000,7 @@ bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info,
             if (pane_info.floating_size != wxDefaultSize)
                 existing_pane.FloatingSize(pane_info.floating_size);
         }
             if (pane_info.floating_size != wxDefaultSize)
                 existing_pane.FloatingSize(pane_info.floating_size);
         }

-         else
+        else

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


@@ -986,9 +1038,11 @@ bool wxAuiManager::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) {
+                if (m_action_window == p.frame)
+                {

                     m_action_window = NULL;
                 }
                     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();


@@ -1024,36 +1078,41 @@ bool wxAuiManager::DetachPane(wxWindow* window)
 void wxAuiManager::ClosePane(wxAuiPaneInfo& pane_info)
 {
     // if we were maximized, restore
 void wxAuiManager::ClosePane(wxAuiPaneInfo& pane_info)
 {
     // if we were maximized, restore

-    if(pane_info.IsMaximized()) {
+    if (pane_info.IsMaximized())
+    {

         RestorePane(pane_info);
     }
 
     // first, hide the window
         RestorePane(pane_info);
     }
 
     // first, hide the window

-    if (pane_info.window && pane_info.window->IsShown()) {
+    if (pane_info.window && pane_info.window->IsShown())
+    {

         pane_info.window->Show(false);
     }
 
     // make sure that we are the parent of this window
         pane_info.window->Show(false);
     }
 
     // make sure that we are the parent of this window

-    if(pane_info.window && pane_info.window->GetParent() != m_frame) {
+    if (pane_info.window && pane_info.window->GetParent() != m_frame)
+    {

         pane_info.window->Reparent(m_frame);
     }
 
     // if we have a frame, destroy it
         pane_info.window->Reparent(m_frame);
     }
 
     // if we have a frame, destroy it

-    if(pane_info.frame) {
+    if (pane_info.frame)
+    {

         pane_info.frame->Destroy();
         pane_info.frame = NULL;
     }
 
     // now we need to either destroy or hide the pane
         pane_info.frame->Destroy();
         pane_info.frame = NULL;
     }
 
     // now we need to either destroy or hide the pane

-    if(pane_info.IsDestroyOnClose()) 
+    if (pane_info.IsDestroyOnClose())

     {
         wxWindow * window = pane_info.window;
         DetachPane(window);
     {
         wxWindow * window = pane_info.window;
         DetachPane(window);

-        if(window) {
+        if (window)
+        {

             window->Destroy();
         }
             window->Destroy();
         }

-    } 
-    else 
+    }
+    else

     {
         pane_info.Hide();
     }
     {
         pane_info.Hide();
     }


@@ -1067,9 +1126,16 @@ void wxAuiManager::MaximizePane(wxAuiPaneInfo& pane_info)
     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
     {
         wxAuiPaneInfo& p = m_panes.Item(i);
     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
     {
         wxAuiPaneInfo& p = m_panes.Item(i);

-        if(!p.IsToolbar()) {
+        if (!p.IsToolbar())
+        {

             p.Restore();
             p.Restore();

-            p.SaveHidden();
+
+            // save hidden state
+            p.SetFlag(wxAuiPaneInfo::savedHiddenState,
+                      p.HasFlag(wxAuiPaneInfo::optionHidden));
+
+            // hide the pane, because only the newly
+            // maximized pane should show

             p.Hide();
         }
     }
             p.Hide();
         }
     }


@@ -1080,7 +1146,8 @@ void wxAuiManager::MaximizePane(wxAuiPaneInfo& pane_info)
     m_has_maximized = true;
 
     // last, show the window
     m_has_maximized = true;
 
     // last, show the window

-    if (pane_info.window && !pane_info.window->IsShown()) {
+    if (pane_info.window && !pane_info.window->IsShown())
+    {

         pane_info.window->Show(true);
     }
 }
         pane_info.window->Show(true);
     }
 }


@@ -1093,8 +1160,10 @@ void wxAuiManager::RestorePane(wxAuiPaneInfo& pane_info)
     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
     {
         wxAuiPaneInfo& p = m_panes.Item(i);
     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
     {
         wxAuiPaneInfo& p = m_panes.Item(i);

-        if(!p.IsToolbar()) {
-            p.RestoreHidden();
+        if (!p.IsToolbar())
+        {
+            p.SetFlag(wxAuiPaneInfo::optionHidden,
+                      p.HasFlag(wxAuiPaneInfo::savedHiddenState));

         }
     }
 
         }
     }
 


@@ -1103,7 +1172,8 @@ void wxAuiManager::RestorePane(wxAuiPaneInfo& pane_info)
     m_has_maximized = false;
 
     // last, show the window
     m_has_maximized = false;
 
     // last, show the window

-    if (pane_info.window && !pane_info.window->IsShown()) {
+    if (pane_info.window && !pane_info.window->IsShown())
+    {

         pane_info.window->Show(true);
     }
 }
         pane_info.window->Show(true);
     }
 }


@@ -1116,7 +1186,8 @@ void wxAuiManager::RestoreMaximizedPane()
     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
     {
         wxAuiPaneInfo& p = m_panes.Item(i);
     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
     {
         wxAuiPaneInfo& p = m_panes.Item(i);

-        if(p.IsMaximized()) {
+        if (p.IsMaximized())
+        {

             RestorePane(p);
             break;
         }
             RestorePane(p);
             break;
         }


@@ -1257,7 +1328,7 @@ wxString wxAuiManager::SavePerspective()
 {
     wxString result;
     result.Alloc(500);
 {
     wxString result;
     result.Alloc(500);

-    result = wxT("layout1|");
+    result = wxT("layout2|");

 
     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)


@@ -1288,11 +1359,13 @@ bool wxAuiManager::LoadPerspective(const wxString& layout, bool update)
     wxString part;
 
     // check layout string version
     wxString part;
 
     // check layout string version

+    //    'layout1' = wxAUI 0.9.0 - wxAUI 0.9.2
+    //    'layout2' = wxAUI 0.9.2 (wxWidgets 2.8)

     part = input.BeforeFirst(wxT('|'));
     input = input.AfterFirst(wxT('|'));
     part.Trim(true);
     part.Trim(false);
     part = input.BeforeFirst(wxT('|'));
     input = input.AfterFirst(wxT('|'));
     part.Trim(true);
     part.Trim(false);

-    if (part != wxT("layout1"))
+    if (part != wxT("layout2"))

         return false;
 
     // mark all panes currently managed as docked and hidden
         return false;
 
     // mark all panes currently managed as docked and hidden


@@ -1369,12 +1442,12 @@ bool wxAuiManager::LoadPerspective(const wxString& layout, bool update)
 }
 
 void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
 }
 
 void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,

-                                              wxArrayInt& positions,
-                                              wxArrayInt& sizes)
+                                            wxArrayInt& positions,
+                                            wxArrayInt& sizes)

 {
 {

-    int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);
-    int pane_border_size = m_art->GetMetric(wxAUI_ART_PANE_BORDER_SIZE);
-    int gripper_size = m_art->GetMetric(wxAUI_ART_GRIPPER_SIZE);
+    int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
+    int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
+    int gripper_size = m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);

 
     positions.Empty();
     sizes.Empty();
 
     positions.Empty();
     sizes.Empty();


@@ -1412,7 +1485,7 @@ void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
                 size += gripper_size;
             size += pane.best_size.x;
         }
                 size += gripper_size;
             size += pane.best_size.x;
         }

-         else
+        else

         {
             if (pane.HasGripper() && pane.HasGripperTop())
                 size += gripper_size;
         {
             if (pane.HasGripper() && pane.HasGripperTop())
                 size += gripper_size;


@@ -1437,7 +1510,7 @@ void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
 
         if (amount >= 0)
             offset += amount;
 
         if (amount >= 0)
             offset += amount;

-             else
+        else

             positions[pane_i] -= -amount;
 
         offset += sizes[pane_i];
             positions[pane_i] -= -amount;
 
         offset += sizes[pane_i];


@@ -1451,7 +1524,7 @@ void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
         int amount = positions[pane_i] - offset;
         if (amount >= 0)
             offset += amount;
         int amount = positions[pane_i] - offset;
         if (amount >= 0)
             offset += amount;

-             else
+        else

             positions[pane_i] += -amount;
 
         offset += sizes[pane_i];
             positions[pane_i] += -amount;
 
         offset += sizes[pane_i];


@@ -1460,25 +1533,25 @@ void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
 
 
 void wxAuiManager::LayoutAddPane(wxSizer* cont,
 
 
 void wxAuiManager::LayoutAddPane(wxSizer* cont,

-                                   wxAuiDockInfo& dock,
-                                   wxAuiPaneInfo& pane,
-                                   wxAuiDockUIPartArray& uiparts,
-                                   bool spacer_only)
+                                 wxAuiDockInfo& dock,
+                                 wxAuiPaneInfo& pane,
+                                 wxAuiDockUIPartArray& uiparts,
+                                 bool spacer_only)

 {
     wxAuiDockUIPart part;
     wxSizerItem* sizer_item;
 
 {
     wxAuiDockUIPart part;
     wxSizerItem* sizer_item;
 

-    int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);
-    int gripper_size = m_art->GetMetric(wxAUI_ART_GRIPPER_SIZE);
-    int pane_border_size = m_art->GetMetric(wxAUI_ART_PANE_BORDER_SIZE);
-    int pane_button_size = m_art->GetMetric(wxAUI_ART_PANE_BUTTON_SIZE);
+    int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
+    int gripper_size = m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
+    int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
+    int pane_button_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BUTTON_SIZE);

 
     // find out the orientation of the item (orientation for panes
     // is the same as the dock's orientation)
     int orientation;
     if (dock.IsHorizontal())
         orientation = wxHORIZONTAL;
 
     // find out the orientation of the item (orientation for panes
     // is the same as the dock's orientation)
     int orientation;
     if (dock.IsHorizontal())
         orientation = wxHORIZONTAL;

-         else
+    else

         orientation = wxVERTICAL;
 
     // this variable will store the proportion
         orientation = wxVERTICAL;
 
     // this variable will store the proportion


@@ -1543,6 +1616,13 @@ void wxAuiManager::LayoutAddPane(wxSizer* cont,
             uiparts.Add(part);
         }
 
             uiparts.Add(part);
         }
 

+        // if we have buttons, add a little space to the right
+        // of them to ease visual crowding
+        if (button_count >= 1)
+        {
+            caption_sizer->Add(3,1);
+        }
+

         // add the caption sizer
         sizer_item = vert_pane_sizer->Add(caption_sizer, 0, wxEXPAND);
 
         // add the caption sizer
         sizer_item = vert_pane_sizer->Add(caption_sizer, 0, wxEXPAND);
 


@@ -1574,7 +1654,7 @@ void wxAuiManager::LayoutAddPane(wxSizer* cont,
 
 
     // determine if the pane should have a minimum size; if the pane is
 
 
     // determine if the pane should have a minimum size; if the pane is

-    // non-resizable (fixed) then we must set a minimum size. Alternitavely,
+    // non-resizable (fixed) then we must set a minimum size. Alternatively,

     // if the pane.min_size is set, we must use that value as well
 
     wxSize min_size = pane.min_size;
     // if the pane.min_size is set, we must use that value as well
 
     wxSize min_size = pane.min_size;


@@ -1623,14 +1703,14 @@ void wxAuiManager::LayoutAddPane(wxSizer* cont,
 }
 
 void wxAuiManager::LayoutAddDock(wxSizer* cont,
 }
 
 void wxAuiManager::LayoutAddDock(wxSizer* cont,

-                                   wxAuiDockInfo& dock,
-                                   wxAuiDockUIPartArray& uiparts,
-                                   bool spacer_only)
+                                 wxAuiDockInfo& dock,
+                                 wxAuiDockUIPartArray& uiparts,
+                                 bool spacer_only)

 {
     wxSizerItem* sizer_item;
     wxAuiDockUIPart part;
 
 {
     wxSizerItem* sizer_item;
     wxAuiDockUIPart part;
 

-    int sash_size = m_art->GetMetric(wxAUI_ART_SASH_SIZE);
+    int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE);

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


@@ -1669,16 +1749,17 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
         {
             wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
             int pane_pos = pane_positions.Item(pane_i);
         {
             wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
             int pane_pos = pane_positions.Item(pane_i);

-            if(pane.IsMaximized()) {
+
+            if (pane.IsMaximized())

                 has_maximized_pane = true;
                 has_maximized_pane = true;

-            }
+

 
             int amount = pane_pos - offset;
             if (amount > 0)
             {
                 if (dock.IsVertical())
                     sizer_item = dock_sizer->Add(1, amount, 0, wxEXPAND);
 
             int amount = pane_pos - offset;
             if (amount > 0)
             {
                 if (dock.IsVertical())
                     sizer_item = dock_sizer->Add(1, amount, 0, wxEXPAND);

-                     else
+                else

                     sizer_item = dock_sizer->Add(amount, 1, 0, wxEXPAND);
 
                 part.type = wxAuiDockUIPart::typeBackground;
                     sizer_item = dock_sizer->Add(amount, 1, 0, wxEXPAND);
 
                 part.type = wxAuiDockUIPart::typeBackground;


@@ -1699,7 +1780,7 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
         }
 
         // at the end add a very small stretchable background area
         }
 
         // at the end add a very small stretchable background area

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

 
         part.type = wxAuiDockUIPart::typeBackground;
         part.dock = &dock;
 
         part.type = wxAuiDockUIPart::typeBackground;
         part.dock = &dock;


@@ -1715,9 +1796,9 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
         for (pane_i = 0; pane_i < pane_count; ++pane_i)
         {
             wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
         for (pane_i = 0; pane_i < pane_count; ++pane_i)
         {
             wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));

-            if(pane.IsMaximized()) {
+
+            if (pane.IsMaximized())

                 has_maximized_pane = true;
                 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


@@ -1741,7 +1822,7 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
 
     if (dock.dock_direction == wxAUI_DOCK_CENTER || has_maximized_pane)
         sizer_item = cont->Add(dock_sizer, 1, wxEXPAND);
 
     if (dock.dock_direction == wxAUI_DOCK_CENTER || has_maximized_pane)
         sizer_item = cont->Add(dock_sizer, 1, wxEXPAND);

-         else
+    else

         sizer_item = cont->Add(dock_sizer, 0, wxEXPAND);
 
     part.type = wxAuiDockUIPart::typeDock;
         sizer_item = cont->Add(dock_sizer, 0, wxEXPAND);
 
     part.type = wxAuiDockUIPart::typeDock;


@@ -1755,12 +1836,14 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
 
     if (dock.IsHorizontal())
         cont->SetItemMinSize(dock_sizer, 0, dock.size);
 
     if (dock.IsHorizontal())
         cont->SetItemMinSize(dock_sizer, 0, dock.size);

-         else
+    else

         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 (!m_has_maximized && !dock.fixed && (dock.dock_direction == wxAUI_DOCK_TOP ||
-                        dock.dock_direction == wxAUI_DOCK_LEFT))
+    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);
 
     {
         sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND);
 


@@ -1776,21 +1859,33 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
 }
 
 wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
 }
 
 wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,

-                                   wxAuiDockInfoArray& docks,
-                                   wxAuiDockUIPartArray& uiparts,
-                                   bool spacer_only)
+                                 wxAuiDockInfoArray& docks,
+                                 wxAuiDockUIPartArray& uiparts,
+                                 bool spacer_only)

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

-    int pane_border_size = m_art->GetMetric(wxAUI_ART_PANE_BORDER_SIZE);
-    int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);
+    int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
+    int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);

     wxSize cli_size = m_frame->GetClientSize();
     int i, dock_count, pane_count;
 
 
     // empty all docks out
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     wxSize cli_size = m_frame->GetClientSize();
     int i, dock_count, pane_count;
 
 
     // empty all docks out
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)

-        docks.Item(i).panes.Empty();
+    {
+        wxAuiDockInfo& dock = docks.Item(i);
+
+        // empty out all panes, as they will be readded below
+        dock.panes.Empty();
+
+        if (dock.fixed)
+        {
+            // always reset fixed docks' sizes, because
+            // the contained windows may have been resized
+            dock.size = 0;
+        }
+    }

 
 
     // iterate through all known panes, filing each
 
 
     // iterate through all known panes, filing each


@@ -1800,16 +1895,18 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
     {
         wxAuiPaneInfo& p = panes.Item(i);
 
     {
         wxAuiPaneInfo& p = panes.Item(i);
 

-        // find any docks in this layer
+        // find any docks with the same dock direction, dock layer, and
+        // dock row as the pane we are working on

         wxAuiDockInfo* dock;
         wxAuiDockInfoPtrArray arr;
         FindDocks(docks, p.dock_direction, p.dock_layer, p.dock_row, arr);
 
         if (arr.GetCount() > 0)
         {
         wxAuiDockInfo* dock;
         wxAuiDockInfoPtrArray arr;
         FindDocks(docks, p.dock_direction, p.dock_layer, p.dock_row, arr);
 
         if (arr.GetCount() > 0)
         {

+            // found the right dock

             dock = arr.Item(0);
         }
             dock = arr.Item(0);
         }

-         else
+        else

         {
             // dock was not found, so we need to create a new one
             wxAuiDockInfo d;
         {
             // dock was not found, so we need to create a new one
             wxAuiDockInfo d;


@@ -1831,7 +1928,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
             if (!FindPaneInDock(*dock, p.window))
                 dock->panes.Add(&p);
         }
             if (!FindPaneInDock(*dock, p.window))
                 dock->panes.Add(&p);
         }

-         else
+        else

         {
             // remove the pane from any existing docks
             RemovePaneFromDocks(docks, p);
         {
             // remove the pane from any existing docks
             RemovePaneFromDocks(docks, p);


@@ -1872,7 +1969,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
 
                 if (dock.IsHorizontal())
                     size = wxMax(pane_size.y, size);
 
                 if (dock.IsHorizontal())
                     size = wxMax(pane_size.y, size);

-                     else
+                else

                     size = wxMax(pane_size.x, size);
             }
 
                     size = wxMax(pane_size.x, size);
             }
 


@@ -1901,14 +1998,22 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
                 }
             }
 
                 }
             }
 

-            // new dock's size may not be more than 1/3 of the frame size
+
+            // new dock's size may not be more than the dock constraint
+            // parameter specifies.  See SetDockSizeConstraint()
+
+            int max_dock_x_size = (int)(m_dock_constraint_x * ((double)cli_size.x));
+            int max_dock_y_size = (int)(m_dock_constraint_y * ((double)cli_size.y));
+

             if (dock.IsHorizontal())
             if (dock.IsHorizontal())

-                size = wxMin(size, cli_size.y/3);
-                 else
-                size = wxMin(size, cli_size.x/3);
+                size = wxMin(size, max_dock_y_size);
+            else
+                size = wxMin(size, max_dock_x_size);

 
 

+            // absolute minimum size for a dock is 10 pixels

             if (size < 10)
                 size = 10;
             if (size < 10)
                 size = 10;

+

             dock.size = size;
         }
 
             dock.size = size;
         }
 


@@ -1931,7 +2036,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
                     if (pane.min_size.y > dock_min_size)
                         dock_min_size = pane.min_size.y;
                 }
                     if (pane.min_size.y > dock_min_size)
                         dock_min_size = pane.min_size.y;
                 }

-                 else
+                else

                 {
                     if (pane.min_size.x > dock_min_size)
                         dock_min_size = pane.min_size.x;
                 {
                     if (pane.min_size.x > dock_min_size)
                         dock_min_size = pane.min_size.x;


@@ -1985,7 +2090,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
         // if the dock mode is fixed, and none of the panes
         // are being moved right now, make sure the panes
         // do not overlap each other.  If they do, we will
         // if the dock mode is fixed, and none of the panes
         // are being moved right now, make sure the panes
         // do not overlap each other.  If they do, we will

-        // adjust the panes' positions
+        // adjust the positions of the panes

         if (dock.fixed && !action_pane_marked)
         {
             wxArrayInt pane_positions, pane_sizes;
         if (dock.fixed && !action_pane_marked)
         {
             wxArrayInt pane_positions, pane_sizes;


@@ -2000,7 +2105,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
                 int amount = pane.dock_pos - offset;
                 if (amount >= 0)
                     offset += amount;
                 int amount = pane.dock_pos - offset;
                 if (amount >= 0)
                     offset += amount;

-                     else
+                else

                     pane.dock_pos += -amount;
 
                 offset += pane_sizes[j];
                     pane.dock_pos += -amount;
 
                 offset += pane_sizes[j];


@@ -2077,7 +2182,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& 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 if (!m_has_maximized)
+            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);


@@ -2091,7 +2196,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
                 uiparts.Add(part);
             }
         }
                 uiparts.Add(part);
             }
         }

-         else
+        else

         {
             middle->Add(old_cont, 1, wxEXPAND);
         }
         {
             middle->Add(old_cont, 1, wxEXPAND);
         }


@@ -2141,6 +2246,27 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
 }
 
 
 }
 
 

+// SetDockSizeConstraint() allows the dock constraints to be set.  For example,
+// specifying values of 0.5, 0.5 will mean that upon dock creation, a dock may
+// not be larger than half of the window's size
+
+void wxAuiManager::SetDockSizeConstraint(double width_pct, double height_pct)
+{
+    m_dock_constraint_x = wxMax(0.0, wxMin(1.0, width_pct));
+    m_dock_constraint_y = wxMax(0.0, wxMin(1.0, height_pct));
+}
+
+void wxAuiManager::GetDockSizeConstraint(double* width_pct, double* height_pct) const
+{
+    if (width_pct)
+        *width_pct = m_dock_constraint_x;
+
+    if (height_pct)
+        *height_pct = m_dock_constraint_y;
+}
+
+
+

 // Update() updates the layout.  Whenever changes are made to
 // one or more panes, this function should be called.  It is the
 // external entry point for running the layout engine.
 // Update() updates the layout.  Whenever changes are made to
 // one or more panes, this function should be called.  It is the
 // external entry point for running the layout engine.


@@ -2150,8 +2276,6 @@ void wxAuiManager::Update()
     wxSizer* sizer;
     int i, pane_count = m_panes.GetCount();
 
     wxSizer* sizer;
     int i, pane_count = m_panes.GetCount();
 

-    // delete old sizer first
-    m_frame->SetSizer(NULL);

 
     // destroy floating panes which have been
     // redocked or are becoming non-floating
 
     // destroy floating panes which have been
     // redocked or are becoming non-floating


@@ -2187,11 +2311,11 @@ void wxAuiManager::Update()
                 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)
+            if (m_action_window == p.frame)

             {
                 m_action_window = NULL;
             }
             {
                 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();


@@ -2200,6 +2324,9 @@ void wxAuiManager::Update()
     }
 
 
     }
 
 

+    // delete old sizer first
+    m_frame->SetSizer(NULL);
+

     // create a layout for all of the panes
     sizer = LayoutAll(m_panes, m_docks, m_uiparts, false);
 
     // create a layout for all of the panes
     sizer = LayoutAll(m_panes, m_docks, m_uiparts, false);
 


@@ -2217,14 +2344,12 @@ void wxAuiManager::Update()
                 // pane, which has recently been floated
                 wxAuiFloatingFrame* frame = CreateFloatingFrame(m_frame, p);
 
                 // pane, which has recently been floated
                 wxAuiFloatingFrame* frame = CreateFloatingFrame(m_frame, p);
 

-#if wxCHECK_VERSION(2,7,0)

                 // on MSW and Mac, if the owner desires transparent dragging, and
                 // the dragging is happening right now, then the floating
                 // window should have this style by default
                 if (m_action == actionDragFloatingPane &&
                     (m_flags & wxAUI_MGR_TRANSPARENT_DRAG))
                         frame->SetTransparent(150);
                 // on MSW and Mac, if the owner desires transparent dragging, and
                 // the dragging is happening right now, then the floating
                 // window should have this style by default
                 if (m_action == actionDragFloatingPane &&
                     (m_flags & wxAUI_MGR_TRANSPARENT_DRAG))
                         frame->SetTransparent(150);

-#endif

 
                 frame->SetPaneWindow(p);
                 p.frame = frame;
 
                 frame->SetPaneWindow(p);
                 p.frame = frame;


@@ -2232,23 +2357,28 @@ void wxAuiManager::Update()
                 if (p.IsShown() && !frame->IsShown())
                     frame->Show();
             }
                 if (p.IsShown() && !frame->IsShown())
                     frame->Show();
             }

-             else
+            else

             {
                 // frame already exists, make sure it's position
                 // and size reflect the information in wxAuiPaneInfo
                 if (p.frame->GetPosition() != p.floating_pos)
                 {
             {
                 // frame already exists, make sure it's position
                 // 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,
+                                     p.floating_size.x, p.floating_size.y,
+                                     wxSIZE_USE_EXISTING);
+                /*

                     p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,
                                      wxDefaultCoord, wxDefaultCoord,
                                      wxSIZE_USE_EXISTING);
                     //p.frame->Move(p.floating_pos.x, p.floating_pos.y);
                     p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,
                                      wxDefaultCoord, wxDefaultCoord,
                                      wxSIZE_USE_EXISTING);
                     //p.frame->Move(p.floating_pos.x, p.floating_pos.y);

+                */

                 }
 
                 if (p.frame->IsShown() != p.IsShown())
                     p.frame->Show(p.IsShown());
             }
         }
                 }
 
                 if (p.frame->IsShown() != p.IsShown())
                     p.frame->Show(p.IsShown());
             }
         }

-         else
+        else

         {
             if (p.window->IsShown() != p.IsShown())
                 p.window->Show(p.IsShown());
         {
             if (p.window->IsShown() != p.IsShown())
                 p.window->Show(p.IsShown());


@@ -2451,7 +2581,7 @@ int wxAuiManager::GetDockPixelOffset(wxAuiPaneInfo& test)
         {
             if (dock.IsVertical())
                 return dock.rect.y;
         {
             if (dock.IsVertical())
                 return dock.rect.y;

-                 else
+            else

                 return dock.rect.x;
         }
     }
                 return dock.rect.x;
         }
     }


@@ -2466,7 +2596,7 @@ int wxAuiManager::GetDockPixelOffset(wxAuiPaneInfo& test)
 // the target info.  If the operation was allowed, the function returns true.
 
 bool wxAuiManager::ProcessDockResult(wxAuiPaneInfo& target,
 // the target info.  If the operation was allowed, the function returns true.
 
 bool wxAuiManager::ProcessDockResult(wxAuiPaneInfo& target,

-                              const wxAuiPaneInfo& new_pos)
+                                     const wxAuiPaneInfo& new_pos)

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


@@ -2498,10 +2628,10 @@ const int auiLayerInsertPixels = 40;
 const int auiLayerInsertOffset = 5;
 
 bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
 const int auiLayerInsertOffset = 5;
 
 bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,

-                            wxAuiPaneInfoArray& panes,
-                            wxAuiPaneInfo& target,
-                            const wxPoint& pt,
-                            const wxPoint& offset)
+                          wxAuiPaneInfoArray& panes,
+                          wxAuiPaneInfo& target,
+                          const wxPoint& pt,
+                          const wxPoint& offset)

 {
     wxSize cli_size = m_frame->GetClientSize();
 
 {
     wxSize cli_size = m_frame->GetClientSize();
 


@@ -2517,13 +2647,22 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
 
 
     int layer_insert_offset = auiLayerInsertOffset;
 
 
     int layer_insert_offset = auiLayerInsertOffset;

-    if (target.IsToolbar())
+    if (drop.IsToolbar())

         layer_insert_offset = 0;
 
         layer_insert_offset = 0;
 

+

     if (pt.x < layer_insert_offset &&
         pt.x > layer_insert_offset-auiLayerInsertPixels)
     {
     if (pt.x < layer_insert_offset &&
         pt.x > layer_insert_offset-auiLayerInsertPixels)
     {

+        int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT),
+                                GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)),
+                                GetMaxLayer(docks, wxAUI_DOCK_TOP)) + 1;
+
+        if (drop.IsToolbar())
+            new_layer = auiToolBarLayer;
+

         drop.Dock().Left().
         drop.Dock().Left().

+             Layer(new_layer).

              Row(0).
              Position(pt.y - GetDockPixelOffset(drop) - offset.y);
         return ProcessDockResult(target, drop);
              Row(0).
              Position(pt.y - GetDockPixelOffset(drop) - offset.y);
         return ProcessDockResult(target, drop);


@@ -2531,7 +2670,15 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
     else if (pt.y < layer_insert_offset &&
              pt.y > layer_insert_offset-auiLayerInsertPixels)
     {
     else if (pt.y < layer_insert_offset &&
              pt.y > layer_insert_offset-auiLayerInsertPixels)
     {

+        int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP),
+                                GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
+                                GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1;
+
+        if (drop.IsToolbar())
+            new_layer = auiToolBarLayer;
+

         drop.Dock().Top().
         drop.Dock().Top().

+             Layer(new_layer).

              Row(0).
              Position(pt.x - GetDockPixelOffset(drop) - offset.x);
         return ProcessDockResult(target, drop);
              Row(0).
              Position(pt.x - GetDockPixelOffset(drop) - offset.x);
         return ProcessDockResult(target, drop);


@@ -2539,7 +2686,15 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
     else if (pt.x >= cli_size.x - layer_insert_offset &&
              pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels)
     {
     else if (pt.x >= cli_size.x - layer_insert_offset &&
              pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels)
     {

+        int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT),
+                                GetMaxLayer(docks, wxAUI_DOCK_TOP)),
+                                GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)) + 1;
+
+        if (drop.IsToolbar())
+            new_layer = auiToolBarLayer;
+

         drop.Dock().Right().
         drop.Dock().Right().

+             Layer(new_layer).

              Row(0).
              Position(pt.y - GetDockPixelOffset(drop) - offset.y);
         return ProcessDockResult(target, drop);
              Row(0).
              Position(pt.y - GetDockPixelOffset(drop) - offset.y);
         return ProcessDockResult(target, drop);


@@ -2551,6 +2706,9 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
                                       GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
                                       GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1;
 
                                       GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
                                       GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1;
 

+        if (drop.IsToolbar())
+            new_layer = auiToolBarLayer;
+

         drop.Dock().Bottom().
              Layer(new_layer).
              Row(0).
         drop.Dock().Bottom().
              Layer(new_layer).
              Row(0).


@@ -2558,6 +2716,7 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
         return ProcessDockResult(target, drop);
     }
 
         return ProcessDockResult(target, drop);
     }
 

+

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


@@ -2571,7 +2730,7 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
         int dock_drop_offset = 0;
         if (part->dock->IsHorizontal())
             dock_drop_offset = pt.x - part->dock->rect.x - offset.x;
         int dock_drop_offset = 0;
         if (part->dock->IsHorizontal())
             dock_drop_offset = pt.x - part->dock->rect.x - offset.x;

-             else
+        else

             dock_drop_offset = pt.y - part->dock->rect.y - offset.y;
 
 
             dock_drop_offset = pt.y - part->dock->rect.y - offset.y;
 
 


@@ -2790,23 +2949,19 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
 
                 insert_layer = 0;
                 insert_dock_row = true;
 
                 insert_layer = 0;
                 insert_dock_row = true;

-                if (pt.x >= part->rect.x &&
-                    pt.x < part->rect.x+new_row_pixels_x)
-                        insert_dir = wxAUI_DOCK_LEFT;
-                 else
-                if (pt.y >= part->rect.y &&
-                    pt.y < part->rect.y+new_row_pixels_y)
-                        insert_dir = wxAUI_DOCK_TOP;
-                 else
-                if (pt.x >= part->rect.x + part->rect.width-new_row_pixels_x &&
-                    pt.x < part->rect.x + part->rect.width)
-                        insert_dir = wxAUI_DOCK_RIGHT;
-                 else
-                if (pt.y >= part->rect.y+ part->rect.height-new_row_pixels_y &&
-                    pt.y < part->rect.y + part->rect.height)
-                        insert_dir = wxAUI_DOCK_BOTTOM;
-                 else
-                return false;
+                const wxRect& pr = part->rect;
+                if (pt.x >= pr.x && pt.x < pr.x + new_row_pixels_x)
+                    insert_dir = wxAUI_DOCK_LEFT;
+                else if (pt.y >= pr.y && pt.y < pr.y + new_row_pixels_y)
+                    insert_dir = wxAUI_DOCK_TOP;
+                else if (pt.x >= pr.x + pr.width - new_row_pixels_x &&
+                         pt.x < pr.x + pr.width)
+                    insert_dir = wxAUI_DOCK_RIGHT;
+                else if (pt.y >= pr.y+ pr.height - new_row_pixels_y &&
+                         pt.y < pr.y + pr.height)
+                    insert_dir = wxAUI_DOCK_BOTTOM;
+                else
+                    return false;

 
                 insert_row = GetMaxRow(panes, insert_dir, insert_layer) + 1;
             }
 
                 insert_row = GetMaxRow(panes, insert_dir, insert_layer) + 1;
             }


@@ -2832,7 +2987,7 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
             offset = pt.y - part->rect.y;
             size = part->rect.GetHeight();
         }
             offset = pt.y - part->rect.y;
             size = part->rect.GetHeight();
         }

-         else
+        else

         {
             offset = pt.x - part->rect.x;
             size = part->rect.GetWidth();
         {
             offset = pt.x - part->rect.x;
             size = part->rect.GetWidth();


@@ -2885,12 +3040,7 @@ void wxAuiManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event))
     }
 
     m_hint_fadeamt += 4;
     }
 
     m_hint_fadeamt += 4;

-#if wxCHECK_VERSION(2,7,0)

     m_hint_wnd->SetTransparent(m_hint_fadeamt);
     m_hint_wnd->SetTransparent(m_hint_fadeamt);

-#else
-    if (m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame)))
-        ((wxPseudoTransparentFrame *)m_hint_wnd)->SetTransparent(m_hint_fadeamt);
-#endif

 }
 
 void wxAuiManager::ShowHint(const wxRect& rect)
 }
 
 void wxAuiManager::ShowHint(const wxRect& rect)


@@ -2903,7 +3053,7 @@ void wxAuiManager::ShowHint(const wxRect& rect)
         m_last_hint = rect;
 
         m_hint_fadeamt = m_hint_fademax;
         m_last_hint = rect;
 
         m_hint_fadeamt = m_hint_fademax;

-        
+

         if ((m_flags & wxAUI_MGR_HINT_FADE)
             && !((m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame))) &&
                  (m_flags & wxAUI_MGR_NO_VENETIAN_BLINDS_FADE))
         if ((m_flags & wxAUI_MGR_HINT_FADE)
             && !((m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame))) &&
                  (m_flags & wxAUI_MGR_NO_VENETIAN_BLINDS_FADE))


@@ -2920,12 +3070,7 @@ void wxAuiManager::ShowHint(const wxRect& rect)
         if (m_action == actionDragFloatingPane && m_action_window)
             m_action_window->SetFocus();
 
         if (m_action == actionDragFloatingPane && m_action_window)
             m_action_window->SetFocus();
 

-#if wxCHECK_VERSION(2,7,0)

         m_hint_wnd->SetTransparent(m_hint_fadeamt);
         m_hint_wnd->SetTransparent(m_hint_fadeamt);

-#else
-        if (m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame)))
-            ((wxPseudoTransparentFrame*)m_hint_wnd)->SetTransparent(m_hint_fadeamt);
-#endif

         m_hint_wnd->Raise();
 
 
         m_hint_wnd->Raise();
 
 


@@ -2936,11 +3081,11 @@ void wxAuiManager::ShowHint(const wxRect& rect)
             m_hint_fadetimer.Start(5);
         }
     }
             m_hint_fadetimer.Start(5);
         }
     }

-     else  // Not using a transparent hint window...
+    else  // Not using a transparent hint window...

     {
         if (!(m_flags & wxAUI_MGR_RECTANGLE_HINT))
             return;
     {
         if (!(m_flags & wxAUI_MGR_RECTANGLE_HINT))
             return;

-            
+

         if (m_last_hint != rect)
         {
             // remove the last hint rectangle
         if (m_last_hint != rect)
         {
             // remove the last hint rectangle


@@ -2999,12 +3144,7 @@ void wxAuiManager::HideHint()
     {
         if (m_hint_wnd->IsShown())
             m_hint_wnd->Show(false);
     {
         if (m_hint_wnd->IsShown())
             m_hint_wnd->Show(false);

-#if wxCHECK_VERSION(2,7,0)

         m_hint_wnd->SetTransparent(0);
         m_hint_wnd->SetTransparent(0);

-#else
-        if (m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame)))
-        ((wxPseudoTransparentFrame *)m_hint_wnd)->SetTransparent(0);
-#endif

         m_hint_fadetimer.Stop();
         m_last_hint = wxRect();
         return;
         m_hint_fadetimer.Stop();
         m_last_hint = wxRect();
         return;


@@ -3021,15 +3161,40 @@ void wxAuiManager::HideHint()
 
 
 
 
 
 

-// DrawHintRect() draws a drop hint rectangle. First calls DoDrop() to
-// determine the exact position the pane would be at were if dropped.  If
-// the pame would indeed become docked at the specified drop point,
-// 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 wxAuiManager::DrawHintRect(wxWindow* pane_window,
-                                  const wxPoint& pt,
-                                  const wxPoint& offset)
+void wxAuiManager::StartPaneDrag(wxWindow* pane_window,
+                                 const wxPoint& offset)
+{
+    wxAuiPaneInfo& pane = GetPane(pane_window);
+    if (!pane.IsOk())
+        return;
+
+    if (pane.IsToolbar())
+    {
+        m_action = actionDragToolbarPane;
+    }
+    else
+    {
+        m_action = actionDragFloatingPane;
+    }
+
+    m_action_window = pane_window;
+    m_action_offset = offset;
+    m_frame->CaptureMouse();
+}
+
+
+// CalculateHintRect() calculates the drop hint rectangle.  The method
+// first calls DoDrop() to determine the exact position the pane would
+// be at were if dropped.  If the pane would indeed become docked at the
+// specified drop point, the the rectangle hint will be returned in
+// screen coordinates.  Otherwise, an empty rectangle is returned.
+// |pane_window| is the window pointer of the pane being dragged, |pt| is
+// the mouse position, in client coordinates.  |offset| describes the offset
+// that the mouse is from the upper-left corner of the item being dragged
+
+wxRect wxAuiManager::CalculateHintRect(wxWindow* pane_window,
+                                       const wxPoint& pt,
+                                       const wxPoint& offset)

 {
     wxRect rect;
 
 {
     wxRect rect;
 


@@ -3047,7 +3212,7 @@ void wxAuiManager::DrawHintRect(wxWindow* pane_window,
     hint.Show();
 
     if (!hint.IsOk())
     hint.Show();
 
     if (!hint.IsOk())

-        return;
+        return rect;

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


@@ -3066,8 +3231,7 @@ void wxAuiManager::DrawHintRect(wxWindow* pane_window,
     // find out where the new pane would be
     if (!DoDrop(docks, panes, hint, pt, offset))
     {
     // find out where the new pane would be
     if (!DoDrop(docks, panes, hint, pt, offset))
     {

-        HideHint();
-        return;
+        return rect;

     }
 
     panes.Add(hint);
     }
 
     panes.Add(hint);


@@ -3095,13 +3259,39 @@ void wxAuiManager::DrawHintRect(wxWindow* pane_window,
 
     if (rect.IsEmpty())
     {
 
     if (rect.IsEmpty())
     {

-        HideHint();
-        return;
+        return rect;

     }
 
     // actually show the hint rectangle on the screen
     m_frame->ClientToScreen(&rect.x, &rect.y);
     }
 
     // actually show the hint rectangle on the screen
     m_frame->ClientToScreen(&rect.x, &rect.y);

-    ShowHint(rect);
+
+    if ( m_frame->GetLayoutDirection() == wxLayout_RightToLeft )
+    {
+        // Mirror rectangle in RTL mode
+        rect.x -= rect.GetWidth();
+    }
+
+    return rect;
+}
+
+// DrawHintRect() calculates the hint rectangle by calling
+// CalculateHintRect().  If there is a rectangle, it shows it
+// by calling ShowHint(), otherwise it hides any hint
+// rectangle currently shown
+void wxAuiManager::DrawHintRect(wxWindow* pane_window,
+                                const wxPoint& pt,
+                                const wxPoint& offset)
+{
+    wxRect rect = CalculateHintRect(pane_window, pt, offset);
+
+    if (rect.IsEmpty())
+    {
+        HideHint();
+    }
+    else
+    {
+        ShowHint(rect);
+    }

 }
 
 void wxAuiManager::OnFloatingPaneMoveStart(wxWindow* wnd)
 }
 
 void wxAuiManager::OnFloatingPaneMoveStart(wxWindow* wnd)


@@ -3110,10 +3300,8 @@ void wxAuiManager::OnFloatingPaneMoveStart(wxWindow* wnd)
     wxAuiPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
     wxAuiPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 

-#if wxCHECK_VERSION(2,7,0)

     if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
         pane.frame->SetTransparent(150);
     if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
         pane.frame->SetTransparent(150);

-#endif

 }
 
 void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)
 }
 
 void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)


@@ -3134,22 +3322,22 @@ void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)
         pt.y = pos.y;
         // and some more pixels for the title bar
         pt.y -= 5;
         pt.y = pos.y;
         // and some more pixels for the title bar
         pt.y -= 5;

-    } else
-    if (dir == wxWEST)
+    }
+    else if (dir == wxWEST)

     {
         // move to pane's left border
         wxPoint pos( 0,0 );
         pos = wnd->ClientToScreen( pos );
         pt.x = pos.x;
     {
         // move to pane's left border
         wxPoint pos( 0,0 );
         pos = wnd->ClientToScreen( pos );
         pt.x = pos.x;

-    } else
-    if (dir == wxEAST)
+    }
+    else if (dir == wxEAST)

     {
         // move to pane's right border
         wxPoint pos( wnd->GetSize().x, 0 );
         pos = wnd->ClientToScreen( pos );
         pt.x = pos.x;
     {
         // move to pane's right border
         wxPoint pos( wnd->GetSize().x, 0 );
         pos = wnd->ClientToScreen( pos );
         pt.x = pos.x;

-    } else
-    if (dir == wxSOUTH)
+    }
+    else if (dir == wxSOUTH)

     {
         // move to pane's bottom border
         wxPoint pos( 0, wnd->GetSize().y );
     {
         // move to pane's bottom border
         wxPoint pos( 0, wnd->GetSize().y );


@@ -3237,22 +3425,22 @@ void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir)
         pt.y = pos.y;
         // and some more pixels for the title bar
         pt.y -= 10;
         pt.y = pos.y;
         // and some more pixels for the title bar
         pt.y -= 10;

-    } else
-    if (dir == wxWEST)
+    }
+    else if (dir == wxWEST)

     {
         // move to pane's left border
         wxPoint pos( 0,0 );
         pos = wnd->ClientToScreen( pos );
         pt.x = pos.x;
     {
         // move to pane's left border
         wxPoint pos( 0,0 );
         pos = wnd->ClientToScreen( pos );
         pt.x = pos.x;

-    } else
-    if (dir == wxEAST)
+    }
+    else if (dir == wxEAST)

     {
         // move to pane's right border
         wxPoint pos( wnd->GetSize().x, 0 );
         pos = wnd->ClientToScreen( pos );
         pt.x = pos.x;
     {
         // move to pane's right border
         wxPoint pos( wnd->GetSize().x, 0 );
         pos = wnd->ClientToScreen( pos );
         pt.x = pos.x;

-    } else
-    if (dir == wxSOUTH)
+    }
+    else if (dir == wxSOUTH)

     {
         // move to pane's bottom border
         wxPoint pos( 0, wnd->GetSize().y );
     {
         // move to pane's bottom border
         wxPoint pos( 0, wnd->GetSize().y );


@@ -3285,11 +3473,11 @@ void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir)
     {
         pane.floating_pos = pane.frame->GetPosition();
 
     {
         pane.floating_pos = pane.frame->GetPosition();
 

-#if wxCHECK_VERSION(2,7,0)

         if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
             pane.frame->SetTransparent(255);
         if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
             pane.frame->SetTransparent(255);

-#endif
-    } else if(m_has_maximized) {
+    }
+    else if (m_has_maximized)
+    {

         RestoreMaximizedPane();
     }
 
         RestoreMaximizedPane();
     }
 


@@ -3316,7 +3504,7 @@ void wxAuiManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt)
 
 
     // fire pane close event
 
 
     // fire pane close event

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

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


@@ -3326,7 +3514,7 @@ void wxAuiManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt)
         evt.Veto();
         return;
     }
         evt.Veto();
         return;
     }

-     else 
+    else

     {
         ClosePane(pane);
     }
     {
         ClosePane(pane);
     }


@@ -3403,6 +3591,7 @@ void wxAuiManager::OnRender(wxAuiManagerEvent& evt)
 void wxAuiManager::Render(wxDC* dc)
 {
     wxAuiManagerEvent e(wxEVT_AUI_RENDER);
 void wxAuiManager::Render(wxDC* dc)
 {
     wxAuiManagerEvent e(wxEVT_AUI_RENDER);

+    e.SetManager(this);

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


@@ -3465,7 +3654,7 @@ void wxAuiManager::OnSize(wxSizeEvent& event)
     {
         DoFrameLayout();
         Repaint();
     {
         DoFrameLayout();
         Repaint();

-        
+

 #if wxUSE_MDI
         if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
         {
 #if wxUSE_MDI
         if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
         {


@@ -3480,6 +3669,27 @@ void wxAuiManager::OnSize(wxSizeEvent& event)
     event.Skip();
 }
 
     event.Skip();
 }
 

+void wxAuiManager::OnFindManager(wxAuiManagerEvent& evt)
+{
+    // get the window we are managing, if none, return NULL
+    wxWindow* window = GetManagedWindow();
+    if (!window)
+    {
+        evt.SetManager(NULL);
+        return;
+    }
+
+    // if we are managing a child frame, get the 'real' manager
+    if (window->IsKindOf(CLASSINFO(wxAuiFloatingFrame)))
+    {
+        wxAuiFloatingFrame* float_frame = static_cast<wxAuiFloatingFrame*>(window);
+        evt.SetManager(float_frame->GetOwnerManager());
+        return;
+    }
+
+    // return pointer to ourself
+    evt.SetManager(this);
+}

 
 void wxAuiManager::OnSetCursor(wxSetCursorEvent& event)
 {
 
 void wxAuiManager::OnSetCursor(wxSetCursorEvent& event)
 {


@@ -3505,10 +3715,10 @@ void wxAuiManager::OnSetCursor(wxSetCursorEvent& event)
 
             if (part->orientation == wxVERTICAL)
                 cursor = wxCursor(wxCURSOR_SIZEWE);
 
             if (part->orientation == wxVERTICAL)
                 cursor = wxCursor(wxCURSOR_SIZEWE);

-                 else
+            else

                 cursor = wxCursor(wxCURSOR_SIZENS);
         }
                 cursor = wxCursor(wxCURSOR_SIZENS);
         }

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

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


@@ -3520,9 +3730,11 @@ void wxAuiManager::OnSetCursor(wxSetCursorEvent& event)
 
 
 void wxAuiManager::UpdateButtonOnScreen(wxAuiDockUIPart* button_ui_part,
 
 
 void wxAuiManager::UpdateButtonOnScreen(wxAuiDockUIPart* button_ui_part,

-                                          const wxMouseEvent& event)
+                                        const wxMouseEvent& event)

 {
     wxAuiDockUIPart* hit_test = HitTest(event.GetX(), event.GetY());
 {
     wxAuiDockUIPart* hit_test = HitTest(event.GetX(), event.GetY());

+    if (!hit_test || !button_ui_part)
+        return;

 
     int state = wxAUI_BUTTON_STATE_NORMAL;
 
 
     int state = wxAUI_BUTTON_STATE_NORMAL;
 


@@ -3530,10 +3742,10 @@ void wxAuiManager::UpdateButtonOnScreen(wxAuiDockUIPart* button_ui_part,
     {
         if (event.LeftDown())
             state = wxAUI_BUTTON_STATE_PRESSED;
     {
         if (event.LeftDown())
             state = wxAUI_BUTTON_STATE_PRESSED;

-             else
+        else

             state = wxAUI_BUTTON_STATE_HOVER;
     }
             state = wxAUI_BUTTON_STATE_HOVER;
     }

-     else
+    else

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


@@ -3568,7 +3780,7 @@ void wxAuiManager::OnLeftDown(wxMouseEvent& event)
         {
             if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER)
                 return;
         {
             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
             if (part->type == wxAuiDockUIPart::typeDockSizer && part->dock &&
             // a dock may not be resized if it has a single
             // pane which is not resizable
             if (part->type == wxAuiDockUIPart::typeDockSizer && part->dock &&


@@ -3588,7 +3800,7 @@ void wxAuiManager::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 == wxAuiDockUIPart::typePaneButton)
+        else if (part->type == wxAuiDockUIPart::typePaneButton)

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


@@ -3597,9 +3809,29 @@ void wxAuiManager::OnLeftDown(wxMouseEvent& event)
 
             UpdateButtonOnScreen(part, event);
         }
 
             UpdateButtonOnScreen(part, event);
         }

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

                   part->type == wxAuiDockUIPart::typeGripper)
         {
                   part->type == wxAuiDockUIPart::typeGripper)
         {

+            // if we are managing a wxAuiFloatingFrame window, then
+            // we are an embedded wxAuiManager inside the wxAuiFloatingFrame.
+            // We want to initiate a toolbar drag in our owner manager
+            wxWindow* managed_wnd = GetManagedWindow();
+
+            if (part->pane &&
+                part->pane->window &&
+                managed_wnd &&
+                managed_wnd->IsKindOf(CLASSINFO(wxAuiFloatingFrame)))
+            {
+                wxAuiFloatingFrame* floating_frame = (wxAuiFloatingFrame*)managed_wnd;
+                wxAuiManager* owner_mgr = floating_frame->GetOwnerManager();
+                owner_mgr->StartPaneDrag(part->pane->window,
+                                             wxPoint(event.m_x - part->rect.x,
+                                                     event.m_y - part->rect.y));
+                return;
+            }
+
+
+

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


@@ -3674,8 +3906,8 @@ void wxAuiManager::OnLeftUp(wxMouseEvent& event)
             Update();
             Repaint(NULL);
         }
             Update();
             Repaint(NULL);
         }

-         else if (m_action_part &&
-                  m_action_part->type == wxAuiDockUIPart::typePaneSizer)
+        else if (m_action_part &&
+                 m_action_part->type == wxAuiDockUIPart::typePaneSizer)

         {
             wxAuiDockInfo& dock = *m_action_part->dock;
             wxAuiPaneInfo& pane = *m_action_part->pane;
         {
             wxAuiDockInfo& dock = *m_action_part->dock;
             wxAuiPaneInfo& pane = *m_action_part->pane;


@@ -3684,9 +3916,9 @@ void wxAuiManager::OnLeftUp(wxMouseEvent& event)
             int dock_pixels = 0;
             int new_pixsize = 0;
 
             int dock_pixels = 0;
             int new_pixsize = 0;
 

-            int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);
-            int pane_border_size = m_art->GetMetric(wxAUI_ART_PANE_BORDER_SIZE);
-            int sash_size = m_art->GetMetric(wxAUI_ART_SASH_SIZE);
+            int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
+            int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
+            int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE);

 
             wxPoint new_pos(event.m_x - m_action_offset.x,
                             event.m_y - m_action_offset.y);
 
             wxPoint new_pos(event.m_x - m_action_offset.x,
                             event.m_y - m_action_offset.y);


@@ -3700,13 +3932,13 @@ void wxAuiManager::OnLeftUp(wxMouseEvent& event)
             // this will help us recalculate the pane's proportion
             if (dock.IsHorizontal())
                 new_pixsize = new_pos.x - pane_part->rect.x;
             // this will help us recalculate the pane's proportion
             if (dock.IsHorizontal())
                 new_pixsize = new_pos.x - pane_part->rect.x;

-                 else
+            else

                 new_pixsize = new_pos.y - pane_part->rect.y;
 
             // determine the size of the dock, based on orientation
             if (dock.IsHorizontal())
                 dock_pixels = dock.rect.GetWidth();
                 new_pixsize = new_pos.y - pane_part->rect.y;
 
             // determine the size of the dock, based on orientation
             if (dock.IsHorizontal())
                 dock_pixels = dock.rect.GetWidth();

-                 else
+            else

                 dock_pixels = dock.rect.GetHeight();
 
             // determine the total proportion of all resizable panes,
                 dock_pixels = dock.rect.GetHeight();
 
             // determine the total proportion of all resizable panes,


@@ -3733,10 +3965,10 @@ void wxAuiManager::OnLeftUp(wxMouseEvent& event)
                 {
                     if (dock.IsHorizontal())
                         dock_pixels -= p.best_size.x;
                 {
                     if (dock.IsHorizontal())
                         dock_pixels -= p.best_size.x;

-                         else
+                    else

                         dock_pixels -= p.best_size.y;
                 }
                         dock_pixels -= p.best_size.y;
                 }

-                 else
+                else

                 {
                     total_proportion += p.dock_proportion;
                 }
                 {
                     total_proportion += p.dock_proportion;
                 }


@@ -3793,7 +4025,7 @@ void wxAuiManager::OnLeftUp(wxMouseEvent& event)
                     if (pane.HasCaption())
                         min_size += caption_size;
                 }
                     if (pane.HasCaption())
                         min_size += caption_size;
                 }

-                 else
+                else

                 {
                     min_size += pane.min_size.x;
                 }
                 {
                     min_size += pane.min_size.x;
                 }


@@ -3835,7 +4067,8 @@ void wxAuiManager::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

-            wxAuiManagerEvent e(wxEVT_AUI_PANEBUTTON);
+            wxAuiManagerEvent e(wxEVT_AUI_PANE_BUTTON);
+            e.SetManager(this);

             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);


@@ -3904,7 +4137,7 @@ void wxAuiManager::OnMotion(wxMouseEvent& event)
         wxPoint pos = m_action_part->rect.GetPosition();
         if (m_action_part->orientation == wxHORIZONTAL)
             pos.y = wxMax(0, event.m_y - m_action_offset.y);
         wxPoint pos = m_action_part->rect.GetPosition();
         if (m_action_part->orientation == wxHORIZONTAL)
             pos.y = wxMax(0, event.m_y - m_action_offset.y);

-             else
+        else

             pos.x = wxMax(0, event.m_x - m_action_offset.x);
 
         wxRect rect(m_frame->ClientToScreen(pos),
             pos.x = wxMax(0, event.m_x - m_action_offset.x);
 
         wxRect rect(m_frame->ClientToScreen(pos),


@@ -3942,9 +4175,8 @@ void wxAuiManager::OnMotion(wxMouseEvent& event)
                                                       pt.y - m_action_offset.y);
 
                     // float the window
                                                       pt.y - m_action_offset.y);
 
                     // float the window

-                    if(pane_info->IsMaximized()) {
+                    if (pane_info->IsMaximized())

                         RestorePane(*pane_info);
                         RestorePane(*pane_info);

-                    }

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


@@ -3960,7 +4192,7 @@ void wxAuiManager::OnMotion(wxMouseEvent& event)
                         m_action_offset.x = 30;
                 }
             }
                         m_action_offset.x = 30;
                 }
             }

-             else
+            else

             {
                 m_action = actionDragToolbarPane;
                 m_action_window = pane_info->window;
             {
                 m_action = actionDragToolbarPane;
                 m_action_window = pane_info->window;


@@ -3969,7 +4201,8 @@ void wxAuiManager::OnMotion(wxMouseEvent& event)
     }
     else if (m_action == actionDragFloatingPane)
     {
     }
     else if (m_action == actionDragFloatingPane)
     {

-        if(m_action_window) {
+        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);
             wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
             m_action_window->Move(pt.x - m_action_offset.x,
                                 pt.y - m_action_offset.y);


@@ -4023,22 +4256,22 @@ void wxAuiManager::OnMotion(wxMouseEvent& event)
                     UpdateButtonOnScreen(m_hover_button, event);
                     Repaint();
                 }
                     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

         {
             if (m_hover_button)
             {
                 m_hover_button = NULL;
                 Repaint();
             }
         {
             if (m_hover_button)
             {
                 m_hover_button = NULL;
                 Repaint();
             }

-             else
+            else

             {
                 event.Skip();
             }
             {
                 event.Skip();
             }


@@ -4084,7 +4317,8 @@ void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt)
     if (evt.button == wxAUI_BUTTON_CLOSE)
     {
         // fire pane close event
     if (evt.button == wxAUI_BUTTON_CLOSE)
     {
         // fire pane close event

-        wxAuiManagerEvent e(wxEVT_AUI_PANECLOSE);
+        wxAuiManagerEvent e(wxEVT_AUI_PANE_CLOSE);
+        e.SetManager(this);

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


@@ -4097,7 +4331,8 @@ void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt)
     else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && !pane.IsMaximized())
     {
         // fire pane close event
     else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && !pane.IsMaximized())
     {
         // fire pane close event

-        wxAuiManagerEvent e(wxEVT_AUI_PANEMAXIMIZE);
+        wxAuiManagerEvent e(wxEVT_AUI_PANE_MAXIMIZE);
+        e.SetManager(this);

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


@@ -4110,7 +4345,8 @@ void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt)
     else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && pane.IsMaximized())
     {
         // fire pane close event
     else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && pane.IsMaximized())
     {
         // fire pane close event

-        wxAuiManagerEvent e(wxEVT_AUI_PANERESTORE);
+        wxAuiManagerEvent e(wxEVT_AUI_PANE_RESTORE);
+        e.SetManager(this);

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


@@ -4120,7 +4356,7 @@ void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt)
             Update();
         }
     }
             Update();
         }
     }

-     else if (evt.button == wxAUI_BUTTON_PIN)
+    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())