fix wxGTK1 compilation after wxTextEntry DoGetValue() change

[wxWidgets.git] / src / propgrid / property.cpp

diff --git a/src/propgrid/property.cpp b/src/propgrid/property.cpp
index 32db12d24591df4a15f5b9587b08c682afc1606d..bfb0e446e9d8104d360e79f1ed3f90984a17ada4 100644 (file)
--- a/src/propgrid/property.cpp
+++ b/src/propgrid/property.cpp
@@ -4,7 +4,7 @@
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2008-08-23
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2008-08-23

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

 // Copyright:   (c) Jaakko Salli
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 // Copyright:   (c) Jaakko Salli
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////


@@ -16,6 +16,8 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#if wxUSE_PROPGRID
+

 #ifndef WX_PRECOMP
     #include "wx/defs.h"
     #include "wx/object.h"
 #ifndef WX_PRECOMP
     #include "wx/defs.h"
     #include "wx/object.h"


@@ -27,29 +29,13 @@
     #include "wx/panel.h"
     #include "wx/dc.h"
     #include "wx/dcmemory.h"
     #include "wx/panel.h"
     #include "wx/dc.h"
     #include "wx/dcmemory.h"

-    #include "wx/button.h"

     #include "wx/pen.h"
     #include "wx/brush.h"
     #include "wx/pen.h"
     #include "wx/brush.h"

-    #include "wx/cursor.h"
-    #include "wx/dialog.h"

     #include "wx/settings.h"
     #include "wx/settings.h"

-    #include "wx/msgdlg.h"
-    #include "wx/choice.h"
-    #include "wx/stattext.h"
-    #include "wx/scrolwin.h"
-    #include "wx/dirdlg.h"
-    #include "wx/layout.h"
-    #include "wx/sizer.h"
-    #include "wx/textdlg.h"
-    #include "wx/filedlg.h"
-    #include "wx/statusbr.h"

     #include "wx/intl.h"
     #include "wx/intl.h"

-    #include "wx/frame.h"

 #endif
 
 #endif
 

-#include <wx/propgrid/propgrid.h>
-
-#include <typeinfo>
+#include "wx/propgrid/propgrid.h"

 
 
 #define PWC_CHILD_SUMMARY_LIMIT         16 // Maximum number of children summarized in a parent property's
 
 
 #define PWC_CHILD_SUMMARY_LIMIT         16 // Maximum number of children summarized in a parent property's


@@ -57,6 +43,12 @@
 
 #define PWC_CHILD_SUMMARY_CHAR_LIMIT    64 // Character limit of summary field when not editing
 
 
 #define PWC_CHILD_SUMMARY_CHAR_LIMIT    64 // Character limit of summary field when not editing
 

+#if wxPG_COMPATIBILITY_1_4
+
+// Used to establish backwards compatiblity
+const char* g_invalidStringContent = "@__TOTALLY_INVALID_STRING__@";
+
+#endif

 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 


@@ -145,26 +137,27 @@ int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell&
 {
     int imageOffset = 0;
 
 {
     int imageOffset = 0;
 

-    if ( !(flags & Selected) )
+    // If possible, use cell colours
+    if ( !(flags & DontUseCellBgCol) )

     {
     {

-        // Draw using wxPGCell information, if available
-        wxColour fgCol = cell.GetFgCol();
-        if ( fgCol.Ok() )
-            dc.SetTextForeground(fgCol);
+        dc.SetPen(cell.GetBgCol());
+        dc.SetBrush(cell.GetBgCol());
+    }

 
 

-        wxColour bgCol = cell.GetBgCol();
-        if ( bgCol.Ok() )
-        {
-            dc.SetPen(bgCol);
-            dc.SetBrush(bgCol);
-            dc.DrawRectangle(rect);
-        }
+    if ( !(flags & DontUseCellFgCol) )
+    {
+        dc.SetTextForeground(cell.GetFgCol());

     }
 
     }
 

+    // Draw Background, but only if not rendering in control
+    // (as control already has rendered correct background).
+    if ( !(flags & (Control|ChoicePopup)) )
+        dc.DrawRectangle(rect);
+

     const wxBitmap& bmp = cell.GetBitmap();
     if ( bmp.Ok() &&
     const wxBitmap& bmp = cell.GetBitmap();
     if ( bmp.Ok() &&

-        // In control, do not draw oversized bitmap
-         (!(flags & Control) || bmp.GetHeight() < rect.height )
+        // Do not draw oversized bitmap outside choice popup
+         ((flags & ChoicePopup) || bmp.GetHeight() < rect.height )

         )
     {
         dc.DrawBitmap( bmp,
         )
     {
         dc.DrawBitmap( bmp,


@@ -200,46 +193,17 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
     }
 
     const wxPGEditor* editor = NULL;
     }
 
     const wxPGEditor* editor = NULL;

-    const wxPGCell* cell = property->GetCell(column);
+    const wxPGCell* cell = NULL;

 
     wxString text;
     int imageOffset = 0;
 
     wxString text;
     int imageOffset = 0;

+    int preDrawFlags = flags;

 
 

-    // Use choice cell?
-    if ( column == 1 && (flags & Control) )
-    {
-        const wxPGCell* ccell = property->GetCurrentChoice();
-        if ( ccell &&
-             ( ccell->GetBitmap().IsOk() || ccell->GetFgCol().IsOk() || ccell->GetBgCol().IsOk() )
-           )
-            cell = ccell;
-    }
-
-    if ( cell )
-    {
-        int preDrawFlags = flags;
+    property->GetDisplayInfo(column, item, flags, &text, &cell);

 
 

-        if ( propertyGrid->GetInternalFlags() & wxPG_FL_CELL_OVERRIDES_SEL )
-            preDrawFlags = preDrawFlags & ~(Selected);
+    imageOffset = PreDrawCell( dc, rect, *cell, preDrawFlags );

 
 

-        imageOffset = PreDrawCell( dc, rect, *cell, preDrawFlags );
-        text = cell->GetText();
-        if ( text == wxS("@!") )
-        {
-            if ( column == 0 )
-                text = property->GetLabel();
-            else if ( column == 1 )
-                text = property->GetValueString();
-            else
-                text = wxEmptyString;
-        }
-    }
-    else if ( column == 0 )
-    {
-        // Caption
-        DrawText( dc, rect, 0, property->GetLabel() );
-    }
-    else if ( column == 1 )
+    if ( column == 1 )

     {
         if ( !isUnspecified )
         {
     {
         if ( !isUnspecified )
         {


@@ -260,30 +224,17 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
                                  wxPG_CUSTOM_IMAGE_WIDTH,
                                  rect.height-(wxPG_CUSTOM_IMAGE_SPACINGY*2));
 
                                  wxPG_CUSTOM_IMAGE_WIDTH,
                                  rect.height-(wxPG_CUSTOM_IMAGE_SPACINGY*2));
 

-                /*if ( imageSize.x == wxPG_FULL_CUSTOM_PAINT_WIDTH )
-                {
-                    imageRect.width = m_width - imageRect.x;
-                }*/
-

                 dc.SetPen( wxPen(propertyGrid->GetCellTextColour(), 1, wxSOLID) );
 
                 paintdata.m_drawnWidth = imageSize.x;
                 paintdata.m_drawnHeight = imageSize.y;
 
                 dc.SetPen( wxPen(propertyGrid->GetCellTextColour(), 1, wxSOLID) );
 
                 paintdata.m_drawnWidth = imageSize.x;
                 paintdata.m_drawnHeight = imageSize.y;
 

-                if ( !isUnspecified )
-                {
-                    property->OnCustomPaint( dc, imageRect, paintdata );
-                }
-                else
-                {
-                    dc.SetBrush(*wxWHITE_BRUSH);
-                    dc.DrawRectangle(imageRect);
-                }
+                property->OnCustomPaint( dc, imageRect, paintdata );

 
                 imageOffset = paintdata.m_drawnWidth;
             }
 
 
                 imageOffset = paintdata.m_drawnWidth;
             }
 

-            text = property->GetValueString();
+            text = property->GetValueAsString();

 
             // Add units string?
             if ( propertyGrid->GetColumnCount() <= 2 )
 
             // Add units string?
             if ( propertyGrid->GetColumnCount() <= 2 )


@@ -305,12 +256,6 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
             }
         }
     }
             }
         }
     }

-    else if ( column == 2 )
-    {
-        // Add units string?
-        if ( !text.length() )
-            text = property->GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
-    }

 
     DrawEditorValue( dc, rect, imageOffset, text, property, editor );
 
 
     DrawEditorValue( dc, rect, imageOffset, text, property, editor );
 


@@ -350,11 +295,22 @@ wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,
     return wxSize(0,0);
 }
 
     return wxSize(0,0);
 }
 

+// -----------------------------------------------------------------------
+// wxPGCellData
+// -----------------------------------------------------------------------
+
+wxPGCellData::wxPGCellData()
+    : wxObjectRefData()
+{
+    m_hasValidText = false;
+}
+

 // -----------------------------------------------------------------------
 // wxPGCell
 // -----------------------------------------------------------------------
 
 wxPGCell::wxPGCell()
 // -----------------------------------------------------------------------
 // wxPGCell
 // -----------------------------------------------------------------------
 
 wxPGCell::wxPGCell()

+    : wxObject()

 {
 }
 
 {
 }
 


@@ -362,9 +318,74 @@ wxPGCell::wxPGCell( const wxString& text,
                     const wxBitmap& bitmap,
                     const wxColour& fgCol,
                     const wxColour& bgCol )
                     const wxBitmap& bitmap,
                     const wxColour& fgCol,
                     const wxColour& bgCol )

-    : m_bitmap(bitmap), m_fgCol(fgCol), m_bgCol(bgCol)
+    : wxObject()
+{
+    wxPGCellData* data = new wxPGCellData();
+    m_refData = data;
+    data->m_text = text;
+    data->m_bitmap = bitmap;
+    data->m_fgCol = fgCol;
+    data->m_bgCol = bgCol;
+    data->m_hasValidText = true;
+}
+
+wxObjectRefData *wxPGCell::CloneRefData( const wxObjectRefData *data ) const
+{
+    wxPGCellData* c = new wxPGCellData();
+    const wxPGCellData* o = (const wxPGCellData*) data;
+    c->m_text = o->m_text;
+    c->m_bitmap = o->m_bitmap;
+    c->m_fgCol = o->m_fgCol;
+    c->m_bgCol = o->m_bgCol;
+    c->m_hasValidText = o->m_hasValidText;
+    return c;
+}
+
+void wxPGCell::SetText( const wxString& text )
+{
+    AllocExclusive();
+
+    GetData()->SetText(text);
+}
+
+void wxPGCell::SetBitmap( const wxBitmap& bitmap )
+{
+    AllocExclusive();
+
+    GetData()->SetBitmap(bitmap);
+}
+
+void wxPGCell::SetFgCol( const wxColour& col )
+{
+    AllocExclusive();
+
+    GetData()->SetFgCol(col);
+}
+
+void wxPGCell::SetBgCol( const wxColour& col )
+{
+    AllocExclusive();
+
+    GetData()->SetBgCol(col);
+}
+
+void wxPGCell::MergeFrom( const wxPGCell& srcCell )

 {
 {

-    m_text = text;
+    AllocExclusive();
+
+    wxPGCellData* data = GetData();
+
+    if ( srcCell.HasText() )
+        data->SetText(srcCell.GetText());
+
+    if ( srcCell.GetFgCol().IsOk() )
+        data->SetFgCol(srcCell.GetFgCol());
+
+    if ( srcCell.GetBgCol().IsOk() )
+        data->SetBgCol(srcCell.GetBgCol());
+
+    if ( srcCell.GetBitmap().IsOk() )
+        data->SetBitmap(srcCell.GetBitmap());

 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------


@@ -381,24 +402,22 @@ void wxPGProperty::Init()
     m_arrIndex = 0xFFFF;
     m_parent = NULL;
 
     m_arrIndex = 0xFFFF;
     m_parent = NULL;
 

-    m_parentState = (wxPropertyGridPageState*) NULL;
+    m_parentState = NULL;

 
     m_clientData = NULL;
     m_clientObject = NULL;
 
 
     m_clientData = NULL;
     m_clientObject = NULL;
 

-    m_customEditor = (wxPGEditor*) NULL;
+    m_customEditor = NULL;

 #if wxUSE_VALIDATORS
 #if wxUSE_VALIDATORS

-    m_validator = (wxValidator*) NULL;
+    m_validator = NULL;

 #endif
 #endif

-    m_valueBitmap = (wxBitmap*) NULL;
+    m_valueBitmap = NULL;

 
     m_maxLen = 0; // infinite maximum length
 
     m_flags = wxPG_PROP_PROPERTY;
 
     m_depth = 1;
 
     m_maxLen = 0; // infinite maximum length
 
     m_flags = wxPG_PROP_PROPERTY;
 
     m_depth = 1;

-    m_bgColIndex = 0;
-    m_fgColIndex = 0;

 
     SetExpanded(true);
 }
 
     SetExpanded(true);
 }


@@ -420,6 +439,136 @@ void wxPGProperty::Init( const wxString& label, const wxString& name )
     Init();
 }
 
     Init();
 }
 

+void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState,
+                                   wxPropertyGrid* propgrid )
+{
+    //
+    // Called after property has been added to grid or page
+    // (so propgrid can be NULL, too).
+
+    wxPGProperty* parent = m_parent;
+    bool parentIsRoot = parent->IsKindOf(CLASSINFO(wxPGRootProperty));
+
+    m_parentState = pageState;
+
+#if wxPG_COMPATIBILITY_1_4
+    // Make sure deprecated virtual functions are not implemented
+    wxString s = GetValueAsString( 0xFFFF );
+    wxASSERT_MSG( s == g_invalidStringContent,
+                  "Implement ValueToString() instead of GetValueAsString()" );
+#endif
+
+    if ( !parentIsRoot && !parent->IsCategory() )
+    {
+        m_cells = parent->m_cells;
+    }
+
+    // If in hideable adding mode, or if assigned parent is hideable, then
+    // make this one hideable.
+    if (
+         ( !parentIsRoot && parent->HasFlag(wxPG_PROP_HIDDEN) ) ||
+         ( propgrid && (propgrid->HasInternalFlag(wxPG_FL_ADDING_HIDEABLES)) )
+       )
+        SetFlag( wxPG_PROP_HIDDEN );
+
+    // Set custom image flag.
+    int custImgHeight = OnMeasureImage().y;
+    if ( custImgHeight < 0 )
+    {
+        SetFlag(wxPG_PROP_CUSTOMIMAGE);
+    }
+
+    if ( propgrid && (propgrid->HasFlag(wxPG_LIMITED_EDITING)) )
+        SetFlag(wxPG_PROP_NOEDITOR);
+
+    // Make sure parent has some parental flags
+    if ( !parent->HasFlag(wxPG_PROP_PARENTAL_FLAGS) )
+        parent->SetParentalType(wxPG_PROP_MISC_PARENT);
+
+    if ( !IsCategory() )
+    {
+        // This is not a category.
+
+        // Depth.
+        //
+        unsigned char depth = 1;
+        if ( !parentIsRoot )
+        {
+            depth = parent->m_depth;
+            if ( !parent->IsCategory() )
+                depth++;
+        }
+        m_depth = depth;
+        unsigned char greyDepth = depth;
+
+        if ( !parentIsRoot )
+        {
+            wxPropertyCategory* pc;
+
+            if ( parent->IsCategory() )
+                pc = (wxPropertyCategory* ) parent;
+            else
+                // This conditional compile is necessary to
+                // bypass some compiler bug.
+                pc = pageState->GetPropertyCategory(parent);
+
+            if ( pc )
+                greyDepth = pc->GetDepth();
+            else
+                greyDepth = parent->m_depthBgCol;
+        }
+
+        m_depthBgCol = greyDepth;
+    }
+    else
+    {
+        // This is a category.
+
+        // depth
+        unsigned char depth = 1;
+        if ( !parentIsRoot )
+        {
+            depth = parent->m_depth + 1;
+        }
+        m_depth = depth;
+        m_depthBgCol = depth;
+    }
+
+    //
+    // Has initial children
+    if ( GetChildCount() )
+    {
+        // Check parental flags
+        wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS),
+                      "Call SetFlag(wxPG_PROP_MISC_PARENT) or"
+                      "SetFlag(wxPG_PROP_AGGREGATE) before calling"
+                      "wxPGProperty::AddChild()." );
+
+        if ( HasFlag(wxPG_PROP_AGGREGATE) )
+        {
+            // Properties with private children are not expanded by default.
+            SetExpanded(false);
+        }
+        else if ( propgrid && propgrid->HasFlag(wxPG_HIDE_MARGIN) )
+        {
+            // ...unless it cannot be expanded by user and therefore must
+            // remain visible at all times
+            SetExpanded(true);
+        }
+
+        //
+        // Prepare children recursively
+        for ( unsigned int i=0; i<GetChildCount(); i++ )
+        {
+            wxPGProperty* child = Item(i);
+            child->InitAfterAdded(pageState, pageState->GetGrid());
+        }
+
+        if ( propgrid && (propgrid->GetExtraStyle() & wxPG_EX_AUTO_UNSPECIFIED_VALUES) )
+            SetFlagRecursively(wxPG_PROP_AUTO_UNSPECIFIED, true);
+    }
+}
+

 wxPGProperty::wxPGProperty()
     : wxObject()
 {
 wxPGProperty::wxPGProperty()
     : wxObject()
 {


@@ -445,11 +594,6 @@ wxPGProperty::~wxPGProperty()
     delete m_validator;
 #endif
 
     delete m_validator;
 #endif
 

-    unsigned int i;
-
-    for ( i=0; i<m_cells.size(); i++ )
-        delete (wxPGCell*) m_cells[i];
-

     // This makes it easier for us to detect dangling pointers
     m_parent = NULL;
 }
     // This makes it easier for us to detect dangling pointers
     m_parent = NULL;
 }


@@ -485,11 +629,14 @@ wxPropertyGrid* wxPGProperty::GetGrid() const
     return m_parentState->GetGrid();
 }
 
     return m_parentState->GetGrid();
 }
 

-
-void wxPGProperty::UpdateControl( wxWindow* primary )
+int wxPGProperty::Index( const wxPGProperty* p ) const

 {
 {

-    if ( primary )
-        GetEditorClass()->UpdateControl(this, primary);
+    for ( unsigned int i = 0; i<m_children.size(); i++ )
+    {
+        if ( p == m_children[i] )
+            return i;
+    }
+    return wxNOT_FOUND;

 }
 
 bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const
 }
 
 bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const


@@ -505,30 +652,99 @@ void wxPGProperty::RefreshChildren ()
 {
 }
 
 {
 }
 

-wxString wxPGProperty::GetColumnText( unsigned int col ) const
+void wxPGProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) )
+{
+}
+
+void wxPGProperty::GetDisplayInfo( unsigned int column,
+                                   int choiceIndex,
+                                   int flags,
+                                   wxString* pString,
+                                   const wxPGCell** pCell )

 {
 {

-    wxPGCell* cell = GetCell(col);
-    if ( cell )
+    const wxPGCell* cell = NULL;
+
+    if ( !(flags & wxPGCellRenderer::ChoicePopup) )
+    {
+        // Not painting listi of choice popups, so get text from property
+        cell = &GetCell(column);
+        if ( cell->HasText() )
+        {
+            *pString = cell->GetText();
+        }
+        else
+        {
+            if ( column == 0 )
+                *pString = GetLabel();
+            else if ( column == 1 )
+                *pString = GetDisplayedString();
+            else if ( column == 2 )
+                *pString = GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
+        }
+    }
+    else
+    {
+        wxASSERT( column == 1 );
+
+        if ( choiceIndex != wxNOT_FOUND )
+        {
+            const wxPGChoiceEntry& entry = m_choices[choiceIndex];
+            if ( entry.GetBitmap().IsOk() ||
+                 entry.GetFgCol().IsOk() ||
+                 entry.GetBgCol().IsOk() )
+                cell = &entry;
+            *pString = m_choices.GetLabel(choiceIndex);
+        }
+    }
+
+    if ( !cell )
+        cell = &GetCell(column);
+
+    wxASSERT_MSG( cell->GetData(),
+                  wxString::Format("Invalid cell for property %s",
+                                   GetName().c_str()) );
+
+    *pCell = cell;
+}
+
+/*
+wxString wxPGProperty::GetColumnText( unsigned int col, int choiceIndex ) const
+{
+    
+    if ( col != 1 || choiceIndex == wxNOT_FOUND )

     {
     {

-        return cell->GetText();
+        const wxPGCell& cell = GetCell(col);
+        if ( cell->HasText() )
+        {
+            return cell->GetText();
+        }
+        else
+        {
+            if ( col == 0 )
+                return GetLabel();
+            else if ( col == 1 )
+                return GetDisplayedString();
+            else if ( col == 2 )
+                return GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
+        }

     }
     else
     {
     }
     else
     {

-        if ( col == 0 )
-            return GetLabel();
-        else if ( col == 1 )
-            return GetDisplayedString();
-        else if ( col == 2 )
-            return GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
+        // Use choice
+        return m_choices.GetLabel(choiceIndex);

     }
 
     return wxEmptyString;
 }
     }
 
     return wxEmptyString;
 }

+*/

 
 

-void wxPGProperty::GenerateComposedValue( wxString& text, int argFlags ) const
+void wxPGProperty::DoGenerateComposedValue( wxString& text,
+                                            int argFlags,
+                                            const wxVariantList* valueOverrides,
+                                            wxPGHashMapS2S* childResults ) const

 {
     int i;
 {
     int i;

-    int iMax = m_children.GetCount();
+    int iMax = m_children.size();

 
     text.clear();
     if ( iMax == 0 )
 
     text.clear();
     if ( iMax == 0 )


@@ -543,13 +759,66 @@ void wxPGProperty::GenerateComposedValue( wxString& text, int argFlags ) const
     if ( !IsTextEditable() )
         argFlags |= wxPG_UNEDITABLE_COMPOSITE_FRAGMENT;
 
     if ( !IsTextEditable() )
         argFlags |= wxPG_UNEDITABLE_COMPOSITE_FRAGMENT;
 

-    wxPGProperty* curChild = (wxPGProperty*) m_children.Item(0);
+    wxPGProperty* curChild = m_children[0];
+
+    bool overridesLeft = false;
+    wxVariant overrideValue;
+    wxVariantList::const_iterator node;
+
+    if ( valueOverrides )
+    {
+        node = valueOverrides->begin();
+        if ( node != valueOverrides->end() )
+        {
+            overrideValue = *node;
+            overridesLeft = true;
+        }
+    }

 
     for ( i = 0; i < iMax; i++ )
     {
 
     for ( i = 0; i < iMax; i++ )
     {

+        wxVariant childValue;
+
+        wxString childLabel = curChild->GetLabel();
+
+        // Check for value override
+        if ( overridesLeft && overrideValue.GetName() == childLabel )
+        {
+            if ( !overrideValue.IsNull() )
+                childValue = overrideValue;
+            else
+                childValue = curChild->GetValue();
+            ++node;
+            if ( node != valueOverrides->end() )
+                overrideValue = *node;
+            else
+                overridesLeft = false;
+        }
+        else
+        {
+            childValue = curChild->GetValue();
+        }
+

         wxString s;
         wxString s;

-        if ( !curChild->IsValueUnspecified() )
-            s = curChild->GetValueString(argFlags|wxPG_COMPOSITE_FRAGMENT);
+        if ( !childValue.IsNull() )
+        {
+            if ( overridesLeft &&
+                 curChild->HasFlag(wxPG_PROP_COMPOSED_VALUE) &&
+                 childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
+            {
+                wxVariantList& childList = childValue.GetList();
+                DoGenerateComposedValue(s, argFlags|wxPG_COMPOSITE_FRAGMENT,
+                                        &childList, childResults);
+            }
+            else
+            {
+                s = curChild->ValueToString(childValue,
+                                            argFlags|wxPG_COMPOSITE_FRAGMENT);
+            }
+        }
+ 
+        if ( childResults && curChild->GetChildCount() )
+            (*childResults)[curChild->GetName()] = s;

 
         bool skip = false;
         if ( (argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT) && !s.length() )
 
         bool skip = false;
         if ( (argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT) && !s.length() )


@@ -575,37 +844,58 @@ void wxPGProperty::GenerateComposedValue( wxString& text, int argFlags ) const
                     text += wxS(" ");
             }
 
                     text += wxS(" ");
             }
 

-            curChild = (wxPGProperty*) m_children.Item(i+1);
+            curChild = m_children[i+1];

         }
     }
 
         }
     }
 

-    // Remove superfluous semicolon and space
-    wxString rest;
-    if ( text.EndsWith(wxS("; "), &rest) )
-        text = rest;
-
-    if ( (unsigned int)i < m_children.GetCount() )
-        text += wxS("; ...");
+    if ( (unsigned int)i < m_children.size() )
+    {
+        if ( !text.EndsWith(wxS("; ")) )
+            text += wxS("; ...");
+        else
+            text += wxS("...");
+    }

 }
 
 }
 

-wxString wxPGProperty::GetValueAsString( int argFlags ) const
+wxString wxPGProperty::ValueToString( wxVariant& WXUNUSED(value),
+                                      int argFlags ) const

 {
     wxCHECK_MSG( GetChildCount() > 0,
                  wxString(),
 {
     wxCHECK_MSG( GetChildCount() > 0,
                  wxString(),

-                 wxT("If user property does not have any children, it must override GetValueAsString") );
+                 "If user property does not have any children, it must "
+                 "override GetValueAsString" );
+
+    // FIXME: Currently code below only works if value is actually m_value
+    wxASSERT_MSG( argFlags & wxPG_VALUE_IS_CURRENT,
+                  "Sorry, currently default wxPGProperty::ValueToString() "
+                  "implementation only works if value is m_value." );

 
     wxString text;
 
     wxString text;

-    GenerateComposedValue(text, argFlags);
+    DoGenerateComposedValue(text, argFlags);

     return text;
 }
 
     return text;
 }
 

-wxString wxPGProperty::GetValueString( int argFlags ) const
+wxString wxPGProperty::GetValueAsString( int argFlags ) const

 {
 {

+#if wxPG_COMPATIBILITY_1_4
+    // This is backwards compatibility test
+    // That is, to make sure this function is not overridden
+    // (instead, ValueToString() should be).
+    if ( argFlags == 0xFFFF )
+    {
+        // Do not override! (for backwards compliancy)
+        return g_invalidStringContent;
+    }
+#endif
+

     if ( IsValueUnspecified() )
         return wxEmptyString;
 
     if ( m_commonValue == -1 )
     if ( IsValueUnspecified() )
         return wxEmptyString;
 
     if ( m_commonValue == -1 )

-        return GetValueAsString(argFlags);
+    {
+        wxVariant value(GetValue());
+        return ValueToString(value, argFlags|wxPG_VALUE_IS_CURRENT);
+    }

 
     //
     // Return common value's string representation
 
     //
     // Return common value's string representation


@@ -626,6 +916,11 @@ wxString wxPGProperty::GetValueString( int argFlags ) const
     }
 }
 
     }
 }
 

+wxString wxPGProperty::GetValueString( int argFlags ) const
+{
+    return GetValueAsString(argFlags);
+}
+

 bool wxPGProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
 {
     variant = (long)number;
 bool wxPGProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
 {
     variant = (long)number;


@@ -640,7 +935,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
     unsigned int curChild = 0;
 
 
     unsigned int curChild = 0;
 

-    unsigned int iMax = m_children.GetCount();
+    unsigned int iMax = m_children.size();

 
     if ( iMax > PWC_CHILD_SUMMARY_LIMIT &&
          !(argFlags & wxPG_FULL_VALUE) )
 
     if ( iMax > PWC_CHILD_SUMMARY_LIMIT &&
          !(argFlags & wxPG_FULL_VALUE) )


@@ -660,7 +955,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
     wxVariantList temp_list;
     wxVariant list(temp_list);
 
     wxVariantList temp_list;
     wxVariant list(temp_list);
 

-    int propagatedFlags = argFlags & wxPG_REPORT_ERROR;
+    int propagatedFlags = argFlags & (wxPG_REPORT_ERROR|wxPG_PROGRAMMATIC_VALUE);

 
 #ifdef __WXDEBUG__
     bool debug_print = false;
 
 #ifdef __WXDEBUG__
     bool debug_print = false;


@@ -681,6 +976,11 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
     for ( ;; )
     {
 
     for ( ;; )
     {

+        // How many units we iterate string forward at the end of loop?
+        // We need to keep track of this or risk going to negative
+        // with it-- operation.
+        unsigned int strPosIncrement = 1;
+

         if ( tokenStart != 0xFFFFFF )
         {
             // Token is running
         if ( tokenStart != 0xFFFFFF )
         {
             // Token is running


@@ -693,43 +993,47 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                 if ( !addOnlyIfNotEmpty || len > 0 )
                 {
                     const wxPGProperty* child = Item(curChild);
                 if ( !addOnlyIfNotEmpty || len > 0 )
                 {
                     const wxPGProperty* child = Item(curChild);

+                    wxVariant variant(child->GetValue());
+                    wxString childName = child->GetBaseName();
+

                 #ifdef __WXDEBUG__
                     if ( debug_print )
                 #ifdef __WXDEBUG__
                     if ( debug_print )

-                        wxLogDebug(wxT("token = '%s', child = %s"),token.c_str(),child->GetLabel().c_str());
+                        wxLogDebug(wxT("token = '%s', child = %s"),
+                                   token.c_str(), childName.c_str());

                 #endif
 
                 #endif
 

-                    if ( len > 0 )
+                    // Add only if editable or setting programmatically
+                    if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
+                         !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )

                     {
                     {

-                        bool wasUnspecified = child->IsValueUnspecified();
-
-                        wxVariant variant(child->GetValueRef());
-                        if ( child->StringToValue(variant, token, propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )
+                        if ( len > 0 )

                         {
                         {

-                            // Use label instead of name, as name can be empty string, but
-                            // label in practice never is.
-                            variant.SetName(child->GetLabel());
-
-                            // Clear unspecified flag only if OnSetValue() didn't
-                            // affect it.
-                            if ( child->IsValueUnspecified() &&
-                                 (wasUnspecified || !UsesAutoUnspecified()) )
+                            if ( child->StringToValue(variant, token,
+                                 propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )

                             {
                             {

-                                variant = child->GetDefaultValue();
+                                // We really need to set the variant's name
+                                // *after* child->StringToValue() has been
+                                // called, since variant's value may be set by
+                                // assigning another variant into it, which
+                                // then usually causes name to be copied (ie.
+                                // usually cleared) as well. wxBoolProperty
+                                // being case in point with its use of
+                                // wxPGVariant_Bool macro as an optimization.
+                                variant.SetName(childName);
+                                list.Append(variant);
+
+                                changed = true;

                             }
                             }

-
+                        }
+                        else
+                        {
+                            // Empty, becomes unspecified
+                            variant.MakeNull();
+                            variant.SetName(childName);

                             list.Append(variant);
                             list.Append(variant);

-

                             changed = true;
                         }
                     }
                             changed = true;
                         }
                     }

-                    else
-                    {
-                        // Empty, becomes unspecified
-                        wxVariant variant2;
-                        variant2.SetName(child->GetLabel());
-                        list.Append(variant2);
-                        changed = true;
-                    }

 
                     curChild++;
                     if ( curChild >= iMax )
 
                     curChild++;
                     if ( curChild >= iMax )


@@ -752,7 +1056,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                 {
                     int depth = 1;
 
                 {
                     int depth = 1;
 

-                    if ( it != text.end() ) it++;
+                    if ( it != text.end() ) ++it;

                     pos++;
                     size_t startPos = pos;
 
                     pos++;
                     size_t startPos = pos;
 


@@ -760,7 +1064,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                     while ( it != text.end() && depth > 0 )
                     {
                         a = *it;
                     while ( it != text.end() && depth > 0 )
                     {
                         a = *it;

-                        it++;
+                        ++it;

                         pos++;
 
                         if ( a == wxS(']') )
                         pos++;
 
                         if ( a == wxS(']') )


@@ -776,22 +1080,27 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
                     const wxPGProperty* child = Item(curChild);
 
 
                     const wxPGProperty* child = Item(curChild);
 

-                    wxVariant variant(child->GetValueRef());
-                    if ( child->StringToValue( variant, token, propagatedFlags ) )
-                    {
-                        // Use label instead of name, as name can be empty string, but
-                        // label in practice never is.
-                        variant.SetName(child->GetLabel());
-                        list.Append(variant);
-                        changed = true;
-                    }
-                    else
+                    wxVariant oldChildValue = child->GetValue();
+                    wxVariant variant(oldChildValue);
+
+                    if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
+                         !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )

                     {
                     {

-                        // Failed, becomes unspecified
-                        wxVariant variant2;
-                        variant2.SetName(child->GetLabel());
-                        list.Append(variant2);
-                        changed = true;
+                        wxString childName = child->GetBaseName();
+
+                        bool stvRes = child->StringToValue( variant, token,
+                                                            propagatedFlags );
+                        if ( stvRes || (variant != oldChildValue) )
+                        {
+                            variant.SetName(childName);
+                            list.Append(variant);
+
+                            changed = true;
+                        }
+                        else
+                        {
+                            // No changes...
+                        }

                     }
 
                     curChild++;
                     }
 
                     curChild++;


@@ -807,10 +1116,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                     tokenStart = pos;
 
                     if ( a == delimeter )
                     tokenStart = pos;
 
                     if ( a == delimeter )

-                    {
-                        pos--;
-                        it--;
-                    }
+                        strPosIncrement -= 1;

                 }
             }
         }
                 }
             }
         }


@@ -818,7 +1124,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
         if ( a == 0 )
             break;
 
         if ( a == 0 )
             break;
 

-        it++;
+        it += strPosIncrement;
+

         if ( it != text.end() )
         {
             a = *it;
         if ( it != text.end() )
         {
             a = *it;


@@ -827,7 +1134,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
         {
             a = 0;
         }
         {
             a = 0;
         }

-        pos++;
+
+        pos += strPosIncrement;

     }
 
     if ( changed )
     }
 
     if ( changed )


@@ -882,7 +1190,7 @@ void wxPGProperty::OnCustomPaint( wxDC& dc,
 
 const wxPGEditor* wxPGProperty::DoGetEditorClass() const
 {
 
 const wxPGEditor* wxPGProperty::DoGetEditorClass() const
 {

-    return wxPG_EDITOR(TextCtrl);
+    return wxPGEditor_TextCtrl;

 }
 
 // Default extra property event handling - that is, none at all.
 }
 
 // Default extra property event handling - that is, none at all.


@@ -894,14 +1202,32 @@ bool wxPGProperty::OnEvent( wxPropertyGrid*, wxWindow*, wxEvent& )
 
 void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
 {
 
 void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
 {

+    // If auto unspecified values are not wanted (via window or property style),
+    // then get default value instead of wxNullVariant.
+    if ( value.IsNull() && (flags & wxPG_SETVAL_BY_USER) &&
+         !UsesAutoUnspecified() )
+    {
+        value = GetDefaultValue();
+    }
+

     if ( !value.IsNull() )
     {
     if ( !value.IsNull() )
     {

+        wxVariant tempListVariant;
+

         SetCommonValue(-1);
         // List variants are reserved a special purpose
         // as intermediate containers for child values
         // of properties with children.
         SetCommonValue(-1);
         // List variants are reserved a special purpose
         // as intermediate containers for child values
         // of properties with children.

-        if ( wxPGIsVariantType(value, list) )
+        if ( value.GetType() == wxPG_VARIANT_TYPE_LIST )

         {
         {

+            //
+            // However, situation is different for composed string properties
+            if ( HasFlag(wxPG_PROP_COMPOSED_VALUE) )
+            {
+                tempListVariant = value;
+                pList = &tempListVariant;
+            }
+

             wxVariant newValue;
             AdaptListToValue(value, &newValue);
             value = newValue;
             wxVariant newValue;
             AdaptListToValue(value, &newValue);
             value = newValue;


@@ -913,7 +1239,7 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
 
         if ( pList && !pList->IsNull() )
         {
 
         if ( pList && !pList->IsNull() )
         {

-            wxASSERT( wxPGIsVariantType(*pList, list) );
+            wxASSERT( pList->GetType() == wxPG_VARIANT_TYPE_LIST );

             wxASSERT( GetChildCount() );
             wxASSERT( !IsCategory() );
 
             wxASSERT( GetChildCount() );
             wxASSERT( !IsCategory() );
 


@@ -924,15 +1250,15 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
             //wxLogDebug(wxT(">> %s.SetValue() pList parsing"),GetName().c_str());
 
             // Children in list can be in any order, but we will give hint to
             //wxLogDebug(wxT(">> %s.SetValue() pList parsing"),GetName().c_str());
 
             // Children in list can be in any order, but we will give hint to

-            // GetPropertyByLabelWH(). This optimizes for full list parsing.
-            for ( node = list.begin(); node != list.end(); node++ )
+            // GetPropertyByNameWH(). This optimizes for full list parsing.
+            for ( node = list.begin(); node != list.end(); ++node )

             {
                 wxVariant& childValue = *((wxVariant*)*node);
             {
                 wxVariant& childValue = *((wxVariant*)*node);

-                wxPGProperty* child = GetPropertyByLabelWH(childValue.GetName(), i);
+                wxPGProperty* child = GetPropertyByNameWH(childValue.GetName(), i);

                 if ( child )
                 {
                 if ( child )
                 {

-                    //wxLogDebug(wxT("%i: child = %s, childValue.GetType()=%s"),i,child->GetLabel().c_str(),childValue.GetType().c_str());
-                    if ( wxPGIsVariantType(childValue, list) )
+                    //wxLogDebug(wxT("%i: child = %s, childValue.GetType()=%s"),i,child->GetBaseName().c_str(),childValue.GetType().c_str());
+                    if ( childValue.GetType() == wxPG_VARIANT_TYPE_LIST )

                     {
                         if ( child->HasFlag(wxPG_PROP_AGGREGATE) && !(flags & wxPG_SETVAL_AGGREGATED) )
                         {
                     {
                         if ( child->HasFlag(wxPG_PROP_AGGREGATE) && !(flags & wxPG_SETVAL_AGGREGATED) )
                         {


@@ -945,16 +1271,14 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
                             child->SetValue(oldVal, &childValue, flags|wxPG_SETVAL_FROM_PARENT);
                         }
                     }
                             child->SetValue(oldVal, &childValue, flags|wxPG_SETVAL_FROM_PARENT);
                         }
                     }

-                    else if ( !wxPG_VARIANT_EQ(child->GetValue(), childValue) )
-                        // This flag is not normally set when setting value programmatically.
-                        // However, this loop is usually only executed when called from
-                        // DoPropertyChanged, which should set this flag.
+                    else if ( child->GetValue() != childValue )

                     {
                         // For aggregate properties, we will trust RefreshChildren()
                         // to update child values.
                         if ( !HasFlag(wxPG_PROP_AGGREGATE) )
                             child->SetValue(childValue, NULL, flags|wxPG_SETVAL_FROM_PARENT);
                     {
                         // For aggregate properties, we will trust RefreshChildren()
                         // to update child values.
                         if ( !HasFlag(wxPG_PROP_AGGREGATE) )
                             child->SetValue(childValue, NULL, flags|wxPG_SETVAL_FROM_PARENT);

-                        child->SetFlag(wxPG_PROP_MODIFIED);
+                        if ( flags & wxPG_SETVAL_BY_USER )
+                            child->SetFlag(wxPG_PROP_MODIFIED);

                     }
                 }
                 i++;
                     }
                 }
                 i++;


@@ -963,14 +1287,11 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
 
         if ( !value.IsNull() )
         {
 
         if ( !value.IsNull() )
         {

-            wxPGVariantAssign(m_value, value);
+            m_value = value;

             OnSetValue();
             OnSetValue();

-
-            if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
-                UpdateParentValues();

         }
 
         }
 

-        if ( pList )
+        if ( flags & wxPG_SETVAL_BY_USER )

             SetFlag(wxPG_PROP_MODIFIED);
 
         if ( HasFlag(wxPG_PROP_AGGREGATE) )
             SetFlag(wxPG_PROP_MODIFIED);
 
         if ( HasFlag(wxPG_PROP_AGGREGATE) )


@@ -997,6 +1318,9 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
         }
     }
 
         }
     }
 

+    if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
+        UpdateParentValues();
+

     //
     // Update editor control
     //
     //
     // Update editor control
     //


@@ -1026,18 +1350,13 @@ void wxPGProperty::SetFlagRecursively( FlagType flag, bool set )
 
 void wxPGProperty::RefreshEditor()
 {
 
 void wxPGProperty::RefreshEditor()
 {

-    if ( m_parent && GetParentState() )
-    {
-        wxPropertyGrid* pg = GetParentState()->GetGrid();
-        if ( pg->GetSelectedProperty() == this )
-        {
-            wxWindow* editor = pg->GetEditorControl();
-            if ( editor )
-                GetEditorClass()->UpdateControl( this, editor );
-        }
-    }
-}
+    if ( !m_parent )
+        return;

 
 

+    wxPropertyGrid* pg = GetGrid();
+    if ( pg && pg->GetSelectedProperty() == this )
+        pg->RefreshEditor();
+}

 
 wxVariant wxPGProperty::GetDefaultValue() const
 {
 
 wxVariant wxPGProperty::GetDefaultValue() const
 {


@@ -1049,144 +1368,202 @@ wxVariant wxPGProperty::GetDefaultValue() const
 
     if ( !value.IsNull() )
     {
 
     if ( !value.IsNull() )
     {

-        wxPGVariantDataClassInfo classInfo = wxPGVariantDataGetClassInfo(value.GetData());
-        if ( wxPGIsVariantClassInfo(classInfo, long) )
+        wxString valueType(value.GetType());
+
+        if ( valueType == wxPG_VARIANT_TYPE_LONG )

             return wxPGVariant_Zero;
             return wxPGVariant_Zero;

-        if ( wxPGIsVariantClassInfo(classInfo, string) )
+        if ( valueType == wxPG_VARIANT_TYPE_STRING )

             return wxPGVariant_EmptyString;
             return wxPGVariant_EmptyString;

-        if ( wxPGIsVariantClassInfo(classInfo, bool) )
+        if ( valueType == wxPG_VARIANT_TYPE_BOOL )

             return wxPGVariant_False;
             return wxPGVariant_False;

-        if ( wxPGIsVariantClassInfo(classInfo, double) )
+        if ( valueType == wxPG_VARIANT_TYPE_DOUBLE )

             return wxVariant(0.0);
             return wxVariant(0.0);

-
-        wxPGVariantData* pgvdata = wxDynamicCastVariantData(m_value.GetData(), wxPGVariantData);
-        if ( pgvdata )
-            return pgvdata->GetDefaultValue();
-
-        if ( wxPGIsVariantClassInfo(classInfo, arrstring) )
+        if ( valueType == wxPG_VARIANT_TYPE_ARRSTRING )

             return wxVariant(wxArrayString());
             return wxVariant(wxArrayString());

-        if ( wxPGIsVariantClassInfo(classInfo, wxColour) )
-            return WXVARIANT(*wxRED);
+        if ( valueType == wxS("wxLongLong") )
+            return WXVARIANT(wxLongLong(0));
+        if ( valueType == wxS("wxULongLong") )
+            return WXVARIANT(wxULongLong(0));
+        if ( valueType == wxS("wxColour") )
+            return WXVARIANT(*wxBLACK);

 #if wxUSE_DATETIME
 #if wxUSE_DATETIME

-        if ( wxPGIsVariantClassInfo(classInfo, datetime) )
+        if ( valueType == wxPG_VARIANT_TYPE_DATETIME )

             return wxVariant(wxDateTime::Now());
 #endif
             return wxVariant(wxDateTime::Now());
 #endif

-
-        wxFAIL_MSG(
-            wxString::Format(wxT("Inorder for value to have default value, it must be added to")
-                             wxT("wxPGProperty::GetDefaultValue or it's variantdata must inherit")
-                             wxT("from wxPGVariantData (unrecognized type was '%s')"),m_value.GetType().c_str())
-                  );
+        if ( valueType == wxS("wxFont") )
+            return WXVARIANT(*wxNORMAL_FONT);
+        if ( valueType == wxS("wxPoint") )
+            return WXVARIANT(wxPoint(0, 0));
+        if ( valueType == wxS("wxSize") )
+            return WXVARIANT(wxSize(0, 0));

     }
 
     return wxVariant();
 }
 
     }
 
     return wxVariant();
 }
 

-void wxPGProperty::SetCell( int column, wxPGCell* cellObj )
+void wxPGProperty::EnsureCells( unsigned int column )

 {
 {

-    if ( column >= (int)m_cells.size() )
-        m_cells.SetCount(column+1, NULL);
-
-    delete (wxPGCell*) m_cells[column];
-    m_cells[column] = cellObj;
-}
+    if ( column >= m_cells.size() )
+    {
+        // Fill empty slots with default cells
+        wxPropertyGrid* pg = GetGrid();
+        wxPGCell defaultCell;

 
 

-void wxPGProperty::SetChoiceSelection( int newValue, const wxPGChoiceInfo& choiceInfo )
-{
-    // Changes value of a property with choices, but only
-    // works if the value type is long or string.
-    wxString ts = GetValue().GetType();
+        if ( !HasFlag(wxPG_PROP_CATEGORY) )
+            defaultCell = pg->GetPropertyDefaultCell();
+        else
+            defaultCell = pg->GetCategoryDefaultCell();

 
 

-    wxCHECK_RET( choiceInfo.m_choices, wxT("invalid choiceinfo") );
+        // TODO: Replace with resize() call
+        unsigned int cellCountMax = column+1;

 
 

-    if ( ts == wxS("long") )
-    {
-        SetValue( (long) newValue );
-    }
-    else if ( ts == wxS("string") )
-    {
-        SetValue( choiceInfo.m_choices->GetLabel(newValue) );
+        for ( unsigned int i=m_cells.size(); i<cellCountMax; i++ )
+            m_cells.push_back(defaultCell);

     }
 }
 
     }
 }
 

-
-wxString wxPGProperty::GetChoiceString( unsigned int index )
+void wxPGProperty::SetCell( int column,
+                            const wxPGCell& cell )

 {
 {

-    wxPGChoiceInfo ci;
-    GetChoiceInfo(&ci);
-    wxASSERT(ci.m_choices);
-    return ci.m_choices->GetLabel(index);
+    EnsureCells(column);
+
+    m_cells[column] = cell;

 }
 
 }
 

-int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
+void wxPGProperty::AdaptiveSetCell( unsigned int firstCol,
+                                    unsigned int lastCol,
+                                    const wxPGCell& cell,
+                                    const wxPGCell& srcData,
+                                    wxPGCellData* unmodCellData,
+                                    FlagType ignoreWithFlags,
+                                    bool recursively )

 {
 {

-    wxPropertyGrid* pg = GetGrid();
-
-    wxPGChoiceInfo ci;
-    ci.m_choices = (wxPGChoices*) NULL;
-    int sel = GetChoiceInfo(&ci);
+    //
+    // Sets cell in memory optimizing fashion. That is, if
+    // current cell data matches unmodCellData, we will
+    // simply get reference to data from cell. Otherwise,
+    // cell information from srcData is merged into current.
+    //

 
 

-    if ( ci.m_choices )
+    if ( !(m_flags & ignoreWithFlags) && !IsRoot() )

     {
     {

-        int newSel = sel;
+        EnsureCells(lastCol);

 
 

-        if ( index < 0 )
-            index = ci.m_choices->GetCount();
-
-        if ( index <= sel )
-            newSel++;
+        for ( unsigned int col=firstCol; col<=lastCol; col++ )
+        {
+            if ( m_cells[col].GetData() == unmodCellData )
+            {
+                // Data matches... use cell directly
+                m_cells[col] = cell;
+            }
+            else
+            {
+                // Data did not match... merge valid information
+                m_cells[col].MergeFrom(srcData);
+            }
+        }
+    }

 
 

-        ci.m_choices->Insert(label, index, value);
+    if ( recursively )
+    {
+        for ( unsigned int i=0; i<GetChildCount(); i++ )
+            Item(i)->AdaptiveSetCell( firstCol,
+                                      lastCol,
+                                      cell,
+                                      srcData,
+                                      unmodCellData,
+                                      ignoreWithFlags,
+                                      recursively );
+    }
+}

 
 

-        if ( sel != newSel )
-            SetChoiceSelection(newSel, ci);
+const wxPGCell& wxPGProperty::GetCell( unsigned int column ) const
+{
+    if ( m_cells.size() > column )
+        return m_cells[column];

 
 

-        if ( this == pg->GetSelection() )
-            GetEditorClass()->InsertItem(pg->GetEditorControl(),label,index);
+    wxPropertyGrid* pg = GetGrid();

 
 

-        return index;
-    }
+    if ( IsCategory() )
+        return pg->GetCategoryDefaultCell();

 
 

-    return -1;
+    return pg->GetPropertyDefaultCell();

 }
 
 }
 

-
-void wxPGProperty::DeleteChoice( int index )
+wxPGCell& wxPGProperty::GetCell( unsigned int column )

 {
 {

-    wxPropertyGrid* pg = GetGrid();
+    EnsureCells(column);
+    return m_cells[column];
+}

 
 

-    wxPGChoiceInfo ci;
-    ci.m_choices = (wxPGChoices*) NULL;
-    int sel = GetChoiceInfo(&ci);
+void wxPGProperty::SetBackgroundColour( const wxColour& colour,
+                                        bool recursively )
+{
+    wxPGProperty* firstProp = this;

 
 

-    if ( ci.m_choices )
+    //
+    // If category is tried to set recursively, skip it and only
+    // affect the children.
+    if ( recursively )

     {
     {

-        int newSel = sel;
-
-        // Adjust current value
-        if ( sel == index )
-        {
-            SetValueToUnspecified();
-            newSel = 0;
-        }
-        else if ( index < sel )
+        while ( firstProp->IsCategory() )

         {
         {

-            newSel--;
+            if ( !firstProp->GetChildCount() )
+                return;
+            firstProp = firstProp->Item(0);

         }
         }

+    }

 
 

-        ci.m_choices->RemoveAt(index);
+    wxPGCell& firstCell = firstProp->GetCell(0);
+    wxPGCellData* firstCellData = firstCell.GetData();

 
 

-        if ( sel != newSel )
-            SetChoiceSelection(newSel, ci);
+    wxPGCell newCell(firstCell);
+    newCell.SetBgCol(colour);
+    wxPGCell srcCell;
+    srcCell.SetBgCol(colour);

 
 

-        if ( this == pg->GetSelection() )
-            GetEditorClass()->DeleteItem(pg->GetEditorControl(), index);
-    }
+    AdaptiveSetCell( 0,
+                     GetParentState()->GetColumnCount()-1,
+                     newCell,
+                     srcCell,
+                     firstCellData,
+                     recursively ? wxPG_PROP_CATEGORY : 0,
+                     recursively );

 }
 
 }
 

-int wxPGProperty::GetChoiceInfo( wxPGChoiceInfo* WXUNUSED(info) )
+void wxPGProperty::SetTextColour( const wxColour& colour,
+                                  bool recursively )

 {
 {

-    return -1;
+    wxPGProperty* firstProp = this;
+
+    //
+    // If category is tried to set recursively, skip it and only
+    // affect the children.
+    if ( recursively )
+    {
+        while ( firstProp->IsCategory() )
+        {
+            if ( !firstProp->GetChildCount() )
+                return;
+            firstProp = firstProp->Item(0);
+        }
+    }
+
+    wxPGCell& firstCell = firstProp->GetCell(0);
+    wxPGCellData* firstCellData = firstCell.GetData();
+
+    wxPGCell newCell(firstCell);
+    newCell.SetFgCol(colour);
+    wxPGCell srcCell;
+    srcCell.SetFgCol(colour);
+
+    AdaptiveSetCell( 0,
+                     GetParentState()->GetColumnCount()-1,
+                     newCell,
+                     srcCell,
+                     firstCellData,
+                     recursively ? wxPG_PROP_CATEGORY : 0,
+                     recursively );

 }
 
 wxPGEditorDialogAdapter* wxPGProperty::GetEditorDialog() const
 }
 
 wxPGEditorDialogAdapter* wxPGProperty::GetEditorDialog() const


@@ -1338,66 +1715,119 @@ void wxPGProperty::SetFlagsFromString( const wxString& str )
 
 wxValidator* wxPGProperty::DoGetValidator() const
 {
 
 wxValidator* wxPGProperty::DoGetValidator() const
 {

-    return (wxValidator*) NULL;
+    return NULL;

 }
 
 }
 

-wxPGChoices& wxPGProperty::GetChoices()
+int wxPGProperty::InsertChoice( const wxString& label, int index, int value )

 {
 {

-    wxPGChoiceInfo choiceInfo;
-    choiceInfo.m_choices = NULL;
-    GetChoiceInfo(&choiceInfo);
-    return *choiceInfo.m_choices;
+    wxPropertyGrid* pg = GetGrid();
+    int sel = GetChoiceSelection();
+
+    int newSel = sel;
+
+    if ( index == wxNOT_FOUND )
+        index = m_choices.GetCount();
+
+    if ( index <= sel )
+        newSel++;
+
+    m_choices.Insert(label, index, value);
+
+    if ( sel != newSel )
+        SetChoiceSelection(newSel);
+
+    if ( this == pg->GetSelection() )
+        GetEditorClass()->InsertItem(pg->GetEditorControl(),label,index);
+
+    return index;

 }
 
 }
 

-const wxPGChoices& wxPGProperty::GetChoices() const
+
+void wxPGProperty::DeleteChoice( int index )

 {
 {

-    return (const wxPGChoices&) ((wxPGProperty*)this)->GetChoices();
+    wxPropertyGrid* pg = GetGrid();
+
+    int sel = GetChoiceSelection();
+    int newSel = sel;
+
+    // Adjust current value
+    if ( sel == index )
+    {
+        SetValueToUnspecified();
+        newSel = 0;
+    }
+    else if ( index < sel )
+    {
+        newSel--;
+    }
+
+    m_choices.RemoveAt(index);
+
+    if ( sel != newSel )
+        SetChoiceSelection(newSel);
+
+    if ( this == pg->GetSelection() )
+        GetEditorClass()->DeleteItem(pg->GetEditorControl(), index);

 }
 
 }
 

-unsigned int wxPGProperty::GetChoiceCount() const
+int wxPGProperty::GetChoiceSelection() const

 {
 {

-    const wxPGChoices& choices = GetChoices();
-    if ( &choices && choices.IsOk() )
-        return choices.GetCount();
-    return 0;
+    wxVariant value = GetValue();
+    wxString valueType = value.GetType();
+    int index = wxNOT_FOUND;
+
+    if ( IsValueUnspecified() || !m_choices.GetCount() )
+        return wxNOT_FOUND;
+
+    if ( valueType == wxPG_VARIANT_TYPE_LONG )
+    {
+        index = value.GetLong();
+    }
+    else if ( valueType == wxPG_VARIANT_TYPE_STRING )
+    {
+        index = m_choices.Index(value.GetString());
+    }
+    else if ( valueType == wxPG_VARIANT_TYPE_BOOL )
+    {
+        index = value.GetBool()? 1 : 0;
+    }
+
+    return index;

 }
 
 }
 

-const wxPGChoiceEntry* wxPGProperty::GetCurrentChoice() const
+void wxPGProperty::SetChoiceSelection( int newValue )

 {
 {

-    wxPGChoiceInfo ci;
-    ci.m_choices = (wxPGChoices*) NULL;
-    int index = ((wxPGProperty*)this)->GetChoiceInfo(&ci);
-    if ( index == -1 || !ci.m_choices || index >= (int)ci.m_choices->GetCount() )
-        return NULL;
+    // Changes value of a property with choices, but only
+    // works if the value type is long or string.
+    wxString valueType = GetValue().GetType();
+
+    wxCHECK_RET( m_choices.IsOk(), wxT("invalid choiceinfo") );

 
 

-    return &(*ci.m_choices)[index];
+    if ( valueType == wxPG_VARIANT_TYPE_STRING )
+    {
+        SetValue( m_choices.GetLabel(newValue) );
+    }
+    else  // if ( valueType == wxPG_VARIANT_TYPE_LONG )
+    {
+        SetValue( (long) newValue );
+    }

 }
 
 bool wxPGProperty::SetChoices( wxPGChoices& choices )
 {
 }
 
 bool wxPGProperty::SetChoices( wxPGChoices& choices )
 {

-    wxPGChoiceInfo ci;
-    ci.m_choices = (wxPGChoices*) NULL;
+    m_choices.Assign(choices);

 
 

-    // Unref existing
-    GetChoiceInfo(&ci);
-    if ( ci.m_choices )

     {
     {

-        ci.m_choices->Assign(choices);
-
-        //if ( m_parent )
-        {
-            // This may be needed to trigger some initialization
-            // (but don't do it if property is somewhat uninitialized)
-            wxVariant defVal = GetDefaultValue();
-            if ( defVal.IsNull() )
-                return false;
-
-            SetValue(defVal);
+        // This may be needed to trigger some initialization
+        // (but don't do it if property is somewhat uninitialized)
+        wxVariant defVal = GetDefaultValue();
+        if ( defVal.IsNull() )
+            return false;

 
 

-            return true;
-        }
+        SetValue(defVal);

     }
     }

-    return false;
+
+    return true;

 }
 
 
 }
 
 


@@ -1418,28 +1848,16 @@ const wxPGEditor* wxPGProperty::GetEditorClass() const
     {
         // TextCtrlAndButton -> ComboBoxAndButton
         if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlAndButtonEditor)) )
     {
         // TextCtrlAndButton -> ComboBoxAndButton
         if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlAndButtonEditor)) )

-            editor = wxPG_EDITOR(ChoiceAndButton);
+            editor = wxPGEditor_ChoiceAndButton;

 
         // TextCtrl -> ComboBox
         else if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlEditor)) )
 
         // TextCtrl -> ComboBox
         else if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlEditor)) )

-            editor = wxPG_EDITOR(ComboBox);
+            editor = wxPGEditor_ComboBox;

     }
 
     return editor;
 }
 
     }
 
     return editor;
 }
 

-
-// Privatizes set of choices
-void wxPGProperty::SetChoicesExclusive()
-{
-    wxPGChoiceInfo ci;
-    ci.m_choices = (wxPGChoices*) NULL;
-
-    GetChoiceInfo(&ci);
-    if ( ci.m_choices )
-        ci.m_choices->SetExclusive();
-}
-

 bool wxPGProperty::HasVisibleChildren() const
 {
     unsigned int i;
 bool wxPGProperty::HasVisibleChildren() const
 {
     unsigned int i;


@@ -1455,12 +1873,6 @@ bool wxPGProperty::HasVisibleChildren() const
     return false;
 }
 
     return false;
 }
 

-bool wxPGProperty::PrepareValueForDialogEditing( wxPropertyGrid* propGrid )
-{
-    return propGrid->EditorValidate();
-}
-
-

 bool wxPGProperty::RecreateEditor()
 {
     wxPropertyGrid* pg = GetGrid();
 bool wxPGProperty::RecreateEditor()
 {
     wxPropertyGrid* pg = GetGrid();


@@ -1599,38 +2011,18 @@ int wxPGProperty::GetY() const
     return GetY2(GetGrid()->GetRowHeight());
 }
 
     return GetY2(GetGrid()->GetRowHeight());
 }
 

-
-wxPGProperty* wxPGPropArgCls::GetPtr( wxPropertyGridInterface* methods ) const
-{
-    if ( !m_isName )
-    {
-        wxASSERT_MSG( m_ptr.property, wxT("invalid property ptr") );
-        return m_ptr.property;
-    }
-    else if ( m_isName == 1 )
-        return methods->GetPropertyByNameA(*m_ptr.name);
-    else if ( m_isName == 2 )
-        return methods->GetPropertyByNameA(m_ptr.rawname);
-    // 3 is like 1, but ptr is freed in dtor - only needed by wxPython bindings.
-    else if ( m_isName == 3 )
-        return methods->GetPropertyByNameA(*m_ptr.name);
-
-    wxASSERT( m_isName <= 3 );
-    return NULL;
-}
-

 // This is used by Insert etc.
 void wxPGProperty::AddChild2( wxPGProperty* prop, int index, bool correct_mode )
 {
 // This is used by Insert etc.
 void wxPGProperty::AddChild2( wxPGProperty* prop, int index, bool correct_mode )
 {

-    if ( index < 0 || (size_t)index >= m_children.GetCount() )
+    if ( index < 0 || (size_t)index >= m_children.size() )

     {
     {

-        if ( correct_mode ) prop->m_arrIndex = m_children.GetCount();
-        m_children.Add( prop );
+        if ( correct_mode ) prop->m_arrIndex = m_children.size();
+        m_children.push_back( prop );

     }
     else
     {
     }
     else
     {

-        m_children.Insert( prop, index );
-        if ( correct_mode ) FixIndexesOfChildren( index );
+        m_children.insert( m_children.begin()+index, prop);
+        if ( correct_mode ) FixIndicesOfChildren( index );

     }
 
     prop->m_parent = this;
     }
 
     prop->m_parent = this;


@@ -1639,8 +2031,11 @@ void wxPGProperty::AddChild2( wxPGProperty* prop, int index, bool correct_mode )
 // This is used by properties that have fixed sub-properties
 void wxPGProperty::AddChild( wxPGProperty* prop )
 {
 // This is used by properties that have fixed sub-properties
 void wxPGProperty::AddChild( wxPGProperty* prop )
 {

-    prop->m_arrIndex = m_children.GetCount();
-    m_children.Add( prop );
+    wxASSERT_MSG( prop->GetBaseName().length(),
+                  "Property's children must have unique, non-empty names within their scope" );
+
+    prop->m_arrIndex = m_children.size();
+    m_children.push_back( prop );

 
     int custImgHeight = prop->OnMeasureImage().y;
     if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )
 
     int custImgHeight = prop->OnMeasureImage().y;
     if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )


@@ -1649,6 +2044,20 @@ void wxPGProperty::AddChild( wxPGProperty* prop )
     prop->m_parent = this;
 }
 
     prop->m_parent = this;
 }
 

+void wxPGProperty::RemoveChild( wxPGProperty* p )
+{
+    wxArrayPGProperty::iterator it;
+    wxArrayPGProperty& children = m_children;
+
+    for ( it=children.begin(); it != children.end(); it++ )
+    {
+        if ( *it == p )
+        {
+            m_children.erase(it);
+            break;
+        }
+    }
+}

 
 void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
 {
 
 void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
 {


@@ -1675,17 +2084,17 @@ void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
     unsigned int i;
     unsigned int n = 0;
 
     unsigned int i;
     unsigned int n = 0;
 

-    //wxLogDebug(wxT(">> %s.AdaptListToValue()"),GetLabel().c_str());
+    //wxLogDebug(wxT(">> %s.AdaptListToValue()"),GetBaseName().c_str());

 
     for ( i=0; i<GetChildCount(); i++ )
     {
         const wxPGProperty* child = Item(i);
 
 
     for ( i=0; i<GetChildCount(); i++ )
     {
         const wxPGProperty* child = Item(i);
 

-        if ( childValue.GetName() == child->GetLabel() )
+        if ( childValue.GetName() == child->GetBaseName() )

         {
             //wxLogDebug(wxT("  %s(n=%i), %s"),childValue.GetName().c_str(),n,childValue.GetType().c_str());
 
         {
             //wxLogDebug(wxT("  %s(n=%i), %s"),childValue.GetName().c_str(),n,childValue.GetType().c_str());
 

-            if ( wxPGIsVariantType(childValue, list) )
+            if ( childValue.GetType() == wxPG_VARIANT_TYPE_LIST )

             {
                 wxVariant cv2(child->GetValue());
                 child->AdaptListToValue(childValue, &cv2);
             {
                 wxVariant cv2(child->GetValue());
                 child->AdaptListToValue(childValue, &cv2);


@@ -1703,7 +2112,7 @@ void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
 }
 
 
 }
 
 

-void wxPGProperty::FixIndexesOfChildren( size_t starthere )
+void wxPGProperty::FixIndicesOfChildren( unsigned int starthere )

 {
     size_t i;
     for ( i=starthere;i<GetChildCount();i++)
 {
     size_t i;
     for ( i=starthere;i<GetChildCount();i++)


@@ -1726,7 +2135,7 @@ wxPGProperty* wxPGProperty::GetPropertyByName( const wxString& name ) const
     // Does it have point, then?
     int pos = name.Find(wxS('.'));
     if ( pos <= 0 )
     // Does it have point, then?
     int pos = name.Find(wxS('.'));
     if ( pos <= 0 )

-        return (wxPGProperty*) NULL;
+        return NULL;

 
     wxPGProperty* p = GetPropertyByName(name. substr(0,pos));
 
 
     wxPGProperty* p = GetPropertyByName(name. substr(0,pos));
 


@@ -1736,7 +2145,7 @@ wxPGProperty* wxPGProperty::GetPropertyByName( const wxString& name ) const
     return p->GetPropertyByName(name.substr(pos+1,name.length()-pos-1));
 }
 
     return p->GetPropertyByName(name.substr(pos+1,name.length()-pos-1));
 }
 

-wxPGProperty* wxPGProperty::GetPropertyByLabelWH( const wxString& label, unsigned int hintIndex ) const
+wxPGProperty* wxPGProperty::GetPropertyByNameWH( const wxString& name, unsigned int hintIndex ) const

 {
     unsigned int i = hintIndex;
 
 {
     unsigned int i = hintIndex;
 


@@ -1751,7 +2160,7 @@ wxPGProperty* wxPGProperty::GetPropertyByLabelWH( const wxString& label, unsigne
     for (;;)
     {
         wxPGProperty* p = Item(i);
     for (;;)
     {
         wxPGProperty* p = Item(i);

-        if ( p->m_label == label )
+        if ( p->m_name == name )

             return p;
 
         if ( i == lastIndex )
             return p;
 
         if ( i == lastIndex )


@@ -1869,12 +2278,22 @@ void wxPGProperty::Empty()
     {
         for ( i=0; i<GetChildCount(); i++ )
         {
     {
         for ( i=0; i<GetChildCount(); i++ )
         {

-            wxPGProperty* p = (wxPGProperty*) Item(i);
-            delete p;
+            delete m_children[i];

         }
     }
 
         }
     }
 

-    m_children.Empty();
+    m_children.clear();
+}
+
+void wxPGProperty::DeleteChildren()
+{
+    wxPropertyGridPageState* state = m_parentState;
+
+    while ( GetChildCount() )
+    {
+        wxPGProperty* child = Item(GetChildCount()-1);
+        state->DoDelete(child, true);
+    }

 }
 
 void wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
 }
 
 void wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),


@@ -1896,8 +2315,6 @@ bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
         node = pList->begin();
     }
 
         node = pList->begin();
     }
 

-    // Children in list can be in any order, but we will give hint to
-    // GetPropertyByLabelWH(). This optimizes for full list parsing.

     for ( i=0; i<GetChildCount(); i++ )
     {
         wxPGProperty* child = Item(i);
     for ( i=0; i<GetChildCount(); i++ )
     {
         wxPGProperty* child = Item(i);


@@ -1906,12 +2323,12 @@ bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
 
         if ( pendingList )
         {
 
         if ( pendingList )
         {

-            const wxString& childLabel = child->GetLabel();
+            const wxString& childName = child->GetBaseName();

 
 

-            for ( ; node != pList->end(); node++ )
+            for ( ; node != pList->end(); ++node )

             {
                 const wxVariant& item = *((const wxVariant*)*node);
             {
                 const wxVariant& item = *((const wxVariant*)*node);

-                if ( item.GetName() == childLabel )
+                if ( item.GetName() == childName )

                 {
                     listValue = &item;
                     value = item;
                 {
                     listValue = &item;
                     value = item;


@@ -1931,7 +2348,7 @@ bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
         {
             const wxVariant* childList = NULL;
 
         {
             const wxVariant* childList = NULL;
 

-            if ( listValue && wxPGIsVariantType(*listValue, list) )
+            if ( listValue && listValue->GetType() == wxPG_VARIANT_TYPE_LIST )

                 childList = listValue;
 
             if ( !child->AreAllChildrenSpecified((wxVariant*)childList) )
                 childList = listValue;
 
             if ( !child->AreAllChildrenSpecified((wxVariant*)childList) )


@@ -1949,7 +2366,7 @@ wxPGProperty* wxPGProperty::UpdateParentValues()
          !parent->IsCategory() && !parent->IsRoot() )
     {
         wxString s;
          !parent->IsCategory() && !parent->IsRoot() )
     {
         wxString s;

-        parent->GenerateComposedValue(s, 0);
+        parent->DoGenerateComposedValue(s);

         parent->m_value = s;
         return parent->UpdateParentValues();
     }
         parent->m_value = s;
         return parent->UpdateParentValues();
     }


@@ -1970,74 +2387,6 @@ bool wxPGProperty::IsTextEditable() const
     return true;
 }
 
     return true;
 }
 

-// Call for after sub-properties added with AddChild
-void wxPGProperty::PrepareSubProperties()
-{
-    wxPropertyGridPageState* state = GetParentState();
-
-    wxASSERT(state);
-
-    if ( !GetChildCount() )
-        return;
-
-    wxByte depth = m_depth + 1;
-    wxByte depthBgCol = m_depthBgCol;
-
-    FlagType inheritFlags = m_flags & wxPG_INHERITED_PROPFLAGS;
-
-    wxByte bgColIndex = m_bgColIndex;
-    wxByte fgColIndex = m_fgColIndex;
-
-    //
-    // Set some values to the children
-    //
-    size_t i = 0;
-    wxPGProperty* nparent = this;
-
-    while ( i < nparent->GetChildCount() )
-    {
-        wxPGProperty* np = nparent->Item(i);
-
-        np->m_parentState = state;
-        np->m_flags |= inheritFlags; // Hideable also if parent.
-        np->m_depth = depth;
-        np->m_depthBgCol = depthBgCol;
-        np->m_bgColIndex = bgColIndex;
-        np->m_fgColIndex = fgColIndex;
-
-        // Also handle children of children
-        if ( np->GetChildCount() > 0 )
-        {
-            nparent = np;
-            i = 0;
-
-            // Init
-            nparent->SetParentalType(wxPG_PROP_AGGREGATE);
-            nparent->SetExpanded(false);
-            depth++;
-        }
-        else
-        {
-            // Next sibling
-            i++;
-        }
-
-        // After reaching last sibling, go back to processing
-        // siblings of the parent
-        while ( i >= nparent->GetChildCount() )
-        {
-            // Exit the loop when top parent hit
-            if ( nparent == this )
-                break;
-
-            depth--;
-
-            i = nparent->GetArrIndex() + 1;
-            nparent = nparent->GetParent();
-        }
-    }
-}
-

 // Call after fixed sub-properties added/removed after creation.
 // if oldSelInd >= 0 and < new max items, then selection is
 // moved to it. Note: oldSelInd -2 indicates that this property
 // Call after fixed sub-properties added/removed after creation.
 // if oldSelInd >= 0 and < new max items, then selection is
 // moved to it. Note: oldSelInd -2 indicates that this property


@@ -2047,14 +2396,20 @@ void wxPGProperty::SubPropsChanged( int oldSelInd )
     wxPropertyGridPageState* state = GetParentState();
     wxPropertyGrid* grid = state->GetGrid();
 
     wxPropertyGridPageState* state = GetParentState();
     wxPropertyGrid* grid = state->GetGrid();
 

-    PrepareSubProperties();
+    //
+    // Re-repare children (recursively)
+    for ( unsigned int i=0; i<GetChildCount(); i++ )
+    {
+        wxPGProperty* child = Item(i);
+        child->InitAfterAdded(state, grid);
+    }

 
 

-    wxPGProperty* sel = (wxPGProperty*) NULL;
-    if ( oldSelInd >= (int)m_children.GetCount() )
-        oldSelInd = (int)m_children.GetCount() - 1;
+    wxPGProperty* sel = NULL;
+    if ( oldSelInd >= (int)m_children.size() )
+        oldSelInd = (int)m_children.size() - 1;

 
     if ( oldSelInd >= 0 )
 
     if ( oldSelInd >= 0 )

-        sel = (wxPGProperty*) m_children[oldSelInd];
+        sel = m_children[oldSelInd];

     else if ( oldSelInd == -2 )
         sel = this;
 
     else if ( oldSelInd == -2 )
         sel = this;
 


@@ -2075,11 +2430,14 @@ WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPGRootProperty,none,TextCtrl)
 IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
 
 

-wxPGRootProperty::wxPGRootProperty()
+wxPGRootProperty::wxPGRootProperty( const wxString& name )

     : wxPGProperty()
 {
 #ifdef __WXDEBUG__
     : wxPGProperty()
 {
 #ifdef __WXDEBUG__

-    m_name = wxS("<root>");
+    m_name = name;
+    m_label = m_name;
+#else
+    wxUnusedVar(name);

 #endif
     SetParentalType(0);
     m_depth = 0;
 #endif
     SetParentalType(0);
     m_depth = 0;


@@ -2125,7 +2483,8 @@ wxPropertyCategory::~wxPropertyCategory()
 }
 
 
 }
 
 

-wxString wxPropertyCategory::GetValueAsString( int ) const
+wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value),
+                                            int WXUNUSED(argFlags) ) const

 {
     return wxEmptyString;
 }
 {
     return wxEmptyString;
 }


@@ -2146,6 +2505,270 @@ void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& font
     m_textExtent = x;
 }
 
     m_textExtent = x;
 }
 

+// -----------------------------------------------------------------------
+// wxPGChoices
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, int value )
+{
+    AllocExclusive();
+
+    wxPGChoiceEntry entry(label, value);
+    return m_data->Insert( -1, entry );
+}
+
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, const wxBitmap& bitmap, int value )
+{
+    AllocExclusive();
+
+    wxPGChoiceEntry entry(label, value);
+    entry.SetBitmap(bitmap);
+    return m_data->Insert( -1, entry );
+}
+
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::Insert( const wxPGChoiceEntry& entry, int index )
+{
+    AllocExclusive();
+
+    return m_data->Insert( index, entry );
+}
+
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::Insert( const wxString& label, int index, int value )
+{
+    AllocExclusive();
+
+    wxPGChoiceEntry entry(label, value);
+    return m_data->Insert( index, entry );
+}
+
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::AddAsSorted( const wxString& label, int value )
+{
+    AllocExclusive();
+
+    size_t index = 0;
+
+    while ( index < GetCount() )
+    {
+        int cmpRes = GetLabel(index).Cmp(label);
+        if ( cmpRes > 0 )
+            break;
+        index++;
+    }
+
+    wxPGChoiceEntry entry(label, value);
+    return m_data->Insert( index, entry );
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Add( const wxChar** labels, const ValArrItem* values )
+{
+    AllocExclusive();
+
+    unsigned int itemcount = 0;
+    const wxChar** p = &labels[0];
+    while ( *p ) { p++; itemcount++; }
+
+    unsigned int i;
+    for ( i = 0; i < itemcount; i++ )
+    {
+        int value = i;
+        if ( values )
+            value = values[i];
+        wxPGChoiceEntry entry(labels[i], value);
+        m_data->Insert( i, entry );
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Add( const wxArrayString& arr, const wxArrayInt& arrint )
+{
+    AllocExclusive();
+
+    unsigned int i;
+    unsigned int itemcount = arr.size();
+
+    for ( i = 0; i < itemcount; i++ )
+    {
+        int value = i;
+        if ( &arrint && arrint.size() )
+            value = arrint[i];
+        wxPGChoiceEntry entry(arr[i], value);
+        m_data->Insert( i, entry );
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::RemoveAt(size_t nIndex, size_t count)
+{
+    AllocExclusive();
+
+    wxASSERT( m_data->m_refCount != 0xFFFFFFF );
+    m_data->m_items.erase(m_data->m_items.begin()+nIndex,
+                          m_data->m_items.begin()+nIndex+count);
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Clear()
+{
+    if ( m_data != wxPGChoicesEmptyData )
+    {
+        AllocExclusive();
+        m_data->Clear();
+    }
+}
+
+// -----------------------------------------------------------------------
+
+int wxPGChoices::Index( const wxString& str ) const
+{
+    if ( IsOk() )
+    {
+        unsigned int i;
+        for ( i=0; i< m_data->GetCount(); i++ )
+        {
+            const wxPGChoiceEntry& entry = m_data->Item(i);
+            if ( entry.HasText() && entry.GetText() == str )
+                return i;
+        }
+    }
+    return -1;
+}
+
+// -----------------------------------------------------------------------
+
+int wxPGChoices::Index( int val ) const
+{
+    if ( IsOk() )
+    {
+        unsigned int i;
+        for ( i=0; i< m_data->GetCount(); i++ )
+        {
+            const wxPGChoiceEntry& entry = m_data->Item(i);
+            if ( entry.GetValue() == val )
+                return i;
+        }
+    }
+    return -1;
+}
+
+// -----------------------------------------------------------------------
+
+wxArrayString wxPGChoices::GetLabels() const
+{
+    wxArrayString arr;
+    unsigned int i;
+
+    if ( this && IsOk() )
+        for ( i=0; i<GetCount(); i++ )
+            arr.push_back(GetLabel(i));
+
+    return arr;
+}
+
+// -----------------------------------------------------------------------
+
+wxArrayInt wxPGChoices::GetValuesForStrings( const wxArrayString& strings ) const
+{
+    wxArrayInt arr;
+
+    if ( IsOk() )
+    {
+        unsigned int i;
+        for ( i=0; i< strings.size(); i++ )
+        {
+            int index = Index(strings[i]);
+            if ( index >= 0 )
+                arr.Add(GetValue(index));
+            else
+                arr.Add(wxPG_INVALID_VALUE);
+        }
+    }
+
+    return arr;
+}
+
+// -----------------------------------------------------------------------
+
+wxArrayInt wxPGChoices::GetIndicesForStrings( const wxArrayString& strings,
+                                              wxArrayString* unmatched ) const
+{
+    wxArrayInt arr;
+
+    if ( IsOk() )
+    {
+        unsigned int i;
+        for ( i=0; i< strings.size(); i++ )
+        {
+            const wxString& str = strings[i];
+            int index = Index(str);
+            if ( index >= 0 )
+                arr.Add(index);
+            else if ( unmatched )
+                unmatched->Add(str);
+        }
+    }
+
+    return arr;
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::AllocExclusive()
+{
+    EnsureData();
+
+    if ( m_data->m_refCount != 1 )
+    {
+        wxPGChoicesData* data = new wxPGChoicesData();
+        data->CopyDataFrom(m_data);
+        Free();
+        m_data = data;
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::AssignData( wxPGChoicesData* data )
+{
+    Free();
+
+    if ( data != wxPGChoicesEmptyData )
+    {
+        m_data = data;
+        data->m_refCount++;
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Init()
+{
+    m_data = wxPGChoicesEmptyData;
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Free()
+{
+    if ( m_data != wxPGChoicesEmptyData )
+    {
+        m_data->DecRef();
+        m_data = wxPGChoicesEmptyData;
+    }
+}
+

 // -----------------------------------------------------------------------
 // wxPGAttributeStorage
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPGAttributeStorage
 // -----------------------------------------------------------------------


@@ -2158,7 +2781,7 @@ wxPGAttributeStorage::~wxPGAttributeStorage()
 {
     wxPGHashMapS2P::iterator it;
 
 {
     wxPGHashMapS2P::iterator it;
 

-    for ( it = m_map.begin(); it != m_map.end(); it++ )
+    for ( it = m_map.begin(); it != m_map.end(); ++it )

     {
         wxVariantData* data = (wxVariantData*) it->second;
         data->DecRef();
     {
         wxVariantData* data = (wxVariantData*) it->second;
         data->DecRef();


@@ -2172,11 +2795,23 @@ void wxPGAttributeStorage::Set( const wxString& name, const wxVariant& value )
     // Free old, if any
     wxPGHashMapS2P::iterator it = m_map.find(name);
     if ( it != m_map.end() )
     // Free old, if any
     wxPGHashMapS2P::iterator it = m_map.find(name);
     if ( it != m_map.end() )

+    {

         ((wxVariantData*)it->second)->DecRef();
 
         ((wxVariantData*)it->second)->DecRef();
 

+        if ( !data )
+        {
+            // If Null variant, just remove from set
+            m_map.erase(it);
+            return;
+        }
+    }
+

     if ( data )
     if ( data )

+    {

         data->IncRef();
 
         data->IncRef();
 

-    m_map[name] = data;
+        m_map[name] = data;
+    }

 }
 
 }
 

+#endif  // wxUSE_PROPGRID