]> git.saurik.com Git - wxWidgets.git/blobdiff - src/propgrid/property.cpp
Add a few missing appearance screenshots for the manual.
[wxWidgets.git] / src / propgrid / property.cpp
index c083039124381245a8f06a4e347a86d67af6343a..bafa791fc48f0383369fece897d4270cba8aeeb7 100644 (file)
@@ -4,9 +4,8 @@
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2008-08-23
-// RCS-ID:      $Id:
 // Copyright:   (c) Jaakko Salli
-// Licence:     wxWindows license
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // For compilers that support precompilation, includes "wx/wx.h".
@@ -24,6 +23,7 @@
     #include "wx/hash.h"
     #include "wx/string.h"
     #include "wx/log.h"
+    #include "wx/math.h"
     #include "wx/event.h"
     #include "wx/window.h"
     #include "wx/panel.h"
@@ -35,7 +35,9 @@
     #include "wx/intl.h"
 #endif
 
-#include <wx/propgrid/propgrid.h>
+#include "wx/image.h"
+
+#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_CHAR_LIMIT    64 // Character limit of summary field when not editing
 
+#if wxPG_COMPATIBILITY_1_4
+
+// Used to establish backwards compatibility
+const char* g_invalidStringContent = "@__TOTALLY_INVALID_STRING__@";
+
+#endif
 
 // -----------------------------------------------------------------------
 
@@ -88,8 +96,6 @@ wxSize wxPGCellRenderer::GetImageSize( const wxPGProperty* WXUNUSED(property),
 void wxPGCellRenderer::DrawText( wxDC& dc, const wxRect& rect,
                                  int xOffset, const wxString& text ) const
 {
-    if ( xOffset )
-        xOffset += wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2;
     dc.DrawText( text,
                  rect.x+xOffset+wxPG_XBEFORETEXT,
                  rect.y+((rect.height-dc.GetCharHeight())/2) );
@@ -100,14 +106,11 @@ void wxPGCellRenderer::DrawEditorValue( wxDC& dc, const wxRect& rect,
                                         wxPGProperty* property,
                                         const wxPGEditor* editor ) const
 {
-    if ( xOffset )
-        xOffset += wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2;
-
     int yOffset = ((rect.height-dc.GetCharHeight())/2);
 
     if ( editor )
     {
-        wxRect rect2(rect); 
+        wxRect rect2(rect);
         rect2.x += xOffset;
         rect2.y += yOffset;
         rect2.height -= yOffset;
@@ -129,48 +132,70 @@ void wxPGCellRenderer::DrawCaptionSelectionRect( wxDC& dc, int x, int y, int w,
 
 int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell& cell, int flags ) const
 {
-    int imageOffset = 0;
+    int imageWidth = 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);
+        const wxColour& bgCol = cell.GetBgCol();
+        dc.SetPen(bgCol);
+        dc.SetBrush(bgCol);
+    }
 
-        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);
+
+    // Use cell font, if provided
+    const wxFont& font = cell.GetFont();
+    if ( font.IsOk() )
+        dc.SetFont(font);
+
     const wxBitmap& bmp = cell.GetBitmap();
-    if ( bmp.Ok() &&
-        // In control, do not draw oversized bitmap
-         (!(flags & Control) || bmp.GetHeight() < rect.height )
+    if ( bmp.IsOk() &&
+        // Do not draw oversized bitmap outside choice popup
+         ((flags & ChoicePopup) || bmp.GetHeight() < rect.height )
         )
     {
         dc.DrawBitmap( bmp,
                        rect.x + wxPG_CONTROL_MARGIN + wxCC_CUSTOM_IMAGE_MARGIN1,
                        rect.y + wxPG_CUSTOM_IMAGE_SPACINGY,
                        true );
-        imageOffset = bmp.GetWidth();
+        imageWidth = bmp.GetWidth();
     }
 
-    return imageOffset;
+    return imageWidth;
+}
+
+void wxPGCellRenderer::PostDrawCell( wxDC& dc,
+                                     const wxPropertyGrid* propGrid,
+                                     const wxPGCell& cell,
+                                     int WXUNUSED(flags) ) const
+{
+    // Revert font
+    const wxFont& font = cell.GetFont();
+    if ( font.IsOk() )
+        dc.SetFont(propGrid->GetFont());
 }
 
 // -----------------------------------------------------------------------
 // wxPGDefaultRenderer
 // -----------------------------------------------------------------------
 
-void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
+bool wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
                                   const wxPropertyGrid* propertyGrid, wxPGProperty* property,
                                   int column, int item, int flags ) const
 {
+    const wxPGEditor* editor = NULL;
+    const wxPGCell* cell = NULL;
+
+    wxString text;
     bool isUnspecified = property->IsValueUnspecified();
 
     if ( column == 1 && item == -1 )
@@ -180,62 +205,30 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
         {
             // Common Value
             if ( !isUnspecified )
-                DrawText( dc, rect, 0, propertyGrid->GetCommonValueLabel(cmnVal) );
-            return;
+            {
+                text = propertyGrid->GetCommonValueLabel(cmnVal);
+                DrawText( dc, rect, 0, text );
+                if ( !text.empty() )
+                    return true;
+            }
+            return false;
         }
     }
 
-    const wxPGEditor* editor = NULL;
-    const wxPGCell* cell = property->GetCell(column);
+    int imageWidth = 0;
+    int preDrawFlags = flags;
+    bool res = false;
 
-    wxString text;
-    int imageOffset = 0;
+    property->GetDisplayInfo(column, item, flags, &text, &cell);
 
-    // Use choice cell?
-    if ( column == 1 && (flags & Control) )
-    {
-        int selectedIndex = property->GetChoiceSelection();
-        if ( selectedIndex != wxNOT_FOUND )
-        {
-            const wxPGChoices& choices = property->GetChoices();
-            const wxPGCell* ccell = &choices[selectedIndex];
-            if ( ccell &&
-                 ( ccell->GetBitmap().IsOk() || ccell->GetFgCol().IsOk() || ccell->GetBgCol().IsOk() )
-               )
-                cell = ccell;
-        }
-    }
+    imageWidth = PreDrawCell( dc, rect, *cell, preDrawFlags );
 
-    if ( cell )
+    if ( column == 1 )
     {
-        int preDrawFlags = flags;
+        editor = property->GetColumnEditor(column);
 
-        if ( propertyGrid->GetInternalFlags() & wxPG_FL_CELL_OVERRIDES_SEL )
-            preDrawFlags = preDrawFlags & ~(Selected);
-
-        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 ( !isUnspecified )
         {
-            editor = property->GetColumnEditor(column);
-
             // Regular property value
 
             wxSize imageSize = propertyGrid->GetImageSize(property, item);
@@ -251,67 +244,63 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
                                  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;
 
-                if ( !isUnspecified )
-                {
-                    property->OnCustomPaint( dc, imageRect, paintdata );
-                }
-                else
-                {
-                    dc.SetBrush(*wxWHITE_BRUSH);
-                    dc.DrawRectangle(imageRect);
-                }
+                property->OnCustomPaint( dc, imageRect, paintdata );
 
-                imageOffset = paintdata.m_drawnWidth;
+                imageWidth = paintdata.m_drawnWidth;
             }
 
-            text = property->GetValueString();
+            text = property->GetValueAsString();
 
             // Add units string?
             if ( propertyGrid->GetColumnCount() <= 2 )
             {
                 wxString unitsString = property->GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
-                if ( unitsString.length() )
+                if ( !unitsString.empty() )
                     text = wxString::Format(wxS("%s %s"), text.c_str(), unitsString.c_str() );
             }
         }
 
-        if ( text.length() == 0 )
+        if ( text.empty() )
         {
-            // Try to show inline help if no text
-            wxVariant vInlineHelp = property->GetAttribute(wxPGGlobalVars->m_strInlineHelp);
-            if ( !vInlineHelp.IsNull() )
+            text = property->GetHintText();
+            if ( !text.empty() )
             {
-                text = vInlineHelp.GetString();
-                dc.SetTextForeground(propertyGrid->GetCellDisabledTextColour());
+                res = true;
+
+                const wxColour& hCol =
+                    propertyGrid->GetCellDisabledTextColour();
+                dc.SetTextForeground(hCol);
+
+                // Must make the editor NULL to override its own rendering
+                // code.
+                editor = NULL;
             }
         }
-    }
-    else if ( column == 2 )
-    {
-        // Add units string?
-        if ( !text.length() )
-            text = property->GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
+        else
+        {
+            res = true;
+        }
     }
 
+    int imageOffset = property->GetImageOffset(imageWidth);
+
     DrawEditorValue( dc, rect, imageOffset, text, property, editor );
 
     // active caption gets nice dotted rectangle
-    if ( property->IsCategory() /*&& column == 0*/ )
+    if ( property->IsCategory() && column == 0 )
     {
         if ( flags & Selected )
         {
             if ( imageOffset > 0 )
+            {
+                imageOffset -= DEFAULT_IMAGE_OFFSET_INCREMENT;
                 imageOffset += wxCC_CUSTOM_IMAGE_MARGIN2 + 4;
+            }
 
             DrawCaptionSelectionRect( dc,
                                       rect.x+wxPG_XBEFORETEXT-wxPG_CAPRECTXMARGIN+imageOffset,
@@ -322,6 +311,10 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
                                       propertyGrid->GetFontHeight()+(wxPG_CAPRECTYMARGIN*2) );
         }
     }
+
+    PostDrawCell(dc, propertyGrid, *cell, preDrawFlags);
+
+    return res;
 }
 
 wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,
@@ -334,18 +327,29 @@ wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,
         {
             wxBitmap* bmp = property->GetValueImage();
 
-            if ( bmp && bmp->Ok() )
+            if ( bmp && bmp->IsOk() )
                 return wxSize(bmp->GetWidth(),bmp->GetHeight());
         }
     }
     return wxSize(0,0);
 }
 
+// -----------------------------------------------------------------------
+// wxPGCellData
+// -----------------------------------------------------------------------
+
+wxPGCellData::wxPGCellData()
+    : wxObjectRefData()
+{
+    m_hasValidText = false;
+}
+
 // -----------------------------------------------------------------------
 // wxPGCell
 // -----------------------------------------------------------------------
 
 wxPGCell::wxPGCell()
+    : wxObject()
 {
 }
 
@@ -353,11 +357,89 @@ wxPGCell::wxPGCell( const wxString& text,
                     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 )
 {
-    m_text = 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::SetFont( const wxFont& font )
+{
+    AllocExclusive();
+
+    GetData()->SetFont(font);
+}
+
+void wxPGCell::SetBgCol( const wxColour& col )
+{
+    AllocExclusive();
+
+    GetData()->SetBgCol(col);
+}
+
+void wxPGCell::MergeFrom( const wxPGCell& srcCell )
+{
+    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());
+}
+
+void wxPGCell::SetEmptyData()
+{
+    AllocExclusive();
+}
+
+
 // -----------------------------------------------------------------------
 // wxPGProperty
 // -----------------------------------------------------------------------
@@ -372,24 +454,22 @@ void wxPGProperty::Init()
     m_arrIndex = 0xFFFF;
     m_parent = NULL;
 
-    m_parentState = (wxPropertyGridPageState*) NULL;
+    m_parentState = NULL;
 
     m_clientData = NULL;
     m_clientObject = NULL;
 
-    m_customEditor = (wxPGEditor*) NULL;
+    m_customEditor = NULL;
 #if wxUSE_VALIDATORS
-    m_validator = (wxValidator*) NULL;
+    m_validator = NULL;
 #endif
-    m_valueBitmap = (wxBitmap*) NULL;
+    m_valueBitmap = NULL;
 
     m_maxLen = 0; // infinite maximum length
 
     m_flags = wxPG_PROP_PROPERTY;
 
     m_depth = 1;
-    m_bgColIndex = 0;
-    m_fgColIndex = 0;
 
     SetExpanded(true);
 }
@@ -411,6 +491,176 @@ void wxPGProperty::Init( const wxString& label, const wxString& name )
     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(wxCLASSINFO(wxPGRootProperty));
+
+    //
+    // Convert invalid cells to default ones in this grid
+    for ( unsigned int i=0; i<m_cells.size(); i++ )
+    {
+        wxPGCell& cell = m_cells[i];
+        if ( cell.IsInvalid() )
+        {
+            const wxPGCell& propDefCell = propgrid->GetPropertyDefaultCell();
+            const wxPGCell& catDefCell = propgrid->GetCategoryDefaultCell();
+
+            if ( !HasFlag(wxPG_PROP_CATEGORY) )
+                cell = propDefCell;
+            else
+                cell = catDefCell;
+        }
+    }
+
+    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) ==
+                            wxPG_PROP_AGGREGATE) ||
+                      ((m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
+                            wxPG_PROP_MISC_PARENT),
+                      "wxPGProperty parental flags set incorrectly at "
+                      "this time" );
+
+        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);
+    }
+}
+
+void wxPGProperty::OnDetached(wxPropertyGridPageState* WXUNUSED(state),
+                              wxPropertyGrid* propgrid)
+{
+    if ( propgrid )
+    {
+        const wxPGCell& propDefCell = propgrid->GetPropertyDefaultCell();
+        const wxPGCell& catDefCell = propgrid->GetCategoryDefaultCell();
+
+        // Make default cells invalid
+        for ( unsigned int i=0; i<m_cells.size(); i++ )
+        {
+            wxPGCell& cell = m_cells[i];
+            if ( cell.IsSameAs(propDefCell) ||
+                 cell.IsSameAs(catDefCell) )
+            {
+                cell.UnRef();
+            }
+        }
+    }
+}
+
 wxPGProperty::wxPGProperty()
     : wxObject()
 {
@@ -436,11 +686,6 @@ wxPGProperty::~wxPGProperty()
     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;
 }
@@ -458,12 +703,21 @@ bool wxPGProperty::IsSomeParent( wxPGProperty* candidate ) const
     return false;
 }
 
+void wxPGProperty::SetName( const wxString& newName )
+{
+    wxPropertyGrid* pg = GetGrid();
+
+    if ( pg )
+        pg->SetPropertyName(this, newName);
+    else
+        DoSetName(newName);
+}
 
 wxString wxPGProperty::GetName() const
 {
     wxPGProperty* parent = GetParent();
 
-    if ( !m_name.length() || !parent || parent->IsCategory() || parent->IsRoot() )
+    if ( m_name.empty() || !parent || parent->IsCategory() || parent->IsRoot() )
         return m_name;
 
     return m_parent->GetName() + wxS(".") + m_name;
@@ -476,11 +730,9 @@ wxPropertyGrid* wxPGProperty::GetGrid() const
     return m_parentState->GetGrid();
 }
 
-
-void wxPGProperty::UpdateControl( wxWindow* primary )
+int wxPGProperty::Index( const wxPGProperty* p ) const
 {
-    if ( primary )
-        GetEditorClass()->UpdateControl(this, primary);
+    return wxPGFindInVector(m_children, p);
 }
 
 bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const
@@ -496,30 +748,108 @@ void wxPGProperty::RefreshChildren ()
 {
 }
 
-wxString wxPGProperty::GetColumnText( unsigned int col ) const
+void wxPGProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) )
 {
-    wxPGCell* cell = GetCell(col);
-    if ( cell )
+}
+
+void wxPGProperty::GetDisplayInfo( unsigned int column,
+                                   int choiceIndex,
+                                   int flags,
+                                   wxString* pString,
+                                   const wxPGCell** pCell )
+{
+    const wxPGCell* cell = NULL;
+
+    if ( !(flags & wxPGCellRenderer::ChoicePopup) )
     {
-        return cell->GetText();
+        // Not painting list of choice popups, so get text from property
+        if ( column != 1 || !IsValueUnspecified() || IsCategory() )
+        {
+            cell = &GetCell(column);
+        }
+        else
+        {
+            // Use special unspecified value cell
+            cell = &GetGrid()->GetUnspecifiedValueAppearance();
+        }
+
+        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
     {
-        if ( col == 0 )
-            return GetLabel();
-        else if ( col == 1 )
-            return GetDisplayedString();
-        else if ( col == 2 )
-            return GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
+        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 )
+    {
+        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
+    {
+        // Use choice
+        return m_choices.GetLabel(choiceIndex);
     }
 
     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 iMax = m_children.GetCount();
+    int iMax = m_children.size();
 
     text.clear();
     if ( iMax == 0 )
@@ -534,16 +864,69 @@ void wxPGProperty::GenerateComposedValue( wxString& text, int argFlags ) const
     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++ )
     {
+        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;
-        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() )
+        if ( (argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT) && s.empty() )
             skip = true;
 
         if ( !curChild->GetChildCount() || skip )
@@ -566,41 +949,63 @@ void wxPGProperty::GenerateComposedValue( wxString& text, int argFlags ) const
                     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(),
-                 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;
-    GenerateComposedValue(text, argFlags);
+    DoGenerateComposedValue(text, argFlags);
     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
+
+    wxPropertyGrid* pg = GetGrid();
+
     if ( IsValueUnspecified() )
-        return wxEmptyString;
+        return pg->GetUnspecifiedValueText(argFlags);
 
     if ( m_commonValue == -1 )
-        return GetValueAsString(argFlags);
+    {
+        wxVariant value(GetValue());
+        return ValueToString(value, argFlags|wxPG_VALUE_IS_CURRENT);
+    }
 
     //
     // Return common value's string representation
-    wxPropertyGrid* pg = GetGrid();
     const wxPGCommonValue* cv = pg->GetCommonValue(m_commonValue);
 
     if ( argFlags & wxPG_FULL_VALUE )
@@ -617,6 +1022,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;
@@ -624,14 +1034,14 @@ bool wxPGProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argF
 }
 
 // Convert semicolon delimited tokens into child values.
-bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
+bool wxPGProperty::StringToValue( wxVariant& v, const wxString& text, int argFlags ) const
 {
     if ( !GetChildCount() )
         return false;
 
     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) )
@@ -651,16 +1061,10 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
     wxVariantList temp_list;
     wxVariant list(temp_list);
 
-    int propagatedFlags = argFlags & wxPG_REPORT_ERROR;
-
-#ifdef __WXDEBUG__
-    bool debug_print = false;
-#endif
+    int propagatedFlags = argFlags & (wxPG_REPORT_ERROR|wxPG_PROGRAMMATIC_VALUE);
 
-#ifdef __WXDEBUG__
-    if ( debug_print )
-        wxLogDebug(wxT(">> %s.StringToValue('%s')"),GetLabel().c_str(),text.c_str());
-#endif
+    wxLogTrace("propgrid",
+               wxT(">> %s.StringToValue('%s')"), GetLabel(), text);
 
     wxString::const_iterator it = text.begin();
     wxUniChar a;
@@ -672,6 +1076,11 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
     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
@@ -684,41 +1093,46 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                 if ( !addOnlyIfNotEmpty || len > 0 )
                 {
                     const wxPGProperty* child = Item(curChild);
-                #ifdef __WXDEBUG__
-                    if ( debug_print )
-                        wxLogDebug(wxT("token = '%s', child = %s"),token.c_str(),child->GetLabel().c_str());
-                #endif
+                    wxVariant variant(child->GetValue());
+                    wxString childName = child->GetBaseName();
 
-                    if ( len > 0 )
-                    {
-                        bool wasUnspecified = child->IsValueUnspecified();
+                    wxLogTrace("propgrid",
+                               wxT("token = '%s', child = %s"),
+                               token, childName);
 
-                        wxVariant variant(child->GetValueRef());
-                        if ( child->StringToValue(variant, token, propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )
+                    // Add only if editable or setting programmatically
+                    if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
+                         (!child->HasFlag(wxPG_PROP_DISABLED) &&
+                          !child->HasFlag(wxPG_PROP_READONLY)) )
+                    {
+                        if ( len > 0 )
                         {
-                            variant.SetName(child->GetBaseName());
-
-                            // 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);
-
                             changed = true;
                         }
                     }
-                    else
-                    {
-                        // Empty, becomes unspecified
-                        wxVariant variant2;
-                        variant2.SetName(child->GetBaseName());
-                        list.Append(variant2);
-                        changed = true;
-                    }
 
                     curChild++;
                     if ( curChild >= iMax )
@@ -741,7 +1155,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                 {
                     int depth = 1;
 
-                    if ( it != text.end() ) it++;
+                    if ( it != text.end() ) ++it;
                     pos++;
                     size_t startPos = pos;
 
@@ -749,7 +1163,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                     while ( it != text.end() && depth > 0 )
                     {
                         a = *it;
-                        it++;
+                        ++it;
                         pos++;
 
                         if ( a == wxS(']') )
@@ -760,28 +1174,34 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
                     token = text.substr(startPos,pos-startPos-1);
 
-                    if ( !token.length() )
+                    if ( token.empty() )
                         break;
 
                     const wxPGProperty* child = Item(curChild);
 
                     wxVariant oldChildValue = child->GetValue();
                     wxVariant variant(oldChildValue);
-                    bool stvRes = child->StringToValue( variant, token, propagatedFlags );
-                    if ( stvRes || (variant != oldChildValue) )
+
+                    if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
+                         (!child->HasFlag(wxPG_PROP_DISABLED) &&
+                          !child->HasFlag(wxPG_PROP_READONLY)) )
                     {
-                        if ( stvRes )
+                        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...
+                        }
                     }
-                    else
-                    {
-                        // Failed, becomes unspecified
-                        variant.MakeNull();
-                        changed = true;
-                    }
-
-                    variant.SetName(child->GetBaseName());
-                    list.Append(variant);
 
                     curChild++;
                     if ( curChild >= iMax )
@@ -796,10 +1216,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                     tokenStart = pos;
 
                     if ( a == delimeter )
-                    {
-                        pos--;
-                        it--;
-                    }
+                        strPosIncrement -= 1;
                 }
             }
         }
@@ -807,7 +1224,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
         if ( a == 0 )
             break;
 
-        it++;
+        it += strPosIncrement;
+
         if ( it != text.end() )
         {
             a = *it;
@@ -816,11 +1234,12 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
         {
             a = 0;
         }
-        pos++;
+
+        pos += strPosIncrement;
     }
 
     if ( changed )
-        variant = list;
+        v = list;
 
     return changed;
 }
@@ -851,6 +1270,22 @@ wxSize wxPGProperty::OnMeasureImage( int WXUNUSED(item) ) const
     return wxSize(0,0);
 }
 
+int wxPGProperty::GetImageOffset( int imageWidth ) const
+{
+    int imageOffset = 0;
+
+    if ( imageWidth )
+    {
+        // Do not increment offset too much for wide images
+        if ( imageWidth <= (wxPG_CUSTOM_IMAGE_WIDTH+5) )
+            imageOffset = imageWidth + DEFAULT_IMAGE_OFFSET_INCREMENT;
+        else
+            imageOffset = imageWidth + 1;
+    }
+
+    return imageOffset;
+}
+
 wxPGCellRenderer* wxPGProperty::GetCellRenderer( int WXUNUSED(column) ) const
 {
     return wxPGGlobalVars->m_defaultRenderer;
@@ -862,7 +1297,7 @@ void wxPGProperty::OnCustomPaint( wxDC& dc,
 {
     wxBitmap* bmp = m_valueBitmap;
 
-    wxCHECK_RET( bmp && bmp->Ok(), wxT("invalid bitmap") );
+    wxCHECK_RET( bmp && bmp->IsOk(), wxT("invalid bitmap") );
 
     wxCHECK_RET( rect.x >= 0, wxT("unexpected measure call") );
 
@@ -871,7 +1306,7 @@ void wxPGProperty::OnCustomPaint( wxDC& dc,
 
 const wxPGEditor* wxPGProperty::DoGetEditorClass() const
 {
-    return wxPG_EDITOR(TextCtrl);
+    return wxPGEditor_TextCtrl;
 }
 
 // Default extra property event handling - that is, none at all.
@@ -883,6 +1318,14 @@ bool wxPGProperty::OnEvent( wxPropertyGrid*, wxWindow*, wxEvent& )
 
 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() )
     {
         wxVariant tempListVariant;
@@ -924,7 +1367,7 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
 
             // Children in list can be in any order, but we will give hint to
             // GetPropertyByNameWH(). This optimizes for full list parsing.
-            for ( node = list.begin(); node != list.end(); node++ )
+            for ( node = list.begin(); node != list.end(); ++node )
             {
                 wxVariant& childValue = *((wxVariant*)*node);
                 wxPGProperty* child = GetPropertyByNameWH(childValue.GetName(), i);
@@ -956,15 +1399,18 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
                 }
                 i++;
             }
+
+            // Always call OnSetValue() for a parent property (do not call it
+            // here if the value is non-null because it will then be called
+            // below)
+            if ( value.IsNull() )
+                OnSetValue();
         }
 
         if ( !value.IsNull() )
         {
             m_value = value;
             OnSetValue();
-
-            if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
-                UpdateParentValues();
         }
 
         if ( flags & wxPG_SETVAL_BY_USER )
@@ -994,13 +1440,28 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
         }
     }
 
-    //
-    // Update editor control
-    //
+    if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
+        UpdateParentValues();
 
-    // We need to check for these, otherwise GetGrid() may fail.
+    //
+    // Update editor control.
     if ( flags & wxPG_SETVAL_REFRESH_EDITOR )
-        RefreshEditor();
+    {
+        wxPropertyGrid* pg = GetGridIfDisplayed();
+        if ( pg )
+        {
+            wxPGProperty* selected = pg->GetSelectedProperty();
+
+            // Only refresh the control if this was selected, or
+            // this was some parent of selected, or vice versa)
+            if ( selected && (selected == this ||
+                              selected->IsSomeParent(this) ||
+                              this->IsSomeParent(selected)) )
+                RefreshEditor();
+
+            pg->DrawItemAndValueRelated(this);
+        }
+    }
 }
 
 
@@ -1009,12 +1470,9 @@ void wxPGProperty::SetValueInEvent( wxVariant value ) const
     GetGrid()->ValueChangeInEvent(value);
 }
 
-void wxPGProperty::SetFlagRecursively( FlagType flag, bool set )
+void wxPGProperty::SetFlagRecursively( wxPGPropertyFlags flag, bool set )
 {
-    if ( set )
-        SetFlag(flag);
-    else
-        ClearFlag(flag);
+    ChangeFlag(flag, set);
 
     unsigned int i;
     for ( i = 0; i < GetChildCount(); i++ )
@@ -1023,22 +1481,17 @@ void wxPGProperty::SetFlagRecursively( FlagType flag, bool set )
 
 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 defVal = GetAttribute(wxS("DefaultValue"));
+    wxVariant defVal = GetAttribute(wxPG_ATTR_DEFAULT_VALUE);
     if ( !defVal.IsNull() )
         return defVal;
 
@@ -1079,13 +1532,203 @@ wxVariant wxPGProperty::GetDefaultValue() const
     return wxVariant();
 }
 
-void wxPGProperty::SetCell( int column, wxPGCell* cellObj )
+void wxPGProperty::Enable( bool enable )
+{
+    wxPropertyGrid* pg = GetGrid();
+
+    // Preferably call the version in the owning wxPropertyGrid,
+    // since it handles the editor de-activation.
+    if ( pg )
+        pg->EnableProperty(this, enable);
+    else
+        DoEnable(enable);
+}
+
+void wxPGProperty::DoEnable( bool enable )
+{
+    if ( enable )
+        ClearFlag(wxPG_PROP_DISABLED);
+    else
+        SetFlag(wxPG_PROP_DISABLED);
+
+    // Apply same to sub-properties as well
+    unsigned int i;
+    for ( i = 0; i < GetChildCount(); i++ )
+        Item(i)->DoEnable( enable );
+}
+
+void wxPGProperty::EnsureCells( unsigned int column )
+{
+    if ( column >= m_cells.size() )
+    {
+        // Fill empty slots with default cells
+        wxPropertyGrid* pg = GetGrid();
+        wxPGCell defaultCell;
+
+        if ( pg )
+        {
+            // Work around possible VC6 bug by using intermediate variables
+            const wxPGCell& propDefCell = pg->GetPropertyDefaultCell();
+            const wxPGCell& catDefCell = pg->GetCategoryDefaultCell();
+
+            if ( !HasFlag(wxPG_PROP_CATEGORY) )
+                defaultCell = propDefCell;
+            else
+                defaultCell = catDefCell;
+        }
+
+        // TODO: Replace with resize() call
+        unsigned int cellCountMax = column+1;
+
+        for ( unsigned int i=m_cells.size(); i<cellCountMax; i++ )
+            m_cells.push_back(defaultCell);
+    }
+}
+
+void wxPGProperty::SetCell( int column,
+                            const wxPGCell& cell )
 {
-    if ( column >= (int)m_cells.size() )
-        m_cells.SetCount(column+1, NULL);
+    EnsureCells(column);
 
-    delete (wxPGCell*) m_cells[column];
-    m_cells[column] = cellObj;
+    m_cells[column] = cell;
+}
+
+void wxPGProperty::AdaptiveSetCell( unsigned int firstCol,
+                                    unsigned int lastCol,
+                                    const wxPGCell& cell,
+                                    const wxPGCell& srcData,
+                                    wxPGCellData* unmodCellData,
+                                    FlagType ignoreWithFlags,
+                                    bool recursively )
+{
+    //
+    // 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 ( !(m_flags & ignoreWithFlags) && !IsRoot() )
+    {
+        EnsureCells(lastCol);
+
+        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);
+            }
+        }
+    }
+
+    if ( recursively )
+    {
+        for ( unsigned int i=0; i<GetChildCount(); i++ )
+            Item(i)->AdaptiveSetCell( firstCol,
+                                      lastCol,
+                                      cell,
+                                      srcData,
+                                      unmodCellData,
+                                      ignoreWithFlags,
+                                      recursively );
+    }
+}
+
+const wxPGCell& wxPGProperty::GetCell( unsigned int column ) const
+{
+    if ( m_cells.size() > column )
+        return m_cells[column];
+
+    wxPropertyGrid* pg = GetGrid();
+
+    if ( IsCategory() )
+        return pg->GetCategoryDefaultCell();
+
+    return pg->GetPropertyDefaultCell();
+}
+
+wxPGCell& wxPGProperty::GetOrCreateCell( unsigned int column )
+{
+    EnsureCells(column);
+    return m_cells[column];
+}
+
+void wxPGProperty::SetBackgroundColour( const wxColour& colour,
+                                        int flags )
+{
+    wxPGProperty* firstProp = this;
+    bool recursively = flags & wxPG_RECURSE ? true : false;
+
+    //
+    // 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.SetBgCol(colour);
+    wxPGCell srcCell;
+    srcCell.SetBgCol(colour);
+
+    AdaptiveSetCell( 0,
+                     GetParentState()->GetColumnCount()-1,
+                     newCell,
+                     srcCell,
+                     firstCellData,
+                     recursively ? wxPG_PROP_CATEGORY : 0,
+                     recursively );
+}
+
+void wxPGProperty::SetTextColour( const wxColour& colour,
+                                  int flags )
+{
+    wxPGProperty* firstProp = this;
+    bool recursively = flags & wxPG_RECURSE ? true : false;
+
+    //
+    // 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
@@ -1144,18 +1787,20 @@ long wxPGProperty::GetAttributeAsLong( const wxString& name, long defVal ) const
 {
     wxVariant variant = m_attributes.FindValue(name);
 
-    return wxPGVariantToInt(variant, defVal);
+    if ( variant.IsNull() )
+        return defVal;
+
+    return variant.GetLong();
 }
 
 double wxPGProperty::GetAttributeAsDouble( const wxString& name, double defVal ) const
 {
-    double retVal;
     wxVariant variant = m_attributes.FindValue(name);
 
-    if ( wxPGVariantToDouble(variant, &retVal) )
-        return retVal;
+    if ( variant.IsNull() )
+        return defVal;
 
-    return defVal;
+    return variant.GetDouble();
 }
 
 wxVariant wxPGProperty::GetAttributesAsList() const
@@ -1175,7 +1820,7 @@ wxVariant wxPGProperty::GetAttributesAsList() const
 // Slots of utility flags are NULL
 const unsigned int gs_propFlagToStringSize = 14;
 
-static const wxChar* gs_propFlagToString[gs_propFlagToStringSize] = {
+static const wxChar* const gs_propFlagToString[gs_propFlagToStringSize] = {
     NULL,
     wxT("DISABLED"),
     wxT("HIDDEN"),
@@ -1205,7 +1850,7 @@ wxString wxPGProperty::GetFlagsAsString( FlagType flagsMask ) const
         {
             const wxChar* fs = gs_propFlagToString[i];
             wxASSERT(fs);
-            if ( s.length() )
+            if ( !s.empty() )
                 s << wxS("|");
             s << fs;
         }
@@ -1237,7 +1882,7 @@ void wxPGProperty::SetFlagsFromString( const wxString& str )
 
 wxValidator* wxPGProperty::DoGetValidator() const
 {
-    return (wxValidator*) NULL;
+    return NULL;
 }
 
 int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
@@ -1335,8 +1980,14 @@ void wxPGProperty::SetChoiceSelection( int newValue )
     }
 }
 
-bool wxPGProperty::SetChoices( wxPGChoices& choices )
+bool wxPGProperty::SetChoices( const wxPGChoices& choices )
 {
+    // Property must be de-selected first (otherwise choices in
+    // the control would be de-synced with true choices)
+    wxPropertyGrid* pg = GetGrid();
+    if ( pg && pg->GetSelection() == this )
+        pg->ClearSelection();
+
     m_choices.Assign(choices);
 
     {
@@ -1369,17 +2020,43 @@ const wxPGEditor* wxPGProperty::GetEditorClass() const
     if ( GetDisplayedCommonValueCount() )
     {
         // TextCtrlAndButton -> ComboBoxAndButton
-        if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlAndButtonEditor)) )
-            editor = wxPG_EDITOR(ChoiceAndButton);
+        if ( wxDynamicCast(editor, wxPGTextCtrlAndButtonEditor) )
+            editor = wxPGEditor_ChoiceAndButton;
 
         // TextCtrl -> ComboBox
-        else if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlEditor)) )
-            editor = wxPG_EDITOR(ComboBox);
+        else if ( wxDynamicCast(editor, wxPGTextCtrlEditor) )
+            editor = wxPGEditor_ComboBox;
     }
 
     return editor;
 }
 
+bool wxPGProperty::Hide( bool hide, int flags )
+{
+    wxPropertyGrid* pg = GetGrid();
+    if ( pg )
+        return pg->HideProperty(this, hide, flags);
+
+    return DoHide( hide, flags );
+}
+
+bool wxPGProperty::DoHide( bool hide, int flags )
+{
+    if ( !hide )
+        ClearFlag( wxPG_PROP_HIDDEN );
+    else
+        SetFlag( wxPG_PROP_HIDDEN );
+
+    if ( flags & wxPG_RECURSE )
+    {
+        unsigned int i;
+        for ( i = 0; i < GetChildCount(); i++ )
+            Item(i)->DoHide(hide, flags | wxPG_RECURSE_STARTS);
+    }
+
+    return true;
+}
+
 bool wxPGProperty::HasVisibleChildren() const
 {
     unsigned int i;
@@ -1395,12 +2072,6 @@ bool wxPGProperty::HasVisibleChildren() const
     return false;
 }
 
-bool wxPGProperty::PrepareValueForDialogEditing( wxPropertyGrid* propGrid )
-{
-    return propGrid->EditorValidate();
-}
-
-
 bool wxPGProperty::RecreateEditor()
 {
     wxPropertyGrid* pg = GetGrid();
@@ -1420,28 +2091,31 @@ void wxPGProperty::SetValueImage( wxBitmap& bmp )
 {
     delete m_valueBitmap;
 
-    if ( &bmp && bmp.Ok() )
+    if ( &bmp && bmp.IsOk() )
     {
         // Resize the image
         wxSize maxSz = GetGrid()->GetImageSize();
         wxSize imSz(bmp.GetWidth(),bmp.GetHeight());
 
-        if ( imSz.x != maxSz.x || imSz.y != maxSz.y )
+        if ( imSz.y != maxSz.y )
         {
-            // Create a memory DC
+        #if wxUSE_IMAGE
+            // Here we use high-quality wxImage scaling functions available
+            wxImage img = bmp.ConvertToImage();
+            double scaleY = (double)maxSz.y / (double)imSz.y;
+            img.Rescale(wxRound(bmp.GetWidth()*scaleY),
+                        wxRound(bmp.GetHeight()*scaleY),
+                        wxIMAGE_QUALITY_HIGH);
+            wxBitmap* bmpNew = new wxBitmap(img, 32);
+        #else
+            // This is the old, deprecated method of scaling the image
             wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth());
-
             wxMemoryDC dc;
             dc.SelectObject(*bmpNew);
-
-            // Scale
-            // FIXME: This is ugly - use image or wait for scaling patch.
-            double scaleX = (double)maxSz.x / (double)imSz.x;
             double scaleY = (double)maxSz.y / (double)imSz.y;
-
-            dc.SetUserScale(scaleX,scaleY);
-
-            dc.DrawBitmap( bmp, 0, 0 );
+            dc.SetUserScale(scaleY, scaleY);
+            dc.DrawBitmap(bmp, 0, 0);
+        #endif
 
             m_valueBitmap = bmpNew;
         }
@@ -1505,6 +2179,8 @@ bool wxPGProperty::IsVisible() const
 wxPropertyGrid* wxPGProperty::GetGridIfDisplayed() const
 {
     wxPropertyGridPageState* state = GetParentState();
+    if ( !state )
+        return NULL;
     wxPropertyGrid* propGrid = state->GetGrid();
     if ( state == propGrid->GetState() )
         return propGrid;
@@ -1522,7 +2198,7 @@ int wxPGProperty::GetY2( int lh ) const
     for ( parent = GetParent(); parent != NULL; parent = child->GetParent() )
     {
         if ( !parent->IsExpanded() )
-            return -1;
+            return parent->GetY2(lh);
         y += parent->GetChildrenHeight(lh, child->GetIndexInParent());
         y += lh;
         child = parent;
@@ -1540,39 +2216,101 @@ int wxPGProperty::GetY() const
 }
 
 // This is used by Insert etc.
-void wxPGProperty::AddChild2( wxPGProperty* prop, int index, bool correct_mode )
+void wxPGProperty::DoAddChild( 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
     {
-        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;
+}
+
+void wxPGProperty::DoPreAddChild( int index, wxPGProperty* prop )
+{
+    wxASSERT_MSG( prop->GetBaseName().length(),
+                  "Property's children must have unique, non-empty "
+                  "names within their scope" );
+
+    prop->m_arrIndex = index;
+    m_children.insert( m_children.begin()+index,
+                       prop );
+
+    int custImgHeight = prop->OnMeasureImage().y;
+    if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )
+        prop->m_flags |= wxPG_PROP_CUSTOMIMAGE;
+
+    prop->m_parent = this;
+}
+
+void wxPGProperty::AddPrivateChild( wxPGProperty* prop )
+{
+    if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
+        SetParentalType(wxPG_PROP_AGGREGATE);
+
+    wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
+                    wxPG_PROP_AGGREGATE,
+                  "Do not mix up AddPrivateChild() calls with other "
+                  "property adders." );
+
+    DoPreAddChild( m_children.size(), prop );
+}
+
+#if wxPG_COMPATIBILITY_1_4
+void wxPGProperty::AddChild( wxPGProperty* prop )
+{
+    AddPrivateChild(prop);
+}
+#endif
+
+wxPGProperty* wxPGProperty::InsertChild( int index,
+                                         wxPGProperty* childProperty )
+{
+    if ( index < 0 )
+        index = m_children.size();
+
+    if ( m_parentState )
+    {
+        m_parentState->DoInsert(this, index, childProperty);
+    }
+    else
+    {
+        if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
+            SetParentalType(wxPG_PROP_MISC_PARENT);
+
+        wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
+                        wxPG_PROP_MISC_PARENT,
+                      "Do not mix up AddPrivateChild() calls with other "
+                      "property adders." );
+
+        DoPreAddChild( index, childProperty );
     }
 
-    prop->m_parent = this;
+    return childProperty;
 }
 
-// This is used by properties that have fixed sub-properties
-void wxPGProperty::AddChild( wxPGProperty* prop )
+void wxPGProperty::RemoveChild( wxPGProperty* p )
 {
-    wxASSERT_MSG( prop->GetBaseName().length(),
-                  "Property's children must have unique, non-empty names within their scope" );
-
-    prop->m_arrIndex = m_children.GetCount();
-    m_children.Add( prop );
-
-    int custImgHeight = prop->OnMeasureImage().y;
-    if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )
-        prop->m_flags |= wxPG_PROP_CUSTOMIMAGE;
+    wxArrayPGProperty::iterator it;
+    wxArrayPGProperty& children = m_children;
 
-    prop->m_parent = this;
+    for ( it=children.begin(); it != children.end(); it++ )
+    {
+        if ( *it == p )
+        {
+            children.erase(it);
+            break;
+        }
+    }
 }
 
-
 void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
 {
     wxASSERT( GetChildCount() );
@@ -1594,9 +2332,9 @@ void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
     else
         allChildrenSpecified = true;
 
-    wxVariant childValue = list[0];
     unsigned int i;
     unsigned int n = 0;
+    wxVariant childValue = list[n];
 
     //wxLogDebug(wxT(">> %s.AdaptListToValue()"),GetBaseName().c_str());
 
@@ -1616,7 +2354,10 @@ void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
             }
 
             if ( allChildrenSpecified )
-                ChildChanged(*value, i, childValue);
+            {
+                *value = ChildChanged(*value, i, childValue);
+            }
+
             n++;
             if ( n == (unsigned int)list.GetCount() )
                 break;
@@ -1626,7 +2367,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++)
@@ -1649,7 +2390,7 @@ wxPGProperty* wxPGProperty::GetPropertyByName( const wxString& name ) const
     // 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));
 
@@ -1727,7 +2468,9 @@ int wxPGProperty::GetChildrenHeight( int lh, int iMax_ ) const
     return h;
 }
 
-wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y, unsigned int lh, unsigned int* nextItemY ) const
+wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y,
+                                        unsigned int lh,
+                                        unsigned int* nextItemY ) const
 {
     wxASSERT( nextItemY );
 
@@ -1777,9 +2520,13 @@ wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y, unsigned int lh, unsigne
 
     /*
     if ( current )
+    {
         wxLogDebug(wxT("%s::GetItemAtY(%i) -> %s"),this->GetLabel().c_str(),y,current->GetLabel().c_str());
+    }
     else
+    {
         wxLogDebug(wxT("%s::GetItemAtY(%i) -> NULL"),this->GetLabel().c_str(),y);
+    }
     */
 
     return (wxPGProperty*) result;
@@ -1792,18 +2539,60 @@ void wxPGProperty::Empty()
     {
         for ( i=0; i<GetChildCount(); i++ )
         {
-            wxPGProperty* p = (wxPGProperty*) Item(i);
-            delete p;
+            delete m_children[i];
         }
     }
 
-    m_children.Empty();
+    m_children.clear();
+}
+
+wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y ) const
+{
+    unsigned int nextItem;
+    return GetItemAtY( y, GetGrid()->GetRowHeight(), &nextItem);
+}
+
+void wxPGProperty::DeleteChildren()
+{
+    wxPropertyGridPageState* state = m_parentState;
+
+    if ( !GetChildCount() )
+        return;
+
+    // Because deletion is sometimes deferred, we have to use
+    // this sort of code for enumerating the child properties.
+    unsigned int i = GetChildCount();
+    while ( i > 0 )
+    {
+        i--;
+        state->DoDelete(Item(i), true);
+    }
+}
+
+bool wxPGProperty::IsChildSelected( bool recursive ) const
+{
+    size_t i;
+    for ( i = 0; i < GetChildCount(); i++ )
+    {
+        wxPGProperty* child = Item(i);
+
+        // Test child
+        if ( m_parentState->DoIsPropertySelected( child ) )
+            return true;
+
+        // Test sub-childs
+        if ( recursive && child->IsChildSelected( recursive ) )
+            return true;
+    }
+
+    return false;
 }
 
-void wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
-                                 int WXUNUSED(childIndex),
-                                 wxVariant& WXUNUSED(childValue) ) const
+wxVariant wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
+                                      int WXUNUSED(childIndex),
+                                      wxVariant& WXUNUSED(childValue) ) const
 {
+    return wxNullVariant;
 }
 
 bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
@@ -1829,7 +2618,7 @@ bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
         {
             const wxString& childName = child->GetBaseName();
 
-            for ( ; node != pList->end(); node++ )
+            for ( ; node != pList->end(); ++node )
             {
                 const wxVariant& item = *((const wxVariant*)*node);
                 if ( item.GetName() == childName )
@@ -1870,7 +2659,7 @@ wxPGProperty* wxPGProperty::UpdateParentValues()
          !parent->IsCategory() && !parent->IsRoot() )
     {
         wxString s;
-        parent->GenerateComposedValue(s, 0);
+        parent->DoGenerateComposedValue(s);
         parent->m_value = s;
         return parent->UpdateParentValues();
     }
@@ -1891,74 +2680,6 @@ bool wxPGProperty::IsTextEditable() const
     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
@@ -1968,14 +2689,20 @@ void wxPGProperty::SubPropsChanged( int oldSelInd )
     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 )
-        sel = (wxPGProperty*) m_children[oldSelInd];
+        sel = m_children[oldSelInd];
     else if ( oldSelInd == -2 )
         sel = this;
 
@@ -1996,12 +2723,11 @@ WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPGRootProperty,none,TextCtrl)
 IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
 
 
-wxPGRootProperty::wxPGRootProperty()
+wxPGRootProperty::wxPGRootProperty( const wxString& name )
     : wxPGProperty()
 {
-#ifdef __WXDEBUG__
-    m_name = wxS("<root>");
-#endif
+    m_name = name;
+    m_label = m_name;
     SetParentalType(0);
     m_depth = 0;
 }
@@ -2046,27 +2772,314 @@ wxPropertyCategory::~wxPropertyCategory()
 }
 
 
-wxString wxPropertyCategory::GetValueAsString( int ) const
+wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value),
+                                            int WXUNUSED(argFlags) ) const
 {
+    if ( m_value.GetType() == wxPG_VARIANT_TYPE_STRING )
+        return m_value.GetString();
     return wxEmptyString;
 }
 
+wxString wxPropertyCategory::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
+
+    // Unspecified value is always empty string
+    if ( IsValueUnspecified() )
+        return wxEmptyString;
+
+    return wxPGProperty::GetValueAsString(argFlags);
+}
+
 int wxPropertyCategory::GetTextExtent( const wxWindow* wnd, const wxFont& font ) const
 {
     if ( m_textExtent > 0 )
         return m_textExtent;
     int x = 0, y = 0;
-       ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font );
+    ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font );
     return x;
 }
 
 void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& font )
 {
     int x = 0, y = 0;
-       wnd->GetTextExtent( m_label, &x, &y, 0, 0, &font );
+    wnd->GetTextExtent( m_label, &x, &y, 0, 0, &font );
     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* const* labels, const ValArrItem* values )
+{
+    AllocExclusive();
+
+    unsigned int itemcount = 0;
+    const wxChar* const* 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->GetRefCount() != -1 );
+    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->GetRefCount() != 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->IncRef();
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Init()
+{
+    m_data = wxPGChoicesEmptyData;
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Free()
+{
+    if ( m_data != wxPGChoicesEmptyData )
+    {
+        m_data->DecRef();
+        m_data = wxPGChoicesEmptyData;
+    }
+}
+
 // -----------------------------------------------------------------------
 // wxPGAttributeStorage
 // -----------------------------------------------------------------------
@@ -2079,7 +3092,7 @@ wxPGAttributeStorage::~wxPGAttributeStorage()
 {
     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();
@@ -2093,12 +3106,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() )
+    {
         ((wxVariantData*)it->second)->DecRef();
 
+        if ( !data )
+        {
+            // If Null variant, just remove from set
+            m_map.erase(it);
+            return;
+        }
+    }
+
     if ( data )
+    {
         data->IncRef();
 
-    m_map[name] = data;
+        m_map[name] = data;
+    }
 }
 
 #endif  // wxUSE_PROPGRID