]> git.saurik.com Git - wxWidgets.git/blobdiff - src/propgrid/manager.cpp
Add wxRichMessageDialog class.
[wxWidgets.git] / src / propgrid / manager.cpp
index 5253c01369c71d1c1af0e048f7784c2284562aaa..30c3f21e8b20cdc376bde255b68bd16c48681500 100644 (file)
@@ -4,9 +4,9 @@
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2005-01-14
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2005-01-14
-// RCS-ID:      $Id:
+// RCS-ID:      $Id$
 // Copyright:   (c) Jaakko Salli
 // Copyright:   (c) Jaakko Salli
-// Licence:     wxWindows license
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // For compilers that support precompilation, includes "wx/wx.h".
 /////////////////////////////////////////////////////////////////////////////
 
 // For compilers that support precompilation, includes "wx/wx.h".
@@ -41,9 +41,9 @@
 // This define is necessary to prevent macro clearing
 #define __wxPG_SOURCE_FILE__
 
 // This define is necessary to prevent macro clearing
 #define __wxPG_SOURCE_FILE__
 
-#include <wx/propgrid/propgrid.h>
+#include "wx/propgrid/propgrid.h"
 
 
-#include <wx/propgrid/manager.h>
+#include "wx/propgrid/manager.h"
 
 
 #define wxPG_MAN_ALTERNATE_BASE_ID          11249 // Needed for wxID_ANY madnesss
 
 
 #define wxPG_MAN_ALTERNATE_BASE_ID          11249 // Needed for wxID_ANY madnesss
 // wxPropertyGridManager
 // -----------------------------------------------------------------------
 
 // wxPropertyGridManager
 // -----------------------------------------------------------------------
 
-const wxChar *wxPropertyGridManagerNameStr = wxT("wxPropertyGridManager");
+const char wxPropertyGridManagerNameStr[] = "wxPropertyGridManager";
 
 
 // Categoric Mode Icon
 
 
 // Categoric Mode Icon
-static const char* gs_xpm_catmode[] = {
+static const char* const gs_xpm_catmode[] = {
 "16 16 5 1",
 ". c none",
 "B c black",
 "16 16 5 1",
 ". c none",
 "B c black",
@@ -102,7 +102,7 @@ static const char* gs_xpm_catmode[] = {
 };
 
 // Alphabetic Mode Icon
 };
 
 // Alphabetic Mode Icon
-static const char* gs_xpm_noncatmode[] = {
+static const char* const gs_xpm_noncatmode[] = {
 "16 16 5 1",
 ". c none",
 "B c black",
 "16 16 5 1",
 ". c none",
 "B c black",
@@ -128,7 +128,7 @@ static const char* gs_xpm_noncatmode[] = {
 };
 
 // Default Page Icon.
 };
 
 // Default Page Icon.
-static const char* gs_xpm_defpage[] = {
+static const char* const gs_xpm_defpage[] = {
 "16 16 5 1",
 ". c none",
 "B c black",
 "16 16 5 1",
 ". c none",
 "B c black",
@@ -153,8 +153,6 @@ static const char* gs_xpm_defpage[] = {
 "................"
 };
 
 "................"
 };
 
-#define GETPAGESTATE(page) ((wxPropertyGridPage*)m_arrPages.Item(page))->GetStatePtr()
-
 // -----------------------------------------------------------------------
 // wxPropertyGridPage
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPropertyGridPage
 // -----------------------------------------------------------------------
@@ -209,14 +207,199 @@ void wxPropertyGridPage::SetSplitterPosition( int splitterPos, int col )
         DoSetSplitterPosition(splitterPos, col, false);
 }
 
         DoSetSplitterPosition(splitterPos, col, false);
 }
 
-void wxPropertyGridPage::DoSetSplitterPosition( int pos, int splitterColumn, bool allPages )
+void wxPropertyGridPage::DoSetSplitterPosition( int pos,
+                                                int splitterColumn,
+                                                int flags )
 {
 {
-    if ( allPages && m_manager->GetPageCount() )
+    if ( (flags & wxPG_SPLITTER_ALL_PAGES) && m_manager->GetPageCount() )
         m_manager->SetSplitterPosition( pos, splitterColumn );
     else
         m_manager->SetSplitterPosition( pos, splitterColumn );
     else
-        DoSetSplitterPositionThisPage( pos, splitterColumn );
+        wxPropertyGridPageState::DoSetSplitterPosition( pos,
+                                                        splitterColumn,
+                                                        flags );
 }
 
 }
 
+// -----------------------------------------------------------------------
+// wxPGHeaderCtrl
+// -----------------------------------------------------------------------
+
+#if wxUSE_HEADERCTRL
+
+class wxPGHeaderCtrl : public wxHeaderCtrl
+{
+public:
+    wxPGHeaderCtrl(wxPropertyGridManager* manager) :
+        wxHeaderCtrl()
+    {
+        m_manager = manager;
+        EnsureColumnCount(2);
+
+        // Seed titles with defaults
+        m_columns[0]->SetTitle(_("Property"));
+        m_columns[1]->SetTitle(_("Value"));
+    }
+
+    virtual ~wxPGHeaderCtrl()
+    {
+        for (unsigned int i=0; i<m_columns.size(); i++ )
+            delete m_columns[i];
+    }
+
+    int DetermineColumnWidth(unsigned int idx, int* pMinWidth) const
+    {
+        const wxPropertyGridPage* page = m_page;
+        int colWidth = page->GetColumnWidth(idx);
+        int colMinWidth = page->GetColumnMinWidth(idx);
+        if ( idx == 0 )
+        {
+            wxPropertyGrid* pg = m_manager->GetGrid();
+            int margin = pg->GetMarginWidth();
+
+            // Compensate for the internal border
+            margin += (pg->GetSize().x - pg->GetClientSize().x) / 2;
+
+            colWidth += margin;
+            colMinWidth += margin;
+        }
+        *pMinWidth = colMinWidth;
+        return colWidth;
+    }
+
+    void OnPageChanged(const wxPropertyGridPage* page)
+    {
+        m_page = page;
+        OnPageUpdated();
+    }
+
+    void OnPageUpdated()
+    {
+        // Get column info from the page
+        const wxPropertyGridPage* page = m_page;
+        unsigned int colCount = page->GetColumnCount();
+        EnsureColumnCount(colCount);
+
+        for ( unsigned int i=0; i<colCount; i++ )
+        {
+            wxHeaderColumnSimple* colInfo = m_columns[i];
+            int colMinWidth = 0;
+            int colWidth = DetermineColumnWidth(i, &colMinWidth);
+            colInfo->SetWidth(colWidth);
+            colInfo->SetMinWidth(colMinWidth);
+        }
+
+        SetColumnCount(colCount);
+    }
+
+    void OnColumWidthsChanged()
+    {
+        const wxPropertyGridPage* page = m_page;
+        unsigned int colCount = page->GetColumnCount();
+
+        for ( unsigned int i=0; i<colCount; i++ )
+        {
+            wxHeaderColumnSimple* colInfo = m_columns[i];
+            int colMinWidth = 0;
+            int colWidth = DetermineColumnWidth(i, &colMinWidth);
+            colInfo->SetWidth(colWidth);
+            colInfo->SetMinWidth(colMinWidth);
+            UpdateColumn(i);
+        }
+    }
+
+    virtual const wxHeaderColumn& GetColumn(unsigned int idx) const
+    {
+        return *m_columns[idx];
+    }
+
+    void SetColumnTitle(unsigned int idx, const wxString& title)
+    {
+        EnsureColumnCount(idx+1);
+        m_columns[idx]->SetTitle(title);
+    }
+
+private:
+    void EnsureColumnCount(unsigned int count)
+    {
+        while ( m_columns.size() < count )
+        {
+            wxHeaderColumnSimple* colInfo = new wxHeaderColumnSimple("");
+            m_columns.push_back(colInfo);
+        }
+    }
+
+    void OnSetColumnWidth(int col, int colWidth)
+    {
+        wxPropertyGrid* pg = m_manager->GetGrid();
+
+        // Compensate for the internal border
+        int x = -((pg->GetSize().x - pg->GetClientSize().x) / 2);
+
+        for ( int i=0; i<col; i++ )
+            x += m_columns[i]->GetWidth();
+
+        x += colWidth;
+
+        pg->DoSetSplitterPosition(x, col,
+                                  wxPG_SPLITTER_REFRESH |
+                                  wxPG_SPLITTER_FROM_EVENT);
+    }
+
+    virtual bool ProcessEvent( wxEvent& event )
+    {
+        if ( event.IsKindOf(CLASSINFO(wxHeaderCtrlEvent)) )
+        {
+            wxHeaderCtrlEvent& hcEvent =
+                static_cast<wxHeaderCtrlEvent&>(event);
+
+            wxPropertyGrid* pg = m_manager->GetGrid();
+            int col = hcEvent.GetColumn();
+            int evtType = event.GetEventType();
+
+            if ( evtType == wxEVT_COMMAND_HEADER_RESIZING )
+            {
+                int colWidth = hcEvent.GetWidth();
+
+                OnSetColumnWidth(col, colWidth);
+
+                pg->SendEvent(wxEVT_PG_COL_DRAGGING,
+                              NULL, NULL, 0,
+                              (unsigned int)col);
+
+                return true;
+            }
+            else if ( evtType == wxEVT_COMMAND_HEADER_BEGIN_RESIZE )
+            {
+                // Never allow column resize if layout is static
+                if ( m_manager->HasFlag(wxPG_STATIC_SPLITTER) )
+                    hcEvent.Veto();
+                // Allow application to veto dragging
+                else if ( pg->SendEvent(wxEVT_PG_COL_BEGIN_DRAG,
+                                        NULL, NULL, 0,
+                                        (unsigned int)col) )
+                    hcEvent.Veto();
+
+                return true;
+            }
+            else if ( evtType == wxEVT_COMMAND_HEADER_END_RESIZE )
+            {
+                pg->SendEvent(wxEVT_PG_COL_END_DRAG,
+                              NULL, NULL, 0,
+                              (unsigned int)col);
+
+                return true;
+            }
+        }
+
+        return wxHeaderCtrl::ProcessEvent(event);
+    }
+
+    wxPropertyGridManager*          m_manager;
+    const wxPropertyGridPage*       m_page;
+    wxVector<wxHeaderColumnSimple*> m_columns;
+};
+
+#endif // wxUSE_HEADERCTRL
+
 // -----------------------------------------------------------------------
 // wxPropertyGridManager
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPropertyGridManager
 // -----------------------------------------------------------------------
@@ -231,7 +414,7 @@ IMPLEMENT_CLASS(wxPropertyGridManager, wxPanel)
 #define ID_ADVTOOLBAR_OFFSET        1
 #define ID_ADVHELPCAPTION_OFFSET    2
 #define ID_ADVHELPCONTENT_OFFSET    3
 #define ID_ADVTOOLBAR_OFFSET        1
 #define ID_ADVHELPCAPTION_OFFSET    2
 #define ID_ADVHELPCONTENT_OFFSET    3
-#define ID_ADVBUTTON_OFFSET         4
+#define ID_ADVHEADERCTRL_OFFSET     4
 #define ID_ADVTBITEMSBASE_OFFSET    5   // Must be last.
 
 // -----------------------------------------------------------------------
 #define ID_ADVTBITEMSBASE_OFFSET    5   // Must be last.
 
 // -----------------------------------------------------------------------
@@ -261,7 +444,7 @@ wxPropertyGridManager::wxPropertyGridManager( wxWindow *parent,
                                               const wxPoint& pos,
                                               const wxSize& size,
                                               long style,
                                               const wxPoint& pos,
                                               const wxSize& size,
                                               long style,
-                                              const wxChar* name )
+                                              const wxString& name )
     : wxPanel()
 {
     Init1();
     : wxPanel()
 {
     Init1();
@@ -275,14 +458,21 @@ bool wxPropertyGridManager::Create( wxWindow *parent,
                                     const wxPoint& pos,
                                     const wxSize& size,
                                     long style,
                                     const wxPoint& pos,
                                     const wxSize& size,
                                     long style,
-                                    const wxChar* name )
+                                    const wxString& name )
 {
 {
+    if ( !m_pPropGrid )
+        m_pPropGrid = CreatePropertyGrid();
 
     bool res = wxPanel::Create( parent, id, pos, size,
                                 (style&0xFFFF0000)|wxWANTS_CHARS,
                                 name );
     Init2(style);
 
 
     bool res = wxPanel::Create( parent, id, pos, size,
                                 (style&0xFFFF0000)|wxWANTS_CHARS,
                                 name );
     Init2(style);
 
+    // FIXME: this changes call ordering so wxPropertyGrid is created
+    // immediately, before SetExtraStyle has a chance to be called. However,
+    // without it, we may get assertions if size is wxDefaultSize.
+    //SetInitialSize(size);
+
     return res;
 }
 
     return res;
 }
 
@@ -294,16 +484,19 @@ bool wxPropertyGridManager::Create( wxWindow *parent,
 void wxPropertyGridManager::Init1()
 {
 
 void wxPropertyGridManager::Init1()
 {
 
-    //m_pPropGrid = (wxPropertyGrid*) NULL;
-    m_pPropGrid = CreatePropertyGrid();
+    m_pPropGrid = NULL;
 
 #if wxUSE_TOOLBAR
 
 #if wxUSE_TOOLBAR
-    m_pToolbar = (wxToolBar*) NULL;
+    m_pToolbar = NULL;
 #endif
 #endif
-    m_pTxtHelpCaption = (wxStaticText*) NULL;
-    m_pTxtHelpContent = (wxStaticText*) NULL;
+#if wxUSE_HEADERCTRL
+    m_pHeaderCtrl = NULL;
+    m_showHeader = false;
+#endif
+    m_pTxtHelpCaption = NULL;
+    m_pTxtHelpContent = NULL;
 
 
-    m_emptyPage = (wxPropertyGridPage*) NULL;
+    m_emptyPage = NULL;
 
     m_selPage = -1;
 
 
     m_selPage = -1;
 
@@ -324,15 +517,9 @@ void wxPropertyGridManager::Init1()
 // -----------------------------------------------------------------------
 
 // These flags are always used in wxPropertyGrid integrated in wxPropertyGridManager.
 // -----------------------------------------------------------------------
 
 // These flags are always used in wxPropertyGrid integrated in wxPropertyGridManager.
-#ifndef __WXMAC__
-  #define wxPG_MAN_PROPGRID_FORCED_FLAGS (wxSIMPLE_BORDER| \
-                                          wxNO_FULL_REPAINT_ON_RESIZE| \
-                                          wxCLIP_CHILDREN)
-#else
-  #define wxPG_MAN_PROPGRID_FORCED_FLAGS (wxNO_BORDER| \
+#define wxPG_MAN_PROPGRID_FORCED_FLAGS (  wxBORDER_THEME | \
                                           wxNO_FULL_REPAINT_ON_RESIZE| \
                                           wxCLIP_CHILDREN)
                                           wxNO_FULL_REPAINT_ON_RESIZE| \
                                           wxCLIP_CHILDREN)
-#endif
 
 // Which flags can be passed to underlying wxPropertyGrid.
 #define wxPG_MAN_PASS_FLAGS_MASK       (0xFFF0|wxTAB_TRAVERSAL)
 
 // Which flags can be passed to underlying wxPropertyGrid.
 #define wxPG_MAN_PASS_FLAGS_MASK       (0xFFF0|wxTAB_TRAVERSAL)
@@ -360,7 +547,7 @@ void wxPropertyGridManager::Init2( int style )
     pd->m_manager = this;
     wxPropertyGridPageState* state = pd->GetStatePtr();
     state->m_pPropGrid = m_pPropGrid;
     pd->m_manager = this;
     wxPropertyGridPageState* state = pd->GetStatePtr();
     state->m_pPropGrid = m_pPropGrid;
-    m_arrPages.Add( (void*)pd );
+    m_arrPages.push_back( pd );
     m_pPropGrid->m_pState = state;
 
     wxWindowID baseId = GetId();
     m_pPropGrid->m_pState = state;
 
     wxWindowID baseId = GetId();
@@ -373,12 +560,25 @@ void wxPropertyGridManager::Init2( int style )
 #ifdef __WXMAC__
    // Smaller controls on Mac
    SetWindowVariant(wxWINDOW_VARIANT_SMALL);
 #ifdef __WXMAC__
    // Smaller controls on Mac
    SetWindowVariant(wxWINDOW_VARIANT_SMALL);
-#endif 
+#endif
+
+   long propGridFlags = (m_windowStyle&wxPG_MAN_PASS_FLAGS_MASK)
+                        |wxPG_MAN_PROPGRID_FORCED_FLAGS;
+
+   propGridFlags &= ~wxBORDER_MASK;
+
+   if ((style & wxPG_NO_INTERNAL_BORDER) == 0)
+   {
+       propGridFlags |= wxBORDER_THEME;
+   }
+   else
+   {
+       propGridFlags |= wxBORDER_NONE;
+       wxWindow::SetExtraStyle(wxPG_EX_TOOLBAR_SEPARATOR);
+   }
 
     // Create propertygrid.
 
     // Create propertygrid.
-    m_pPropGrid->Create(this,baseId,wxPoint(0,0),csz,
-                        (m_windowStyle&wxPG_MAN_PASS_FLAGS_MASK)
-                            |wxPG_MAN_PROPGRID_FORCED_FLAGS);
+    m_pPropGrid->Create(this,baseId,wxPoint(0,0),csz, propGridFlags);
 
     m_pPropGrid->m_eventObject = this;
 
 
     m_pPropGrid->m_eventObject = this;
 
@@ -396,9 +596,13 @@ void wxPropertyGridManager::Init2( int style )
     // Connect to property grid onselect event.
     // NB: Even if wxID_ANY is used, this doesn't connect properly in wxPython
     //     (see wxPropertyGridManager::ProcessEvent).
     // Connect to property grid onselect event.
     // NB: Even if wxID_ANY is used, this doesn't connect properly in wxPython
     //     (see wxPropertyGridManager::ProcessEvent).
-    Connect(m_pPropGrid->GetId()/*wxID_ANY*/,
-            wxEVT_PG_SELECTED,
-            wxPropertyGridEventHandler(wxPropertyGridManager::OnPropertyGridSelect) );
+    Connect(m_pPropGrid->GetId(),
+     wxEVT_PG_SELECTED,
+     wxPropertyGridEventHandler(wxPropertyGridManager::OnPropertyGridSelect));
+
+    Connect(m_pPropGrid->GetId(),
+            wxEVT_PG_COL_DRAGGING,
+            wxPropertyGridEventHandler(wxPropertyGridManager::OnPGColDrag));
 
     // Connect to toolbar button events.
     Connect(baseId+ID_ADVTBITEMSBASE_OFFSET,baseId+ID_ADVTBITEMSBASE_OFFSET+50,
 
     // Connect to toolbar button events.
     Connect(baseId+ID_ADVTBITEMSBASE_OFFSET,baseId+ID_ADVTBITEMSBASE_OFFSET+50,
@@ -418,13 +622,13 @@ wxPropertyGridManager::~wxPropertyGridManager()
 {
     END_MOUSE_CAPTURE
 
 {
     END_MOUSE_CAPTURE
 
-    m_pPropGrid->DoSelectProperty(NULL);
-    m_pPropGrid->m_pState = NULL;
+    //m_pPropGrid->ClearSelection();
+    wxDELETE(m_pPropGrid);
 
     size_t i;
 
     size_t i;
-    for ( i=0; i<m_arrPages.GetCount(); i++ )
+    for ( i=0; i<m_arrPages.size(); i++ )
     {
     {
-        delete (wxPropertyGridPage*)m_arrPages.Item(i);
+        delete m_arrPages[i];
     }
 
     delete m_emptyPage;
     }
 
     delete m_emptyPage;
@@ -464,7 +668,7 @@ bool wxPropertyGridManager::SetFont( const wxFont& font )
 
     // TODO: Need to do caption recacalculations for other pages as well.
     unsigned int i;
 
     // TODO: Need to do caption recacalculations for other pages as well.
     unsigned int i;
-    for ( i=0; i<m_arrPages.GetCount(); i++ )
+    for ( i=0; i<m_arrPages.size(); i++ )
     {
         wxPropertyGridPage* page = GetPage(i);
 
     {
         wxPropertyGridPage* page = GetPage(i);
 
@@ -507,9 +711,30 @@ void wxPropertyGridManager::Thaw()
 
 void wxPropertyGridManager::SetWindowStyleFlag( long style )
 {
 
 void wxPropertyGridManager::SetWindowStyleFlag( long style )
 {
+    int oldWindowStyle = GetWindowStyleFlag();
+
     wxWindow::SetWindowStyleFlag( style );
     m_pPropGrid->SetWindowStyleFlag( (m_pPropGrid->GetWindowStyleFlag()&~(wxPG_MAN_PASS_FLAGS_MASK)) |
                                    (style&wxPG_MAN_PASS_FLAGS_MASK) );
     wxWindow::SetWindowStyleFlag( style );
     m_pPropGrid->SetWindowStyleFlag( (m_pPropGrid->GetWindowStyleFlag()&~(wxPG_MAN_PASS_FLAGS_MASK)) |
                                    (style&wxPG_MAN_PASS_FLAGS_MASK) );
+
+    // Need to re-position windows?
+    if ( (oldWindowStyle & (wxPG_TOOLBAR|wxPG_DESCRIPTION)) !=
+         (style & (wxPG_TOOLBAR|wxPG_DESCRIPTION)) )
+    {
+        RecreateControls();
+    }
+}
+
+// -----------------------------------------------------------------------
+
+bool wxPropertyGridManager::Reparent( wxWindowBase *newParent )
+{
+    if ( m_pPropGrid )
+        m_pPropGrid->OnTLPChanging((wxWindow*)newParent);
+
+    bool res = wxPanel::Reparent(newParent);
+
+    return res;
 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------
@@ -527,7 +752,7 @@ bool wxPropertyGridManager::DoSelectPage( int index )
     if ( m_selPage == index )
         return true;
 
     if ( m_selPage == index )
         return true;
 
-    if ( m_pPropGrid->m_selected )
+    if ( m_pPropGrid->GetSelection() )
     {
         if ( !m_pPropGrid->ClearSelection() )
             return false;
     {
         if ( !m_pPropGrid->ClearSelection() )
             return false;
@@ -544,7 +769,7 @@ bool wxPropertyGridManager::DoSelectPage( int index )
 
     if ( index >= 0 )
     {
 
     if ( index >= 0 )
     {
-        nextPage = (wxPropertyGridPage*)m_arrPages.Item(index);
+        nextPage = m_arrPages[index];
 
         nextPage->OnShow();
     }
 
         nextPage->OnShow();
     }
@@ -577,6 +802,11 @@ bool wxPropertyGridManager::DoSelectPage( int index )
     }
 #endif
 
     }
 #endif
 
+#if wxUSE_HEADERCTRL
+    if ( m_showHeader )
+        m_pHeaderCtrl->OnPageChanged(nextPage);
+#endif
+
     return true;
 }
 
     return true;
 }
 
@@ -595,7 +825,7 @@ int wxPropertyGridManager::GetPageByName( const wxString& name ) const
     size_t i;
     for ( i=0; i<GetPageCount(); i++ )
     {
     size_t i;
     for ( i=0; i<GetPageCount(); i++ )
     {
-        if ( ((wxPropertyGridPage*)m_arrPages.Item(i))->m_label == name )
+        if ( m_arrPages[i]->m_label == name )
             return i;
     }
     return wxNOT_FOUND;
             return i;
     }
     return wxNOT_FOUND;
@@ -610,7 +840,7 @@ int wxPropertyGridManager::GetPageByState( const wxPropertyGridPageState* pState
     size_t i;
     for ( i=0; i<GetPageCount(); i++ )
     {
     size_t i;
     for ( i=0; i<GetPageCount(); i++ )
     {
-        if ( pState == ((wxPropertyGridPage*)m_arrPages.Item(i))->GetStatePtr() )
+        if ( pState == m_arrPages[i]->GetStatePtr() )
             return i;
     }
 
             return i;
     }
 
@@ -622,7 +852,7 @@ int wxPropertyGridManager::GetPageByState( const wxPropertyGridPageState* pState
 const wxString& wxPropertyGridManager::GetPageName( int index ) const
 {
     wxASSERT( index >= 0 && index < (int)GetPageCount() );
 const wxString& wxPropertyGridManager::GetPageName( int index ) const
 {
     wxASSERT( index >= 0 && index < (int)GetPageCount() );
-    return ((wxPropertyGridPage*)m_arrPages.Item(index))->m_label;
+    return m_arrPages[index]->m_label;
 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------
@@ -636,13 +866,15 @@ wxPropertyGridPageState* wxPropertyGridManager::GetPageState( int page ) const
 
     if ( page == -1 )
         return m_pState;
 
     if ( page == -1 )
         return m_pState;
-    return GETPAGESTATE(page);
+    return m_arrPages[page];
 }
 
 // -----------------------------------------------------------------------
 
 void wxPropertyGridManager::Clear()
 {
 }
 
 // -----------------------------------------------------------------------
 
 void wxPropertyGridManager::Clear()
 {
+    m_pPropGrid->ClearSelection(false);
+
     m_pPropGrid->Freeze();
 
     int i;
     m_pPropGrid->Freeze();
 
     int i;
@@ -664,7 +896,7 @@ void wxPropertyGridManager::ClearPage( int page )
 
     if ( page >= 0 && page < (int)GetPageCount() )
     {
 
     if ( page >= 0 && page < (int)GetPageCount() )
     {
-        wxPropertyGridPageState* state = GETPAGESTATE(page);
+        wxPropertyGridPageState* state = m_arrPages[page];
 
         if ( state == m_pPropGrid->GetState() )
             m_pPropGrid->Clear();
 
         if ( state == m_pPropGrid->GetState() )
             m_pPropGrid->Clear();
@@ -692,26 +924,33 @@ void wxPropertyGridManager::SetColumnCount( int colCount, int page )
 
     GetPageState(page)->SetColumnCount( colCount );
     GetGrid()->Refresh();
 
     GetPageState(page)->SetColumnCount( colCount );
     GetGrid()->Refresh();
+
+#if wxUSE_HEADERCTRL
+    if ( m_showHeader )
+        m_pHeaderCtrl->OnPageUpdated();
+#endif
 }
 // -----------------------------------------------------------------------
 
 size_t wxPropertyGridManager::GetPageCount() const
 {
 }
 // -----------------------------------------------------------------------
 
 size_t wxPropertyGridManager::GetPageCount() const
 {
-       if ( !(m_iFlags & wxPG_MAN_FL_PAGE_INSERTED) )
-               return 0;
+    if ( !(m_iFlags & wxPG_MAN_FL_PAGE_INSERTED) )
+        return 0;
 
 
-       return m_arrPages.GetCount();
+    return m_arrPages.size();
 }
 
 // -----------------------------------------------------------------------
 
 }
 
 // -----------------------------------------------------------------------
 
-int wxPropertyGridManager::InsertPage( int index, const wxString& label,
-                                       const wxBitmap& bmp, wxPropertyGridPage* pageObj )
+wxPropertyGridPage* wxPropertyGridManager::InsertPage( int index,
+                                                       const wxString& label,
+                                                       const wxBitmap& bmp,
+                                                       wxPropertyGridPage* pageObj )
 {
     if ( index < 0 )
         index = GetPageCount();
 
 {
     if ( index < 0 )
         index = GetPageCount();
 
-    wxCHECK_MSG( (size_t)index == GetPageCount(), -1,
+    wxCHECK_MSG( (size_t)index == GetPageCount(), NULL,
         wxT("wxPropertyGridManager currently only supports appending pages (due to wxToolBar limitation)."));
 
     bool needInit = true;
         wxT("wxPropertyGridManager currently only supports appending pages (due to wxToolBar limitation)."));
 
     bool needInit = true;
@@ -772,8 +1011,11 @@ int wxPropertyGridManager::InsertPage( int index, const wxString& label,
 
     pageObj->m_id = m_nextTbInd;
 
 
     pageObj->m_id = m_nextTbInd;
 
+    if ( !HasFlag(wxPG_SPLITTER_AUTO_CENTER) )
+        pageObj->m_dontCenterSplitter = true;
+
     if ( isPageInserted )
     if ( isPageInserted )
-        m_arrPages.Add( (void*)pageObj );
+        m_arrPages.push_back( pageObj );
 
 #if wxUSE_TOOLBAR
     if ( m_windowStyle & wxPG_TOOLBAR )
 
 #if wxUSE_TOOLBAR
     if ( m_windowStyle & wxPG_TOOLBAR )
@@ -794,7 +1036,7 @@ int wxPropertyGridManager::InsertPage( int index, const wxString& label,
                 m_pToolbar->AddTool(m_nextTbInd,label,bmp,label,wxITEM_RADIO);
                 //m_pToolbar->InsertTool(index+3,m_nextTbInd,bmp);
             else
                 m_pToolbar->AddTool(m_nextTbInd,label,bmp,label,wxITEM_RADIO);
                 //m_pToolbar->InsertTool(index+3,m_nextTbInd,bmp);
             else
-                m_pToolbar->AddTool(m_nextTbInd,label,wxBitmap( (const char**)gs_xpm_defpage ),
+                m_pToolbar->AddTool(m_nextTbInd,label,wxBitmap(gs_xpm_defpage),
                     label,wxITEM_RADIO);
 
             m_nextTbInd++;
                     label,wxITEM_RADIO);
 
             m_nextTbInd++;
@@ -826,7 +1068,7 @@ int wxPropertyGridManager::InsertPage( int index, const wxString& label,
 
     wxASSERT( pageObj->GetGrid() );
 
 
     wxASSERT( pageObj->GetGrid() );
 
-    return index;
+    return pageObj;
 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------
@@ -836,7 +1078,7 @@ bool wxPropertyGridManager::IsAnyModified() const
     size_t i;
     for ( i=0; i<GetPageCount(); i++ )
     {
     size_t i;
     for ( i=0; i<GetPageCount(); i++ )
     {
-        if ( ((wxPropertyGridPage*)m_arrPages.Item(i))->GetStatePtr()->m_anyModified )
+        if ( m_arrPages[i]->GetStatePtr()->m_anyModified )
             return true;
     }
     return false;
             return true;
     }
     return false;
@@ -846,19 +1088,57 @@ bool wxPropertyGridManager::IsAnyModified() const
 
 bool wxPropertyGridManager::IsPageModified( size_t index ) const
 {
 
 bool wxPropertyGridManager::IsPageModified( size_t index ) const
 {
-    if ( ((wxPropertyGridPage*)m_arrPages.Item(index))->GetStatePtr()->m_anyModified )
+    if ( m_arrPages[index]->GetStatePtr()->m_anyModified )
         return true;
     return false;
 }
 
 // -----------------------------------------------------------------------
 
         return true;
     return false;
 }
 
 // -----------------------------------------------------------------------
 
+#if wxUSE_HEADERCTRL
+void wxPropertyGridManager::ShowHeader(bool show)
+{
+    if ( show != m_showHeader)
+    {
+        m_showHeader = show;
+        RecreateControls();
+    }
+}
+#endif
+
+// -----------------------------------------------------------------------
+
+#if wxUSE_HEADERCTRL
+void wxPropertyGridManager::SetColumnTitle( int idx, const wxString& title )
+{
+    if ( !m_pHeaderCtrl )
+        ShowHeader();
+
+    m_pHeaderCtrl->SetColumnTitle(idx, title);
+}
+#endif
+
+// -----------------------------------------------------------------------
+
+bool wxPropertyGridManager::IsPropertySelected( wxPGPropArg id ) const
+{
+    wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
+    for ( unsigned int i=0; i<GetPageCount(); i++ )
+    {
+        if ( GetPageState(i)->DoIsPropertySelected(p) )
+            return true;
+    }
+    return false;
+}
+
+// -----------------------------------------------------------------------
+
 wxPGProperty* wxPropertyGridManager::GetPageRoot( int index ) const
 {
     wxASSERT( index >= 0 );
 wxPGProperty* wxPropertyGridManager::GetPageRoot( int index ) const
 {
     wxASSERT( index >= 0 );
-    wxASSERT( index < (int)m_arrPages.GetCount() );
+    wxASSERT( index < (int)m_arrPages.size() );
 
 
-    return ((wxPropertyGridPage*)m_arrPages.Item(index))->GetStatePtr()->m_properties;
+    return m_arrPages[index]->GetStatePtr()->m_properties;
 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------
@@ -869,9 +1149,9 @@ bool wxPropertyGridManager::RemovePage( int page )
                  false,
                  wxT("invalid page index") );
 
                  false,
                  wxT("invalid page index") );
 
-    wxPropertyGridPage* pd = (wxPropertyGridPage*)m_arrPages.Item(page);
+    wxPropertyGridPage* pd = m_arrPages[page];
 
 
-    if ( m_arrPages.GetCount() == 1 )
+    if ( m_arrPages.size() == 1 )
     {
         // Last page: do not remove page entry
         m_pPropGrid->Clear();
     {
         // Last page: do not remove page entry
         m_pPropGrid->Clear();
@@ -879,6 +1159,7 @@ bool wxPropertyGridManager::RemovePage( int page )
         m_iFlags &= ~wxPG_MAN_FL_PAGE_INSERTED;
         pd->m_label.clear();
     }
         m_iFlags &= ~wxPG_MAN_FL_PAGE_INSERTED;
         pd->m_label.clear();
     }
+
     // Change selection if current is page
     else if ( page == m_selPage )
     {
     // Change selection if current is page
     else if ( page == m_selPage )
     {
@@ -911,9 +1192,9 @@ bool wxPropertyGridManager::RemovePage( int page )
     }
 #endif
 
     }
 #endif
 
-    if ( m_arrPages.GetCount() > 1 )
+    if ( m_arrPages.size() > 1 )
     {
     {
-        m_arrPages.RemoveAt(page);
+        m_arrPages.erase(m_arrPages.begin() + page);
         delete pd;
     }
 
         delete pd;
     }
 
@@ -964,44 +1245,33 @@ bool wxPropertyGridManager::ProcessEvent( wxEvent& event )
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 
-void wxPropertyGridManager::RepaintSplitter( wxDC& dc, int new_splittery, int new_width,
-                                             int new_height, bool desc_too )
+void wxPropertyGridManager::RepaintDescBoxDecorations( wxDC& dc,
+                                                       int newSplitterY,
+                                                       int newWidth,
+                                                       int newHeight )
 {
 {
-    int use_hei = new_height;
-
     // Draw background
     wxColour bgcol = GetBackgroundColour();
     // Draw background
     wxColour bgcol = GetBackgroundColour();
-    dc.SetBrush( bgcol );
-    dc.SetPen( bgcol );
-    int rect_hei = use_hei-new_splittery;
-    if ( !desc_too )
-        rect_hei = m_splitterHeight;
-    dc.DrawRectangle(0,new_splittery,new_width,rect_hei);
-    dc.SetPen ( wxSystemSettings::GetColour ( wxSYS_COLOUR_3DDKSHADOW ) );
-    int splitter_bottom = new_splittery+m_splitterHeight - 1;
-    int box_height = use_hei-splitter_bottom;
-    if ( box_height > 1 )
-        dc.DrawRectangle(0,splitter_bottom,new_width,box_height);
+    dc.SetBrush(bgcol);
+    dc.SetPen(bgcol);
+    int rectHeight = m_splitterHeight;
+    dc.DrawRectangle(0, newSplitterY, newWidth, rectHeight);
+    dc.SetPen( wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW) );
+    int splitterBottom = newSplitterY + m_splitterHeight - 1;
+    int boxHeight = newHeight - splitterBottom;
+    if ( boxHeight > 1 )
+        dc.DrawRectangle(0, splitterBottom, newWidth, boxHeight);
     else
     else
-        dc.DrawLine(0,splitter_bottom,new_width,splitter_bottom);
+        dc.DrawLine(0, splitterBottom, newWidth, splitterBottom);
 }
 
 // -----------------------------------------------------------------------
 
 }
 
 // -----------------------------------------------------------------------
 
-void wxPropertyGridManager::RefreshHelpBox( int new_splittery, int new_width, int new_height )
+void wxPropertyGridManager::UpdateDescriptionBox( int new_splittery, int new_width, int new_height )
 {
 {
-    //if ( new_splittery == m_splitterY && new_width == m_width )
-    //    return;
-
     int use_hei = new_height;
     use_hei--;
 
     int use_hei = new_height;
     use_hei--;
 
-    //wxRendererNative::Get().DrawSplitterSash(this,dc,
-        //wxSize(width,m_splitterHeight),new_splittery,wxHORIZONTAL);
-
-    //wxRendererNative::Get().DrawSplitterBorder(this,dc,
-    //    wxRect(0,new_splittery,new_width,m_splitterHeight));
-
     // Fix help control positions.
     int cap_hei = m_pPropGrid->m_fontHeight;
     int cap_y = new_splittery+m_splitterHeight+5;
     // Fix help control positions.
     int cap_hei = m_pPropGrid->m_fontHeight;
     int cap_y = new_splittery+m_splitterHeight+5;
@@ -1034,8 +1304,8 @@ void wxPropertyGridManager::RefreshHelpBox( int new_splittery, int new_width, in
         }
     }
 
         }
     }
 
-    wxClientDC dc(this);
-    RepaintSplitter( dc, new_splittery, new_width, new_height, true );
+    wxRect r(0, new_splittery, new_width, new_height-new_splittery);
+    RefreshRect(r);
 
     m_splitterY = new_splittery;
 
 
     m_splitterY = new_splittery;
 
@@ -1053,25 +1323,20 @@ void wxPropertyGridManager::RecalculatePositions( int width, int height )
 #if wxUSE_TOOLBAR
     if ( m_pToolbar )
     {
 #if wxUSE_TOOLBAR
     if ( m_pToolbar )
     {
-        int tbHeight;
+        m_pToolbar->SetSize(0, 0, width, -1);
+        propgridY += m_pToolbar->GetSize().y;
 
 
-    #if ( wxMINOR_VERSION < 6 || (wxMINOR_VERSION == 6 && wxRELEASE_NUMBER < 2) )
-        tbHeight = -1;
-    #else
-        // In wxWidgets 2.6.2+, Toolbar default height may be broken
-        #if defined(__WXMSW__)
-            tbHeight = 24;
-        #elif defined(__WXGTK__)
-            tbHeight = -1; // 22;
-        #elif defined(__WXMAC__)
-            tbHeight = 22;
-        #else
-            tbHeight = 22;
-        #endif
-    #endif
+        if (GetExtraStyle() & wxPG_EX_TOOLBAR_SEPARATOR)
+            propgridY += 1;
+    }
+#endif
 
 
-        m_pToolbar->SetSize(0,0,width,tbHeight);
-        propgridY += m_pToolbar->GetSize().y;
+    // Header comes after the tool bar
+#if wxUSE_HEADERCTRL
+    if ( m_showHeader )
+    {
+        m_pHeaderCtrl->SetSize(0, propgridY, width, -1);
+        propgridY += m_pHeaderCtrl->GetSize().y;
     }
 #endif
 
     }
 #endif
 
@@ -1104,12 +1369,14 @@ void wxPropertyGridManager::RecalculatePositions( int width, int height )
 
         propgridBottomY = new_splittery;
 
 
         propgridBottomY = new_splittery;
 
-        RefreshHelpBox( new_splittery, width, height );
+        UpdateDescriptionBox( new_splittery, width, height );
     }
 
     if ( m_iFlags & wxPG_FL_INITIALIZED )
     {
         int pgh = propgridBottomY - propgridY;
     }
 
     if ( m_iFlags & wxPG_FL_INITIALIZED )
     {
         int pgh = propgridBottomY - propgridY;
+        if ( pgh < 0 )
+            pgh = 0;
         m_pPropGrid->SetSize( 0, propgridY, width, pgh );
 
         m_extraHeight = height - pgh;
         m_pPropGrid->SetSize( 0, propgridY, width, pgh );
 
         m_extraHeight = height - pgh;
@@ -1125,9 +1392,12 @@ void wxPropertyGridManager::SetDescBoxHeight( int ht, bool refresh )
 {
     if ( m_windowStyle & wxPG_DESCRIPTION )
     {
 {
     if ( m_windowStyle & wxPG_DESCRIPTION )
     {
-        m_nextDescBoxSize = ht;
-        if ( refresh )
-            RecalculatePositions(m_width, m_height);
+        if ( ht != GetDescBoxHeight() )
+        {
+            m_nextDescBoxSize = ht;
+            if ( refresh )
+                RecalculatePositions(m_width, m_height);
+        }
     }
 }
 
     }
 }
 
@@ -1135,7 +1405,7 @@ void wxPropertyGridManager::SetDescBoxHeight( int ht, bool refresh )
 
 int wxPropertyGridManager::GetDescBoxHeight() const
 {
 
 int wxPropertyGridManager::GetDescBoxHeight() const
 {
-    return GetClientSize().y - m_splitterY;
+    return GetClientSize().y - m_splitterY - m_splitterHeight;
 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------
@@ -1147,11 +1417,21 @@ void wxPropertyGridManager::OnPaint( wxPaintEvent& WXUNUSED(event) )
     // Update everything inside the box
     wxRect r = GetUpdateRegion().GetBox();
 
     // Update everything inside the box
     wxRect r = GetUpdateRegion().GetBox();
 
-    // Repaint splitter?
-    int r_bottom = r.y + r.height;
-    int splitter_bottom = m_splitterY + m_splitterHeight;
-    if ( r.y < splitter_bottom && r_bottom >= m_splitterY )
-        RepaintSplitter( dc, m_splitterY, m_width, m_height, false );
+    if (GetExtraStyle() & wxPG_EX_TOOLBAR_SEPARATOR)
+    {
+        if (m_pToolbar && m_pPropGrid)
+        {
+            wxPen marginPen(m_pPropGrid->GetMarginColour());
+            dc.SetPen(marginPen);
+
+            int y = m_pPropGrid->GetPosition().y-1;
+            dc.DrawLine(0, y, GetClientSize().x, y);
+        }
+    }
+
+    // Repaint splitter and any other description box decorations
+    if ( (r.y + r.height) >= m_splitterY && m_splitterY != -1)
+        RepaintDescBoxDecorations( dc, m_splitterY, m_width, m_height );
 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------
@@ -1191,10 +1471,14 @@ void wxPropertyGridManager::RecreateControls()
         // Has toolbar.
         if ( !m_pToolbar )
         {
         // Has toolbar.
         if ( !m_pToolbar )
         {
+            long toolBarFlags = ((GetExtraStyle()&wxPG_EX_NO_FLAT_TOOLBAR)?0:wxTB_FLAT);
+            if (GetExtraStyle() & wxPG_EX_NO_TOOLBAR_DIVIDER)
+                toolBarFlags |= wxTB_NODIVIDER;
+
             m_pToolbar = new wxToolBar(this,baseId+ID_ADVTOOLBAR_OFFSET,
                                        wxDefaultPosition,wxDefaultSize,
             m_pToolbar = new wxToolBar(this,baseId+ID_ADVTOOLBAR_OFFSET,
                                        wxDefaultPosition,wxDefaultSize,
-                                       ((GetExtraStyle()&wxPG_EX_NO_FLAT_TOOLBAR)?0:wxTB_FLAT)
-                                        /*| wxTB_HORIZONTAL | wxNO_BORDER*/ );
+                                       toolBarFlags);
+            m_pToolbar->SetToolBitmapSize(wxSize(16, 15));
 
         #if defined(__WXMSW__)
             // Eliminate toolbar flicker on XP
 
         #if defined(__WXMSW__)
             // Eliminate toolbar flicker on XP
@@ -1220,10 +1504,10 @@ void wxPropertyGridManager::RecreateControls()
                 wxString desc1(_("Categorized Mode"));
                 wxString desc2(_("Alphabetic Mode"));
                 m_pToolbar->AddTool(baseId+ID_ADVTBITEMSBASE_OFFSET+0,
                 wxString desc1(_("Categorized Mode"));
                 wxString desc2(_("Alphabetic Mode"));
                 m_pToolbar->AddTool(baseId+ID_ADVTBITEMSBASE_OFFSET+0,
-                    desc1,wxBitmap ( (const char**)gs_xpm_catmode ),
+                    desc1,wxBitmap (gs_xpm_catmode),
                     desc1,wxITEM_RADIO);
                 m_pToolbar->AddTool(baseId+ID_ADVTBITEMSBASE_OFFSET+1,
                     desc1,wxITEM_RADIO);
                 m_pToolbar->AddTool(baseId+ID_ADVTBITEMSBASE_OFFSET+1,
-                    desc2,wxBitmap ( (const char**)gs_xpm_noncatmode ),
+                    desc2,wxBitmap (gs_xpm_noncatmode),
                     desc2,wxITEM_RADIO);
                 m_pToolbar->Realize();
             }
                     desc2,wxITEM_RADIO);
                 m_pToolbar->Realize();
             }
@@ -1253,7 +1537,32 @@ void wxPropertyGridManager::RecreateControls()
         // No toolbar.
         if ( m_pToolbar )
             m_pToolbar->Destroy();
         // No toolbar.
         if ( m_pToolbar )
             m_pToolbar->Destroy();
-        m_pToolbar = (wxToolBar*) NULL;
+        m_pToolbar = NULL;
+    }
+#endif
+
+#if wxUSE_HEADERCTRL
+    if ( m_showHeader )
+    {
+        wxPGHeaderCtrl* hc;
+
+        if ( !m_pHeaderCtrl )
+        {
+            hc = new wxPGHeaderCtrl(this);
+            hc->Create(this, baseId+ID_ADVHEADERCTRL_OFFSET);
+            m_pHeaderCtrl = hc;
+        }
+        else
+        {
+            m_pHeaderCtrl->Show();
+        }
+
+        m_pHeaderCtrl->OnPageChanged(GetCurrentPage());
+    }
+    else
+    {
+        if ( m_pHeaderCtrl )
+            m_pHeaderCtrl->Hide();
     }
 #endif
 
     }
 #endif
 
@@ -1264,16 +1573,27 @@ void wxPropertyGridManager::RecreateControls()
 
         if ( !m_pTxtHelpCaption )
         {
 
         if ( !m_pTxtHelpCaption )
         {
-            m_pTxtHelpCaption = new wxStaticText (this,baseId+ID_ADVHELPCAPTION_OFFSET,wxEmptyString);
+            m_pTxtHelpCaption = new wxStaticText(this,
+                                                 baseId+ID_ADVHELPCAPTION_OFFSET,
+                                                 wxT(""),
+                                                 wxDefaultPosition,
+                                                 wxDefaultSize,
+                                                 wxALIGN_LEFT|wxST_NO_AUTORESIZE);
             m_pTxtHelpCaption->SetFont( m_pPropGrid->m_captionFont );
             m_pTxtHelpCaption->SetFont( m_pPropGrid->m_captionFont );
-            m_pTxtHelpCaption->SetCursor ( *wxSTANDARD_CURSOR );
+            m_pTxtHelpCaption->SetCursor( *wxSTANDARD_CURSOR );
         }
         if ( !m_pTxtHelpContent )
         {
         }
         if ( !m_pTxtHelpContent )
         {
-            m_pTxtHelpContent = new wxStaticText (this,baseId+ID_ADVHELPCONTENT_OFFSET,
-                wxEmptyString,wxDefaultPosition,wxDefaultSize,wxALIGN_LEFT|wxST_NO_AUTORESIZE);
-            m_pTxtHelpContent->SetCursor ( *wxSTANDARD_CURSOR );
+            m_pTxtHelpContent = new wxStaticText(this,
+                                                 baseId+ID_ADVHELPCONTENT_OFFSET,
+                                                 wxT(""),
+                                                 wxDefaultPosition,
+                                                 wxDefaultSize,
+                                                 wxALIGN_LEFT|wxST_NO_AUTORESIZE);
+            m_pTxtHelpContent->SetCursor( *wxSTANDARD_CURSOR );
         }
         }
+
+        SetDescribedProperty(GetSelection());
     }
     else
     {
     }
     else
     {
@@ -1283,12 +1603,12 @@ void wxPropertyGridManager::RecreateControls()
         if ( m_pTxtHelpCaption )
             m_pTxtHelpCaption->Destroy();
 
         if ( m_pTxtHelpCaption )
             m_pTxtHelpCaption->Destroy();
 
-        m_pTxtHelpCaption = (wxStaticText*) NULL;
+        m_pTxtHelpCaption = NULL;
 
         if ( m_pTxtHelpContent )
             m_pTxtHelpContent->Destroy();
 
 
         if ( m_pTxtHelpContent )
             m_pTxtHelpContent->Destroy();
 
-        m_pTxtHelpContent = (wxStaticText*) NULL;
+        m_pTxtHelpContent = NULL;
     }
 
     int width, height;
     }
 
     int width, height;
@@ -1308,7 +1628,7 @@ wxPGProperty* wxPropertyGridManager::DoGetPropertyByName( const wxString& name )
     size_t i;
     for ( i=0; i<GetPageCount(); i++ )
     {
     size_t i;
     for ( i=0; i<GetPageCount(); i++ )
     {
-        wxPropertyGridPageState* pState = ((wxPropertyGridPage*)m_arrPages.Item(i))->GetStatePtr();
+        wxPropertyGridPageState* pState = m_arrPages[i]->GetStatePtr();
         wxPGProperty* p = pState->BaseGetPropertyByName(name);
         if ( p )
         {
         wxPGProperty* p = pState->BaseGetPropertyByName(name);
         if ( p )
         {
@@ -1335,13 +1655,6 @@ bool wxPropertyGridManager::EnsureVisible( wxPGPropArg id )
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 
-size_t wxPropertyGridManager::GetChildrenCount( int page_index )
-{
-    return GetChildrenCount( GetPage(page_index)->GetStatePtr()->m_properties );
-}
-
-// -----------------------------------------------------------------------
-
 void wxPropertyGridManager::OnToolbarClick( wxCommandEvent &event )
 {
     int id = event.GetId();
 void wxPropertyGridManager::OnToolbarClick( wxCommandEvent &event )
 {
     int id = event.GetId();
@@ -1355,13 +1668,25 @@ void wxPropertyGridManager::OnToolbarClick( wxCommandEvent &event )
         {
             // Categorized mode.
             if ( m_pPropGrid->m_windowStyle & wxPG_HIDE_CATEGORIES )
         {
             // Categorized mode.
             if ( m_pPropGrid->m_windowStyle & wxPG_HIDE_CATEGORIES )
+            {
+                if ( !m_pPropGrid->HasInternalFlag(wxPG_FL_CATMODE_AUTO_SORT) )
+                    m_pPropGrid->m_windowStyle &= ~wxPG_AUTO_SORT;
                 m_pPropGrid->EnableCategories( true );
                 m_pPropGrid->EnableCategories( true );
+            }
         }
         else if ( id == ( baseId + ID_ADVTBITEMSBASE_OFFSET + 1 ) )
         {
             // Alphabetic mode.
             if ( !(m_pPropGrid->m_windowStyle & wxPG_HIDE_CATEGORIES) )
         }
         else if ( id == ( baseId + ID_ADVTBITEMSBASE_OFFSET + 1 ) )
         {
             // Alphabetic mode.
             if ( !(m_pPropGrid->m_windowStyle & wxPG_HIDE_CATEGORIES) )
+            {
+                if ( m_pPropGrid->HasFlag(wxPG_AUTO_SORT) )
+                    m_pPropGrid->SetInternalFlag(wxPG_FL_CATMODE_AUTO_SORT);
+                else
+                    m_pPropGrid->ClearInternalFlag(wxPG_FL_CATMODE_AUTO_SORT);
+
+                m_pPropGrid->m_windowStyle |= wxPG_AUTO_SORT;
                 m_pPropGrid->EnableCategories( false );
                 m_pPropGrid->EnableCategories( false );
+            }
         }
         else
         {
         }
         else
         {
@@ -1374,7 +1699,7 @@ void wxPropertyGridManager::OnToolbarClick( wxCommandEvent &event )
             // Find page with given id.
             for ( i=0; i<GetPageCount(); i++ )
             {
             // Find page with given id.
             for ( i=0; i<GetPageCount(); i++ )
             {
-                pdc = (wxPropertyGridPage*)m_arrPages.Item(i);
+                pdc = m_arrPages[i];
                 if ( pdc->m_id == id )
                 {
                     index = i;
                 if ( pdc->m_id == id )
                 {
                     index = i;
@@ -1388,7 +1713,7 @@ void wxPropertyGridManager::OnToolbarClick( wxCommandEvent &event )
             {
 
                 // Event dispatching must be last.
             {
 
                 // Event dispatching must be last.
-                m_pPropGrid->SendEvent(  wxEVT_PG_PAGE_CHANGED, (wxPGProperty*) NULL );
+                m_pPropGrid->SendEvent(  wxEVT_PG_PAGE_CHANGED, NULL );
 
             }
             else
 
             }
             else
@@ -1402,6 +1727,29 @@ void wxPropertyGridManager::OnToolbarClick( wxCommandEvent &event )
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 
+bool wxPropertyGridManager::SetEditableStateItem( const wxString& name, wxVariant value )
+{
+    if ( name == wxS("descboxheight") )
+    {
+        SetDescBoxHeight(value.GetLong(), true);
+        return true;
+    }
+    return false;
+}
+
+// -----------------------------------------------------------------------
+
+wxVariant wxPropertyGridManager::GetEditableStateItem( const wxString& name ) const
+{
+    if ( name == wxS("descboxheight") )
+    {
+        return (long) GetDescBoxHeight();
+    }
+    return wxNullVariant;
+}
+
+// -----------------------------------------------------------------------
+
 void wxPropertyGridManager::SetDescription( const wxString& label, const wxString& content )
 {
     if ( m_pTxtHelpCaption )
 void wxPropertyGridManager::SetDescription( const wxString& label, const wxString& content )
 {
     if ( m_pTxtHelpCaption )
@@ -1415,8 +1763,7 @@ void wxPropertyGridManager::SetDescription( const wxString& label, const wxStrin
         m_pTxtHelpCaption->SetSize(-1,osz1.y);
         m_pTxtHelpContent->SetSize(-1,osz2.y);
 
         m_pTxtHelpCaption->SetSize(-1,osz1.y);
         m_pTxtHelpContent->SetSize(-1,osz2.y);
 
-        if ( (m_iFlags & wxPG_FL_DESC_REFRESH_REQUIRED) || (osz2.x<(m_width-10)) )
-            RefreshHelpBox( m_splitterY, m_width, m_height );
+        UpdateDescriptionBox( m_splitterY, m_width, m_height );
     }
 }
 
     }
 }
 
@@ -1432,8 +1779,7 @@ void wxPropertyGridManager::SetDescribedProperty( wxPGProperty* p )
         }
         else
         {
         }
         else
         {
-            m_pTxtHelpCaption->SetLabel(wxEmptyString);
-            m_pTxtHelpContent->SetLabel(wxEmptyString);
+            SetDescription( wxEmptyString, wxEmptyString );
         }
     }
 }
         }
     }
 }
@@ -1449,24 +1795,28 @@ void wxPropertyGridManager::SetSplitterLeft( bool subProps, bool allPages )
     else
     {
         wxClientDC dc(this);
     else
     {
         wxClientDC dc(this);
-        dc.SetFont(m_pPropGrid->m_font);
+        dc.SetFont(m_pPropGrid->GetFont());
 
         int highest = 0;
         unsigned int i;
 
         for ( i=0; i<GetPageCount(); i++ )
         {
 
         int highest = 0;
         unsigned int i;
 
         for ( i=0; i<GetPageCount(); i++ )
         {
-            int maxW = m_pState->GetColumnFitWidth(dc, GETPAGESTATE(i)->m_properties, 0, subProps );
+            int maxW = m_pState->GetColumnFitWidth(dc, m_arrPages[i]->m_properties, 0, subProps );
             maxW += m_pPropGrid->m_marginWidth;
             if ( maxW > highest )
                 highest = maxW;
             maxW += m_pPropGrid->m_marginWidth;
             if ( maxW > highest )
                 highest = maxW;
+            m_pState->m_dontCenterSplitter = true;
         }
 
         if ( highest > 0 )
             m_pPropGrid->SetSplitterPosition( highest );
         }
 
         if ( highest > 0 )
             m_pPropGrid->SetSplitterPosition( highest );
-
-        m_pPropGrid->m_iFlags |= wxPG_FL_DONT_CENTER_SPLITTER;
     }
     }
+
+#if wxUSE_HEADERCTRL
+    if ( m_showHeader )
+        m_pHeaderCtrl->OnColumWidthsChanged();
+#endif
 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------
@@ -1483,16 +1833,47 @@ void wxPropertyGridManager::OnPropertyGridSelect( wxPropertyGridEvent& event )
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 
+void
+wxPropertyGridManager::OnPGColDrag( wxPropertyGridEvent& WXUNUSED(event) )
+{
+#if wxUSE_HEADERCTRL
+    if ( !m_showHeader )
+        return;
+
+    m_pHeaderCtrl->OnColumWidthsChanged();
+#endif
+}
+
+// -----------------------------------------------------------------------
+
 void wxPropertyGridManager::OnResize( wxSizeEvent& WXUNUSED(event) )
 {
     int width, height;
 
 void wxPropertyGridManager::OnResize( wxSizeEvent& WXUNUSED(event) )
 {
     int width, height;
 
-    GetClientSize(&width,&height);
+    GetClientSize(&width, &height);
 
     if ( m_width == -12345 )
         RecreateControls();
 
 
     if ( m_width == -12345 )
         RecreateControls();
 
-    RecalculatePositions(width,height);
+    RecalculatePositions(width, height);
+
+    if ( m_pPropGrid && m_pPropGrid->m_parent )
+    {
+        int pgWidth, pgHeight;
+        m_pPropGrid->GetClientSize(&pgWidth, &pgHeight);
+
+        // Regenerate splitter positions for non-current pages
+        for ( unsigned int i=0; i<GetPageCount(); i++ )
+        {
+            wxPropertyGridPage* page = GetPage(i);
+            if ( page != m_pPropGrid->GetState() )
+            {
+                page->OnClientWidthChange(pgWidth,
+                                          pgWidth - page->m_width,
+                                          true);
+            }
+        }
+    }
 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------
@@ -1534,7 +1915,7 @@ void wxPropertyGridManager::OnMouseMove( wxMouseEvent &event )
                 m_splitterY = sy;
 
                 m_pPropGrid->SetSize( m_width, m_splitterY - m_pPropGrid->GetPosition().y );
                 m_splitterY = sy;
 
                 m_pPropGrid->SetSize( m_width, m_splitterY - m_pPropGrid->GetPosition().y );
-                RefreshHelpBox( m_splitterY, m_width, m_height );
+                UpdateDescriptionBox( m_splitterY, m_width, m_height );
 
                 m_extraHeight -= change;
                 InvalidateBestSize();
 
                 m_extraHeight -= change;
                 InvalidateBestSize();
@@ -1629,10 +2010,28 @@ void wxPropertyGridManager::SetSplitterPosition( int pos, int splitterColumn )
     for ( i=0; i<GetPageCount(); i++ )
     {
         wxPropertyGridPage* page = GetPage(i);
     for ( i=0; i<GetPageCount(); i++ )
     {
         wxPropertyGridPage* page = GetPage(i);
-        page->DoSetSplitterPositionThisPage( pos, splitterColumn );
+        page->DoSetSplitterPosition( pos, splitterColumn,
+                                     wxPG_SPLITTER_REFRESH );
     }
 
     }
 
-    m_pPropGrid->SetInternalFlag(wxPG_FL_SPLITTER_PRE_SET);
+#if wxUSE_HEADERCTRL
+    if ( m_showHeader )
+        m_pHeaderCtrl->OnColumWidthsChanged();
+#endif
+}
+
+// -----------------------------------------------------------------------
+
+void wxPropertyGridManager::SetPageSplitterPosition( int page,
+                                                     int pos,
+                                                     int column )
+{
+    GetPage(page)->DoSetSplitterPosition( pos, column );
+
+#if wxUSE_HEADERCTRL
+    if ( m_showHeader )
+        m_pHeaderCtrl->OnColumWidthsChanged();
+#endif
 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------