rename various gsock* files to sock* (except for MSW where this will be done later)

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

diff --git a/src/propgrid/property.cpp b/src/propgrid/property.cpp
index d2ad9a372d8f024ca643c61a89170284135e85b0..53a26de39ffa726c53f994b3517d90bda3b28d03 100644 (file)
--- a/src/propgrid/property.cpp
+++ b/src/propgrid/property.cpp
@@ -137,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,


@@ -192,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->GetValueAsString();
-            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 )
         {


@@ -257,25 +224,12 @@ 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;
             }


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


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

 {
 }
 
 {
 }
 


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

 {
 {

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

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


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


@@ -436,10 +458,9 @@ void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState,
                   "Implement ValueToString() instead of GetValueAsString()" );
 #endif
 
                   "Implement ValueToString() instead of GetValueAsString()" );
 #endif
 

-    if ( !parentIsRoot )
+    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


@@ -517,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()." );


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


@@ -644,30 +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 wxVariantList* valueOverrides,
-                                          wxPGHashMapS2S* childResults ) 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();


@@ -714,7 +790,7 @@ void wxPGProperty::GenerateComposedValue( wxString& text,
                 childValue = overrideValue;
             else
                 childValue = curChild->GetValue();
                 childValue = overrideValue;
             else
                 childValue = curChild->GetValue();

-            node++;
+            ++node;

             if ( node != valueOverrides->end() )
                 overrideValue = *node;
             else
             if ( node != valueOverrides->end() )
                 overrideValue = *node;
             else


@@ -733,8 +809,8 @@ void wxPGProperty::GenerateComposedValue( wxString& text,
                  childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
             {
                 wxVariantList& childList = childValue.GetList();
                  childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
             {
                 wxVariantList& childList = childValue.GetList();

-                GenerateComposedValue(s, argFlags|wxPG_COMPOSITE_FRAGMENT,
-                                      &childList, childResults);
+                DoGenerateComposedValue(s, argFlags|wxPG_COMPOSITE_FRAGMENT,
+                                        &childList, childResults);

             }
             else
             {
             }
             else
             {


@@ -774,13 +850,13 @@ void wxPGProperty::GenerateComposedValue( wxString& text,
         }
     }
 
         }
     }
 

-    // 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::ValueToString( wxVariant& WXUNUSED(value),
 }
 
 wxString wxPGProperty::ValueToString( wxVariant& WXUNUSED(value),


@@ -797,7 +873,7 @@ wxString wxPGProperty::ValueToString( wxVariant& WXUNUSED(value),
                   "implementation only works if value is m_value." );
 
     wxString text;
                   "implementation only works if value is m_value." );
 
     wxString text;

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

     return text;
 }
 
     return text;
 }
 


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


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


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


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


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


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

-                        it--;
+                        --it;

                     }
                 }
             }
                     }
                 }
             }


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


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


@@ -1317,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 >= 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();
+
+    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);

 
 

-    delete (wxPGCell*) m_cells[column];
-    m_cells[column] = cellObj;
+    AdaptiveSetCell( 0,
+                     GetParentState()->GetColumnCount()-1,
+                     newCell,
+                     srcCell,
+                     firstCellData,
+                     recursively ? wxPG_PROP_CATEGORY : 0,
+                     recursively );

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


@@ -2074,7 +2305,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 )


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

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

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


@@ -2263,7 +2494,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();