reduce the margins around bitmaps to avoid truncating the label unnecessarily

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

diff --git a/src/propgrid/property.cpp b/src/propgrid/property.cpp
index 7479aba04a9d03089c41ad6a5e1ce3a7e20541bc..ac6d0d192cf1b01dce98403257808072c54cbc11 100644 (file)
--- a/src/propgrid/property.cpp
+++ b/src/propgrid/property.cpp
@@ -43,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

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


@@ -131,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,


@@ -186,51 +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) )
-    {
-        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;
-        }
-    }
+    property->GetDisplayInfo(column, item, flags, &text, &cell);

 
 

-    if ( cell )
-    {
-        int preDrawFlags = flags;
-
-        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 )
         {


@@ -251,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 )


@@ -296,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 );
 


@@ -341,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()

 {
 }
 
 {
 }
 


@@ -353,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 )

 {
 {

-    m_text = text;
+    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());

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


@@ -388,8 +418,6 @@ void wxPGProperty::Init()
     m_flags = wxPG_PROP_PROPERTY;
 
     m_depth = 1;
     m_flags = wxPG_PROP_PROPERTY;
 
     m_depth = 1;

-    m_bgColIndex = 0;
-    m_fgColIndex = 0;

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


@@ -423,10 +451,16 @@ void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState,
 
     m_parentState = pageState;
 
 
     m_parentState = pageState;
 

-    if ( !parentIsRoot )
+#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_bgColIndex = parent->m_bgColIndex;
-        m_fgColIndex = parent->m_fgColIndex;
+        m_cells = parent->m_cells;

     }
 
     // If in hideable adding mode, or if assigned parent is hideable, then
     }
 
     // If in hideable adding mode, or if assigned parent is hideable, then


@@ -504,10 +538,8 @@ void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState,
     // Has initial children
     if ( GetChildCount() )
     {
     // Has initial children
     if ( GetChildCount() )
     {

-        FlagType parentalFlags = m_flags & wxPG_PROP_PARENTAL_FLAGS;
-

         // Check parental flags
         // Check parental flags

-        wxASSERT_MSG( parentalFlags,
+        wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS),

                       "Call SetFlag(wxPG_PROP_MISC_PARENT) or"
                       "SetFlag(wxPG_PROP_AGGREGATE) before calling"
                       "wxPGProperty::AddChild()." );
                       "Call SetFlag(wxPG_PROP_MISC_PARENT) or"
                       "SetFlag(wxPG_PROP_AGGREGATE) before calling"
                       "wxPGProperty::AddChild()." );


@@ -562,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;
 }


@@ -612,12 +639,6 @@ int wxPGProperty::Index( const wxPGProperty* p ) const
     return wxNOT_FOUND;
 }
 
     return wxNOT_FOUND;
 }
 

-void wxPGProperty::UpdateControl( wxWindow* primary )
-{
-    if ( primary )
-        GetEditorClass()->UpdateControl(this, primary);
-}
-

 bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const
 {
     return true;
 bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const
 {
     return true;


@@ -631,27 +652,96 @@ 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) )

     {
     {

-        return cell->GetText();
+        // 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
     {
     }
     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;
 }
     }
 
     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.size();
 {
     int i;
     int iMax = m_children.size();


@@ -671,11 +761,64 @@ void wxPGProperty::GenerateComposedValue( wxString& text, int argFlags ) const
 
     wxPGProperty* curChild = m_children[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() )


@@ -705,33 +848,54 @@ void wxPGProperty::GenerateComposedValue( wxString& text, int argFlags ) const
         }
     }
 
         }
     }
 

-    // Remove superfluous semicolon and space
-    wxString rest;
-    if ( text.EndsWith(wxS("; "), &rest) )
-        text = rest;
-

     if ( (unsigned int)i < m_children.size() )
     if ( (unsigned int)i < m_children.size() )

-        text += wxS("; ...");
+    {
+        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


@@ -752,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;


@@ -786,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;


@@ -807,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


@@ -819,41 +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 )

                         {
                         {

-                            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);
                             list.Append(variant);

-

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

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

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


@@ -876,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;
 


@@ -884,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(']') )


@@ -902,22 +1082,27 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
                     wxVariant oldChildValue = child->GetValue();
                     wxVariant variant(oldChildValue);
 
                     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|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;
                             changed = true;

-                    }
-                    else
-                    {
-                        // Failed, becomes unspecified
-                        variant.MakeNull();
-                        changed = true;
+                        }
+                        else
+                        {
+                            // No changes...
+                        }

                     }
 
                     }
 

-                    variant.SetName(child->GetBaseName());
-                    list.Append(variant);
-

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


@@ -931,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;

                 }
             }
         }
                 }
             }
         }


@@ -942,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;


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

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

     }
 
     if ( changed )
     }
 
     if ( changed )


@@ -1067,7 +1251,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.
 
             // 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);
             {
                 wxVariant& childValue = *((wxVariant*)*node);
                 wxPGProperty* child = GetPropertyByNameWH(childValue.GetName(), i);


@@ -1105,9 +1289,6 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
         {
             m_value = value;
             OnSetValue();
         {
             m_value = value;
             OnSetValue();

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

         }
 
         if ( flags & wxPG_SETVAL_BY_USER )
         }
 
         if ( flags & wxPG_SETVAL_BY_USER )


@@ -1137,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
     //


@@ -1166,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
 {


@@ -1222,13 +1401,169 @@ wxVariant wxPGProperty::GetDefaultValue() const
     return wxVariant();
 }
 
     return wxVariant();
 }
 

-void wxPGProperty::SetCell( int column, wxPGCell* cellObj )
+void wxPGProperty::EnsureCells( unsigned int column )
+{
+    if ( column >= m_cells.size() )
+    {
+        // Fill empty slots with default cells
+        wxPropertyGrid* pg = GetGrid();
+        wxPGCell defaultCell;
+
+        if ( !HasFlag(wxPG_PROP_CATEGORY) )
+            defaultCell = pg->GetPropertyDefaultCell();
+        else
+            defaultCell = pg->GetCategoryDefaultCell();
+
+        // 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 )
+{
+    EnsureCells(column);
+
+    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 ( column >= (int)m_cells.size() )
-        m_cells.SetCount(column+1, NULL);
+    if ( m_cells.size() > column )
+        return m_cells[column];
+
+    wxPropertyGrid* pg = GetGrid();
+
+    if ( IsCategory() )
+        return pg->GetCategoryDefaultCell();

 
 

-    delete (wxPGCell*) m_cells[column];
-    m_cells[column] = cellObj;
+    return pg->GetPropertyDefaultCell();
+}
+
+wxPGCell& wxPGProperty::GetCell( unsigned int column )
+{
+    EnsureCells(column);
+    return m_cells[column];
+}
+
+void wxPGProperty::SetBackgroundColour( const wxColour& colour,
+                                        bool recursively )
+{
+    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.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,
+                                  bool recursively )
+{
+    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


@@ -1950,6 +2285,17 @@ void wxPGProperty::Empty()
     m_children.clear();
 }
 
     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),
                                  int WXUNUSED(childIndex),
                                  wxVariant& WXUNUSED(childValue) ) const
 void wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
                                  int WXUNUSED(childIndex),
                                  wxVariant& WXUNUSED(childValue) ) const


@@ -1979,7 +2325,7 @@ bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
         {
             const wxString& childName = child->GetBaseName();
 
         {
             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 )
             {
                 const wxVariant& item = *((const wxVariant*)*node);
                 if ( item.GetName() == childName )


@@ -2020,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();
     }


@@ -2134,7 +2480,8 @@ wxPropertyCategory::~wxPropertyCategory()
 }
 
 
 }
 
 

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

 {
     return wxEmptyString;
 }
 {
     return wxEmptyString;
 }


@@ -2167,7 +2514,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();