]> git.saurik.com Git - wxWidgets.git/blobdiff - src/propgrid/property.cpp
Add support for stretchable spaces to wxToolBar.
[wxWidgets.git] / src / propgrid / property.cpp
index 328084687586732832936a0c784d045ae464c334..09f4bc8ba86266680fcf094e64ff5bdba669cf2f 100644 (file)
@@ -94,8 +94,6 @@ wxSize wxPGCellRenderer::GetImageSize( const wxPGProperty* WXUNUSED(property),
 void wxPGCellRenderer::DrawText( wxDC& dc, const wxRect& rect,
                                  int xOffset, const wxString& text ) const
 {
 void wxPGCellRenderer::DrawText( wxDC& dc, const wxRect& rect,
                                  int xOffset, const wxString& text ) const
 {
-    if ( xOffset )
-        xOffset += wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2;
     dc.DrawText( text,
                  rect.x+xOffset+wxPG_XBEFORETEXT,
                  rect.y+((rect.height-dc.GetCharHeight())/2) );
     dc.DrawText( text,
                  rect.x+xOffset+wxPG_XBEFORETEXT,
                  rect.y+((rect.height-dc.GetCharHeight())/2) );
@@ -106,14 +104,11 @@ void wxPGCellRenderer::DrawEditorValue( wxDC& dc, const wxRect& rect,
                                         wxPGProperty* property,
                                         const wxPGEditor* editor ) const
 {
                                         wxPGProperty* property,
                                         const wxPGEditor* editor ) const
 {
-    if ( xOffset )
-        xOffset += wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2;
-
     int yOffset = ((rect.height-dc.GetCharHeight())/2);
 
     if ( editor )
     {
     int yOffset = ((rect.height-dc.GetCharHeight())/2);
 
     if ( editor )
     {
-        wxRect rect2(rect); 
+        wxRect rect2(rect);
         rect2.x += xOffset;
         rect2.y += yOffset;
         rect2.height -= yOffset;
         rect2.x += xOffset;
         rect2.y += yOffset;
         rect2.height -= yOffset;
@@ -135,7 +130,7 @@ void wxPGCellRenderer::DrawCaptionSelectionRect( wxDC& dc, int x, int y, int w,
 
 int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell& cell, int flags ) const
 {
 
 int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell& cell, int flags ) const
 {
-    int imageOffset = 0;
+    int imageWidth = 0;
 
     // If possible, use cell colours
     if ( !(flags & DontUseCellBgCol) )
 
     // If possible, use cell colours
     if ( !(flags & DontUseCellBgCol) )
@@ -149,8 +144,15 @@ int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell&
         dc.SetTextForeground(cell.GetFgCol());
     }
 
         dc.SetTextForeground(cell.GetFgCol());
     }
 
-    // Draw Background
-    dc.DrawRectangle(rect);
+    // Draw Background, but only if not rendering in control
+    // (as control already has rendered correct background).
+    if ( !(flags & (Control|ChoicePopup)) )
+        dc.DrawRectangle(rect);
+
+    // Use cell font, if provided
+    const wxFont& font = cell.GetFont();
+    if ( font.IsOk() )
+        dc.SetFont(font);
 
     const wxBitmap& bmp = cell.GetBitmap();
     if ( bmp.Ok() &&
 
     const wxBitmap& bmp = cell.GetBitmap();
     if ( bmp.Ok() &&
@@ -162,10 +164,21 @@ int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell&
                        rect.x + wxPG_CONTROL_MARGIN + wxCC_CUSTOM_IMAGE_MARGIN1,
                        rect.y + wxPG_CUSTOM_IMAGE_SPACINGY,
                        true );
                        rect.x + wxPG_CONTROL_MARGIN + wxCC_CUSTOM_IMAGE_MARGIN1,
                        rect.y + wxPG_CUSTOM_IMAGE_SPACINGY,
                        true );
-        imageOffset = bmp.GetWidth();
+        imageWidth = bmp.GetWidth();
     }
 
     }
 
-    return imageOffset;
+    return imageWidth;
+}
+
+void wxPGCellRenderer::PostDrawCell( wxDC& dc,
+                                     const wxPropertyGrid* propGrid,
+                                     const wxPGCell& cell,
+                                     int WXUNUSED(flags) ) const
+{
+    // Revert font
+    const wxFont& font = cell.GetFont();
+    if ( font.IsOk() )
+        dc.SetFont(propGrid->GetFont());
 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------
@@ -194,12 +207,12 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
     const wxPGCell* cell = NULL;
 
     wxString text;
     const wxPGCell* cell = NULL;
 
     wxString text;
-    int imageOffset = 0;
+    int imageWidth = 0;
     int preDrawFlags = flags;
 
     property->GetDisplayInfo(column, item, flags, &text, &cell);
 
     int preDrawFlags = flags;
 
     property->GetDisplayInfo(column, item, flags, &text, &cell);
 
-    imageOffset = PreDrawCell( dc, rect, *cell, preDrawFlags );
+    imageWidth = PreDrawCell( dc, rect, *cell, preDrawFlags );
 
     if ( column == 1 )
     {
 
     if ( column == 1 )
     {
@@ -227,17 +240,9 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
                 paintdata.m_drawnWidth = imageSize.x;
                 paintdata.m_drawnHeight = imageSize.y;
 
                 paintdata.m_drawnWidth = imageSize.x;
                 paintdata.m_drawnHeight = imageSize.y;
 
-                if ( !isUnspecified )
-                {
-                    property->OnCustomPaint( dc, imageRect, paintdata );
-                }
-                else
-                {
-                    dc.SetBrush(*wxWHITE_BRUSH);
-                    dc.DrawRectangle(imageRect);
-                }
+                property->OnCustomPaint( dc, imageRect, paintdata );
 
 
-                imageOffset = paintdata.m_drawnWidth;
+                imageWidth = paintdata.m_drawnWidth;
             }
 
             text = property->GetValueAsString();
             }
 
             text = property->GetValueAsString();
@@ -263,6 +268,8 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
         }
     }
 
         }
     }
 
+    int imageOffset = property->GetImageOffset(imageWidth);
+
     DrawEditorValue( dc, rect, imageOffset, text, property, editor );
 
     // active caption gets nice dotted rectangle
     DrawEditorValue( dc, rect, imageOffset, text, property, editor );
 
     // active caption gets nice dotted rectangle
@@ -271,7 +278,10 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
         if ( flags & Selected )
         {
             if ( imageOffset > 0 )
         if ( flags & Selected )
         {
             if ( imageOffset > 0 )
+            {
+                imageOffset -= DEFAULT_IMAGE_OFFSET_INCREMENT;
                 imageOffset += wxCC_CUSTOM_IMAGE_MARGIN2 + 4;
                 imageOffset += wxCC_CUSTOM_IMAGE_MARGIN2 + 4;
+            }
 
             DrawCaptionSelectionRect( dc,
                                       rect.x+wxPG_XBEFORETEXT-wxPG_CAPRECTXMARGIN+imageOffset,
 
             DrawCaptionSelectionRect( dc,
                                       rect.x+wxPG_XBEFORETEXT-wxPG_CAPRECTXMARGIN+imageOffset,
@@ -282,6 +292,8 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
                                       propertyGrid->GetFontHeight()+(wxPG_CAPRECTYMARGIN*2) );
         }
     }
                                       propertyGrid->GetFontHeight()+(wxPG_CAPRECTYMARGIN*2) );
         }
     }
+
+    PostDrawCell(dc, propertyGrid, *cell, preDrawFlags);
 }
 
 wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,
 }
 
 wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,
@@ -368,6 +380,13 @@ void wxPGCell::SetFgCol( const wxColour& col )
     GetData()->SetFgCol(col);
 }
 
     GetData()->SetFgCol(col);
 }
 
+void wxPGCell::SetFont( const wxFont& font )
+{
+    AllocExclusive();
+
+    GetData()->SetFont(font);
+}
+
 void wxPGCell::SetBgCol( const wxColour& col )
 {
     AllocExclusive();
 void wxPGCell::SetBgCol( const wxColour& col )
 {
     AllocExclusive();
@@ -408,16 +427,16 @@ void wxPGProperty::Init()
     m_arrIndex = 0xFFFF;
     m_parent = NULL;
 
     m_arrIndex = 0xFFFF;
     m_parent = NULL;
 
-    m_parentState = (wxPropertyGridPageState*) NULL;
+    m_parentState = NULL;
 
     m_clientData = NULL;
     m_clientObject = NULL;
 
 
     m_clientData = NULL;
     m_clientObject = NULL;
 
-    m_customEditor = (wxPGEditor*) NULL;
+    m_customEditor = NULL;
 #if wxUSE_VALIDATORS
 #if wxUSE_VALIDATORS
-    m_validator = (wxValidator*) NULL;
+    m_validator = NULL;
 #endif
 #endif
-    m_valueBitmap = (wxBitmap*) NULL;
+    m_valueBitmap = NULL;
 
     m_maxLen = 0; // infinite maximum length
 
 
     m_maxLen = 0; // infinite maximum length
 
@@ -545,10 +564,12 @@ void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState,
     if ( GetChildCount() )
     {
         // Check parental flags
     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()." );
+        wxASSERT_MSG( ((m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
+                            wxPG_PROP_AGGREGATE) ||
+                      ((m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
+                            wxPG_PROP_MISC_PARENT),
+                      "wxPGProperty parental flags set incorrectly at "
+                      "this time" );
 
         if ( HasFlag(wxPG_PROP_AGGREGATE) )
         {
 
         if ( HasFlag(wxPG_PROP_AGGREGATE) )
         {
@@ -617,6 +638,15 @@ bool wxPGProperty::IsSomeParent( wxPGProperty* candidate ) const
     return false;
 }
 
     return false;
 }
 
+void wxPGProperty::SetName( const wxString& newName )
+{
+    wxPropertyGrid* pg = GetGrid();
+
+    if ( pg )
+        pg->SetPropertyName(this, newName);
+    else
+        DoSetName(newName);
+}
 
 wxString wxPGProperty::GetName() const
 {
 
 wxString wxPGProperty::GetName() const
 {
@@ -645,12 +675,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;
@@ -664,6 +688,10 @@ void wxPGProperty::RefreshChildren ()
 {
 }
 
 {
 }
 
+void wxPGProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) )
+{
+}
+
 void wxPGProperty::GetDisplayInfo( unsigned int column,
                                    int choiceIndex,
                                    int flags,
 void wxPGProperty::GetDisplayInfo( unsigned int column,
                                    int choiceIndex,
                                    int flags,
@@ -718,7 +746,7 @@ void wxPGProperty::GetDisplayInfo( unsigned int column,
 /*
 wxString wxPGProperty::GetColumnText( unsigned int col, int choiceIndex ) const
 {
 /*
 wxString wxPGProperty::GetColumnText( unsigned int col, int choiceIndex ) const
 {
-    
+
     if ( col != 1 || choiceIndex == wxNOT_FOUND )
     {
         const wxPGCell& cell = GetCell(col);
     if ( col != 1 || choiceIndex == wxNOT_FOUND )
     {
         const wxPGCell& cell = GetCell(col);
@@ -796,7 +824,7 @@ void wxPGProperty::DoGenerateComposedValue( 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
@@ -824,7 +852,7 @@ void wxPGProperty::DoGenerateComposedValue( wxString& text,
                                             argFlags|wxPG_COMPOSITE_FRAGMENT);
             }
         }
                                             argFlags|wxPG_COMPOSITE_FRAGMENT);
             }
         }
+
         if ( childResults && curChild->GetChildCount() )
             (*childResults)[curChild->GetName()] = s;
 
         if ( childResults && curChild->GetChildCount() )
             (*childResults)[curChild->GetName()] = s;
 
@@ -856,13 +884,13 @@ void wxPGProperty::DoGenerateComposedValue( 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),
@@ -965,14 +993,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
     int propagatedFlags = argFlags & (wxPG_REPORT_ERROR|wxPG_PROGRAMMATIC_VALUE);
 
 
     int propagatedFlags = argFlags & (wxPG_REPORT_ERROR|wxPG_PROGRAMMATIC_VALUE);
 
-#ifdef __WXDEBUG__
-    bool debug_print = false;
-#endif
-
-#ifdef __WXDEBUG__
-    if ( debug_print )
-        wxLogDebug(wxT(">> %s.StringToValue('%s')"),GetLabel().c_str(),text.c_str());
-#endif
+    wxLogTrace("propgrid",
+               wxT(">> %s.StringToValue('%s')"), GetLabel(), text);
 
     wxString::const_iterator it = text.begin();
     wxUniChar a;
 
     wxString::const_iterator it = text.begin();
     wxUniChar a;
@@ -984,6 +1006,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
@@ -997,12 +1024,11 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                 {
                     const wxPGProperty* child = Item(curChild);
                     wxVariant variant(child->GetValue());
                 {
                     const wxPGProperty* child = Item(curChild);
                     wxVariant variant(child->GetValue());
-                    variant.SetName(child->GetBaseName());
+                    wxString childName = child->GetBaseName();
 
 
-                #ifdef __WXDEBUG__
-                    if ( debug_print )
-                        wxLogDebug(wxT("token = '%s', child = %s"),token.c_str(),child->GetLabel().c_str());
-                #endif
+                    wxLogTrace("propgrid",
+                               wxT("token = '%s', child = %s"),
+                               token, childName);
 
                     // Add only if editable or setting programmatically
                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
 
                     // Add only if editable or setting programmatically
                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
@@ -1010,18 +1036,18 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                     {
                         if ( len > 0 )
                         {
                     {
                         if ( len > 0 )
                         {
-                            bool wasUnspecified = child->IsValueUnspecified();
-
-                            if ( child->StringToValue(variant, token, propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )
+                            if ( child->StringToValue(variant, token,
+                                 propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )
                             {
                             {
-                                // Clear unspecified flag only if OnSetValue() didn't
-                                // affect it.
-                                if ( child->IsValueUnspecified() &&
-                                     (wasUnspecified || !UsesAutoUnspecified()) )
-                                {
-                                    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;
                                 list.Append(variant);
 
                                 changed = true;
@@ -1031,6 +1057,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                         {
                             // Empty, becomes unspecified
                             variant.MakeNull();
                         {
                             // Empty, becomes unspecified
                             variant.MakeNull();
+                            variant.SetName(childName);
                             list.Append(variant);
                             changed = true;
                         }
                             list.Append(variant);
                             changed = true;
                         }
@@ -1057,7 +1084,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;
 
@@ -1065,7 +1092,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(']') )
@@ -1087,23 +1114,23 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
                          !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
                     {
                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
                          !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
                     {
-                        bool stvRes = child->StringToValue( variant, token, propagatedFlags );
+                        wxString childName = child->GetBaseName();
+
+                        bool stvRes = child->StringToValue( variant, token,
+                                                            propagatedFlags );
                         if ( stvRes || (variant != oldChildValue) )
                         {
                         if ( stvRes || (variant != oldChildValue) )
                         {
-                            if ( stvRes )
-                                changed = true;
+                            variant.SetName(childName);
+                            list.Append(variant);
+
+                            changed = true;
                         }
                         else
                         {
                         }
                         else
                         {
-                            // Failed, becomes unspecified
-                            variant.MakeNull();
-                            changed = true;
+                            // No changes...
                         }
                     }
 
                         }
                     }
 
-                    variant.SetName(child->GetBaseName());
-                    list.Append(variant);
-
                     curChild++;
                     if ( curChild >= iMax )
                         break;
                     curChild++;
                     if ( curChild >= iMax )
                         break;
@@ -1117,10 +1144,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                     tokenStart = pos;
 
                     if ( a == delimeter )
                     tokenStart = pos;
 
                     if ( a == delimeter )
-                    {
-                        pos--;
-                        it--;
-                    }
+                        strPosIncrement -= 1;
                 }
             }
         }
                 }
             }
         }
@@ -1128,7 +1152,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;
@@ -1137,7 +1162,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
         {
             a = 0;
         }
         {
             a = 0;
         }
-        pos++;
+
+        pos += strPosIncrement;
     }
 
     if ( changed )
     }
 
     if ( changed )
@@ -1172,6 +1198,22 @@ wxSize wxPGProperty::OnMeasureImage( int WXUNUSED(item) ) const
     return wxSize(0,0);
 }
 
     return wxSize(0,0);
 }
 
+int wxPGProperty::GetImageOffset( int imageWidth ) const
+{
+    int imageOffset = 0;
+
+    if ( imageWidth )
+    {
+        // Do not increment offset too much for wide images
+        if ( imageWidth <= (wxPG_CUSTOM_IMAGE_WIDTH+5) )
+            imageOffset = imageWidth + DEFAULT_IMAGE_OFFSET_INCREMENT;
+        else
+            imageOffset = imageWidth + 1;
+    }
+
+    return imageOffset;
+}
+
 wxPGCellRenderer* wxPGProperty::GetCellRenderer( int WXUNUSED(column) ) const
 {
     return wxPGGlobalVars->m_defaultRenderer;
 wxPGCellRenderer* wxPGProperty::GetCellRenderer( int WXUNUSED(column) ) const
 {
     return wxPGGlobalVars->m_defaultRenderer;
@@ -1253,7 +1295,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);
@@ -1291,9 +1333,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 )
@@ -1323,13 +1362,21 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
         }
     }
 
         }
     }
 
+    if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
+        UpdateParentValues();
+
     //
     // Update editor control
     //
 
     // We need to check for these, otherwise GetGrid() may fail.
     if ( flags & wxPG_SETVAL_REFRESH_EDITOR )
     //
     // Update editor control
     //
 
     // We need to check for these, otherwise GetGrid() may fail.
     if ( flags & wxPG_SETVAL_REFRESH_EDITOR )
+    {
         RefreshEditor();
         RefreshEditor();
+        wxPropertyGrid* pg = GetGridIfDisplayed();
+        if ( pg )
+            pg->DrawItemAndValueRelated(this);
+    }
 }
 
 
 }
 
 
@@ -1340,10 +1387,7 @@ void wxPGProperty::SetValueInEvent( wxVariant value ) const
 
 void wxPGProperty::SetFlagRecursively( FlagType flag, bool set )
 {
 
 void wxPGProperty::SetFlagRecursively( FlagType flag, bool set )
 {
-    if ( set )
-        SetFlag(flag);
-    else
-        ClearFlag(flag);
+    ChangeFlag(flag, set);
 
     unsigned int i;
     for ( i = 0; i < GetChildCount(); i++ )
 
     unsigned int i;
     for ( i = 0; i < GetChildCount(); i++ )
@@ -1352,22 +1396,17 @@ 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
 {
-    wxVariant defVal = GetAttribute(wxS("DefaultValue"));
+    wxVariant defVal = GetAttribute(wxPG_ATTR_DEFAULT_VALUE);
     if ( !defVal.IsNull() )
         return defVal;
 
     if ( !defVal.IsNull() )
         return defVal;
 
@@ -1416,10 +1455,14 @@ void wxPGProperty::EnsureCells( unsigned int column )
         wxPropertyGrid* pg = GetGrid();
         wxPGCell defaultCell;
 
         wxPropertyGrid* pg = GetGrid();
         wxPGCell defaultCell;
 
+        // Work around possible VC6 bug by using intermediate variables
+        const wxPGCell& propDefCell = pg->GetPropertyDefaultCell();
+        const wxPGCell& catDefCell = pg->GetCategoryDefaultCell();
+
         if ( !HasFlag(wxPG_PROP_CATEGORY) )
         if ( !HasFlag(wxPG_PROP_CATEGORY) )
-            defaultCell = pg->GetPropertyDefaultCell();
+            defaultCell = propDefCell;
         else
         else
-            defaultCell = pg->GetCategoryDefaultCell();
+            defaultCell = catDefCell;
 
         // TODO: Replace with resize() call
         unsigned int cellCountMax = column+1;
 
         // TODO: Replace with resize() call
         unsigned int cellCountMax = column+1;
@@ -1497,16 +1540,17 @@ const wxPGCell& wxPGProperty::GetCell( unsigned int column ) const
     return pg->GetPropertyDefaultCell();
 }
 
     return pg->GetPropertyDefaultCell();
 }
 
-wxPGCell& wxPGProperty::GetCell( unsigned int column )
+wxPGCell& wxPGProperty::GetOrCreateCell( unsigned int column )
 {
     EnsureCells(column);
     return m_cells[column];
 }
 
 void wxPGProperty::SetBackgroundColour( const wxColour& colour,
 {
     EnsureCells(column);
     return m_cells[column];
 }
 
 void wxPGProperty::SetBackgroundColour( const wxColour& colour,
-                                        bool recursively )
+                                        int flags )
 {
     wxPGProperty* firstProp = this;
 {
     wxPGProperty* firstProp = this;
+    bool recursively = flags & wxPG_RECURSE ? true : false;
 
     //
     // If category is tried to set recursively, skip it and only
 
     //
     // If category is tried to set recursively, skip it and only
@@ -1539,9 +1583,10 @@ void wxPGProperty::SetBackgroundColour( const wxColour& colour,
 }
 
 void wxPGProperty::SetTextColour( const wxColour& colour,
 }
 
 void wxPGProperty::SetTextColour( const wxColour& colour,
-                                  bool recursively )
+                                  int flags )
 {
     wxPGProperty* firstProp = this;
 {
     wxPGProperty* firstProp = this;
+    bool recursively = flags & wxPG_RECURSE ? true : false;
 
     //
     // If category is tried to set recursively, skip it and only
 
     //
     // If category is tried to set recursively, skip it and only
@@ -1629,18 +1674,20 @@ long wxPGProperty::GetAttributeAsLong( const wxString& name, long defVal ) const
 {
     wxVariant variant = m_attributes.FindValue(name);
 
 {
     wxVariant variant = m_attributes.FindValue(name);
 
-    return wxPGVariantToInt(variant, defVal);
+    if ( variant.IsNull() )
+        return defVal;
+
+    return variant.GetLong();
 }
 
 double wxPGProperty::GetAttributeAsDouble( const wxString& name, double defVal ) const
 {
 }
 
 double wxPGProperty::GetAttributeAsDouble( const wxString& name, double defVal ) const
 {
-    double retVal;
     wxVariant variant = m_attributes.FindValue(name);
 
     wxVariant variant = m_attributes.FindValue(name);
 
-    if ( wxPGVariantToDouble(variant, &retVal) )
-        return retVal;
+    if ( variant.IsNull() )
+        return defVal;
 
 
-    return defVal;
+    return variant.GetDouble();
 }
 
 wxVariant wxPGProperty::GetAttributesAsList() const
 }
 
 wxVariant wxPGProperty::GetAttributesAsList() const
@@ -1660,7 +1707,7 @@ wxVariant wxPGProperty::GetAttributesAsList() const
 // Slots of utility flags are NULL
 const unsigned int gs_propFlagToStringSize = 14;
 
 // Slots of utility flags are NULL
 const unsigned int gs_propFlagToStringSize = 14;
 
-static const wxChar* gs_propFlagToString[gs_propFlagToStringSize] = {
+static const wxChar* const gs_propFlagToString[gs_propFlagToStringSize] = {
     NULL,
     wxT("DISABLED"),
     wxT("HIDDEN"),
     NULL,
     wxT("DISABLED"),
     wxT("HIDDEN"),
@@ -1722,7 +1769,7 @@ void wxPGProperty::SetFlagsFromString( const wxString& str )
 
 wxValidator* wxPGProperty::DoGetValidator() const
 {
 
 wxValidator* wxPGProperty::DoGetValidator() const
 {
-    return (wxValidator*) NULL;
+    return NULL;
 }
 
 int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
 }
 
 int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
@@ -1905,7 +1952,7 @@ void wxPGProperty::SetValueImage( wxBitmap& bmp )
         wxSize maxSz = GetGrid()->GetImageSize();
         wxSize imSz(bmp.GetWidth(),bmp.GetHeight());
 
         wxSize maxSz = GetGrid()->GetImageSize();
         wxSize imSz(bmp.GetWidth(),bmp.GetHeight());
 
-        if ( imSz.x != maxSz.x || imSz.y != maxSz.y )
+        if ( imSz.y != maxSz.y )
         {
             // Create a memory DC
             wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth());
         {
             // Create a memory DC
             wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth());
@@ -1915,12 +1962,11 @@ void wxPGProperty::SetValueImage( wxBitmap& bmp )
 
             // Scale
             // FIXME: This is ugly - use image or wait for scaling patch.
 
             // Scale
             // FIXME: This is ugly - use image or wait for scaling patch.
-            double scaleX = (double)maxSz.x / (double)imSz.x;
             double scaleY = (double)maxSz.y / (double)imSz.y;
 
             double scaleY = (double)maxSz.y / (double)imSz.y;
 
-            dc.SetUserScale(scaleX,scaleY);
+            dc.SetUserScale(scaleY, scaleY);
 
 
-            dc.DrawBitmap( bmp, 0, 0 );
+            dc.DrawBitmap(bmp, 0, 0);
 
             m_valueBitmap = bmpNew;
         }
 
             m_valueBitmap = bmpNew;
         }
@@ -1984,6 +2030,8 @@ bool wxPGProperty::IsVisible() const
 wxPropertyGrid* wxPGProperty::GetGridIfDisplayed() const
 {
     wxPropertyGridPageState* state = GetParentState();
 wxPropertyGrid* wxPGProperty::GetGridIfDisplayed() const
 {
     wxPropertyGridPageState* state = GetParentState();
+    if ( !state )
+        return NULL;
     wxPropertyGrid* propGrid = state->GetGrid();
     if ( state == propGrid->GetState() )
         return propGrid;
     wxPropertyGrid* propGrid = state->GetGrid();
     if ( state == propGrid->GetState() )
         return propGrid;
@@ -2019,7 +2067,8 @@ int wxPGProperty::GetY() const
 }
 
 // This is used by Insert etc.
 }
 
 // This is used by Insert etc.
-void wxPGProperty::AddChild2( wxPGProperty* prop, int index, bool correct_mode )
+void wxPGProperty::DoAddChild( wxPGProperty* prop, int index,
+                               bool correct_mode )
 {
     if ( index < 0 || (size_t)index >= m_children.size() )
     {
 {
     if ( index < 0 || (size_t)index >= m_children.size() )
     {
@@ -2035,14 +2084,15 @@ void wxPGProperty::AddChild2( wxPGProperty* prop, int index, bool correct_mode )
     prop->m_parent = this;
 }
 
     prop->m_parent = this;
 }
 
-// This is used by properties that have fixed sub-properties
-void wxPGProperty::AddChild( wxPGProperty* prop )
+void wxPGProperty::DoPreAddChild( int index, wxPGProperty* prop )
 {
     wxASSERT_MSG( prop->GetBaseName().length(),
 {
     wxASSERT_MSG( prop->GetBaseName().length(),
-                  "Property's children must have unique, non-empty names within their scope" );
+                  "Property's children must have unique, non-empty "
+                  "names within their scope" );
 
 
-    prop->m_arrIndex = m_children.size();
-    m_children.push_back( prop );
+    prop->m_arrIndex = index;
+    m_children.insert( m_children.begin()+index,
+                       prop );
 
     int custImgHeight = prop->OnMeasureImage().y;
     if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )
 
     int custImgHeight = prop->OnMeasureImage().y;
     if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )
@@ -2051,6 +2101,52 @@ void wxPGProperty::AddChild( wxPGProperty* prop )
     prop->m_parent = this;
 }
 
     prop->m_parent = this;
 }
 
+void wxPGProperty::AddPrivateChild( wxPGProperty* prop )
+{
+    if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
+        SetParentalType(wxPG_PROP_AGGREGATE);
+
+    wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
+                    wxPG_PROP_AGGREGATE,
+                  "Do not mix up AddPrivateChild() calls with other "
+                  "property adders." );
+
+    DoPreAddChild( m_children.size(), prop );
+}
+
+#if wxPG_COMPATIBILITY_1_4
+void wxPGProperty::AddChild( wxPGProperty* prop )
+{
+    AddPrivateChild(prop);
+}
+#endif
+
+wxPGProperty* wxPGProperty::InsertChild( int index,
+                                         wxPGProperty* childProperty )
+{
+    if ( index < 0 )
+        index = m_children.size();
+
+    if ( m_parentState )
+    {
+        m_parentState->DoInsert(this, index, childProperty);
+    }
+    else
+    {
+        if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
+            SetParentalType(wxPG_PROP_MISC_PARENT);
+
+        wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
+                        wxPG_PROP_MISC_PARENT,
+                      "Do not mix up AddPrivateChild() calls with other "
+                      "property adders." );
+
+        DoPreAddChild( index, childProperty );
+    }
+
+    return childProperty;
+}
+
 void wxPGProperty::RemoveChild( wxPGProperty* p )
 {
     wxArrayPGProperty::iterator it;
 void wxPGProperty::RemoveChild( wxPGProperty* p )
 {
     wxArrayPGProperty::iterator it;
@@ -2060,7 +2156,7 @@ void wxPGProperty::RemoveChild( wxPGProperty* p )
     {
         if ( *it == p )
         {
     {
         if ( *it == p )
         {
-            m_children.erase(it);
+            children.erase(it);
             break;
         }
     }
             break;
         }
     }
@@ -2109,7 +2205,10 @@ void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
             }
 
             if ( allChildrenSpecified )
             }
 
             if ( allChildrenSpecified )
-                ChildChanged(*value, i, childValue);
+            {
+                *value = ChildChanged(*value, i, childValue);
+            }
+
             n++;
             if ( n == (unsigned int)list.GetCount() )
                 break;
             n++;
             if ( n == (unsigned int)list.GetCount() )
                 break;
@@ -2142,7 +2241,7 @@ wxPGProperty* wxPGProperty::GetPropertyByName( const wxString& name ) const
     // Does it have point, then?
     int pos = name.Find(wxS('.'));
     if ( pos <= 0 )
     // Does it have point, then?
     int pos = name.Find(wxS('.'));
     if ( pos <= 0 )
-        return (wxPGProperty*) NULL;
+        return NULL;
 
     wxPGProperty* p = GetPropertyByName(name. substr(0,pos));
 
 
     wxPGProperty* p = GetPropertyByName(name. substr(0,pos));
 
@@ -2220,7 +2319,9 @@ int wxPGProperty::GetChildrenHeight( int lh, int iMax_ ) const
     return h;
 }
 
     return h;
 }
 
-wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y, unsigned int lh, unsigned int* nextItemY ) const
+wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y,
+                                        unsigned int lh,
+                                        unsigned int* nextItemY ) const
 {
     wxASSERT( nextItemY );
 
 {
     wxASSERT( nextItemY );
 
@@ -2270,9 +2371,13 @@ wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y, unsigned int lh, unsigne
 
     /*
     if ( current )
 
     /*
     if ( current )
+    {
         wxLogDebug(wxT("%s::GetItemAtY(%i) -> %s"),this->GetLabel().c_str(),y,current->GetLabel().c_str());
         wxLogDebug(wxT("%s::GetItemAtY(%i) -> %s"),this->GetLabel().c_str(),y,current->GetLabel().c_str());
+    }
     else
     else
+    {
         wxLogDebug(wxT("%s::GetItemAtY(%i) -> NULL"),this->GetLabel().c_str(),y);
         wxLogDebug(wxT("%s::GetItemAtY(%i) -> NULL"),this->GetLabel().c_str(),y);
+    }
     */
 
     return (wxPGProperty*) result;
     */
 
     return (wxPGProperty*) result;
@@ -2292,10 +2397,28 @@ void wxPGProperty::Empty()
     m_children.clear();
 }
 
     m_children.clear();
 }
 
-void wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
-                                 int WXUNUSED(childIndex),
-                                 wxVariant& WXUNUSED(childValue) ) const
+wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y ) const
+{
+    unsigned int nextItem;
+    return GetItemAtY( y, GetGrid()->GetRowHeight(), &nextItem);
+}
+
+void wxPGProperty::DeleteChildren()
+{
+    wxPropertyGridPageState* state = m_parentState;
+
+    while ( GetChildCount() )
+    {
+        wxPGProperty* child = Item(GetChildCount()-1);
+        state->DoDelete(child, true);
+    }
+}
+
+wxVariant wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
+                                      int WXUNUSED(childIndex),
+                                      wxVariant& WXUNUSED(childValue) ) const
 {
 {
+    return wxNullVariant;
 }
 
 bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
 }
 
 bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
@@ -2321,7 +2444,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 )
@@ -2400,7 +2523,7 @@ void wxPGProperty::SubPropsChanged( int oldSelInd )
         child->InitAfterAdded(state, grid);
     }
 
         child->InitAfterAdded(state, grid);
     }
 
-    wxPGProperty* sel = (wxPGProperty*) NULL;
+    wxPGProperty* sel = NULL;
     if ( oldSelInd >= (int)m_children.size() )
         oldSelInd = (int)m_children.size() - 1;
 
     if ( oldSelInd >= (int)m_children.size() )
         oldSelInd = (int)m_children.size() - 1;
 
@@ -2426,12 +2549,11 @@ WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPGRootProperty,none,TextCtrl)
 IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
 
 
-wxPGRootProperty::wxPGRootProperty()
+wxPGRootProperty::wxPGRootProperty( const wxString& name )
     : wxPGProperty()
 {
     : wxPGProperty()
 {
-#ifdef __WXDEBUG__
-    m_name = wxS("<root>");
-#endif
+    m_name = name;
+    m_label = m_name;
     SetParentalType(0);
     m_depth = 0;
 }
     SetParentalType(0);
     m_depth = 0;
 }
@@ -2487,17 +2609,281 @@ int wxPropertyCategory::GetTextExtent( const wxWindow* wnd, const wxFont& font )
     if ( m_textExtent > 0 )
         return m_textExtent;
     int x = 0, y = 0;
     if ( m_textExtent > 0 )
         return m_textExtent;
     int x = 0, y = 0;
-       ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font );
+    ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font );
     return x;
 }
 
 void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& font )
 {
     int x = 0, y = 0;
     return x;
 }
 
 void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& font )
 {
     int x = 0, y = 0;
-       wnd->GetTextExtent( m_label, &x, &y, 0, 0, &font );
+    wnd->GetTextExtent( m_label, &x, &y, 0, 0, &font );
     m_textExtent = x;
 }
 
     m_textExtent = x;
 }
 
+// -----------------------------------------------------------------------
+// wxPGChoices
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, int value )
+{
+    AllocExclusive();
+
+    wxPGChoiceEntry entry(label, value);
+    return m_data->Insert( -1, entry );
+}
+
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, const wxBitmap& bitmap, int value )
+{
+    AllocExclusive();
+
+    wxPGChoiceEntry entry(label, value);
+    entry.SetBitmap(bitmap);
+    return m_data->Insert( -1, entry );
+}
+
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::Insert( const wxPGChoiceEntry& entry, int index )
+{
+    AllocExclusive();
+
+    return m_data->Insert( index, entry );
+}
+
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::Insert( const wxString& label, int index, int value )
+{
+    AllocExclusive();
+
+    wxPGChoiceEntry entry(label, value);
+    return m_data->Insert( index, entry );
+}
+
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::AddAsSorted( const wxString& label, int value )
+{
+    AllocExclusive();
+
+    size_t index = 0;
+
+    while ( index < GetCount() )
+    {
+        int cmpRes = GetLabel(index).Cmp(label);
+        if ( cmpRes > 0 )
+            break;
+        index++;
+    }
+
+    wxPGChoiceEntry entry(label, value);
+    return m_data->Insert( index, entry );
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Add( const wxChar* const* labels, const ValArrItem* values )
+{
+    AllocExclusive();
+
+    unsigned int itemcount = 0;
+    const wxChar* const* p = &labels[0];
+    while ( *p ) { p++; itemcount++; }
+
+    unsigned int i;
+    for ( i = 0; i < itemcount; i++ )
+    {
+        int value = i;
+        if ( values )
+            value = values[i];
+        wxPGChoiceEntry entry(labels[i], value);
+        m_data->Insert( i, entry );
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Add( const wxArrayString& arr, const wxArrayInt& arrint )
+{
+    AllocExclusive();
+
+    unsigned int i;
+    unsigned int itemcount = arr.size();
+
+    for ( i = 0; i < itemcount; i++ )
+    {
+        int value = i;
+        if ( &arrint && arrint.size() )
+            value = arrint[i];
+        wxPGChoiceEntry entry(arr[i], value);
+        m_data->Insert( i, entry );
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::RemoveAt(size_t nIndex, size_t count)
+{
+    AllocExclusive();
+
+    wxASSERT( m_data->GetRefCount() != -1 );
+    m_data->m_items.erase(m_data->m_items.begin()+nIndex,
+                          m_data->m_items.begin()+nIndex+count);
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Clear()
+{
+    if ( m_data != wxPGChoicesEmptyData )
+    {
+        AllocExclusive();
+        m_data->Clear();
+    }
+}
+
+// -----------------------------------------------------------------------
+
+int wxPGChoices::Index( const wxString& str ) const
+{
+    if ( IsOk() )
+    {
+        unsigned int i;
+        for ( i=0; i< m_data->GetCount(); i++ )
+        {
+            const wxPGChoiceEntry& entry = m_data->Item(i);
+            if ( entry.HasText() && entry.GetText() == str )
+                return i;
+        }
+    }
+    return -1;
+}
+
+// -----------------------------------------------------------------------
+
+int wxPGChoices::Index( int val ) const
+{
+    if ( IsOk() )
+    {
+        unsigned int i;
+        for ( i=0; i< m_data->GetCount(); i++ )
+        {
+            const wxPGChoiceEntry& entry = m_data->Item(i);
+            if ( entry.GetValue() == val )
+                return i;
+        }
+    }
+    return -1;
+}
+
+// -----------------------------------------------------------------------
+
+wxArrayString wxPGChoices::GetLabels() const
+{
+    wxArrayString arr;
+    unsigned int i;
+
+    if ( this && IsOk() )
+        for ( i=0; i<GetCount(); i++ )
+            arr.push_back(GetLabel(i));
+
+    return arr;
+}
+
+// -----------------------------------------------------------------------
+
+wxArrayInt wxPGChoices::GetValuesForStrings( const wxArrayString& strings ) const
+{
+    wxArrayInt arr;
+
+    if ( IsOk() )
+    {
+        unsigned int i;
+        for ( i=0; i< strings.size(); i++ )
+        {
+            int index = Index(strings[i]);
+            if ( index >= 0 )
+                arr.Add(GetValue(index));
+            else
+                arr.Add(wxPG_INVALID_VALUE);
+        }
+    }
+
+    return arr;
+}
+
+// -----------------------------------------------------------------------
+
+wxArrayInt wxPGChoices::GetIndicesForStrings( const wxArrayString& strings,
+                                              wxArrayString* unmatched ) const
+{
+    wxArrayInt arr;
+
+    if ( IsOk() )
+    {
+        unsigned int i;
+        for ( i=0; i< strings.size(); i++ )
+        {
+            const wxString& str = strings[i];
+            int index = Index(str);
+            if ( index >= 0 )
+                arr.Add(index);
+            else if ( unmatched )
+                unmatched->Add(str);
+        }
+    }
+
+    return arr;
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::AllocExclusive()
+{
+    EnsureData();
+
+    if ( m_data->GetRefCount() != 1 )
+    {
+        wxPGChoicesData* data = new wxPGChoicesData();
+        data->CopyDataFrom(m_data);
+        Free();
+        m_data = data;
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::AssignData( wxPGChoicesData* data )
+{
+    Free();
+
+    if ( data != wxPGChoicesEmptyData )
+    {
+        m_data = data;
+        data->IncRef();
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Init()
+{
+    m_data = wxPGChoicesEmptyData;
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Free()
+{
+    if ( m_data != wxPGChoicesEmptyData )
+    {
+        m_data->DecRef();
+        m_data = wxPGChoicesEmptyData;
+    }
+}
+
 // -----------------------------------------------------------------------
 // wxPGAttributeStorage
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPGAttributeStorage
 // -----------------------------------------------------------------------
@@ -2510,7 +2896,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();