Put the reentrance check inside #ifdef __DEBUG__

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

diff --git a/src/aui/framemanager.cpp b/src/aui/framemanager.cpp
index 609be6a75bfe35a726c94fed04156db7b68ff6d3..27e3bf941619124aeed9df3f5662bae8e1ce865b 100644 (file)
--- a/src/aui/framemanager.cpp
+++ b/src/aui/framemanager.cpp
@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        framemanager.cpp
+// Name:        src/aui/framemanager.cpp

 // Purpose:     wxaui: wx advanced user interface - docking window manager
 // Author:      Benjamin I. Williams
 // Modified by:
 // Created:     2005-05-17
 // Purpose:     wxaui: wx advanced user interface - docking window manager
 // Author:      Benjamin I. Williams
 // Modified by:
 // Created:     2005-05-17

-// RCS-ID:      
+// RCS-ID:      $Id$

 // Copyright:   (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
 // Licence:     wxWindows Library Licence, Version 3.1
 ///////////////////////////////////////////////////////////////////////////////
 // Copyright:   (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
 // Licence:     wxWindows Library Licence, Version 3.1
 ///////////////////////////////////////////////////////////////////////////////


@@ -30,13 +30,15 @@
 #include "wx/aui/floatpane.h"
 
 #ifndef WX_PRECOMP
 #include "wx/aui/floatpane.h"
 
 #ifndef WX_PRECOMP

-//    #include "wx/log.h"
+    #include "wx/settings.h"
+    #include "wx/app.h"
+    #include "wx/dcclient.h"
+    #include "wx/dcscreen.h"
+    #include "wx/toolbar.h"
+    #include "wx/mdi.h"
+    #include "wx/image.h"

 #endif
 
 #endif
 

-//#include "wx/dcbuffer.h"
-
-#include "wx/app.h"
-#include "wx/image.h"

 WX_CHECK_BUILD_OPTIONS("wxAUI")
 
 #include "wx/arrimpl.cpp"
 WX_CHECK_BUILD_OPTIONS("wxAUI")
 
 #include "wx/arrimpl.cpp"


@@ -50,6 +52,8 @@ WX_DEFINE_OBJARRAY(wxPaneInfoArray)
 wxPaneInfo wxNullPaneInfo;
 wxDockInfo wxNullDockInfo;
 DEFINE_EVENT_TYPE(wxEVT_AUI_PANEBUTTON)
 wxPaneInfo wxNullPaneInfo;
 wxDockInfo wxNullDockInfo;
 DEFINE_EVENT_TYPE(wxEVT_AUI_PANEBUTTON)

+DEFINE_EVENT_TYPE(wxEVT_AUI_PANECLOSE)
+DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER)

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


@@ -58,6 +62,8 @@ DEFINE_EVENT_TYPE(wxEVT_AUI_PANEBUTTON)
     #include "wx/mac/private.h"
 #endif
 
     #include "wx/mac/private.h"
 #endif
 

+IMPLEMENT_DYNAMIC_CLASS(wxFrameManagerEvent, wxEvent)
+

 
 // -- static utility functions --
 
 
 // -- static utility functions --
 


@@ -72,46 +78,61 @@ static void DrawResizeHint(wxDC& dc, const wxRect& rect)
 {
     wxBitmap stipple = wxPaneCreateStippleBitmap();
     wxBrush brush(stipple);
 {
     wxBitmap stipple = wxPaneCreateStippleBitmap();
     wxBrush brush(stipple);

-    dc.SetBrush(brush);    
+    dc.SetBrush(brush);

     dc.SetPen(*wxTRANSPARENT_PEN);
 
     dc.SetLogicalFunction(wxXOR);
     dc.DrawRectangle(rect);
 }
 
     dc.SetPen(*wxTRANSPARENT_PEN);
 
     dc.SetLogicalFunction(wxXOR);
     dc.DrawRectangle(rect);
 }
 

-#ifdef __WXMSW__

 
 

-// on supported windows systems (Win2000 and greater), this function
+// on supported windows systems (Win2000 and greater, Mac), this function

 // will make a frame window transparent by a certain amount
 static void MakeWindowTransparent(wxWindow* wnd, int amount)
 {
 // will make a frame window transparent by a certain amount
 static void MakeWindowTransparent(wxWindow* wnd, int amount)
 {

+#if defined(__WXMSW__)

     // this API call is not in all SDKs, only the newer ones, so
     // we will runtime bind this
     typedef DWORD (WINAPI *PSETLAYEREDWINDOWATTR)(HWND, DWORD, BYTE, DWORD);
     static PSETLAYEREDWINDOWATTR pSetLayeredWindowAttributes = NULL;
     static HMODULE h = NULL;
     HWND hwnd = (HWND)wnd->GetHWND();
     // this API call is not in all SDKs, only the newer ones, so
     // we will runtime bind this
     typedef DWORD (WINAPI *PSETLAYEREDWINDOWATTR)(HWND, DWORD, BYTE, DWORD);
     static PSETLAYEREDWINDOWATTR pSetLayeredWindowAttributes = NULL;
     static HMODULE h = NULL;
     HWND hwnd = (HWND)wnd->GetHWND();

-    
+

     if (!h)
         h = LoadLibrary(_T("user32"));
     if (!h)
         h = LoadLibrary(_T("user32"));

-        
+

     if (!pSetLayeredWindowAttributes)
     {
         pSetLayeredWindowAttributes =
     if (!pSetLayeredWindowAttributes)
     {
         pSetLayeredWindowAttributes =

-         (PSETLAYEREDWINDOWATTR)GetProcAddress(h,"SetLayeredWindowAttributes");
+         (PSETLAYEREDWINDOWATTR)GetProcAddress(h,
+#ifdef __WXWINCE__
+                                                 wxT("SetLayeredWindowAttributes")
+#else
+                                                 "SetLayeredWindowAttributes"
+#endif
+                                               );

     }
     }

-    
+

     if (pSetLayeredWindowAttributes == NULL)
         return;
     if (pSetLayeredWindowAttributes == NULL)
         return;

-        
+

     LONG exstyle = GetWindowLong(hwnd, GWL_EXSTYLE);
     if (0 == (exstyle & 0x80000) /*WS_EX_LAYERED*/)
     LONG exstyle = GetWindowLong(hwnd, GWL_EXSTYLE);
     if (0 == (exstyle & 0x80000) /*WS_EX_LAYERED*/)

-        SetWindowLong(hwnd, GWL_EXSTYLE, exstyle | 0x80000 /*WS_EX_LAYERED*/);   
-             
-    pSetLayeredWindowAttributes(hwnd, 0, amount, 2 /*LWA_ALPHA*/);
-}
+        SetWindowLong(hwnd, GWL_EXSTYLE, exstyle | 0x80000 /*WS_EX_LAYERED*/);
+
+    pSetLayeredWindowAttributes(hwnd, 0, (BYTE)amount, 2 /*LWA_ALPHA*/);
+
+#elif defined(__WXMAC__)
+
+    WindowRef handle = GetControlOwner((OpaqueControlRef*)wnd->GetHandle());
+    SetWindowAlpha(handle, float(amount)/ 255.0);

 
 

+#else
+    wxUnusedVar(wnd);
+    wxUnusedVar(amount);

 #endif
 #endif

+}
+

 
 
 // CopyDocksAndPanes() - this utility function creates copies of
 
 
 // CopyDocksAndPanes() - this utility function creates copies of


@@ -162,7 +183,7 @@ static int GetMaxRow(const wxPaneInfoArray& panes, int direction, int layer)
     {
         wxPaneInfo& pane = panes.Item(i);
         if (pane.dock_direction == direction &&
     {
         wxPaneInfo& pane = panes.Item(i);
         if (pane.dock_direction == direction &&

-            pane.dock_layer == layer && 
+            pane.dock_layer == layer &&

             pane.dock_row > max_row)
                 max_row = pane.dock_row;
     }
             pane.dock_row > max_row)
                 max_row = pane.dock_row;
     }


@@ -207,7 +228,7 @@ static void DoInsertDockRow(wxPaneInfoArray& panes,
     }
 }
 
     }
 }
 

-// DoInsertDockLayer() is an internal function that inserts a space for 
+// DoInsertDockLayer() is an internal function that inserts a space for

 // another dock pane by incrementing all existing dock row values by one
 static void DoInsertPane(wxPaneInfoArray& panes,
                          int dock_direction,
 // another dock pane by incrementing all existing dock row values by one
 static void DoInsertPane(wxPaneInfoArray& panes,
                          int dock_direction,


@@ -250,14 +271,14 @@ static void FindDocks(wxDockInfoArray& docks,
         max_row = wxMax(max_row, docks.Item(i).dock_row);
         max_layer = wxMax(max_layer, docks.Item(i).dock_layer);
     }
         max_row = wxMax(max_row, docks.Item(i).dock_row);
         max_layer = wxMax(max_layer, docks.Item(i).dock_layer);
     }

-    
+

     // if no dock layer was specified, search all dock layers
     if (dock_layer == -1)
     {
         begin_layer = 0;
         end_layer = max_layer;
     }
     // if no dock layer was specified, search all dock layers
     if (dock_layer == -1)
     {
         begin_layer = 0;
         end_layer = max_layer;
     }

-    
+

     // if no dock row was specified, search all dock row
     if (dock_row == -1)
     {
     // if no dock row was specified, search all dock row
     if (dock_row == -1)
     {


@@ -328,7 +349,9 @@ static void RenumberDockRows(wxDockInfoPtrArray& docks)
 }
 
 
 }
 
 

-
+// SetActivePane() sets the active pane, as well as cycles through
+// every other pane and makes sure that all others' active flags
+// are turned off

 static void SetActivePane(wxPaneInfoArray& panes, wxWindow* active_pane)
 {
     int i, pane_count;
 static void SetActivePane(wxPaneInfoArray& panes, wxWindow* active_pane)
 {
     int i, pane_count;


@@ -354,6 +377,7 @@ static int PaneSortFunc(wxPaneInfo** p1, wxPaneInfo** p2)
 
 BEGIN_EVENT_TABLE(wxFrameManager, wxEvtHandler)
     EVT_AUI_PANEBUTTON(wxFrameManager::OnPaneButton)
 
 BEGIN_EVENT_TABLE(wxFrameManager, wxEvtHandler)
     EVT_AUI_PANEBUTTON(wxFrameManager::OnPaneButton)

+    EVT_AUI_RENDER(wxFrameManager::OnRender)

     EVT_PAINT(wxFrameManager::OnPaint)
     EVT_ERASE_BACKGROUND(wxFrameManager::OnEraseBackground)
     EVT_SIZE(wxFrameManager::OnSize)
     EVT_PAINT(wxFrameManager::OnPaint)
     EVT_ERASE_BACKGROUND(wxFrameManager::OnEraseBackground)
     EVT_SIZE(wxFrameManager::OnSize)


@@ -367,7 +391,7 @@ BEGIN_EVENT_TABLE(wxFrameManager, wxEvtHandler)
 END_EVENT_TABLE()
 
 
 END_EVENT_TABLE()
 
 

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

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


@@ -376,9 +400,9 @@ wxFrameManager::wxFrameManager(wxFrame* frame, unsigned int flags)
     m_hint_wnd = NULL;
     m_flags = flags;
 
     m_hint_wnd = NULL;
     m_flags = flags;
 

-    if (frame)
+    if (managed_wnd)

     {
     {

-        SetFrame(frame);
+        SetManagedWindow(managed_wnd);

     }
 }
 
     }
 }
 


@@ -439,26 +463,26 @@ wxDockUIPart* wxFrameManager::HitTest(int x, int y)
     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
     {
         wxDockUIPart* item = &m_uiparts.Item(i);
     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
     {
         wxDockUIPart* item = &m_uiparts.Item(i);

-        
-        // we are not interested in typeDock, because this space 
+
+        // we are not interested in typeDock, because this space

         // isn't used to draw anything, just for measurements;
         // besides, the entire dock area is covered with other
         // rectangles, which we are interested in.
         if (item->type == wxDockUIPart::typeDock)
             continue;
         // isn't used to draw anything, just for measurements;
         // besides, the entire dock area is covered with other
         // rectangles, which we are interested in.
         if (item->type == wxDockUIPart::typeDock)
             continue;

-        
+

         // if we already have a hit on a more specific item, we are not
         // interested in a pane hit.  If, however, we don't already have
         // a hit, returning a pane hit is necessary for some operations
         if ((item->type == wxDockUIPart::typePane ||
             item->type == wxDockUIPart::typePaneBorder) && result)
             continue;
         // if we already have a hit on a more specific item, we are not
         // interested in a pane hit.  If, however, we don't already have
         // a hit, returning a pane hit is necessary for some operations
         if ((item->type == wxDockUIPart::typePane ||
             item->type == wxDockUIPart::typePaneBorder) && result)
             continue;

-           
+

         // if the point is inside the rectangle, we have a hit
         if (item->rect.Inside(x,y))
             result = item;
     }
         // if the point is inside the rectangle, we have a hit
         if (item->rect.Inside(x,y))
             result = item;
     }

-    
+

     return result;
 }
 
     return result;
 }
 


@@ -476,10 +500,25 @@ unsigned int wxFrameManager::GetFlags() const
 }
 
 
 }
 
 

-// SetFrame() is usually called once when the frame
+// don't use these anymore as they are deprecated
+// use Set/GetManagedFrame() instead
+void wxFrameManager::SetFrame(wxFrame* frame)
+{
+    SetManagedWindow((wxWindow*)frame);
+}
+
+wxFrame* wxFrameManager::GetFrame() const
+{
+    return (wxFrame*)m_frame;
+}
+
+
+
+
+// SetManagedWindow() is usually called once when the frame

 // manager class is being initialized.  "frame" specifies
 // the frame which should be managed by the frame mananger
 // manager class is being initialized.  "frame" specifies
 // the frame which should be managed by the frame mananger

-void wxFrameManager::SetFrame(wxFrame* frame)
+void wxFrameManager::SetManagedWindow(wxWindow* frame)

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


@@ -494,7 +533,7 @@ void wxFrameManager::SetFrame(wxFrame* frame)
     if (frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
     {
         wxMDIParentFrame* mdi_frame = (wxMDIParentFrame*)frame;
     if (frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
     {
         wxMDIParentFrame* mdi_frame = (wxMDIParentFrame*)frame;

-        wxMDIClientWindow* client_window = mdi_frame->GetClientWindow();
+        wxWindow* client_window = mdi_frame->GetClientWindow();

 
         wxASSERT_MSG(client_window, wxT("Client window is NULL!"));
 
 
         wxASSERT_MSG(client_window, wxT("Client window is NULL!"));
 


@@ -514,8 +553,8 @@ void wxFrameManager::UnInit()
     m_frame->RemoveEventHandler(this);
 }
 
     m_frame->RemoveEventHandler(this);
 }
 

-// GetFrame() returns the frame pointer being managed by wxFrameManager
-wxFrame* wxFrameManager::GetFrame() const
+// GetManagedWindow() returns the window pointer being managed
+wxWindow* wxFrameManager::GetManagedWindow() const

 {
     return m_frame;
 }
 {
     return m_frame;
 }


@@ -539,16 +578,19 @@ void wxFrameManager::ProcessMgrEvent(wxFrameManagerEvent& event)
 
 // SetArtProvider() instructs wxFrameManager to use the
 // specified art provider for all drawing calls.  This allows
 
 // SetArtProvider() instructs wxFrameManager to use the
 // specified art provider for all drawing calls.  This allows

-// plugable look-and-feel features
+// plugable look-and-feel features.  The pointer that is
+// passed to this method subsequently belongs to wxFrameManager,
+// and is deleted in the frame manager destructor

 void wxFrameManager::SetArtProvider(wxDockArt* art_provider)
 {
     // delete the last art provider, if any
     delete m_art;
 void wxFrameManager::SetArtProvider(wxDockArt* art_provider)
 {
     // delete the last art provider, if any
     delete m_art;

-    
+

     // assign the new art provider
     m_art = art_provider;
 }
 
     // assign the new art provider
     m_art = art_provider;
 }
 

+

 bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info)
 {
     // check if the pane has a valid window
 bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info)
 {
     // check if the pane has a valid window


@@ -565,16 +607,21 @@ bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info)
 
     // set the pane window
     pinfo.window = window;
 
     // set the pane window
     pinfo.window = window;

-    
+

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

-    if (pinfo.name.IsEmpty())
+    if (pinfo.name.empty())

     {
     {

-        pinfo.name.Printf(wxT("%08x%08x%08x%08x"),
+        pinfo.name.Printf(wxT("%08lx%08x%08x%08lx"),

              ((unsigned long)pinfo.window) & 0xffffffff,
              (unsigned int)time(NULL),
              ((unsigned long)pinfo.window) & 0xffffffff,
              (unsigned int)time(NULL),

-             (unsigned int)clock(), m_panes.GetCount());
+#ifdef __WXWINCE__
+             (unsigned int)GetTickCount(),
+#else
+             (unsigned int)clock(),
+#endif
+             (unsigned long)m_panes.GetCount());

     }
     }

-    
+

     // set initial proportion (if not already set)
     if (pinfo.dock_proportion == 0)
         pinfo.dock_proportion = 100000;
     // set initial proportion (if not already set)
     if (pinfo.dock_proportion == 0)
         pinfo.dock_proportion = 100000;


@@ -586,7 +633,7 @@ bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info)
         button.button_id = wxPaneInfo::buttonClose;
         pinfo.buttons.Add(button);
     }
         button.button_id = wxPaneInfo::buttonClose;
         pinfo.buttons.Add(button);
     }

-    
+

     if (pinfo.best_size == wxDefaultSize &&
         pinfo.window)
     {
     if (pinfo.best_size == wxDefaultSize &&
         pinfo.window)
     {


@@ -598,7 +645,7 @@ bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info)
             // a toolbar under some newer versions of wxWidgets,
             // so use GetBestSize()
             pinfo.best_size = pinfo.window->GetBestSize();
             // 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
             // 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


@@ -606,7 +653,7 @@ bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info)
             // correct?
             pinfo.best_size.y++;
         }
             // correct?
             pinfo.best_size.y++;
         }

-        
+

         if (pinfo.min_size != wxDefaultSize)
         {
             if (pinfo.best_size.x < pinfo.min_size.x)
         if (pinfo.min_size != wxDefaultSize)
         {
             if (pinfo.best_size.x < pinfo.min_size.x)


@@ -661,7 +708,7 @@ bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info,
                  pane_info.dock_layer);
             break;
     }
                  pane_info.dock_layer);
             break;
     }

-    
+

     // if the window already exists, we are basically just moving/inserting the
     // existing window.  If it doesn't exist, we need to add it and insert it
     wxPaneInfo& existing_pane = GetPane(window);
     // if the window already exists, we are basically just moving/inserting the
     // existing window.  If it doesn't exist, we need to add it and insert it
     wxPaneInfo& existing_pane = GetPane(window);


@@ -669,7 +716,7 @@ bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info,
     {
         return AddPane(window, pane_info);
     }
     {
         return AddPane(window, pane_info);
     }

-     else
+    else

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


@@ -691,13 +738,15 @@ bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info,
     return true;
 }
 
     return true;
 }
 

-    
+
+// DetachPane() removes a pane from the frame manager.  This
+// method will not destroy the window that is removed.

 bool wxFrameManager::DetachPane(wxWindow* window)
 {
     int i, count;
     for (i = 0, count = m_panes.GetCount(); i < count; ++i)
     {
 bool wxFrameManager::DetachPane(wxWindow* window)
 {
     int i, count;
     for (i = 0, count = m_panes.GetCount(); i < count; ++i)
     {

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

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


@@ -729,7 +778,7 @@ bool wxFrameManager::DetachPane(wxWindow* window)
 static wxString EscapeDelimiters(const wxString& s)
 {
     wxString result;
 static wxString EscapeDelimiters(const wxString& s)
 {
     wxString result;

-    result.Alloc(s.Length());
+    result.Alloc(s.length());

     const wxChar* ch = s.c_str();
     while (*ch)
     {
     const wxChar* ch = s.c_str();
     while (*ch)
     {


@@ -757,15 +806,15 @@ wxString wxFrameManager::SavePerspective()
     for (pane_i = 0; pane_i < pane_count; ++pane_i)
     {
         wxPaneInfo& pane = m_panes.Item(pane_i);
     for (pane_i = 0; pane_i < pane_count; ++pane_i)
     {
         wxPaneInfo& pane = m_panes.Item(pane_i);

-        
+

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

-        
+

         result += wxT("caption=");
         result += EscapeDelimiters(pane.caption);
         result += wxT(";");
         result += wxT("caption=");
         result += EscapeDelimiters(pane.caption);
         result += wxT(";");

-        
+

         result += wxString::Format(wxT("state=%u;"), pane.state);
         result += wxString::Format(wxT("dir=%d;"), pane.dock_direction);
         result += wxString::Format(wxT("layer=%d;"), pane.dock_layer);
         result += wxString::Format(wxT("state=%u;"), pane.state);
         result += wxString::Format(wxT("dir=%d;"), pane.dock_direction);
         result += wxString::Format(wxT("layer=%d;"), pane.dock_layer);


@@ -784,17 +833,17 @@ wxString wxFrameManager::SavePerspective()
         result += wxString::Format(wxT("floath=%d"), pane.floating_size.y);
         result += wxT("|");
     }
         result += wxString::Format(wxT("floath=%d"), pane.floating_size.y);
         result += wxT("|");
     }

-    
+

     int dock_i, dock_count = m_docks.GetCount();
     for (dock_i = 0; dock_i < dock_count; ++dock_i)
     {
         wxDockInfo& dock = m_docks.Item(dock_i);
     int dock_i, dock_count = m_docks.GetCount();
     for (dock_i = 0; dock_i < dock_count; ++dock_i)
     {
         wxDockInfo& dock = m_docks.Item(dock_i);

-        
+

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

-    
+

     return result;
 }
 
     return result;
 }
 


@@ -805,7 +854,7 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
 {
     wxString input = layout;
     wxString part;
 {
     wxString input = layout;
     wxString part;

-    
+

     // check layout string version
     part = input.BeforeFirst(wxT('|'));
     input = input.AfterFirst(wxT('|'));
     // check layout string version
     part = input.BeforeFirst(wxT('|'));
     input = input.AfterFirst(wxT('|'));


@@ -813,8 +862,8 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
     part.Trim(false);
     if (part != wxT("layout1"))
         return false;
     part.Trim(false);
     if (part != wxT("layout1"))
         return false;

-    
-    
+
+

     // mark all panes currently managed as docked and hidden
     int pane_i, pane_count = m_panes.GetCount();
     for (pane_i = 0; pane_i < pane_count; ++pane_i)
     // mark all panes currently managed as docked and hidden
     int pane_i, pane_count = m_panes.GetCount();
     for (pane_i = 0; pane_i < pane_count; ++pane_i)


@@ -822,12 +871,12 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
 
     // clear out the dock array; this will be reconstructed
     m_docks.Clear();
 
     // clear out the dock array; this will be reconstructed
     m_docks.Clear();

-    
+

     // replace escaped characters so we can
     // split up the string easily
     input.Replace(wxT("\\|"), wxT("\a"));
     input.Replace(wxT("\\;"), wxT("\b"));
     // replace escaped characters so we can
     // split up the string easily
     input.Replace(wxT("\\|"), wxT("\a"));
     input.Replace(wxT("\\;"), wxT("\b"));

-    
+

     while (1)
     {
         wxPaneInfo pane;
     while (1)
     {
         wxPaneInfo pane;


@@ -837,7 +886,7 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
         pane_part.Trim(true);
 
         // if the string is empty, we're done parsing
         pane_part.Trim(true);
 
         // if the string is empty, we're done parsing

-        if (pane_part.IsEmpty())
+        if (pane_part.empty())

             break;
 
 
             break;
 
 


@@ -845,7 +894,7 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
         {
             wxString val_name = pane_part.BeforeFirst(wxT('='));
             wxString value = pane_part.AfterFirst(wxT('='));
         {
             wxString val_name = pane_part.BeforeFirst(wxT('='));
             wxString value = pane_part.AfterFirst(wxT('='));

-                  
+

             long dir, layer, row, size;
             wxString piece = val_name.AfterFirst(wxT('('));
             piece = piece.BeforeLast(wxT(')'));
             long dir, layer, row, size;
             wxString piece = val_name.AfterFirst(wxT('('));
             piece = piece.BeforeLast(wxT(')'));


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

-            
+

             wxDockInfo dock;
             dock.dock_direction = dir;
             dock.dock_layer = layer;
             wxDockInfo dock;
             dock.dock_direction = dir;
             dock.dock_layer = layer;


@@ -875,8 +924,8 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
             val_name.Trim(false);
             value.Trim(true);
             value.Trim(false);
             val_name.Trim(false);
             value.Trim(true);
             value.Trim(false);

-        
-            if (val_name.IsEmpty())
+
+            if (val_name.empty())

                 break;
 
             if (val_name == wxT("name"))
                 break;
 
             if (val_name == wxT("name"))


@@ -919,14 +968,14 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
                 wxFAIL_MSG(wxT("Bad Perspective String"));
             }
         }
                 wxFAIL_MSG(wxT("Bad Perspective String"));
             }
         }

-        
+

         // replace escaped characters so we can
         // split up the string easily
         pane.name.Replace(wxT("\a"), wxT("|"));
         pane.name.Replace(wxT("\b"), wxT(";"));
         pane.caption.Replace(wxT("\a"), wxT("|"));
         pane.caption.Replace(wxT("\b"), wxT(";"));
         // replace escaped characters so we can
         // split up the string easily
         pane.name.Replace(wxT("\a"), wxT("|"));
         pane.name.Replace(wxT("\b"), wxT(";"));
         pane.caption.Replace(wxT("\a"), wxT("|"));
         pane.caption.Replace(wxT("\b"), wxT(";"));

-        
+

         wxPaneInfo& p = GetPane(pane.name);
         if (!p.IsOk())
         {
         wxPaneInfo& p = GetPane(pane.name);
         if (!p.IsOk())
         {


@@ -934,13 +983,13 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
             // in the existing layout
             return false;
         }
             // in the existing layout
             return false;
         }

-        
+

         pane.window = p.window;
         pane.frame = p.frame;
         pane.buttons = p.buttons;
         p = pane;
     }
         pane.window = p.window;
         pane.frame = p.frame;
         pane.buttons = p.buttons;
         p = pane;
     }

-    
+

     if (update)
         Update();
 
     if (update)
         Update();
 


@@ -973,7 +1022,7 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock,
             action_pane = pane_i;
         }
     }
             action_pane = pane_i;
         }
     }

-    
+

     // set up each panes default position, and
     // determine the size (width or height, depending
     // on the dock's orientation) of each pane
     // set up each panes default position, and
     // determine the size (width or height, depending
     // on the dock's orientation) of each pane


@@ -982,10 +1031,10 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock,
         wxPaneInfo& pane = *(dock.panes.Item(pane_i));
         positions.Add(pane.dock_pos);
         int size = 0;
         wxPaneInfo& pane = *(dock.panes.Item(pane_i));
         positions.Add(pane.dock_pos);
         int size = 0;

-        
+

         if (pane.HasBorder())
             size += (pane_border_size*2);
         if (pane.HasBorder())
             size += (pane_border_size*2);

-                
+

         if (dock.IsHorizontal())
         {
             if (pane.HasGripper() && !pane.HasGripperTop())
         if (dock.IsHorizontal())
         {
             if (pane.HasGripper() && !pane.HasGripperTop())


@@ -998,10 +1047,10 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock,
                 size += gripper_size;
 
             if (pane.HasCaption())
                 size += gripper_size;
 
             if (pane.HasCaption())

-                size += caption_size; 
+                size += caption_size;

             size += pane.best_size.y;
         }
             size += pane.best_size.y;
         }

-   
+

         sizes.Add(size);
     }
 
         sizes.Add(size);
     }
 


@@ -1022,7 +1071,7 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock,
 
         offset += sizes[pane_i];
     }
 
         offset += sizes[pane_i];
     }

-    
+

     // if the dock mode is fixed, make sure none of the panes
     // overlap; we will bump panes that overlap
     offset = 0;
     // if the dock mode is fixed, make sure none of the panes
     // overlap; we will bump panes that overlap
     offset = 0;


@@ -1044,7 +1093,7 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont,
                                    wxPaneInfo& pane,
                                    wxDockUIPartArray& uiparts,
                                    bool spacer_only)
                                    wxPaneInfo& pane,
                                    wxDockUIPartArray& uiparts,
                                    bool spacer_only)

-{        
+{

     wxDockUIPart part;
     wxSizerItem* sizer_item;
 
     wxDockUIPart part;
     wxSizerItem* sizer_item;
 


@@ -1072,7 +1121,7 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont,
     {
         if (pane.HasGripperTop())
             sizer_item = vert_pane_sizer ->Add(1, gripper_size, 0, wxEXPAND);
     {
         if (pane.HasGripperTop())
             sizer_item = vert_pane_sizer ->Add(1, gripper_size, 0, wxEXPAND);

-       else
+        else

             sizer_item = horz_pane_sizer ->Add(gripper_size, 1, 0, wxEXPAND);
 
         part.type = wxDockUIPart::typeGripper;
             sizer_item = horz_pane_sizer ->Add(gripper_size, 1, 0, wxEXPAND);
 
         part.type = wxDockUIPart::typeGripper;


@@ -1134,9 +1183,12 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont,
     {
         sizer_item = vert_pane_sizer->Add(1, 1, 1, wxEXPAND);
     }
     {
         sizer_item = vert_pane_sizer->Add(1, 1, 1, wxEXPAND);
     }

-     else
+    else

     {
         sizer_item = vert_pane_sizer->Add(pane.window, 1, wxEXPAND);
     {
         sizer_item = vert_pane_sizer->Add(pane.window, 1, wxEXPAND);

+        // Don't do this because it breaks the pane size in floating windows
+        // BIW: Right now commenting this out is causing problems with
+        // an mdi client window as the center pane.

         vert_pane_sizer->SetItemMinSize(pane.window, 1, 1);
     }
 
         vert_pane_sizer->SetItemMinSize(pane.window, 1, 1);
     }
 


@@ -1153,7 +1205,7 @@ void wxFrameManager::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,
     // if the pane.min_size is set, we must use that value as well
     // determine if the pane should have a minimum size; if the pane is
     // non-resizable (fixed) then we must set a minimum size. Alternitavely,
     // if the pane.min_size is set, we must use that value as well

-    
+

     wxSize min_size = pane.min_size;
     if (pane.IsFixed())
     {
     wxSize min_size = pane.min_size;
     if (pane.IsFixed())
     {


@@ -1163,7 +1215,7 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont,
             pane_proportion = 0;
         }
     }
             pane_proportion = 0;
         }
     }

-    
+

     if (min_size != wxDefaultSize)
     {
         vert_pane_sizer->SetItemMinSize(
     if (min_size != wxDefaultSize)
     {
         vert_pane_sizer->SetItemMinSize(


@@ -1193,7 +1245,7 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont,
         part.sizer_item = sizer_item;
         uiparts.Add(part);
     }
         part.sizer_item = sizer_item;
         uiparts.Add(part);
     }

-     else
+    else

     {
         sizer_item = cont->Add(horz_pane_sizer, pane_proportion, wxEXPAND);
     }
     {
         sizer_item = cont->Add(horz_pane_sizer, pane_proportion, wxEXPAND);
     }


@@ -1235,7 +1287,7 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont,
     if (dock.fixed)
     {
         wxArrayInt pane_positions, pane_sizes;
     if (dock.fixed)
     {
         wxArrayInt pane_positions, pane_sizes;

-        
+

         // figure out the real pane positions we will
         // use, without modifying the each pane's pane_pos member
         GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
         // figure out the real pane positions we will
         // use, without modifying the each pane's pane_pos member
         GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);


@@ -1283,7 +1335,7 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont,
         part.sizer_item = sizer_item;
         uiparts.Add(part);
     }
         part.sizer_item = sizer_item;
         uiparts.Add(part);
     }

-     else
+    else

     {
         for (pane_i = 0; pane_i < pane_count; ++pane_i)
         {
     {
         for (pane_i = 0; pane_i < pane_count; ++pane_i)
         {


@@ -1356,12 +1408,12 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
     int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);
     wxSize cli_size = m_frame->GetClientSize();
     int i, dock_count, pane_count;
     int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);
     wxSize cli_size = m_frame->GetClientSize();
     int i, dock_count, pane_count;

-    
+

 
     // empty all docks out
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
         docks.Item(i).panes.Empty();
 
     // empty all docks out
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
         docks.Item(i).panes.Empty();

-    
+

     // iterate through all known panes, filing each
     // of them into the appropriate dock. If the
     // pane does not exist in the dock, add it
     // iterate through all known panes, filing each
     // of them into the appropriate dock. If the
     // pane does not exist in the dock, add it


@@ -1396,7 +1448,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
             RemovePaneFromDocks(docks, p, dock);
 
             // pane needs to be added to the dock,
             RemovePaneFromDocks(docks, p, dock);
 
             // pane needs to be added to the dock,

-            // if it doesn't already exist 
+            // if it doesn't already exist

             if (!FindPaneInDock(*dock, p.window))
                 dock->panes.Add(&p);
         }
             if (!FindPaneInDock(*dock, p.window))
                 dock->panes.Add(&p);
         }


@@ -1420,7 +1472,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
     {
         wxDockInfo& dock = docks.Item(i);
         int j, dock_pane_count = dock.panes.GetCount();
     {
         wxDockInfo& dock = docks.Item(i);
         int j, dock_pane_count = dock.panes.GetCount();

-        
+

         // sort the dock pane array by the pane's
         // dock position (dock_pos), in ascending order
         dock.panes.Sort(PaneSortFunc);
         // sort the dock pane array by the pane's
         // dock position (dock_pos), in ascending order
         dock.panes.Sort(PaneSortFunc);


@@ -1438,13 +1490,13 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
                     pane_size = pane.min_size;
                 if (pane_size == wxDefaultSize)
                     pane_size = pane.window->GetSize();
                     pane_size = pane.min_size;
                 if (pane_size == wxDefaultSize)
                     pane_size = pane.window->GetSize();

-                
+

                 if (dock.IsHorizontal())
                     size = wxMax(pane_size.y, size);
                      else
                     size = wxMax(pane_size.x, size);
             }
                 if (dock.IsHorizontal())
                     size = wxMax(pane_size.y, size);
                      else
                     size = wxMax(pane_size.x, size);
             }

-            
+

             // add space for the border (two times), but only
             // if at least one pane inside the dock has a pane border
             for (j = 0; j < dock_pane_count; ++j)
             // add space for the border (two times), but only
             // if at least one pane inside the dock has a pane border
             for (j = 0; j < dock_pane_count; ++j)


@@ -1507,15 +1559,15 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
                 }
             }
         }
                 }
             }
         }

-        
+

         if (plus_border)
             dock_min_size += (pane_border_size*2);
         if (plus_caption && dock.IsHorizontal())
             dock_min_size += (caption_size);
         if (plus_border)
             dock_min_size += (pane_border_size*2);
         if (plus_caption && dock.IsHorizontal())
             dock_min_size += (caption_size);

-           
+

         dock.min_size = dock_min_size;
         dock.min_size = dock_min_size;

-        
-        
+
+

         // if the pane's current size is less than it's
         // minimum, increase the dock's size to it's minimum
         if (dock.size < dock.min_size)
         // if the pane's current size is less than it's
         // minimum, increase the dock's size to it's minimum
         if (dock.size < dock.min_size)


@@ -1559,7 +1611,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
         {
             wxArrayInt pane_positions, pane_sizes;
             GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
         {
             wxArrayInt pane_positions, pane_sizes;
             GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);

-            
+

             int offset = 0;
             for (j = 0; j < dock_pane_count; ++j)
             {
             int offset = 0;
             for (j = 0; j < dock_pane_count; ++j)
             {


@@ -1576,12 +1628,12 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
             }
         }
     }
             }
         }
     }

-    
+

     // discover the maximum dock layer
     int max_layer = 0;
     for (i = 0; i < dock_count; ++i)
         max_layer = wxMax(max_layer, docks.Item(i).dock_layer);
     // discover the maximum dock layer
     int max_layer = 0;
     for (i = 0; i < dock_count; ++i)
         max_layer = wxMax(max_layer, docks.Item(i).dock_layer);

- 
+

 
     // clear out uiparts
     uiparts.Empty();
 
     // clear out uiparts
     uiparts.Empty();


@@ -1620,10 +1672,10 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
                 LayoutAddDock(cont, *arr.Item(row), uiparts, spacer_only);
         }
 
                 LayoutAddDock(cont, *arr.Item(row), uiparts, spacer_only);
         }
 

-        
+

         // fill out the middle layer (which consists
         // of left docks, content area and right docks)
         // fill out the middle layer (which consists
         // of left docks, content area and right docks)

-        
+

         middle = new wxBoxSizer(wxHORIZONTAL);
 
         // find any left docks in this layer
         middle = new wxBoxSizer(wxHORIZONTAL);
 
         // find any left docks in this layer


@@ -1732,11 +1784,11 @@ void wxFrameManager::Update()
         {
             // because the pane is no longer in a floating, we need to
             // reparent it to m_frame and destroy the floating frame
         {
             // because the pane is no longer in a floating, we need to
             // reparent it to m_frame and destroy the floating frame

-            
+

             // reduce flicker
             p.window->SetSize(1,1);
             p.frame->Show(false);
             // reduce flicker
             p.window->SetSize(1,1);
             p.frame->Show(false);

-                       
+

             // reparent to m_frame and destroy the pane
             p.window->Reparent(m_frame);
             p.frame->SetSizer(NULL);
             // reparent to m_frame and destroy the pane
             p.window->Reparent(m_frame);
             p.frame->SetSizer(NULL);


@@ -1762,19 +1814,16 @@ void wxFrameManager::Update()
                 // we need to create a frame for this
                 // pane, which has recently been floated
                 wxFloatingPane* frame = new wxFloatingPane(m_frame,
                 // we need to create a frame for this
                 // pane, which has recently been floated
                 wxFloatingPane* frame = new wxFloatingPane(m_frame,

-                                                  this, -1,
-                                                  p.floating_pos,
-                                                  p.floating_size);
-                                
-                // on MSW, if the owner desires transparent dragging, and
+                                                  this,
+                                                  p);
+
+                // on MSW and Mac, if the owner desires transparent dragging, and

                 // the dragging is happening right now, then the floating
                 // the dragging is happening right now, then the floating

-                // window should have this style by default                  
-                #ifdef __WXMSW__
+                // window should have this style by default

                 if (m_action == actionDragFloatingPane &&
                     (m_flags & wxAUI_MGR_TRANSPARENT_DRAG))
                         MakeWindowTransparent(frame, 150);
                 if (m_action == actionDragFloatingPane &&
                     (m_flags & wxAUI_MGR_TRANSPARENT_DRAG))
                         MakeWindowTransparent(frame, 150);

-                #endif
-                
+

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


@@ -1790,7 +1839,8 @@ void wxFrameManager::Update()
                 if (p.frame->GetPosition() != p.floating_pos)
                 {
                     p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,
                 if (p.frame->GetPosition() != p.floating_pos)
                 {
                     p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,

-                                     -1, -1, wxSIZE_USE_EXISTING);
+                                     wxDefaultCoord, wxDefaultCoord,
+                                     wxSIZE_USE_EXISTING);

                     //p.frame->Move(p.floating_pos.x, p.floating_pos.y);
                 }
 
                     //p.frame->Move(p.floating_pos.x, p.floating_pos.y);
                 }
 


@@ -1854,9 +1904,9 @@ void wxFrameManager::Update()
 
 
     Repaint();
 
 
     Repaint();

-    
+

     // set frame's minimum size
     // set frame's minimum size

-    
+

 /*
     // N.B. More work needs to be done on frame minimum sizes;
     // this is some intresting code that imposes the minimum size,
 /*
     // N.B. More work needs to be done on frame minimum sizes;
     // this is some intresting code that imposes the minimum size,


@@ -1868,9 +1918,9 @@ void wxFrameManager::Update()
 
     wxSize minframe_size(min_size.x+frame_size.x-client_size.x,
                          min_size.y+frame_size.y-client_size.y );
 
     wxSize minframe_size(min_size.x+frame_size.x-client_size.x,
                          min_size.y+frame_size.y-client_size.y );

-                         
+

     m_frame->SetMinSize(minframe_size);
     m_frame->SetMinSize(minframe_size);

- 
+

     if (frame_size.x < minframe_size.x ||
         frame_size.y < minframe_size.y)
             sizer->Fit(m_frame);
     if (frame_size.x < minframe_size.x ||
         frame_size.y < minframe_size.y)
             sizer->Fit(m_frame);


@@ -1886,7 +1936,7 @@ void wxFrameManager::Update()
 void wxFrameManager::DoFrameLayout()
 {
     m_frame->Layout();
 void wxFrameManager::DoFrameLayout()
 {
     m_frame->Layout();

-    
+

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


@@ -1897,7 +1947,7 @@ void wxFrameManager::DoFrameLayout()
         //    part.rect = wxRect(part.sizer_item->GetPosition(),
         //                       part.sizer_item->GetSize());
         // this worked quite well, with one exception: the mdi
         //    part.rect = wxRect(part.sizer_item->GetPosition(),
         //                       part.sizer_item->GetSize());
         // this worked quite well, with one exception: the mdi

-        // client window had a "deferred" size variable 
+        // client window had a "deferred" size variable

         // that returned the wrong size.  It looks like
         // a bug in wx, because the former size of the window
         // was being returned.  So, we will retrieve the part's
         // that returned the wrong size.  It looks like
         // a bug in wx, because the former size of the window
         // was being returned.  So, we will retrieve the part's


@@ -1967,7 +2017,7 @@ int wxFrameManager::GetDockPixelOffset(wxPaneInfo& test)
 {
     // the only way to accurately calculate the dock's
     // offset is to actually run a theoretical layout
 {
     // the only way to accurately calculate the dock's
     // offset is to actually run a theoretical layout

-    
+

     int i, part_count, dock_count;
     wxDockInfoArray docks;
     wxPaneInfoArray panes;
     int i, part_count, dock_count;
     wxDockInfoArray docks;
     wxPaneInfoArray panes;


@@ -1988,9 +2038,9 @@ int wxFrameManager::GetDockPixelOffset(wxPaneInfo& test)
         if (part.type == wxDockUIPart::typeDock)
             part.dock->rect = part.rect;
     }
         if (part.type == wxDockUIPart::typeDock)
             part.dock->rect = part.rect;
     }

-    
+

     delete sizer;
     delete sizer;

-    
+

     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {
         wxDockInfo& dock = docks.Item(i);
     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
     {
         wxDockInfo& dock = docks.Item(i);


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

-static bool ProcessDockResult(wxPaneInfo& target,
+bool wxFrameManager::ProcessDockResult(wxPaneInfo& target,

                               const wxPaneInfo& new_pos)
 {
     bool allowed = false;
                               const wxPaneInfo& new_pos)
 {
     bool allowed = false;


@@ -2058,7 +2108,7 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
 
     // The result should always be shown
     drop.Show();
 
     // The result should always be shown
     drop.Show();

-    
+

 
     // Check to see if the pane has been dragged outside of the window
     // (or near to the outside of the window), if so, dock it along the edge
 
     // Check to see if the pane has been dragged outside of the window
     // (or near to the outside of the window), if so, dock it along the edge


@@ -2067,21 +2117,21 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
     int layer_insert_offset = auiLayerInsertOffset;
     if (target.IsToolbar())
         layer_insert_offset = 0;
     int layer_insert_offset = auiLayerInsertOffset;
     if (target.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)),
     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;

         drop.Dock().Left().
              Layer(new_layer).
              Row(0).
              Position(pt.y - GetDockPixelOffset(drop) - offset.y);
         return ProcessDockResult(target, drop);
     }
         drop.Dock().Left().
              Layer(new_layer).
              Row(0).
              Position(pt.y - GetDockPixelOffset(drop) - offset.y);
         return ProcessDockResult(target, drop);
     }

-     else if (pt.y < layer_insert_offset &&
-              pt.y > layer_insert_offset-auiLayerInsertPixels)
+    else if (pt.y < layer_insert_offset &&
+             pt.y > layer_insert_offset-auiLayerInsertPixels)

     {
         int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP),
                                     GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
     {
         int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP),
                                     GetMaxLayer(docks, wxAUI_DOCK_LEFT)),


@@ -2092,20 +2142,20 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
              Position(pt.x - GetDockPixelOffset(drop) - offset.x);
         return ProcessDockResult(target, drop);
     }
              Position(pt.x - GetDockPixelOffset(drop) - offset.x);
         return ProcessDockResult(target, drop);
     }

-     else if (pt.x >= cli_size.x - layer_insert_offset &&
-              pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels)
+    else if (pt.x >= cli_size.x - layer_insert_offset &&
+             pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels)

     {
         int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT),
                                     GetMaxLayer(docks, wxAUI_DOCK_TOP)),
     {
         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;

         drop.Dock().Right().
              Layer(new_layer).
              Row(0).
              Position(pt.y - GetDockPixelOffset(drop) - offset.y);
         return ProcessDockResult(target, drop);
     }
         drop.Dock().Right().
              Layer(new_layer).
              Row(0).
              Position(pt.y - GetDockPixelOffset(drop) - offset.y);
         return ProcessDockResult(target, drop);
     }

-     else if (pt.y >= cli_size.y - layer_insert_offset &&
-              pt.y < cli_size.y - layer_insert_offset + auiLayerInsertPixels)
+    else if (pt.y >= cli_size.y - layer_insert_offset &&
+             pt.y < cli_size.y - layer_insert_offset + auiLayerInsertPixels)

     {
         int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_BOTTOM),
                                     GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
     {
         int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_BOTTOM),
                                     GetMaxLayer(docks, wxAUI_DOCK_LEFT)),


@@ -2125,7 +2175,7 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
     {
         if (!part || !part->dock)
             return false;
     {
         if (!part || !part->dock)
             return false;

-        
+

 
         // calculate the offset from where the dock begins
         // to the point where the user dropped the pane
 
         // calculate the offset from where the dock begins
         // to the point where the user dropped the pane


@@ -2148,10 +2198,10 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
             {
                 drop.Float();
             }
             {
                 drop.Float();
             }

-            
+

             return ProcessDockResult(target, drop);
         }
             return ProcessDockResult(target, drop);
         }

-        
+

         drop.Dock().
              Direction(part->dock->dock_direction).
              Layer(part->dock->dock_layer).
         drop.Dock().
              Direction(part->dock->dock_direction).
              Layer(part->dock->dock_layer).


@@ -2169,7 +2219,7 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
                             part->dock->dock_row);
             drop.dock_row = row;
         }
                             part->dock->dock_row);
             drop.dock_row = row;
         }

-        
+

         if ((
             ((pt.y > part->dock->rect.y + part->dock->rect.height - 2 ) && part->dock->IsHorizontal()) ||
             ((pt.x > part->dock->rect.x + part->dock->rect.width - 2 ) && part->dock->IsVertical())
         if ((
             ((pt.y > part->dock->rect.y + part->dock->rect.height - 2 ) && part->dock->IsHorizontal()) ||
             ((pt.x > part->dock->rect.x + part->dock->rect.width - 2 ) && part->dock->IsVertical())


@@ -2186,7 +2236,7 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
 
 
 
 
 
 

-    
+

     if (!part)
         return false;
 
     if (!part)
         return false;
 


@@ -2257,12 +2307,12 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
         part = GetPanePart(part->pane->window);
         if (!part)
             return false;
         part = GetPanePart(part->pane->window);
         if (!part)
             return false;

-            
+

         bool insert_dock_row = false;
         int insert_row = part->pane->dock_row;
         int insert_dir = part->pane->dock_direction;
         int insert_layer = part->pane->dock_layer;
         bool insert_dock_row = false;
         int insert_row = part->pane->dock_row;
         int insert_dir = part->pane->dock_direction;
         int insert_layer = part->pane->dock_layer;

-        
+

         switch (part->pane->dock_direction)
         {
             case wxAUI_DOCK_TOP:
         switch (part->pane->dock_direction)
         {
             case wxAUI_DOCK_TOP:


@@ -2298,7 +2348,7 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
                 if (new_row_pixels_y > (part->rect.height*20)/100)
                     new_row_pixels_y = (part->rect.height*20)/100;
 
                 if (new_row_pixels_y > (part->rect.height*20)/100)
                     new_row_pixels_y = (part->rect.height*20)/100;
 

-                
+

                 // determine if the mouse pointer is in a location that
                 // will cause a new row to be inserted.  The hot spot positions
                 // are along the borders of the center pane
                 // determine if the mouse pointer is in a location that
                 // will cause a new row to be inserted.  The hot spot positions
                 // are along the borders of the center pane


@@ -2328,7 +2378,7 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
         }
 
         if (insert_dock_row)
         }
 
         if (insert_dock_row)

-        { 
+        {

             DoInsertDockRow(panes, insert_dir, insert_layer, insert_row);
             drop.Dock().Direction(insert_dir).
                         Layer(insert_layer).
             DoInsertDockRow(panes, insert_dir, insert_layer, insert_row);
             drop.Dock().Direction(insert_dir).
                         Layer(insert_layer).


@@ -2336,25 +2386,25 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
                         Position(0);
             return ProcessDockResult(target, drop);
         }
                         Position(0);
             return ProcessDockResult(target, drop);
         }

-        
+

         // determine the mouse offset and the pane size, both in the
         // direction of the dock itself, and perpendicular to the dock
         // determine the mouse offset and the pane size, both in the
         // direction of the dock itself, and perpendicular to the dock

-        
+

         int offset, size;
         int offset, size;

-        
+

         if (part->orientation == wxVERTICAL)
         {
             offset = pt.y - part->rect.y;
         if (part->orientation == wxVERTICAL)
         {
             offset = pt.y - part->rect.y;

-            size = part->rect.GetHeight(); 
+            size = part->rect.GetHeight();

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

-        
+

         int drop_position = part->pane->dock_pos;
         int drop_position = part->pane->dock_pos;

-        
+

         // if we are in the top/left part of the pane,
         // insert the pane before the pane being hovered over
         if (offset <= size/2)
         // if we are in the top/left part of the pane,
         // insert the pane before the pane being hovered over
         if (offset <= size/2)


@@ -2393,49 +2443,50 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
 
 void wxFrameManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event))
 {
 
 void wxFrameManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event))
 {

-#ifdef __WXMSW__

     if (!m_hint_wnd || m_hint_fadeamt >= 50)
     {
         m_hint_fadetimer.Stop();
         return;
     }
     if (!m_hint_wnd || m_hint_fadeamt >= 50)
     {
         m_hint_fadetimer.Stop();
         return;
     }

-    
+

     m_hint_fadeamt += 5;
     MakeWindowTransparent(m_hint_wnd, m_hint_fadeamt);
     m_hint_fadeamt += 5;
     MakeWindowTransparent(m_hint_wnd, m_hint_fadeamt);

-#endif

 }
 
 void wxFrameManager::ShowHint(const wxRect& rect)
 {
 }
 
 void wxFrameManager::ShowHint(const wxRect& rect)
 {

-    #ifdef __WXMSW__
-    
+#if defined(__WXMSW__) || defined(__WXMAC__)

     // First, determine if the operating system can handle transparency.
     // Transparency is available on Win2000 and above
     // First, determine if the operating system can handle transparency.
     // Transparency is available on Win2000 and above

-    
+

     static int os_type = -1;
     static int ver_major = -1;
     static int os_type = -1;
     static int ver_major = -1;

-    
+

     if (os_type == -1)
         os_type = ::wxGetOsVersion(&ver_major);
 
     // If the transparent flag is set, and the OS supports it,
     // go ahead and use a transparent hint
     if (os_type == -1)
         os_type = ::wxGetOsVersion(&ver_major);
 
     // If the transparent flag is set, and the OS supports it,
     // go ahead and use a transparent hint

-    
-    if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0 &&
-        os_type == wxWINDOWS_NT && ver_major >= 5)
+
+    if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0
+#ifdef __WXMSW__
+        && os_type == wxWINDOWS_NT && ver_major >= 5
+#endif
+        )

     {
         if (m_last_hint == rect)
             return;
         m_last_hint = rect;
     {
         if (m_last_hint == rect)
             return;
         m_last_hint = rect;

-        
+

         int initial_fade = 50;
         if (m_flags & wxAUI_MGR_TRANSPARENT_HINT_FADE)
             initial_fade = 0;
         int initial_fade = 50;
         if (m_flags & wxAUI_MGR_TRANSPARENT_HINT_FADE)
             initial_fade = 0;

-            
+

         if (m_hint_wnd == NULL)
         {
             wxPoint pt = rect.GetPosition();
             wxSize size = rect.GetSize();
         if (m_hint_wnd == NULL)
         {
             wxPoint pt = rect.GetPosition();
             wxSize size = rect.GetSize();

+#if defined(__WXMSW__)

             m_hint_wnd = new wxFrame(m_frame, -1, wxEmptyString, pt, size,
                                      wxFRAME_TOOL_WINDOW |
                                      wxFRAME_FLOAT_ON_PARENT |
             m_hint_wnd = new wxFrame(m_frame, -1, wxEmptyString, pt, size,
                                      wxFRAME_TOOL_WINDOW |
                                      wxFRAME_FLOAT_ON_PARENT |


@@ -2444,6 +2495,23 @@ void wxFrameManager::ShowHint(const wxRect& rect)
 
             MakeWindowTransparent(m_hint_wnd, initial_fade);
             m_hint_wnd->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION));
 
             MakeWindowTransparent(m_hint_wnd, initial_fade);
             m_hint_wnd->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION));

+#elif defined(__WXMAC__)
+            // Using a miniframe with float and tool styles keeps the parent
+            // frame activated and highlighted as such...
+            m_hint_wnd = new wxMiniFrame(m_frame, -1, wxEmptyString, pt, size,
+                                         wxFRAME_FLOAT_ON_PARENT
+                                         | wxFRAME_TOOL_WINDOW
+                                         | wxCAPTION );
+
+            // Can't set the bg colour of a Frame in wxMac
+            wxPanel* p = new wxPanel(m_hint_wnd);
+
+            // The default wxSYS_COLOUR_ACTIVECAPTION colour is a light silver
+            // color that is really hard to see, especially transparent.
+            // Until a better system color is decided upon we'll just use
+            // blue.
+            p->SetBackgroundColour(*wxBLUE);
+#endif

             m_hint_wnd->Show();
 
             // if we are dragging a floating pane, set the focus
             m_hint_wnd->Show();
 
             // if we are dragging a floating pane, set the focus


@@ -2452,14 +2520,13 @@ void wxFrameManager::ShowHint(const wxRect& rect)
                 m_action_window->SetFocus();
 
         }
                 m_action_window->SetFocus();
 
         }

-         else
+        else

         {
         {

-            wxPoint pt = rect.GetPosition();
-            wxSize size = rect.GetSize();

             MakeWindowTransparent(m_hint_wnd, initial_fade);
             MakeWindowTransparent(m_hint_wnd, initial_fade);

-            m_hint_wnd->SetSize(pt.x, pt.y, rect.width, rect.height);
+            m_hint_wnd->SetSize(rect);
+            m_hint_wnd->Raise();

         }
         }

-        
+

         if (m_flags & wxAUI_MGR_TRANSPARENT_HINT_FADE)
         {
             // start fade in timer
         if (m_flags & wxAUI_MGR_TRANSPARENT_HINT_FADE)
         {
             // start fade in timer


@@ -2467,11 +2534,11 @@ void wxFrameManager::ShowHint(const wxRect& rect)
             m_hint_fadetimer.SetOwner(this, 101);
             m_hint_fadetimer.Start(5);
         }
             m_hint_fadetimer.SetOwner(this, 101);
             m_hint_fadetimer.Start(5);
         }

-        
+

         return;
     }
         return;
     }

-    #endif
-
+#endif
+    

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


@@ -2479,7 +2546,7 @@ void wxFrameManager::ShowHint(const wxRect& rect)
         m_frame->Refresh();
         m_frame->Update();
     }
         m_frame->Refresh();
         m_frame->Update();
     }

-    
+

     wxScreenDC screendc;
     wxRegion clip(1, 1, 10000, 10000);
 
     wxScreenDC screendc;
     wxRegion clip(1, 1, 10000, 10000);
 


@@ -2518,9 +2585,8 @@ void wxFrameManager::ShowHint(const wxRect& rect)
 }
 
 void wxFrameManager::HideHint()
 }
 
 void wxFrameManager::HideHint()

-{   
-    // hides a transparent window hint (currently wxMSW only)
-    #ifdef __WXMSW__
+{
+    // hides a transparent window hint, if there is one

     if (m_hint_wnd)
     {
         MakeWindowTransparent(m_hint_wnd, 0);
     if (m_hint_wnd)
     {
         MakeWindowTransparent(m_hint_wnd, 0);


@@ -2528,8 +2594,7 @@ void wxFrameManager::HideHint()
         m_last_hint = wxRect();
         return;
     }
         m_last_hint = wxRect();
         return;
     }

-    #endif
-    
+

     // hides a painted hint by redrawing the frame window
     if (!m_last_hint.IsEmpty())
     {
     // hides a painted hint by redrawing the frame window
     if (!m_last_hint.IsEmpty())
     {


@@ -2564,6 +2629,7 @@ void wxFrameManager::DrawHintRect(wxWindow* pane_window,
     wxDockUIPartArray uiparts;
     wxPaneInfo hint = GetPane(pane_window);
     hint.name = wxT("__HINT__");
     wxDockUIPartArray uiparts;
     wxPaneInfo hint = GetPane(pane_window);
     hint.name = wxT("__HINT__");

+    hint.Show();

 
     if (!hint.IsOk())
         return;
 
     if (!hint.IsOk())
         return;


@@ -2609,7 +2675,7 @@ void wxFrameManager::DrawHintRect(wxWindow* pane_window,
             break;
         }
     }
             break;
         }
     }

-    
+

     delete sizer;
 
     if (rect.IsEmpty())
     delete sizer;
 
     if (rect.IsEmpty())


@@ -2628,11 +2694,9 @@ void wxFrameManager::OnFloatingPaneMoveStart(wxWindow* wnd)
     // try to find the pane
     wxPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
     // try to find the pane
     wxPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));

-    
-    #ifdef __WXMSW__
+

     if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
         MakeWindowTransparent(pane.frame, 150);
     if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
         MakeWindowTransparent(pane.frame, 150);

-    #endif

 }
 
 void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd)
 }
 
 void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd)


@@ -2640,10 +2704,10 @@ void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd)
     // try to find the pane
     wxPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
     // try to find the pane
     wxPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));

-    
+

     wxPoint pt = ::wxGetMousePosition();
     wxPoint client_pt = m_frame->ScreenToClient(pt);
     wxPoint pt = ::wxGetMousePosition();
     wxPoint client_pt = m_frame->ScreenToClient(pt);

-    
+

     // calculate the offset from the upper left-hand corner
     // of the frame to the mouse pointer
     wxPoint frame_pos = pane.frame->GetPosition();
     // calculate the offset from the upper left-hand corner
     // of the frame to the mouse pointer
     wxPoint frame_pos = pane.frame->GetPosition();


@@ -2658,7 +2722,7 @@ void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd)
             wxPaneInfoArray panes;
             wxDockUIPartArray uiparts;
             wxPaneInfo hint = pane;
             wxPaneInfoArray panes;
             wxDockUIPartArray uiparts;
             wxPaneInfo hint = pane;

-            
+

             CopyDocksAndPanes(docks, panes, m_docks, m_panes);
 
             // find out where the new pane would be
             CopyDocksAndPanes(docks, panes, m_docks, m_panes);
 
             // find out where the new pane would be


@@ -2666,14 +2730,14 @@ void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd)
                 return;
             if (hint.IsFloating())
                 return;
                 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;
     }
 
         return;
     }
 


@@ -2689,14 +2753,14 @@ void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd)
 
     DrawHintRect(wnd, client_pt, action_offset);
 
 
     DrawHintRect(wnd, client_pt, action_offset);
 

-    #ifdef __WXGTK__
+#ifdef __WXGTK__

     // this cleans up some screen artifacts that are caused on GTK because
     // we aren't getting the exact size of the window (see comment
     // in DrawHintRect)
     //Refresh();
     // this cleans up some screen artifacts that are caused on GTK because
     // we aren't getting the exact size of the window (see comment
     // in DrawHintRect)
     //Refresh();

-    #endif
-    
-    
+#endif
+
+

     // reduces flicker
     m_frame->Update();
 }
     // reduces flicker
     m_frame->Update();
 }


@@ -2706,15 +2770,15 @@ void wxFrameManager::OnFloatingPaneMoved(wxWindow* wnd)
     // try to find the pane
     wxPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
     // try to find the pane
     wxPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));

-    
+

     wxPoint pt = ::wxGetMousePosition();
     wxPoint client_pt = m_frame->ScreenToClient(pt);
     wxPoint pt = ::wxGetMousePosition();
     wxPoint client_pt = m_frame->ScreenToClient(pt);

-    
+

     // calculate the offset from the upper left-hand corner
     // of the frame to the mouse pointer
     wxPoint frame_pos = pane.frame->GetPosition();
     wxPoint action_offset(pt.x-frame_pos.x, pt.y-frame_pos.y);
     // calculate the offset from the upper left-hand corner
     // of the frame to the mouse pointer
     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 a key modifier is pressed while dragging the frame,
     // don't dock the window


@@ -2733,15 +2797,13 @@ void wxFrameManager::OnFloatingPaneMoved(wxWindow* wnd)
     if (pane.IsFloating())
     {
         pane.floating_pos = pane.frame->GetPosition();
     if (pane.IsFloating())
     {
         pane.floating_pos = pane.frame->GetPosition();

-        
-        #ifdef __WXMSW__
+

         if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
             MakeWindowTransparent(pane.frame, 255);
         if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
             MakeWindowTransparent(pane.frame, 255);

-        #endif

     }
     }

-        
+

     Update();
     Update();

-    
+

     HideHint();
 }
 
     HideHint();
 }
 


@@ -2750,43 +2812,62 @@ void wxFrameManager::OnFloatingPaneResized(wxWindow* wnd, const wxSize& size)
     // try to find the pane
     wxPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
     // try to find the pane
     wxPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));

-    
+

     pane.floating_size = size;
 }
 
     pane.floating_size = size;
 }
 

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

 {
     // try to find the pane
     wxPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 
 {
     // try to find the pane
     wxPaneInfo& pane = GetPane(wnd);
     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
 

-    // reparent the pane window back to us and
-    // prepare the frame window for destruction
-    pane.window->Show(false);
-    pane.window->Reparent(m_frame);
-    pane.frame = NULL;
-    pane.Hide();
+
+    // fire pane close event
+    wxFrameManagerEvent e(wxEVT_AUI_PANECLOSE);
+    e.SetPane(&pane);
+    e.SetCanVeto(evt.CanVeto());
+    ProcessMgrEvent(e);
+
+    if (e.GetVeto())
+    {
+        evt.Veto();
+        return;
+    }
+     else
+    {
+        // reparent the pane window back to us and
+        // prepare the frame window for destruction
+        pane.window->Show(false);
+        pane.window->Reparent(m_frame);
+        pane.frame = NULL;
+        pane.Hide();
+    }

 }
 
 }
 

+
+

 void wxFrameManager::OnFloatingPaneActivated(wxWindow* wnd)
 {
     if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
     {
         // try to find the pane
 void wxFrameManager::OnFloatingPaneActivated(wxWindow* wnd)
 {
     if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
     {
         // try to find the pane

-        wxPaneInfo& pane = GetPane(wnd);
-        wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
+        wxASSERT_MSG(GetPane(wnd).IsOk(), wxT("Pane window not found"));

 
         SetActivePane(m_panes, wnd);
         Repaint();
     }
 }
 
 
         SetActivePane(m_panes, wnd);
         Repaint();
     }
 }
 

-// Render() draws all of the pane captions, sashes,
+// OnRender() draws all of the pane captions, sashes,

 // backgrounds, captions, grippers, pane borders and buttons.
 // It renders the entire user interface.
 
 // backgrounds, captions, grippers, pane borders and buttons.
 // It renders the entire user interface.
 

-void wxFrameManager::Render(wxDC* dc)
+void wxFrameManager::OnRender(wxFrameManagerEvent& evt)

 {
 {

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

 #ifdef __WXMAC__
     dc->Clear() ;
 #endif
 #ifdef __WXMAC__
     dc->Clear() ;
 #endif


@@ -2799,7 +2880,7 @@ void wxFrameManager::Render(wxDC* dc)
         // don't draw hidden pane items
         if (part.sizer_item && !part.sizer_item->IsShown())
             continue;
         // don't draw hidden pane items
         if (part.sizer_item && !part.sizer_item->IsShown())
             continue;

-        
+

         switch (part.type)
         {
             case wxDockUIPart::typeDockSizer:
         switch (part.type)
         {
             case wxDockUIPart::typeDockSizer:


@@ -2814,7 +2895,7 @@ void wxFrameManager::Render(wxDC* dc)
                 break;
             case wxDockUIPart::typeGripper:
                 m_art->DrawGripper(*dc, part.rect, *part.pane);
                 break;
             case wxDockUIPart::typeGripper:
                 m_art->DrawGripper(*dc, part.rect, *part.pane);

-                break;     
+                break;

             case wxDockUIPart::typePaneBorder:
                 m_art->DrawBorder(*dc, part.rect, *part.pane);
                 break;
             case wxDockUIPart::typePaneBorder:
                 m_art->DrawBorder(*dc, part.rect, *part.pane);
                 break;


@@ -2826,6 +2907,20 @@ void wxFrameManager::Render(wxDC* dc)
     }
 }
 
     }
 }
 

+
+// Render() fire a render event, which is normally handled by
+// wxFrameManager::OnRender().  This allows the render function to
+// be overridden via the render event.  This can be useful for paintin
+// custom graphics in the main window. Default behavior can be
+// invoked in the overridden function by calling OnRender()
+
+void wxFrameManager::Render(wxDC* dc)
+{
+    wxFrameManagerEvent e(wxEVT_AUI_RENDER);
+    e.SetDC(dc);
+    ProcessMgrEvent(e);
+}
+

 void wxFrameManager::Repaint(wxDC* dc)
 {
 #ifdef __WXMAC__
 void wxFrameManager::Repaint(wxDC* dc)
 {
 #ifdef __WXMAC__


@@ -2920,7 +3015,7 @@ void wxFrameManager::OnSetCursor(wxSetCursorEvent& event)
             cursor = wxCursor(wxCURSOR_SIZING);
         }
     }
             cursor = wxCursor(wxCURSOR_SIZING);
         }
     }

-    
+

     event.SetCursor(cursor);
 }
 
     event.SetCursor(cursor);
 }
 


@@ -2932,7 +3027,7 @@ void wxFrameManager::UpdateButtonOnScreen(wxDockUIPart* button_ui_part,
     wxDockUIPart* hit_test = HitTest(event.GetX(), event.GetY());
 
     int state = wxAUI_BUTTON_STATE_NORMAL;
     wxDockUIPart* hit_test = HitTest(event.GetX(), event.GetY());
 
     int state = wxAUI_BUTTON_STATE_NORMAL;

-    
+

     if (hit_test == button_ui_part)
     {
         if (event.LeftDown())
     if (hit_test == button_ui_part)
     {
         if (event.LeftDown())


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

-     else
+    else

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


@@ -3120,13 +3215,13 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
                 wxPaneInfo& p = *dock.panes.Item(i);
                 if (p.window == pane.window)
                     pane_position = i;
                 wxPaneInfo& 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;
                 // 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
                 // also, the whole size (including decorations) of
                 // all fixed panes must also be subtracted, because they
                 // are not part of the proportion calculation


@@ -3142,7 +3237,7 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
                     total_proportion += p.dock_proportion;
                 }
             }
                     total_proportion += p.dock_proportion;
                 }
             }

-            
+

             // 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
             // 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


@@ -3157,12 +3252,12 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
                     break;
                 }
             }
                     break;
                 }
             }

-            
-            
+
+

             // 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"));
             // 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)
             {
             // prevent division by zero
             if (dock_pixels == 0 || total_proportion == 0 || borrow_pane == -1)
             {


@@ -3172,10 +3267,10 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
 
             // calculate the new proportion of the pane
             int new_proportion = (new_pixsize*total_proportion)/dock_pixels;
 
             // calculate the new proportion of the pane
             int new_proportion = (new_pixsize*total_proportion)/dock_pixels;

-            
+

             // default minimum size
             int min_size = 0;
             // 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,
             // 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,


@@ -3183,7 +3278,7 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
             if (pane.min_size.IsFullySpecified())
             {
                 min_size = 0;
             if (pane.min_size.IsFullySpecified())
             {
                 min_size = 0;

-                
+

                 if (pane.HasBorder())
                     min_size += (pane_border_size*2);
 
                 if (pane.HasBorder())
                     min_size += (pane_border_size*2);
 


@@ -3199,8 +3294,8 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
                     min_size += pane.min_size.x;
                 }
             }
                     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
             // 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


@@ -3208,33 +3303,33 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
             min_size++;
 
             int min_proportion = (min_size*total_proportion)/dock_pixels;
             min_size++;
 
             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;
 
             // 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;
             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;

-            
+

             // repaint
             Update();
             Repaint(NULL);
         }
     }
             // repaint
             Update();
             Repaint(NULL);
         }
     }

-     else if (m_action == actionClickButton)
+    else if (m_action == actionClickButton)

     {
         m_hover_button = NULL;
     {
         m_hover_button = NULL;

-        m_frame->ReleaseMouse();     
+        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()))
         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
             wxFrameManagerEvent e(wxEVT_AUI_PANEBUTTON);
             e.SetPane(m_action_part->pane);
             // fire button-click event
             wxFrameManagerEvent e(wxEVT_AUI_PANEBUTTON);
             e.SetPane(m_action_part->pane);


@@ -3242,21 +3337,21 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
             ProcessMgrEvent(e);
         }
     }
             ProcessMgrEvent(e);
         }
     }

-     else if (m_action == actionClickCaption)
+    else if (m_action == actionClickCaption)

     {
         m_frame->ReleaseMouse();
     }
     {
         m_frame->ReleaseMouse();
     }

-     else if (m_action == actionDragFloatingPane)
+    else if (m_action == actionDragFloatingPane)

     {
         m_frame->ReleaseMouse();
     }
     {
         m_frame->ReleaseMouse();
     }

-     else if (m_action == actionDragToolbarPane)
+    else if (m_action == actionDragToolbarPane)

     {
         m_frame->ReleaseMouse();
 
         wxPaneInfo& pane = GetPane(m_action_window);
         wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
     {
         m_frame->ReleaseMouse();
 
         wxPaneInfo& pane = GetPane(m_action_window);
         wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));

-    
+

         // save the new positions
         wxDockInfoPtrArray docks;
         FindDocks(m_docks, pane.dock_direction,
         // save the new positions
         wxDockInfoPtrArray docks;
         FindDocks(m_docks, pane.dock_direction,


@@ -3264,19 +3359,19 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event)
         if (docks.GetCount() == 1)
         {
             wxDockInfo& dock = *docks.Item(0);
         if (docks.GetCount() == 1)
         {
             wxDockInfo& dock = *docks.Item(0);

-            
+

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

-            
+

             int i, dock_pane_count = dock.panes.GetCount();
             for (i = 0; i < dock_pane_count; ++i)
                 dock.panes.Item(i)->dock_pos = pane_positions[i];
         }
             int i, dock_pane_count = dock.panes.GetCount();
             for (i = 0; i < dock_pane_count; ++i)
                 dock.panes.Item(i)->dock_pos = pane_positions[i];
         }

-        
+

         pane.state &= ~wxPaneInfo::actionPane;
         Update();
     }
         pane.state &= ~wxPaneInfo::actionPane;
         Update();
     }

-     else
+    else

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


@@ -3293,13 +3388,13 @@ void wxFrameManager::OnMotion(wxMouseEvent& event)
     // sure that only real mouse moves will get anywhere in this method;
     // this appears to be a bug somewhere, and I don't know where the
     // mouse move event is being generated.  only verified on MSW
     // sure that only real mouse moves will get anywhere in this method;
     // this appears to be a bug somewhere, and I don't know where the
     // mouse move event is being generated.  only verified on MSW

-    
+

     wxPoint mouse_pos = event.GetPosition();
     if (m_last_mouse_move == mouse_pos)
         return;
     m_last_mouse_move = mouse_pos;
 
     wxPoint mouse_pos = event.GetPosition();
     if (m_last_mouse_move == mouse_pos)
         return;
     m_last_mouse_move = mouse_pos;
 

-    
+

     if (m_action == actionResize)
     {
         wxPoint pos = m_action_part->rect.GetPosition();
     if (m_action == actionResize)
     {
         wxPoint pos = m_action_part->rect.GetPosition();


@@ -3317,23 +3412,23 @@ void wxFrameManager::OnMotion(wxMouseEvent& event)
         DrawResizeHint(dc, rect);
         m_action_hintrect = rect;
     }
         DrawResizeHint(dc, rect);
         m_action_hintrect = rect;
     }

-     else if (m_action == actionClickCaption)
+    else if (m_action == actionClickCaption)

     {
         int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
         int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
     {
         int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
         int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);

-        
+

         // 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 ||
         // 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)     
+            abs(event.m_y - m_action_start.y) > drag_y_threshold)

         {
             wxPaneInfo* pane_info = m_action_part->pane;
 
             if (!pane_info->IsToolbar())
             {
                 if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
         {
             wxPaneInfo* pane_info = m_action_part->pane;
 
             if (!pane_info->IsToolbar())
             {
                 if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&

-                    pane_info->IsFloatable()) 
+                    pane_info->IsFloatable())

                 {
                     m_action = actionDragFloatingPane;
 
                 {
                     m_action = actionDragFloatingPane;
 


@@ -3346,7 +3441,7 @@ void wxFrameManager::OnMotion(wxMouseEvent& event)
                     Update();
 
                     m_action_window = pane_info->frame;
                     Update();
 
                     m_action_window = pane_info->frame;

-                    
+

                     // action offset is used here to make it feel "natural" to the user
                     // to drag a docked pane and suddenly have it become a floating frame.
                     // Sometimes, however, the offset where the user clicked on the docked
                     // action offset is used here to make it feel "natural" to the user
                     // to drag a docked pane and suddenly have it become a floating frame.
                     // Sometimes, however, the offset where the user clicked on the docked


@@ -3364,13 +3459,13 @@ void wxFrameManager::OnMotion(wxMouseEvent& event)
             }
         }
     }
             }
         }
     }

-     else if (m_action == actionDragFloatingPane)
+    else if (m_action == actionDragFloatingPane)

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

-     else if (m_action == actionDragToolbarPane)
+    else if (m_action == actionDragToolbarPane)

     {
         wxPaneInfo& pane = GetPane(m_action_window);
         wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
     {
         wxPaneInfo& pane = GetPane(m_action_window);
         wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));


@@ -3379,7 +3474,7 @@ void wxFrameManager::OnMotion(wxMouseEvent& event)
 
         wxPoint pt = event.GetPosition();
         DoDrop(m_docks, m_panes, pane, pt, m_action_offset);
 
         wxPoint pt = event.GetPosition();
         DoDrop(m_docks, m_panes, pane, pt, m_action_offset);

-        
+

         // if DoDrop() decided to float the pane, set up
         // the floating pane's initial position
         if (pane.IsFloating())
         // if DoDrop() decided to float the pane, set up
         // the floating pane's initial position
         if (pane.IsFloating())


@@ -3388,13 +3483,13 @@ void wxFrameManager::OnMotion(wxMouseEvent& event)
             pane.floating_pos = wxPoint(pt.x - m_action_offset.x,
                                         pt.y - m_action_offset.y);
         }
             pane.floating_pos = wxPoint(pt.x - m_action_offset.x,
                                         pt.y - m_action_offset.y);
         }

-        
+

         // this will do the actiual move operation;
         // in the case that the pane has been floated,
         // this call will create the floating pane
         // and do the reparenting
         Update();
         // this will do the actiual move operation;
         // in the case that the pane has been floated,
         // this call will create the floating pane
         // and do the reparenting
         Update();

-        
+

         // if the pane has been floated, change the mouse
         // action actionDragFloatingPane so that subsequent
         // EVT_MOTION() events will move the floating pane
         // if the pane has been floated, change the mouse
         // action actionDragFloatingPane so that subsequent
         // EVT_MOTION() events will move the floating pane


@@ -3404,8 +3499,8 @@ void wxFrameManager::OnMotion(wxMouseEvent& event)
             m_action = actionDragFloatingPane;
             m_action_window = pane.frame;
         }
             m_action = actionDragFloatingPane;
             m_action_window = pane.frame;
         }

-    } 
-     else
+    }
+    else

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


@@ -3448,8 +3543,8 @@ void wxFrameManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
 
 void wxFrameManager::OnChildFocus(wxChildFocusEvent& event)
 {
 
 void wxFrameManager::OnChildFocus(wxChildFocusEvent& event)
 {

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

     // active panes are allowed by the owner)
     if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
     {
     // active panes are allowed by the owner)
     if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
     {


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

-void wxFrameManager::OnPaneButton(wxFrameManagerEvent& event)
+void wxFrameManager::OnPaneButton(wxFrameManagerEvent& evt)

 {
 {

-    wxPaneInfo& pane = *(event.pane);
-    
-    if (event.button == wxPaneInfo::buttonClose)
+    wxASSERT_MSG(evt.pane, wxT("Pane Info passed to wxFrameManager::OnPaneButton must be non-null"));
+
+    wxPaneInfo& pane = *(evt.pane);
+
+    if (evt.button == wxPaneInfo::buttonClose)

     {
     {

-        pane.Hide();
-        Update();
+        // fire pane close event
+        wxFrameManagerEvent e(wxEVT_AUI_PANECLOSE);
+        e.SetPane(evt.pane);
+        ProcessMgrEvent(e);
+
+        if (!e.GetVeto())
+        {
+            pane.Hide();
+            Update();
+        }

     }
     }

-     else if (event.button == wxPaneInfo::buttonPin)
+     else if (evt.button == wxPaneInfo::buttonPin)

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