correct typo in one of the last changes

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

diff --git a/src/propgrid/property.cpp b/src/propgrid/property.cpp
index d8cdd2c5e3771637f9789bbae0eda1c1cfdcb04a..addc80c0c20af351f4585859df050a027bfcde36 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;
-        }
-    }
-
-    if ( cell )
-    {
-        int preDrawFlags = flags;
+    property->GetDisplayInfo(column, item, flags, &text, &cell);

 
 

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

 
 

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

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


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

 {
 {

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


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

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

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


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


@@ -505,27 +658,92 @@ void wxPGProperty::RefreshChildren ()
 {
 }
 
 {
 }
 

-wxString wxPGProperty::GetColumnText( unsigned int col ) const
+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();


@@ -545,11 +763,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() )


@@ -579,33 +850,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


@@ -626,6 +918,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;


@@ -660,7 +957,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;


@@ -693,41 +990,35 @@ 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());
+                    variant.SetName(child->GetBaseName());
+

                 #ifdef __WXDEBUG__
                     if ( debug_print )
                         wxLogDebug(wxT("token = '%s', child = %s"),token.c_str(),child->GetLabel().c_str());
                 #endif
 
                 #ifdef __WXDEBUG__
                     if ( debug_print )
                         wxLogDebug(wxT("token = '%s', child = %s"),token.c_str(),child->GetLabel().c_str());
                 #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();
-                            }
+                                list.Append(variant);

 
 

+                                changed = true;
+                            }
+                        }
+                        else
+                        {
+                            // Empty, becomes unspecified
+                            variant.MakeNull();

                             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 )


@@ -750,7 +1041,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;
 


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

-                        it++;
+                        ++it;

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


@@ -776,17 +1067,22 @@ 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 )
+                        bool stvRes = child->StringToValue( variant, token, propagatedFlags );
+                        if ( stvRes || (variant != oldChildValue) )
+                        {
+                            if ( stvRes )
+                                changed = true;
+                        }
+                        else
+                        {
+                            // Failed, becomes unspecified
+                            variant.MakeNull();

                             changed = true;
                             changed = true;

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

                     }
 
                     variant.SetName(child->GetBaseName());
                     }
 
                     variant.SetName(child->GetBaseName());


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

-                        it--;
+                        --it;

                     }
                 }
             }
                     }
                 }
             }


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

-        it++;
+        ++it;

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


@@ -941,7 +1237,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);


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

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

 {
 {

-    if ( column >= (int)m_cells.size() )
-        m_cells.SetCount(column+1, NULL);
+    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;

 
 

-    delete (wxPGCell*) m_cells[column];
-    m_cells[column] = cellObj;
+        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 ( m_cells.size() > column )
+        return m_cells[column];
+
+    wxPropertyGrid* pg = GetGrid();
+
+    if ( IsCategory() )
+        return pg->GetCategoryDefaultCell();
+
+    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


@@ -1561,7 +2013,7 @@ void wxPGProperty::AddChild2( wxPGProperty* prop, int index, bool correct_mode )
     else
     {
         m_children.insert( m_children.begin()+index, prop);
     else
     {
         m_children.insert( m_children.begin()+index, prop);

-        if ( correct_mode ) FixIndecesOfChildren( index );
+        if ( correct_mode ) FixIndicesOfChildren( index );

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


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

-void wxPGProperty::FixIndecesOfChildren( unsigned int starthere )
+void wxPGProperty::FixIndicesOfChildren( unsigned int starthere )

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


@@ -1824,6 +2276,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


@@ -1853,7 +2316,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 )


@@ -1894,7 +2357,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();
     }


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

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

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


@@ -1992,7 +2387,13 @@ void wxPGProperty::SubPropsChanged( int oldSelInd )
     wxPropertyGridPageState* state = GetParentState();
     wxPropertyGrid* grid = state->GetGrid();
 
     wxPropertyGridPageState* state = GetParentState();
     wxPropertyGrid* grid = state->GetGrid();
 

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

 
     wxPGProperty* sel = (wxPGProperty*) NULL;
     if ( oldSelInd >= (int)m_children.size() )
 
     wxPGProperty* sel = (wxPGProperty*) NULL;
     if ( oldSelInd >= (int)m_children.size() )


@@ -2070,7 +2471,8 @@ wxPropertyCategory::~wxPropertyCategory()
 }
 
 
 }
 
 

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

 {
     return wxEmptyString;
 }
 {
     return wxEmptyString;
 }


@@ -2103,7 +2505,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();