]> git.saurik.com Git - wxWidgets.git/blobdiff - src/aui/framemanager.cpp
No changes, just minor cleanup.
[wxWidgets.git] / src / aui / framemanager.cpp
index 2e3aecb032cbfac6af7a237f3acad9beef839c1f..cd0eebc4f96768c9089d131039552f9a16964fdf 100644 (file)
@@ -28,6 +28,9 @@
 #include "wx/aui/framemanager.h"
 #include "wx/aui/dockart.h"
 #include "wx/aui/floatpane.h"
+#include "wx/aui/tabmdi.h"
+#include "wx/aui/auibar.h"
+#include "wx/mdi.h"
 
 #ifndef WX_PRECOMP
     #include "wx/panel.h"
@@ -36,8 +39,8 @@
     #include "wx/dcclient.h"
     #include "wx/dcscreen.h"
     #include "wx/toolbar.h"
-    #include "wx/mdi.h"
     #include "wx/image.h"
+    #include "wx/statusbr.h"
 #endif
 
 WX_CHECK_BUILD_OPTIONS("wxAUI")
@@ -52,30 +55,34 @@ WX_DEFINE_OBJARRAY(wxAuiPaneInfoArray)
 
 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_RENDER)
-DEFINE_EVENT_TYPE(wxEVT_AUI_FINDMANAGER)
+wxDEFINE_EVENT( wxEVT_AUI_PANE_BUTTON, wxAuiManagerEvent );
+wxDEFINE_EVENT( wxEVT_AUI_PANE_CLOSE, wxAuiManagerEvent );
+wxDEFINE_EVENT( wxEVT_AUI_PANE_MAXIMIZE, wxAuiManagerEvent );
+wxDEFINE_EVENT( wxEVT_AUI_PANE_RESTORE, wxAuiManagerEvent );
+wxDEFINE_EVENT( wxEVT_AUI_RENDER, wxAuiManagerEvent );
+wxDEFINE_EVENT( wxEVT_AUI_FIND_MANAGER, wxAuiManagerEvent );
 
 #ifdef __WXMAC__
     // a few defines to avoid nameclashes
     #define __MAC_OS_X_MEMORY_MANAGER_CLEAN__ 1
     #define __AIFF__
-    #include "wx/mac/private.h"
+    #include "wx/osx/private.h"
+#endif
+
+#ifdef __WXMSW__
+    #include "wx/msw/wrapwin.h"
+    #include "wx/msw/private.h"
+    #include "wx/msw/dc.h"
 #endif
 
 IMPLEMENT_DYNAMIC_CLASS(wxAuiManagerEvent, wxEvent)
 IMPLEMENT_CLASS(wxAuiManager, wxEvtHandler)
 
-// private manager flags (not yet on the public API)
-enum wxAuiPrivateManagerOption
-{
-    wxAUI_MGR_NO_DOCK_SIZE_LIMIT = 1 << 28
-};
 
 
+const int auiToolBarLayer = 10;
+
+#ifndef __WXGTK20__
 
 
 class wxPseudoTransparentFrame : public wxFrame
@@ -155,7 +162,7 @@ public:
             wxRect rect(upd.GetRect());
             dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 
-            upd++;
+            ++upd;
         }
     }
 
@@ -212,6 +219,85 @@ BEGIN_EVENT_TABLE(wxPseudoTransparentFrame, wxFrame)
 END_EVENT_TABLE()
 
 
+#else
+  // __WXGTK20__
+
+#include <gtk/gtk.h>
+
+static void
+gtk_pseudo_window_realized_callback( GtkWidget *m_widget, void *WXUNUSED(win) )
+{
+        wxSize disp = wxGetDisplaySize();
+        int amount = 128;
+        wxRegion region;
+        for (int y=0; y<disp.y; y++)
+                {
+                    // Reverse the order of the bottom 4 bits
+                    int j=((y&8)?1:0)|((y&4)?2:0)|((y&2)?4:0)|((y&1)?8:0);
+                    if ((j*16+8)<amount)
+                        region.Union(0, y, disp.x, 1);
+                }
+        gdk_window_shape_combine_region(m_widget->window, region.GetRegion(), 0, 0);
+}
+
+
+class wxPseudoTransparentFrame: public wxFrame
+{
+public:
+    wxPseudoTransparentFrame(wxWindow* parent = NULL,
+                wxWindowID id = wxID_ANY,
+                const wxString& title = wxEmptyString,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxDEFAULT_FRAME_STYLE,
+                const wxString &name = wxT("frame"))
+    {
+         if (!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
+            return;
+
+        m_title = title;
+
+        m_widget = gtk_window_new( GTK_WINDOW_POPUP );
+        g_object_ref(m_widget);
+
+        if (parent) parent->AddChild(this);
+
+        g_signal_connect( m_widget, "realize",
+                      G_CALLBACK (gtk_pseudo_window_realized_callback), this );
+
+        GdkColor col;
+        col.red = 128 * 256;
+        col.green = 192 * 256;
+        col.blue = 255 * 256;
+        gtk_widget_modify_bg( m_widget, GTK_STATE_NORMAL, &col );
+    }
+
+    bool SetTransparent(wxByte WXUNUSED(alpha))
+    {
+        return true;
+    }
+
+protected:
+    virtual void DoSetSizeHints( int minW, int minH,
+                                 int maxW, int maxH,
+                                 int incW, int incH)
+    {
+        // the real wxFrame method doesn't work for us because we're not really
+        // a top level window so skip it
+        wxWindow::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH);
+    }
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxPseudoTransparentFrame)
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxPseudoTransparentFrame, wxFrame)
+
+#endif
+ // __WXGTK20__
+
+
+
 // -- static utility functions --
 
 static wxBitmap wxPaneCreateStippleBitmap()
@@ -226,10 +312,15 @@ static void DrawResizeHint(wxDC& dc, const wxRect& rect)
     wxBitmap stipple = wxPaneCreateStippleBitmap();
     wxBrush brush(stipple);
     dc.SetBrush(brush);
+#ifdef __WXMSW__
+    wxMSWDCImpl *impl = (wxMSWDCImpl*) dc.GetImpl();
+    PatBlt(GetHdcOf(*impl), rect.GetX(), rect.GetY(), rect.GetWidth(), rect.GetHeight(), PATINVERT);
+#else
     dc.SetPen(*wxTRANSPARENT_PEN);
 
     dc.SetLogicalFunction(wxXOR);
     dc.DrawRectangle(rect);
+#endif
 }
 
 
@@ -259,7 +350,8 @@ static void CopyDocksAndPanes(wxAuiDockInfoArray& dest_docks,
 
 // 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)
@@ -432,20 +524,26 @@ static void RemovePaneFromDocks(wxAuiDockInfoArray& docks,
     }
 }
 
+/*
+// This function works fine, and may be used in the future
+
 // 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(wxAuiDockInfoPtrArray& docks)
 {
-    int i, dock_count, j, pane_count;
+    int i, dock_count;
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {
         wxAuiDockInfo& dock = *docks.Item(i);
         dock.dock_row = i;
+
+        int j, pane_count;
         for (j = 0, pane_count = dock.panes.GetCount(); j < pane_count; ++j)
             dock.panes.Item(j)->dock_row = i;
     }
 }
+*/
 
 
 // SetActivePane() sets the active pane, as well as cycles through
@@ -471,11 +569,141 @@ static int PaneSortFunc(wxAuiPaneInfo** p1, wxAuiPaneInfo** p2)
 }
 
 
+
+
+// this utility class implements a proportional sizer
+// as it existed in wxWidgets 2.8 and before.
+
+class wxAuiProportionalBoxSizer : public wxBoxSizer
+{
+public:
+    wxAuiProportionalBoxSizer(int orientation) : wxBoxSizer(orientation) { }
+
+    void RecalcSizes()
+    {
+        if (m_children.GetCount() == 0)
+            return;
+
+        int fixed_height = 0;
+        int fixed_width = 0;
+        int stretchable = 0;
+        wxSizerItemList::compatibility_iterator node;
+
+        // find fixed width and height, as well
+        // as the total stretchable proportions
+        node = m_children.GetFirst();
+        while (node)
+        {
+            wxSizerItem *item = node->GetData();
+
+            if (item->IsShown())
+            {
+                stretchable += item->GetProportion();
+
+                wxSize size(item->GetMinSizeWithBorder());
+                if (item->GetProportion() == 0)
+                {
+                    if (m_orient == wxVERTICAL)
+                    {
+                        fixed_height += size.y;
+                        fixed_width = wxMax(fixed_width, size.x);
+                    }
+                     else
+                    {
+                        fixed_width += size.x;
+                        fixed_height = wxMax(fixed_height, size.y);
+                    }
+                }
+            }
+
+            node = node->GetNext();
+        }
+
+
+        // delta specifies the total amount to be allocated to stretch spaces
+        int delta = 0;
+        if (stretchable)
+        {
+            if (m_orient == wxHORIZONTAL)
+                delta = m_size.x - fixed_width;
+                 else
+                delta = m_size.y - fixed_height;
+        }
+
+        // go through each item and assign sizes
+        wxPoint pt(m_position);
+        node = m_children.GetFirst();
+        while (node)
+        {
+            wxSizerItem* item = node->GetData();
+
+            if (item->IsShown())
+            {
+                wxSize size(item->GetMinSizeWithBorder());
+
+                if (m_orient == wxVERTICAL)
+                {
+                    wxCoord height = size.y;
+                    if (item->GetProportion())
+                    {
+                        height = (delta * item->GetProportion()) / stretchable;
+                        delta -= height;
+                        stretchable -= item->GetProportion();
+                    }
+
+                    wxPoint child_pos(pt);
+                    wxSize child_size(size.x, height);
+
+                    if (item->GetFlag() & (wxEXPAND | wxSHAPED))
+                        child_size.x = m_size.x;
+                    else if (item->GetFlag() & wxALIGN_RIGHT)
+                        child_pos.x += m_size.x - size.x;
+                    else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_HORIZONTAL))
+                        child_pos.x += (m_size.x - size.x) / 2;
+
+                    item->SetDimension(child_pos, child_size);
+
+                    pt.y += height;
+                }
+                 else
+                {
+                    wxCoord width = size.x;
+                    if (item->GetProportion())
+                    {
+                        width = (delta * item->GetProportion()) / stretchable;
+                        delta -= width;
+                        stretchable -= item->GetProportion();
+                    }
+
+                    wxPoint child_pos(pt);
+                    wxSize child_size(width, size.y);
+
+                    if (item->GetFlag() & (wxEXPAND | wxSHAPED))
+                        child_size.y = m_size.y;
+                    else if (item->GetFlag() & wxALIGN_BOTTOM)
+                        child_pos.y += m_size.y - size.y;
+                    else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_VERTICAL))
+                        child_pos.y += (m_size.y - size.y) / 2;
+
+                    item->SetDimension(child_pos, child_size);
+
+                    pt.x += width;
+                }
+            }
+
+            node = node->GetNext();
+        }
+    }
+};
+
+
+
+
 // -- wxAuiManager class implementation --
 
 
 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)
@@ -485,15 +713,16 @@ BEGIN_EVENT_TABLE(wxAuiManager, wxEvtHandler)
     EVT_LEFT_UP(wxAuiManager::OnLeftUp)
     EVT_MOTION(wxAuiManager::OnMotion)
     EVT_LEAVE_WINDOW(wxAuiManager::OnLeaveWindow)
+    EVT_MOUSE_CAPTURE_LOST(wxAuiManager::OnCaptureLost)
     EVT_CHILD_FOCUS(wxAuiManager::OnChildFocus)
-    EVT_AUI_FINDMANAGER(wxAuiManager::OnFindManager)
-    EVT_TIMER(101, wxAuiManager::OnHintFadeTimer)
+    EVT_AUI_FIND_MANAGER(wxAuiManager::OnFindManager)
 END_EVENT_TABLE()
 
 
 wxAuiManager::wxAuiManager(wxWindow* managed_wnd, unsigned int flags)
 {
     m_action = actionNone;
+    m_action_window = NULL;
     m_last_mouse_move = wxPoint();
     m_hover_button = NULL;
     m_art = new wxAuiDefaultDockArt;
@@ -502,7 +731,11 @@ wxAuiManager::wxAuiManager(wxWindow* managed_wnd, unsigned int flags)
     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;
+    m_currentDragItem = -1;
+
     if (managed_wnd)
     {
         SetManagedWindow(managed_wnd);
@@ -511,13 +744,34 @@ wxAuiManager::wxAuiManager(wxWindow* managed_wnd, unsigned int flags)
 
 wxAuiManager::~wxAuiManager()
 {
+    // NOTE: It's possible that the windows have already been destroyed by the
+    // time this dtor is called, so this loop can result in memory access via
+    // invalid pointers, resulting in a crash.  So it will be disabled while
+    // waiting for a better solution.
+#if 0
+    for ( size_t i = 0; i < m_panes.size(); i++ )
+    {
+        wxAuiPaneInfo& pinfo = m_panes[i];
+        if (pinfo.window && !pinfo.window->GetParent())
+            delete pinfo.window;
+    }
+#endif
+
     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, pane_info);
+}
+
+bool wxAuiManager::CanDockPanel(const wxAuiPaneInfo & WXUNUSED(p))
 {
-    return new wxAuiFloatingFrame(parent, this, p);
+    // if a key modifier is pressed while dragging the frame,
+    // don't dock the window
+    return !(wxGetKeyState(WXK_CONTROL) || wxGetKeyState(WXK_ALT));
 }
 
 // GetPane() looks up a wxAuiPaneInfo structure based
@@ -611,7 +865,7 @@ void wxAuiManager::SetFlags(unsigned int flags)
 
     // set the new flags
     m_flags = flags;
-    
+
     if (update_hint_wnd)
     {
         UpdateHintWindowConfig();
@@ -623,6 +877,18 @@ unsigned int wxAuiManager::GetFlags() const
     return m_flags;
 }
 
+// Convenience function
+bool wxAuiManager_HasLiveResize(wxAuiManager& manager)
+{
+    // With Core Graphics on Mac, it's not possible to show sash feedback,
+    // so we'll always use live update instead.
+#if defined(__WXMAC__)
+    wxUnusedVar(manager);
+    return true;
+#else
+    return (manager.GetFlags() & wxAUI_MGR_LIVE_RESIZE) == wxAUI_MGR_LIVE_RESIZE;
+#endif
+}
 
 // don't use these anymore as they are deprecated
 // use Set/GetManagedFrame() instead
@@ -644,12 +910,12 @@ wxFrame* wxAuiManager::GetFrame() const
 // need to be managed by the manager itself.
 wxAuiManager* wxAuiManager::GetManager(wxWindow* window)
 {
-    wxAuiManagerEvent evt(wxEVT_AUI_FINDMANAGER);
+    wxAuiManagerEvent evt(wxEVT_AUI_FIND_MANAGER);
     evt.SetManager(NULL);
     evt.ResumePropagation(wxEVENT_PROPAGATE_MAX);
-    if (!window->ProcessEvent(evt))
+    if (!window->GetEventHandler()->ProcessEvent(evt))
         return NULL;
-        
+
     return evt.GetManager();
 }
 
@@ -658,7 +924,7 @@ void wxAuiManager::UpdateHintWindowConfig()
 {
     // find out if the the system can do transparent frames
     bool can_do_transparent = false;
-    
+
     wxWindow* w = m_frame;
     while (w)
     {
@@ -666,12 +932,13 @@ void wxAuiManager::UpdateHintWindowConfig()
         {
             wxFrame* f = static_cast<wxFrame*>(w);
             can_do_transparent = f->CanSetTransparent();
+
             break;
         }
-        
+
         w = w->GetParent();
     }
-    
+
     // if there is an existing hint window, delete it
     if (m_hint_wnd)
     {
@@ -681,9 +948,9 @@ void wxAuiManager::UpdateHintWindowConfig()
 
     m_hint_fademax = 50;
     m_hint_wnd = NULL;
-    
+
     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,
@@ -701,6 +968,8 @@ void wxAuiManager::UpdateHintWindowConfig()
                                          wxDefaultPosition, wxSize(1,1),
                                          wxFRAME_FLOAT_ON_PARENT
                                          | wxFRAME_TOOL_WINDOW );
+            m_hint_wnd->Connect(wxEVT_ACTIVATE,
+                wxActivateEventHandler(wxAuiManager::OnHintActivate), NULL, this);
 
             // Can't set the bg colour of a Frame in wxMac
             wxPanel* p = new wxPanel(m_hint_wnd);
@@ -711,9 +980,9 @@ void wxAuiManager::UpdateHintWindowConfig()
             // blue.
             p->SetBackgroundColour(*wxBLUE);
         #endif
-        
+
     }
-     else
+    else
     {
         if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0 ||
             (m_flags & wxAUI_MGR_VENETIAN_BLINDS_HINT) != 0)
@@ -761,6 +1030,17 @@ void wxAuiManager::SetManagedWindow(wxWindow* wnd)
                 wxAuiPaneInfo().Name(wxT("mdiclient")).
                 CenterPane().PaneBorder(false));
     }
+    else if (m_frame->IsKindOf(CLASSINFO(wxAuiMDIParentFrame)))
+    {
+        wxAuiMDIParentFrame* mdi_frame = (wxAuiMDIParentFrame*)m_frame;
+        wxAuiMDIClientWindow* client_window = mdi_frame->GetClientWindow();
+        wxASSERT_MSG(client_window, wxT("Client window is NULL!"));
+
+        AddPane(client_window,
+                wxAuiPaneInfo().Name(wxT("mdiclient")).
+                CenterPane().PaneBorder(false));
+    }
+
 #endif
 
     UpdateHintWindowConfig();
@@ -794,7 +1074,7 @@ void wxAuiManager::ProcessMgrEvent(wxAuiManagerEvent& event)
     // first, give the owner frame a chance to override
     if (m_frame)
     {
-        if (m_frame->ProcessEvent(event))
+        if (m_frame->GetEventHandler()->ProcessEvent(event))
             return;
     }
 
@@ -818,16 +1098,27 @@ void wxAuiManager::SetArtProvider(wxAuiDockArt* art_provider)
 
 bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)
 {
+    wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed"));
+
     // check if the pane has a valid window
     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;
 
+    // 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(pane_info.IsDocked())
+    if (pane_info.IsDocked())
         RestoreMaximizedPane();
 
     m_panes.Add(pane_info);
@@ -837,11 +1128,12 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)
     // set the pane window
     pinfo.window = window;
 
+
     // 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,
+             wxPtrToUInt(pinfo.window) & 0xffffffff,
              (unsigned int)time(NULL),
 #ifdef __WXWINCE__
              (unsigned int)GetTickCount(),
@@ -861,14 +1153,14 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)
         button.button_id = wxAUI_BUTTON_MAXIMIZE_RESTORE;
         pinfo.buttons.Add(button);
     }
-    
+
     if (pinfo.HasPinButton())
     {
         wxAuiPaneButton button;
         button.button_id = wxAUI_BUTTON_PIN;
         pinfo.buttons.Add(button);
     }
-    
+
     if (pinfo.HasCloseButton())
     {
         wxAuiPaneButton button;
@@ -876,25 +1168,36 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)
         pinfo.buttons.Add(button);
     }
 
+    if (pinfo.HasGripper())
+    {
+        if (pinfo.window->IsKindOf(CLASSINFO(wxAuiToolBar)))
+        {
+            // prevent duplicate gripper -- both wxAuiManager and wxAuiToolBar
+            // have a gripper control.  The toolbar's built-in gripper
+            // meshes better with the look and feel of the control than ours,
+            // so turn wxAuiManager's gripper off, and the toolbar's on.
+
+            wxAuiToolBar* tb = static_cast<wxAuiToolBar*>(pinfo.window);
+            pinfo.SetFlag(wxAuiPaneInfo::optionGripper, false);
+            tb->SetGripperVisible(true);
+        }
+    }
+
+
     if (pinfo.best_size == wxDefaultSize &&
         pinfo.window)
     {
         pinfo.best_size = pinfo.window->GetClientSize();
 
+#if wxUSE_TOOLBAR
         if (pinfo.window->IsKindOf(CLASSINFO(wxToolBar)))
         {
             // GetClientSize() doesn't get the best size for
             // a toolbar under some newer versions of wxWidgets,
             // so use GetBestSize()
             pinfo.best_size = pinfo.window->GetBestSize();
-
-            // for some reason, wxToolBar::GetBestSize() is returning
-            // a size that is a pixel shy of the correct amount.
-            // I believe this to be the correct action, until
-            // wxToolBar::GetBestSize() is fixed.  Is this assumption
-            // correct?
-            pinfo.best_size.y++;
         }
+#endif // wxUSE_TOOLBAR
 
         if (pinfo.min_size != wxDefaultSize)
         {
@@ -905,12 +1208,14 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)
         }
     }
 
+
+
     return true;
 }
 
 bool wxAuiManager::AddPane(wxWindow* window,
-                             int direction,
-                             const wxString& caption)
+                           int direction,
+                           const wxString& caption)
 {
     wxAuiPaneInfo pinfo;
     pinfo.Caption(caption);
@@ -926,8 +1231,8 @@ 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;
@@ -942,6 +1247,8 @@ bool wxAuiManager::AddPane(wxWindow* window,
 bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info,
                                 int insert_level)
 {
+    wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed"));
+
     // shift the panes around, depending on the insert level
     switch (insert_level)
     {
@@ -972,7 +1279,7 @@ bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info,
     {
         return AddPane(window, pane_info);
     }
-     else
+    else
     {
         if (pane_info.IsFloating())
         {
@@ -982,7 +1289,7 @@ bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info,
             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();
@@ -1002,6 +1309,8 @@ bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info,
 // method will not destroy the window that is removed.
 bool wxAuiManager::DetachPane(wxWindow* window)
 {
+    wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed"));
+
     int i, count;
     for (i = 0, count = m_panes.GetCount(); i < count; ++i)
     {
@@ -1020,11 +1329,11 @@ bool wxAuiManager::DetachPane(wxWindow* window)
                     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;
                 }
-                
+
                 p.window->Reparent(m_frame);
                 p.frame->SetSizer(NULL);
                 p.frame->Destroy();
@@ -1055,8 +1364,7 @@ bool wxAuiManager::DetachPane(wxWindow* window)
     return false;
 }
 
-// ClosePane() destroys or hides the pane depending on its
-// flags
+// ClosePane() destroys or hides the pane depending on its flags
 void wxAuiManager::ClosePane(wxAuiPaneInfo& pane_info)
 {
     // if we were maximized, restore
@@ -1085,16 +1393,16 @@ void wxAuiManager::ClosePane(wxAuiPaneInfo& pane_info)
     }
 
     // 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);
-        if(window)
+        if (window)
         {
             window->Destroy();
         }
-    } 
-    else 
+    }
+    else
     {
         pane_info.Hide();
     }
@@ -1108,10 +1416,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);
-        if (!p.IsToolbar())
+        if (!p.IsToolbar() && !p.IsFloating())
         {
             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();
         }
     }
@@ -1138,7 +1452,8 @@ void wxAuiManager::RestorePane(wxAuiPaneInfo& pane_info)
         wxAuiPaneInfo& p = m_panes.Item(i);
         if (!p.IsToolbar())
         {
-            p.RestoreHidden();
+            p.SetFlag(wxAuiPaneInfo::optionHidden,
+                      p.HasFlag(wxAuiPaneInfo::savedHiddenState));
         }
     }
 
@@ -1161,7 +1476,7 @@ void wxAuiManager::RestoreMaximizedPane()
     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;
@@ -1303,7 +1618,7 @@ wxString wxAuiManager::SavePerspective()
 {
     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)
@@ -1334,11 +1649,13 @@ bool wxAuiManager::LoadPerspective(const wxString& layout, bool update)
     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);
-    if (part != wxT("layout1"))
+    if (part != wxT("layout2"))
         return false;
 
     // mark all panes currently managed as docked and hidden
@@ -1400,12 +1717,11 @@ bool wxAuiManager::LoadPerspective(const wxString& layout, bool update)
         if (!p.IsOk())
         {
             // the pane window couldn't be found
-            // in the existing layout
-            return false;
+            // in the existing layout -- skip it
+            continue;
         }
 
         p.SafeSet(pane);
-
     }
 
     if (update)
@@ -1415,8 +1731,8 @@ bool wxAuiManager::LoadPerspective(const wxString& layout, bool update)
 }
 
 void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
-                                              wxArrayInt& positions,
-                                              wxArrayInt& sizes)
+                                            wxArrayInt& positions,
+                                            wxArrayInt& sizes)
 {
     int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
     int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
@@ -1433,7 +1749,7 @@ void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
     {
         wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
 
-        if (pane.state & wxAuiPaneInfo::actionPane)
+        if (pane.HasFlag(wxAuiPaneInfo::actionPane))
         {
             wxASSERT_MSG(action_pane==-1, wxT("Too many fixed action panes"));
             action_pane = pane_i;
@@ -1458,7 +1774,7 @@ void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
                 size += gripper_size;
             size += pane.best_size.x;
         }
-         else
+        else
         {
             if (pane.HasGripper() && pane.HasGripperTop())
                 size += gripper_size;
@@ -1483,7 +1799,7 @@ void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
 
         if (amount >= 0)
             offset += amount;
-             else
+        else
             positions[pane_i] -= -amount;
 
         offset += sizes[pane_i];
@@ -1497,7 +1813,7 @@ void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
         int amount = positions[pane_i] - offset;
         if (amount >= 0)
             offset += amount;
-             else
+        else
             positions[pane_i] += -amount;
 
         offset += sizes[pane_i];
@@ -1506,10 +1822,10 @@ void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
 
 
 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;
@@ -1524,15 +1840,15 @@ void wxAuiManager::LayoutAddPane(wxSizer* cont,
     int orientation;
     if (dock.IsHorizontal())
         orientation = wxHORIZONTAL;
-         else
+    else
         orientation = wxVERTICAL;
 
     // this variable will store the proportion
     // value that the pane will receive
     int pane_proportion = pane.dock_proportion;
 
-    wxBoxSizer* horz_pane_sizer = new wxBoxSizer(wxHORIZONTAL);
-    wxBoxSizer* vert_pane_sizer = new wxBoxSizer(wxVERTICAL);
+    wxAuiProportionalBoxSizer* horz_pane_sizer = new wxAuiProportionalBoxSizer(wxHORIZONTAL);
+    wxAuiProportionalBoxSizer* vert_pane_sizer = new wxAuiProportionalBoxSizer(wxVERTICAL);
 
     if (pane.HasGripper())
     {
@@ -1554,7 +1870,7 @@ void wxAuiManager::LayoutAddPane(wxSizer* cont,
     if (pane.HasCaption())
     {
         // create the caption sizer
-        wxBoxSizer* caption_sizer = new wxBoxSizer(wxHORIZONTAL);
+        wxAuiProportionalBoxSizer* caption_sizer = new wxAuiProportionalBoxSizer(wxHORIZONTAL);
 
         sizer_item = caption_sizer->Add(1, caption_size, 1, wxEXPAND);
 
@@ -1588,7 +1904,7 @@ void wxAuiManager::LayoutAddPane(wxSizer* cont,
             part.sizer_item = sizer_item;
             uiparts.Add(part);
         }
-        
+
         // if we have buttons, add a little space to the right
         // of them to ease visual crowding
         if (button_count >= 1)
@@ -1627,7 +1943,7 @@ void wxAuiManager::LayoutAddPane(wxSizer* cont,
 
 
     // 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;
@@ -1676,9 +1992,9 @@ void wxAuiManager::LayoutAddPane(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;
@@ -1703,7 +2019,7 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
     }
 
     // create the sizer for the dock
-    wxSizer* dock_sizer = new wxBoxSizer(orientation);
+    wxSizer* dock_sizer = new wxAuiProportionalBoxSizer(orientation);
 
     // add each pane to the dock
     bool has_maximized_pane = false;
@@ -1722,16 +2038,17 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
         {
             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;
-            }
+
 
             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;
@@ -1752,7 +2069,7 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
         }
 
         // 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;
@@ -1768,9 +2085,9 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
         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;
-            }
 
             // if this is not the first pane being added,
             // we need to add a pane sizer
@@ -1794,7 +2111,7 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
 
     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;
@@ -1808,12 +2125,14 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
 
     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
-    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);
 
@@ -1829,11 +2148,11 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont,
 }
 
 wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
-                                   wxAuiDockInfoArray& docks,
-                                   wxAuiDockUIPartArray& uiparts,
-                                   bool spacer_only)
+                                 wxAuiDockInfoArray& docks,
+                                 wxAuiDockUIPartArray& uiparts,
+                                 bool spacer_only)
 {
-    wxBoxSizer* container = new wxBoxSizer(wxVERTICAL);
+    wxAuiProportionalBoxSizer* container = new wxAuiProportionalBoxSizer(wxVERTICAL);
 
     int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
     int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
@@ -1843,7 +2162,19 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
 
     // 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
@@ -1853,16 +2184,18 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
     {
         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)
         {
+            // found the right dock
             dock = arr.Item(0);
         }
-         else
+        else
         {
             // dock was not found, so we need to create a new one
             wxAuiDockInfo d;
@@ -1884,7 +2217,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
             if (!FindPaneInDock(*dock, p.window))
                 dock->panes.Add(&p);
         }
-         else
+        else
         {
             // remove the pane from any existing docks
             RemovePaneFromDocks(docks, p);
@@ -1925,7 +2258,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
 
                 if (dock.IsHorizontal())
                     size = wxMax(pane_size.y, size);
-                     else
+                else
                     size = wxMax(pane_size.x, size);
             }
 
@@ -1954,17 +2287,22 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
                 }
             }
 
-            if (!(m_flags & wxAUI_MGR_NO_DOCK_SIZE_LIMIT))
-            {
-                // new dock's size may not be more than 1/3 of the frame size
-                if (dock.IsHorizontal())
-                    size = wxMin(size, cli_size.y/3);
-                     else
-                    size = wxMin(size, cli_size.x/3);
-            }
-            
+
+            // 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())
+                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;
+
             dock.size = size;
         }
 
@@ -1987,7 +2325,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
                     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;
@@ -2021,7 +2359,9 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
                 dock.fixed = false;
             if (!pane.IsToolbar())
                 dock.toolbar = false;
-            if (pane.state & wxAuiPaneInfo::actionPane)
+            if (pane.HasFlag(wxAuiPaneInfo::optionDockFixed))
+                dock.fixed = true;
+            if (pane.HasFlag(wxAuiPaneInfo::actionPane))
                 action_pane_marked = true;
         }
 
@@ -2041,7 +2381,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
-        // adjust the panes' positions
+        // adjust the positions of the panes
         if (dock.fixed && !action_pane_marked)
         {
             wxArrayInt pane_positions, pane_sizes;
@@ -2056,7 +2396,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
                 int amount = pane.dock_pos - offset;
                 if (amount >= 0)
                     offset += amount;
-                     else
+                else
                     pane.dock_pos += -amount;
 
                 offset += pane_sizes[j];
@@ -2095,12 +2435,11 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
 
         // create a container which will hold this layer's
         // docks (top, bottom, left, right)
-        cont = new wxBoxSizer(wxVERTICAL);
+        cont = new wxAuiProportionalBoxSizer(wxVERTICAL);
 
 
         // find any top docks in this layer
         FindDocks(docks, wxAUI_DOCK_TOP, layer, -1, arr);
-        RenumberDockRows(arr);
         if (!arr.IsEmpty())
         {
             for (row = 0, row_count = arr.GetCount(); row < row_count; ++row)
@@ -2111,11 +2450,10 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
         // fill out the middle layer (which consists
         // of left docks, content area and right docks)
 
-        middle = new wxBoxSizer(wxHORIZONTAL);
+        middle = new wxAuiProportionalBoxSizer(wxHORIZONTAL);
 
         // find any left docks in this layer
         FindDocks(docks, wxAUI_DOCK_LEFT, layer, -1, arr);
-        RenumberDockRows(arr);
         if (!arr.IsEmpty())
         {
             for (row = 0, row_count = arr.GetCount(); row < row_count; ++row)
@@ -2133,7 +2471,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);
             }
-             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);
@@ -2147,27 +2485,28 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
                 uiparts.Add(part);
             }
         }
-         else
+        else
         {
             middle->Add(old_cont, 1, wxEXPAND);
         }
 
         // find any right docks in this layer
         FindDocks(docks, wxAUI_DOCK_RIGHT, layer, -1, arr);
-        RenumberDockRows(arr);
         if (!arr.IsEmpty())
         {
             for (row = arr.GetCount()-1; row >= 0; --row)
                 LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only);
         }
 
-        cont->Add(middle, 1, wxEXPAND);
+        if (middle->GetChildren().GetCount() > 0)
+            cont->Add(middle, 1, wxEXPAND);
+             else
+            delete middle;
 
 
 
         // find any bottom docks in this layer
         FindDocks(docks, wxAUI_DOCK_BOTTOM, layer, -1, arr);
-        RenumberDockRows(arr);
         if (!arr.IsEmpty())
         {
             for (row = arr.GetCount()-1; row >= 0; --row)
@@ -2180,7 +2519,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
     {
         // no sizer available, because there are no docks,
         // therefore we will create a simple background area
-        cont = new wxBoxSizer(wxVERTICAL);
+        cont = new wxAuiProportionalBoxSizer(wxVERTICAL);
         wxSizerItem* sizer_item = cont->Add(1,1, 1, wxEXPAND);
         wxAuiDockUIPart part;
         part.type = wxAuiDockUIPart::typeBackground;
@@ -2197,12 +2536,36 @@ 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.
 
 void wxAuiManager::Update()
 {
+    m_hover_button = NULL;
+    m_action_part = NULL;
+
     wxSizer* sizer;
     int i, pane_count = m_panes.GetCount();
 
@@ -2222,30 +2585,30 @@ void wxAuiManager::Update()
             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_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(m_action_window == p.frame)
+            if (m_action_window == p.frame)
             {
                 m_action_window = NULL;
             }
-            
+
             p.window->Reparent(m_frame);
             p.frame->SetSizer(NULL);
             p.frame->Destroy();
@@ -2287,23 +2650,28 @@ void wxAuiManager::Update()
                 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)
+                if ((p.frame->GetPosition() != p.floating_pos) || (p.frame->GetSize() != p.floating_size))
                 {
+                    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);
+                */
                 }
 
                 if (p.frame->IsShown() != p.IsShown())
                     p.frame->Show(p.IsShown());
             }
         }
-         else
+        else
         {
             if (p.window->IsShown() != p.IsShown())
                 p.window->Show(p.IsShown());
@@ -2506,7 +2874,7 @@ int wxAuiManager::GetDockPixelOffset(wxAuiPaneInfo& test)
         {
             if (dock.IsVertical())
                 return dock.rect.y;
-                 else
+            else
                 return dock.rect.x;
         }
     }
@@ -2521,7 +2889,7 @@ int wxAuiManager::GetDockPixelOffset(wxAuiPaneInfo& test)
 // 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)
@@ -2553,10 +2921,10 @@ const int auiLayerInsertPixels = 40;
 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();
 
@@ -2572,15 +2940,20 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
 
 
     int layer_insert_offset = auiLayerInsertOffset;
-    if (target.IsToolbar())
+    if (drop.IsToolbar())
         layer_insert_offset = 0;
 
+
     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;  
+                                GetMaxLayer(docks, wxAUI_DOCK_TOP)) + 1;
+
+        if (drop.IsToolbar())
+            new_layer = auiToolBarLayer;
+
         drop.Dock().Left().
              Layer(new_layer).
              Row(0).
@@ -2593,6 +2966,10 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
         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().
              Layer(new_layer).
              Row(0).
@@ -2604,8 +2981,11 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
     {
         int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT),
                                 GetMaxLayer(docks, wxAUI_DOCK_TOP)),
-                                GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)) + 1; 
-                                
+                                GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)) + 1;
+
+        if (drop.IsToolbar())
+            new_layer = auiToolBarLayer;
+
         drop.Dock().Right().
              Layer(new_layer).
              Row(0).
@@ -2619,6 +2999,9 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
                                       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).
@@ -2626,6 +3009,7 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
         return ProcessDockResult(target, drop);
     }
 
+
     wxAuiDockUIPart* part = HitTest(pt.x, pt.y);
 
 
@@ -2639,14 +3023,15 @@ 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;
-             else
+        else
             dock_drop_offset = pt.y - part->dock->rect.y - offset.y;
 
 
         // toolbars may only be moved in and to fixed-pane docks,
         // otherwise we will try to float the pane.  Also, the pane
         // should float if being dragged over center pane windows
-        if (!part->dock->fixed || part->dock->dock_direction == wxAUI_DOCK_CENTER)
+        if (!part->dock->fixed || part->dock->dock_direction == wxAUI_DOCK_CENTER ||
+            pt.x >= cli_size.x || pt.x <= 0 || pt.y >= cli_size.y || pt.y <= 0)
         {
             if (m_last_rect.IsEmpty() || m_last_rect.Contains(pt.x, pt.y ))
             {
@@ -2654,10 +3039,7 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
             }
             else
             {
-                if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
-                   (drop.IsFloatable() ||
-                    (part->dock->dock_direction != wxAUI_DOCK_CENTER &&
-                     part->dock->dock_direction != wxAUI_DOCK_NONE)))
+                if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) && drop.IsFloatable())
                 {
                     drop.Float();
                 }
@@ -2671,16 +3053,11 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
 
             return ProcessDockResult(target, drop);
         }
-        else
-        {
-            m_skipping = false;
-        }
 
-        if (!m_skipping)
-        {
-            m_last_rect = part->dock->rect;
-            m_last_rect.Inflate( 15, 15 );
-        }
+        m_skipping = false;
+
+        m_last_rect = part->dock->rect;
+        m_last_rect.Inflate( 15, 15 );
 
         drop.Dock().
              Direction(part->dock->dock_direction).
@@ -2858,23 +3235,19 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
 
                 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;
             }
@@ -2900,7 +3273,7 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
             offset = pt.y - part->rect.y;
             size = part->rect.GetHeight();
         }
-         else
+        else
         {
             offset = pt.x - part->rect.x;
             size = part->rect.GetWidth();
@@ -2949,6 +3322,8 @@ void wxAuiManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event))
     if (!m_hint_wnd || m_hint_fadeamt >= m_hint_fademax)
     {
         m_hint_fadetimer.Stop();
+        Disconnect(m_hint_fadetimer.GetId(), wxEVT_TIMER,
+                   wxTimerEventHandler(wxAuiManager::OnHintFadeTimer));
         return;
     }
 
@@ -2966,7 +3341,7 @@ void wxAuiManager::ShowHint(const wxRect& rect)
         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))
@@ -2974,6 +3349,7 @@ void wxAuiManager::ShowHint(const wxRect& rect)
             m_hint_fadeamt = 0;
 
         m_hint_wnd->SetSize(rect);
+        m_hint_wnd->SetTransparent(m_hint_fadeamt);
 
         if (!m_hint_wnd->IsShown())
             m_hint_wnd->Show();
@@ -2983,22 +3359,23 @@ void wxAuiManager::ShowHint(const wxRect& rect)
         if (m_action == actionDragFloatingPane && m_action_window)
             m_action_window->SetFocus();
 
-        m_hint_wnd->SetTransparent(m_hint_fadeamt);
         m_hint_wnd->Raise();
 
 
         if (m_hint_fadeamt != m_hint_fademax) //  Only fade if we need to
         {
             // start fade in timer
-            m_hint_fadetimer.SetOwner(this, 101);
+            m_hint_fadetimer.SetOwner(this);
             m_hint_fadetimer.Start(5);
+            Connect(m_hint_fadetimer.GetId(), wxEVT_TIMER,
+                    wxTimerEventHandler(wxAuiManager::OnHintFadeTimer));
         }
     }
-     else  // Not using a transparent hint window...
+    else  // Not using a transparent hint window...
     {
         if (!(m_flags & wxAUI_MGR_RECTANGLE_HINT))
             return;
-            
+
         if (m_last_hint != rect)
         {
             // remove the last hint rectangle
@@ -3036,7 +3413,7 @@ void wxAuiManager::ShowHint(const wxRect& rect)
         // nasty redrawn problems.
         clip.Intersect(m_frame->GetRect());
 
-        screendc.SetClippingRegion(clip);
+        screendc.SetDeviceClippingRegion(clip);
 
         wxBitmap stipple = wxPaneCreateStippleBitmap();
         wxBrush brush(stipple);
@@ -3059,6 +3436,10 @@ void wxAuiManager::HideHint()
             m_hint_wnd->Show(false);
         m_hint_wnd->SetTransparent(0);
         m_hint_fadetimer.Stop();
+        // In case this is called while a hint fade is going, we need to
+        // disconnect the event handler.
+        Disconnect(m_hint_fadetimer.GetId(), wxEVT_TIMER,
+                   wxTimerEventHandler(wxAuiManager::OnHintFadeTimer));
         m_last_hint = wxRect();
         return;
     }
@@ -3072,6 +3453,17 @@ void wxAuiManager::HideHint()
     }
 }
 
+void wxAuiManager::OnHintActivate(wxActivateEvent& WXUNUSED(event))
+{
+    // Do nothing so this event isn't handled in the base handlers.
+
+    // Letting the hint window activate without this handler can lead to
+    // weird behavior on Mac where the menu is switched out to the top
+    // window's menu in MDI applications when it shouldn't be. So since
+    // we don't want user interaction with the hint window anyway, we just
+    // prevent it from activating here.
+}
+
 
 
 void wxAuiManager::StartPaneDrag(wxWindow* pane_window,
@@ -3080,16 +3472,16 @@ void wxAuiManager::StartPaneDrag(wxWindow* pane_window,
     wxAuiPaneInfo& pane = GetPane(pane_window);
     if (!pane.IsOk())
         return;
-    
+
     if (pane.IsToolbar())
     {
         m_action = actionDragToolbarPane;
     }
-     else
+    else
     {
         m_action = actionDragFloatingPane;
     }
-    
+
     m_action_window = pane_window;
     m_action_offset = offset;
     m_frame->CaptureMouse();
@@ -3122,6 +3514,7 @@ wxRect wxAuiManager::CalculateHintRect(wxWindow* pane_window,
     wxAuiDockUIPartArray uiparts;
     wxAuiPaneInfo hint = GetPane(pane_window);
     hint.name = wxT("__HINT__");
+    hint.PaneBorder(true);
     hint.Show();
 
     if (!hint.IsOk())
@@ -3178,6 +3571,12 @@ wxRect wxAuiManager::CalculateHintRect(wxWindow* pane_window,
     // actually show the hint rectangle on the screen
     m_frame->ClientToScreen(&rect.x, &rect.y);
 
+    if ( m_frame->GetLayoutDirection() == wxLayout_RightToLeft )
+    {
+        // Mirror rectangle in RTL mode
+        rect.x -= rect.GetWidth();
+    }
+
     return rect;
 }
 
@@ -3190,12 +3589,12 @@ void wxAuiManager::DrawHintRect(wxWindow* pane_window,
                                 const wxPoint& offset)
 {
     wxRect rect = CalculateHintRect(pane_window, pt, offset);
-    
+
     if (rect.IsEmpty())
     {
         HideHint();
     }
-     else
+    else
     {
         ShowHint(rect);
     }
@@ -3207,6 +3606,9 @@ void wxAuiManager::OnFloatingPaneMoveStart(wxWindow* wnd)
     wxAuiPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
+    if(!pane.frame)
+        return;
+
     if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
         pane.frame->SetTransparent(150);
 }
@@ -3217,6 +3619,9 @@ void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)
     wxAuiPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
+    if(!pane.frame)
+        return;
+
     wxPoint pt = ::wxGetMousePosition();
 
 #if 0
@@ -3229,22 +3634,22 @@ void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)
         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;
-    } 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;
-    } else
-    if (dir == wxSOUTH)
+    }
+    else if (dir == wxSOUTH)
     {
         // move to pane's bottom border
         wxPoint pos( 0, wnd->GetSize().y );
@@ -3265,27 +3670,24 @@ void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)
     // no hint for toolbar floating windows
     if (pane.IsToolbar() && m_action == actionDragFloatingPane)
     {
-        if (m_action == actionDragFloatingPane)
-        {
-            wxAuiDockInfoArray docks;
-            wxAuiPaneInfoArray panes;
-            wxAuiDockUIPartArray uiparts;
-            wxAuiPaneInfo 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);
 
-            // find out where the new pane would be
-            if (!DoDrop(docks, panes, hint, client_pt))
-                return;
-            if (hint.IsFloating())
-                return;
+        // find out where the new pane would be
+        if (!DoDrop(docks, panes, hint, client_pt))
+            return;
+        if (hint.IsFloating())
+            return;
 
-            pane = hint;
-            m_action = actionDragToolbarPane;
-            m_action_window = pane.window;
+        pane = hint;
+        m_action = actionDragToolbarPane;
+        m_action_window = pane.window;
 
-            Update();
-        }
+        Update();
 
         return;
     }
@@ -3293,7 +3695,7 @@ void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)
 
     // if a key modifier is pressed while dragging the frame,
     // don't dock the window
-    if (wxGetKeyState(WXK_CONTROL) || wxGetKeyState(WXK_ALT))
+    if (!CanDockPanel(pane))
     {
         HideHint();
         return;
@@ -3320,6 +3722,9 @@ void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir)
     wxAuiPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
+    if(!pane.frame)
+        return;
+
     wxPoint pt = ::wxGetMousePosition();
 
 #if 0
@@ -3332,22 +3737,22 @@ void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir)
         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;
-    } 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;
-    } else
-    if (dir == wxSOUTH)
+    }
+    else if (dir == wxSOUTH)
     {
         // move to pane's bottom border
         wxPoint pos( 0, wnd->GetSize().y );
@@ -3365,10 +3770,9 @@ void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir)
     wxPoint frame_pos = pane.frame->GetPosition();
     wxPoint action_offset(pt.x-frame_pos.x, pt.y-frame_pos.y);
 
-
     // if a key modifier is pressed while dragging the frame,
     // don't dock the window
-    if (!wxGetKeyState(WXK_CONTROL) && !wxGetKeyState(WXK_ALT))
+    if (CanDockPanel(pane))
     {
         // do the drop calculation
         DoDrop(m_docks, m_panes, pane, client_pt, action_offset);
@@ -3383,7 +3787,7 @@ void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir)
         if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
             pane.frame->SetTransparent(255);
     }
-     else if (m_has_maximized)
+    else if (m_has_maximized)
     {
         RestoreMaximizedPane();
     }
@@ -3411,7 +3815,7 @@ void wxAuiManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt)
 
 
     // fire pane close event
-    wxAuiManagerEvent e(wxEVT_AUI_PANECLOSE);
+    wxAuiManagerEvent e(wxEVT_AUI_PANE_CLOSE);
     e.SetPane(&pane);
     e.SetCanVeto(evt.CanVeto());
     ProcessMgrEvent(e);
@@ -3421,9 +3825,17 @@ void wxAuiManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt)
         evt.Veto();
         return;
     }
-     else 
+    else
     {
-        ClosePane(pane);
+        // close the pane, but check that it
+        // still exists in our pane array first
+        // (the event handler above might have removed it)
+
+        wxAuiPaneInfo& check = GetPane(wnd);
+        if (check.IsOk())
+        {
+            ClosePane(pane);
+        }
     }
 }
 
@@ -3431,11 +3843,8 @@ void wxAuiManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt)
 
 void wxAuiManager::OnFloatingPaneActivated(wxWindow* wnd)
 {
-    if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
+    if ((GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE) && GetPane(wnd).IsOk())
     {
-        // try to find the pane
-        wxASSERT_MSG(GetPane(wnd).IsOk(), wxT("Pane window not found"));
-
         SetActivePane(m_panes, wnd);
         Repaint();
     }
@@ -3447,6 +3856,10 @@ void wxAuiManager::OnFloatingPaneActivated(wxWindow* wnd)
 
 void wxAuiManager::OnRender(wxAuiManagerEvent& evt)
 {
+    // if the frame is about to be deleted, don't bother
+    if (!m_frame || wxPendingDelete.Member(m_frame))
+        return;
+
     wxDC* dc = evt.GetDC();
 
 #ifdef __WXMAC__
@@ -3458,8 +3871,8 @@ void wxAuiManager::OnRender(wxAuiManagerEvent& evt)
     {
         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 or items that aren't windows
+        if (part.sizer_item && ((!part.sizer_item->IsWindow() && !part.sizer_item->IsSpacer() && !part.sizer_item->IsSizer()) || !part.sizer_item->IsShown()))
             continue;
 
         switch (part.type)
@@ -3561,7 +3974,7 @@ void wxAuiManager::OnSize(wxSizeEvent& event)
     {
         DoFrameLayout();
         Repaint();
-        
+
 #if wxUSE_MDI
         if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
         {
@@ -3585,7 +3998,7 @@ void wxAuiManager::OnFindManager(wxAuiManagerEvent& evt)
         evt.SetManager(NULL);
         return;
     }
-    
+
     // if we are managing a child frame, get the 'real' manager
     if (window->IsKindOf(CLASSINFO(wxAuiFloatingFrame)))
     {
@@ -3593,7 +4006,7 @@ void wxAuiManager::OnFindManager(wxAuiManagerEvent& evt)
         evt.SetManager(float_frame->GetOwnerManager());
         return;
     }
-        
+
     // return pointer to ourself
     evt.SetManager(this);
 }
@@ -3622,10 +4035,10 @@ void wxAuiManager::OnSetCursor(wxSetCursorEvent& event)
 
             if (part->orientation == wxVERTICAL)
                 cursor = wxCursor(wxCURSOR_SIZEWE);
-                 else
+            else
                 cursor = wxCursor(wxCURSOR_SIZENS);
         }
-         else if (part->type == wxAuiDockUIPart::typeGripper)
+        else if (part->type == wxAuiDockUIPart::typeGripper)
         {
             cursor = wxCursor(wxCURSOR_SIZING);
         }
@@ -3642,17 +4055,17 @@ void wxAuiManager::UpdateButtonOnScreen(wxAuiDockUIPart* button_ui_part,
     wxAuiDockUIPart* hit_test = HitTest(event.GetX(), event.GetY());
     if (!hit_test || !button_ui_part)
         return;
-        
+
     int state = wxAUI_BUTTON_STATE_NORMAL;
 
     if (hit_test == button_ui_part)
     {
         if (event.LeftDown())
             state = wxAUI_BUTTON_STATE_PRESSED;
-             else
+        else
             state = wxAUI_BUTTON_STATE_HOVER;
     }
-     else
+    else
     {
         if (event.LeftDown())
             state = wxAUI_BUTTON_STATE_HOVER;
@@ -3679,15 +4092,18 @@ void wxAuiManager::UpdateButtonOnScreen(wxAuiDockUIPart* button_ui_part,
 
 void wxAuiManager::OnLeftDown(wxMouseEvent& event)
 {
+    m_currentDragItem = -1;
+
     wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY());
     if (part)
     {
         if (part->type == wxAuiDockUIPart::typeDockSizer ||
             part->type == wxAuiDockUIPart::typePaneSizer)
         {
-            if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER)
-                return;
-        
+            // Removing this restriction so that a centre pane can be resized
+            //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 &&
@@ -3707,7 +4123,7 @@ void wxAuiManager::OnLeftDown(wxMouseEvent& event)
                                       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;
@@ -3716,11 +4132,28 @@ void wxAuiManager::OnLeftDown(wxMouseEvent& event)
 
             UpdateButtonOnScreen(part, event);
         }
-         else if (part->type == wxAuiDockUIPart::typeCaption ||
+        else if (part->type == wxAuiDockUIPart::typeCaption ||
                   part->type == wxAuiDockUIPart::typeGripper)
         {
-            if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER)
+            // 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 (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
             {
@@ -3729,6 +4162,9 @@ void wxAuiManager::OnLeftDown(wxMouseEvent& event)
                 Repaint();
             }
 
+            if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER)
+                return;
+
             m_action = actionClickCaption;
             m_action_part = part;
             m_action_start = wxPoint(event.m_x, event.m_y);
@@ -3753,212 +4189,310 @@ void wxAuiManager::OnLeftDown(wxMouseEvent& event)
 #endif
 }
 
-
-void wxAuiManager::OnLeftUp(wxMouseEvent& event)
+/// Ends a resize action, or for live update, resizes the sash
+bool wxAuiManager::DoEndResizeAction(wxMouseEvent& event)
 {
-    if (m_action == actionResize)
+    // resize the dock or the pane
+    if (m_action_part && m_action_part->type==wxAuiDockUIPart::typeDockSizer)
     {
-        m_frame->ReleaseMouse();
+        // first, we must calculate the maximum size the dock may be
+        int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE);
 
-        // get rid of the hint rectangle
-        wxScreenDC dc;
-        DrawResizeHint(dc, m_action_hintrect);
+        int used_width = 0, used_height = 0;
 
-        // resize the dock or the pane
-        if (m_action_part && m_action_part->type==wxAuiDockUIPart::typeDockSizer)
+        wxSize client_size = m_frame->GetClientSize();
+
+        size_t dock_i, dock_count = m_docks.GetCount();
+        for (dock_i = 0; dock_i < dock_count; ++dock_i)
         {
-            wxRect& rect = m_action_part->dock->rect;
+            wxAuiDockInfo& dock = m_docks.Item(dock_i);
+            if (dock.dock_direction == wxAUI_DOCK_TOP ||
+                dock.dock_direction == wxAUI_DOCK_BOTTOM)
+            {
+                used_height += dock.size;
+            }
+            if (dock.dock_direction == wxAUI_DOCK_LEFT ||
+                dock.dock_direction == wxAUI_DOCK_RIGHT)
+            {
+                used_width += dock.size;
+            }
+            if (dock.resizable)
+                used_width += sash_size;
+        }
 
-            wxPoint new_pos(event.m_x - m_action_offset.x,
-                            event.m_y - m_action_offset.y);
 
-            switch (m_action_part->dock->dock_direction)
+        int available_width = client_size.GetWidth() - used_width;
+        int available_height = client_size.GetHeight() - used_height;
+
+
+#if wxUSE_STATUSBAR
+        // if there's a status control, the available
+        // height decreases accordingly
+        if (m_frame && m_frame->IsKindOf(CLASSINFO(wxFrame)))
+        {
+            wxFrame* frame = static_cast<wxFrame*>(m_frame);
+            wxStatusBar* status = frame->GetStatusBar();
+            if (status)
             {
-                case wxAUI_DOCK_LEFT:
-                    m_action_part->dock->size = new_pos.x - rect.x;
-                    break;
-                case wxAUI_DOCK_TOP:
-                    m_action_part->dock->size = new_pos.y - rect.y;
-                    break;
-                case wxAUI_DOCK_RIGHT:
-                    m_action_part->dock->size = rect.x + rect.width -
-                                  new_pos.x - m_action_part->rect.GetWidth();
-                    break;
-                case wxAUI_DOCK_BOTTOM:
-                    m_action_part->dock->size = rect.y + rect.height -
-                                  new_pos.y - m_action_part->rect.GetHeight();
-                    break;
+                wxSize status_client_size = status->GetClientSize();
+                available_height -= status_client_size.GetHeight();
             }
-
-            Update();
-            Repaint(NULL);
         }
-         else if (m_action_part &&
-                  m_action_part->type == wxAuiDockUIPart::typePaneSizer)
+#endif
+
+        wxRect& rect = m_action_part->dock->rect;
+
+        wxPoint new_pos(event.m_x - m_action_offset.x,
+            event.m_y - m_action_offset.y);
+        int new_size, old_size = m_action_part->dock->size;
+
+        switch (m_action_part->dock->dock_direction)
         {
-            wxAuiDockInfo& dock = *m_action_part->dock;
-            wxAuiPaneInfo& pane = *m_action_part->pane;
+        case wxAUI_DOCK_LEFT:
+            new_size = new_pos.x - rect.x;
+            if (new_size-old_size > available_width)
+                new_size = old_size+available_width;
+            m_action_part->dock->size = new_size;
+            break;
+        case wxAUI_DOCK_TOP:
+            new_size = new_pos.y - rect.y;
+            if (new_size-old_size > available_height)
+                new_size = old_size+available_height;
+            m_action_part->dock->size = new_size;
+            break;
+        case wxAUI_DOCK_RIGHT:
+            new_size = rect.x + rect.width - new_pos.x -
+                       m_action_part->rect.GetWidth();
+            if (new_size-old_size > available_width)
+                new_size = old_size+available_width;
+            m_action_part->dock->size = new_size;
+            break;
+        case wxAUI_DOCK_BOTTOM:
+            new_size = rect.y + rect.height -
+                new_pos.y - m_action_part->rect.GetHeight();
+            if (new_size-old_size > available_height)
+                new_size = old_size+available_height;
+            m_action_part->dock->size = new_size;
+            break;
+        }
 
-            int total_proportion = 0;
-            int dock_pixels = 0;
-            int new_pixsize = 0;
+        Update();
+        Repaint(NULL);
+    }
+    else if (m_action_part &&
+        m_action_part->type == wxAuiDockUIPart::typePaneSizer)
+    {
+        wxAuiDockInfo& dock = *m_action_part->dock;
+        wxAuiPaneInfo& pane = *m_action_part->pane;
 
-            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);
+        int total_proportion = 0;
+        int dock_pixels = 0;
+        int new_pixsize = 0;
 
-            wxPoint new_pos(event.m_x - m_action_offset.x,
-                            event.m_y - m_action_offset.y);
+        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);
 
-            // determine the pane rectangle by getting the pane part
-            wxAuiDockUIPart* pane_part = GetPanePart(pane.window);
-            wxASSERT_MSG(pane_part,
-                       wxT("Pane border part not found -- shouldn't happen"));
+        wxPoint new_pos(event.m_x - m_action_offset.x,
+            event.m_y - m_action_offset.y);
 
-            // determine the new pixel size that the user wants;
-            // this will help us recalculate the pane's proportion
-            if (dock.IsHorizontal())
-                new_pixsize = new_pos.x - pane_part->rect.x;
-                 else
-                new_pixsize = new_pos.y - pane_part->rect.y;
+        // determine the pane rectangle by getting the pane part
+        wxAuiDockUIPart* pane_part = GetPanePart(pane.window);
+        wxASSERT_MSG(pane_part,
+            wxT("Pane border part not found -- shouldn't happen"));
 
-            // determine the size of the dock, based on orientation
-            if (dock.IsHorizontal())
-                dock_pixels = dock.rect.GetWidth();
-                 else
-                dock_pixels = dock.rect.GetHeight();
+        // determine the new pixel size that the user wants;
+        // this will help us recalculate the pane's proportion
+        if (dock.IsHorizontal())
+            new_pixsize = new_pos.x - pane_part->rect.x;
+        else
+            new_pixsize = new_pos.y - pane_part->rect.y;
 
-            // determine the total proportion of all resizable panes,
-            // and the total size of the dock minus the size of all
-            // the fixed panes
-            int i, dock_pane_count = dock.panes.GetCount();
-            int pane_position = -1;
-            for (i = 0; i < dock_pane_count; ++i)
+        // determine the size of the dock, based on orientation
+        if (dock.IsHorizontal())
+            dock_pixels = dock.rect.GetWidth();
+        else
+            dock_pixels = dock.rect.GetHeight();
+
+        // determine the total proportion of all resizable panes,
+        // and the total size of the dock minus the size of all
+        // the fixed panes
+        int i, dock_pane_count = dock.panes.GetCount();
+        int pane_position = -1;
+        for (i = 0; i < dock_pane_count; ++i)
+        {
+            wxAuiPaneInfo& p = *dock.panes.Item(i);
+            if (p.window == pane.window)
+                pane_position = i;
+
+            // while we're at it, subtract the pane sash
+            // width from the dock width, because this would
+            // skew our proportion calculations
+            if (i > 0)
+                dock_pixels -= sash_size;
+
+            // also, the whole size (including decorations) of
+            // all fixed panes must also be subtracted, because they
+            // are not part of the proportion calculation
+            if (p.IsFixed())
             {
-                wxAuiPaneInfo& p = *dock.panes.Item(i);
-                if (p.window == pane.window)
-                    pane_position = i;
-
-                // while we're at it, subtract the pane sash
-                // width from the dock width, because this would
-                // skew our proportion calculations
-                if (i > 0)
-                    dock_pixels -= sash_size;
-
-                // also, the whole size (including decorations) of
-                // all fixed panes must also be subtracted, because they
-                // are not part of the proportion calculation
-                if (p.IsFixed())
-                {
-                    if (dock.IsHorizontal())
-                        dock_pixels -= p.best_size.x;
-                         else
-                        dock_pixels -= p.best_size.y;
-                }
-                 else
-                {
-                    total_proportion += p.dock_proportion;
-                }
+                if (dock.IsHorizontal())
+                    dock_pixels -= p.best_size.x;
+                else
+                    dock_pixels -= p.best_size.y;
             }
-
-            // find a pane in our dock to 'steal' space from or to 'give'
-            // space to -- this is essentially what is done when a pane is
-            // resized; the pane should usually be the first non-fixed pane
-            // to the right of the action pane
-            int borrow_pane = -1;
-            for (i = pane_position+1; i < dock_pane_count; ++i)
+            else
             {
-                wxAuiPaneInfo& p = *dock.panes.Item(i);
-                if (!p.IsFixed())
-                {
-                    borrow_pane = i;
-                    break;
-                }
+                total_proportion += p.dock_proportion;
             }
+        }
 
+        // new size can never be more than the number of dock pixels
+        if (new_pixsize > dock_pixels)
+            new_pixsize = dock_pixels;
 
-            // demand that the pane being resized is found in this dock
-            // (this assert really never should be raised)
-            wxASSERT_MSG(pane_position != -1, wxT("Pane not found in dock"));
 
-            // prevent division by zero
-            if (dock_pixels == 0 || total_proportion == 0 || borrow_pane == -1)
+        // find a pane in our dock to 'steal' space from or to 'give'
+        // space to -- this is essentially what is done when a pane is
+        // resized; the pane should usually be the first non-fixed pane
+        // to the right of the action pane
+        int borrow_pane = -1;
+        for (i = pane_position+1; i < dock_pane_count; ++i)
+        {
+            wxAuiPaneInfo& p = *dock.panes.Item(i);
+            if (!p.IsFixed())
             {
-                m_action = actionNone;
-                return;
+                borrow_pane = i;
+                break;
             }
+        }
 
-            // calculate the new proportion of the pane
-            int new_proportion = (new_pixsize*total_proportion)/dock_pixels;
 
-            // default minimum size
-            int min_size = 0;
+        // demand that the pane being resized is found in this dock
+        // (this assert really never should be raised)
+        wxASSERT_MSG(pane_position != -1, wxT("Pane not found in dock"));
 
-            // check against the pane's minimum size, if specified. please note
-            // that this is not enough to ensure that the minimum size will
-            // not be violated, because the whole frame might later be shrunk,
-            // causing the size of the pane to violate it's minimum size
-            if (pane.min_size.IsFullySpecified())
-            {
-                min_size = 0;
+        // prevent division by zero
+        if (dock_pixels == 0 || total_proportion == 0 || borrow_pane == -1)
+        {
+            m_action = actionNone;
+            return false;
+        }
 
-                if (pane.HasBorder())
-                    min_size += (pane_border_size*2);
+        // calculate the new proportion of the pane
+        int new_proportion = (new_pixsize*total_proportion)/dock_pixels;
 
-                // calculate minimum size with decorations (border,caption)
-                if (pane_part->orientation == wxVERTICAL)
-                {
-                    min_size += pane.min_size.y;
-                    if (pane.HasCaption())
-                        min_size += caption_size;
-                }
-                 else
-                {
-                    min_size += pane.min_size.x;
-                }
+        // default minimum size
+        int min_size = 0;
+
+        // check against the pane's minimum size, if specified. please note
+        // that this is not enough to ensure that the minimum size will
+        // not be violated, because the whole frame might later be shrunk,
+        // causing the size of the pane to violate it's minimum size
+        if (pane.min_size.IsFullySpecified())
+        {
+            min_size = 0;
+
+            if (pane.HasBorder())
+                min_size += (pane_border_size*2);
+
+            // calculate minimum size with decorations (border,caption)
+            if (pane_part->orientation == wxVERTICAL)
+            {
+                min_size += pane.min_size.y;
+                if (pane.HasCaption())
+                    min_size += caption_size;
             }
+            else
+            {
+                min_size += pane.min_size.x;
+            }
+        }
 
 
-            // for some reason, an arithmatic error somewhere is causing
-            // the proportion calculations to always be off by 1 pixel;
-            // for now we will add the 1 pixel on, but we really should
-            // determine what's causing this.
-            min_size++;
+        // for some reason, an arithmatic error somewhere is causing
+        // the proportion calculations to always be off by 1 pixel;
+        // for now we will add the 1 pixel on, but we really should
+        // determine what's causing this.
+        min_size++;
 
-            int min_proportion = (min_size*total_proportion)/dock_pixels;
+        int min_proportion = (min_size*total_proportion)/dock_pixels;
 
-            if (new_proportion < min_proportion)
-                new_proportion = min_proportion;
+        if (new_proportion < min_proportion)
+            new_proportion = min_proportion;
 
 
 
-            int prop_diff = new_proportion - pane.dock_proportion;
+        int prop_diff = new_proportion - pane.dock_proportion;
 
-            // borrow the space from our neighbor pane to the
-            // right or bottom (depending on orientation)
-            dock.panes.Item(borrow_pane)->dock_proportion -= prop_diff;
-            pane.dock_proportion = new_proportion;
+        // borrow the space from our neighbor pane to the
+        // right or bottom (depending on orientation);
+        // also make sure we don't make the neighbor too small
+        int prop_borrow = dock.panes.Item(borrow_pane)->dock_proportion;
 
-            // repaint
-            Update();
-            Repaint(NULL);
+        if (prop_borrow - prop_diff < 0)
+        {
+            // borrowing from other pane would make it too small,
+            // so cancel the resize operation
+            prop_borrow = min_proportion;
+        }
+         else
+        {
+            prop_borrow -= prop_diff;
         }
+
+
+        dock.panes.Item(borrow_pane)->dock_proportion = prop_borrow;
+        pane.dock_proportion = new_proportion;
+
+
+        // repaint
+        Update();
+        Repaint(NULL);
+    }
+
+    return true;
+}
+
+void wxAuiManager::OnLeftUp(wxMouseEvent& event)
+{
+    if (m_action == actionResize)
+    {
+        m_frame->ReleaseMouse();
+
+        if (!wxAuiManager_HasLiveResize(*this))
+        {
+            // get rid of the hint rectangle
+            wxScreenDC dc;
+            DrawResizeHint(dc, m_action_hintrect);
+        }
+        if (m_currentDragItem != -1 && wxAuiManager_HasLiveResize(*this))
+            m_action_part = & (m_uiparts.Item(m_currentDragItem));
+
+        DoEndResizeAction(event);
+
+        m_currentDragItem = -1;
+
     }
     else if (m_action == actionClickButton)
     {
         m_hover_button = NULL;
         m_frame->ReleaseMouse();
-        UpdateButtonOnScreen(m_action_part, event);
 
-        // make sure we're still over the item that was originally clicked
-        if (m_action_part == HitTest(event.GetX(), event.GetY()))
+        if (m_action_part)
         {
-            // fire button-click event
-            wxAuiManagerEvent e(wxEVT_AUI_PANEBUTTON);
-            e.SetManager(this);
-            e.SetPane(m_action_part->pane);
-            e.SetButton(m_action_part->button->button_id);
-            ProcessMgrEvent(e);
+            UpdateButtonOnScreen(m_action_part, event);
+
+            // make sure we're still over the item that was originally clicked
+            if (m_action_part == HitTest(event.GetX(), event.GetY()))
+            {
+                // fire button-click event
+                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);
+            }
         }
     }
     else if (m_action == actionClickCaption)
@@ -4021,20 +4555,49 @@ void wxAuiManager::OnMotion(wxMouseEvent& event)
 
     if (m_action == actionResize)
     {
-        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
-            pos.x = wxMax(0, event.m_x - m_action_offset.x);
+        // It's necessary to reset m_action_part since it destroyed
+        // by the Update within DoEndResizeAction.
+        if (m_currentDragItem != -1)
+            m_action_part = & (m_uiparts.Item(m_currentDragItem));
+        else
+            m_currentDragItem = m_uiparts.Index(* m_action_part);
 
-        wxRect rect(m_frame->ClientToScreen(pos),
+        if (m_action_part)
+        {
+            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
+                pos.x = wxMax(0, event.m_x - m_action_offset.x);
+
+            if (wxAuiManager_HasLiveResize(*this))
+            {
+                m_frame->ReleaseMouse();
+                DoEndResizeAction(event);
+                m_frame->CaptureMouse();
+            }
+            else
+            {
+                wxRect rect(m_frame->ClientToScreen(pos),
                     m_action_part->rect.GetSize());
+                wxScreenDC dc;
 
-        wxScreenDC dc;
-        if (!m_action_hintrect.IsEmpty())
-            DrawResizeHint(dc, m_action_hintrect);
-        DrawResizeHint(dc, rect);
-        m_action_hintrect = rect;
+                if (!m_action_hintrect.IsEmpty())
+                {
+                    // remove old resize hint
+                    DrawResizeHint(dc, m_action_hintrect);
+                    m_action_hintrect = wxRect();
+                }
+
+                // draw new resize hint, if it's inside the managed frame
+                wxRect frame_screen_rect = m_frame->GetScreenRect();
+                if (frame_screen_rect.Contains(rect))
+                {
+                    DrawResizeHint(dc, rect);
+                    m_action_hintrect = rect;
+                }
+            }
+        }
     }
     else if (m_action == actionClickCaption)
     {
@@ -4044,8 +4607,9 @@ void wxAuiManager::OnMotion(wxMouseEvent& event)
         // caption has been clicked.  we need to check if the mouse
         // is now being dragged. if it is, we need to change the
         // mouse action to 'drag'
-        if (abs(event.m_x - m_action_start.x) > drag_x_threshold ||
-            abs(event.m_y - m_action_start.y) > drag_y_threshold)
+        if (m_action_part &&
+            (abs(event.m_x - m_action_start.x) > drag_x_threshold ||
+             abs(event.m_y - m_action_start.y) > drag_y_threshold))
         {
             wxAuiPaneInfo* pane_info = m_action_part->pane;
 
@@ -4079,7 +4643,7 @@ void wxAuiManager::OnMotion(wxMouseEvent& event)
                         m_action_offset.x = 30;
                 }
             }
-             else
+            else
             {
                 m_action = actionDragToolbarPane;
                 m_action_window = pane_info->window;
@@ -4088,7 +4652,8 @@ void wxAuiManager::OnMotion(wxMouseEvent& event)
     }
     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);
@@ -4099,7 +4664,7 @@ void wxAuiManager::OnMotion(wxMouseEvent& event)
         wxAuiPaneInfo& pane = GetPane(m_action_window);
         wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
-        pane.state |= wxAuiPaneInfo::actionPane;
+        pane.SetFlag(wxAuiPaneInfo::actionPane, true);
 
         wxPoint pt = event.GetPosition();
         DoDrop(m_docks, m_panes, pane, pt, m_action_offset);
@@ -4142,22 +4707,22 @@ void wxAuiManager::OnMotion(wxMouseEvent& 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;
-                
+
             }
         }
-         else
+        else
         {
             if (m_hover_button)
             {
                 m_hover_button = NULL;
                 Repaint();
             }
-             else
+            else
             {
                 event.Skip();
             }
@@ -4174,6 +4739,16 @@ void wxAuiManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
     }
 }
 
+void wxAuiManager::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
+{
+    // cancel the operation in progress, if any
+    if ( m_action != actionNone )
+    {
+        m_action = actionNone;
+        HideHint();
+    }
+}
+
 void wxAuiManager::OnChildFocus(wxChildFocusEvent& event)
 {
     // when a child pane has it's focus set, we should change the
@@ -4181,7 +4756,8 @@ void wxAuiManager::OnChildFocus(wxChildFocusEvent& event)
     // active panes are allowed by the owner)
     if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
     {
-        if (GetPane(event.GetWindow()).IsOk())
+        wxAuiPaneInfo& pane = GetPane(event.GetWindow());
+        if (pane.IsOk() && (pane.state & wxAuiPaneInfo::optionActive) == 0)
         {
             SetActivePane(m_panes, event.GetWindow());
             m_frame->Refresh();
@@ -4203,21 +4779,30 @@ void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt)
     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);
 
         if (!e.GetVeto())
         {
-            ClosePane(pane);
+            // close the pane, but check that it
+            // still exists in our pane array first
+            // (the event handler above might have removed it)
+
+            wxAuiPaneInfo& check = GetPane(pane.window);
+            if (check.IsOk())
+            {
+                ClosePane(pane);
+            }
+
             Update();
         }
     }
     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);
@@ -4231,7 +4816,7 @@ void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt)
     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);
@@ -4242,7 +4827,7 @@ void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt)
             Update();
         }
     }
-     else if (evt.button == wxAUI_BUTTON_PIN)
+    else if (evt.button == wxAUI_BUTTON_PIN)
     {
         if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
             pane.IsFloatable())