Add support for wxHELP button to wxMessageDialog.

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

diff --git a/src/propgrid/property.cpp b/src/propgrid/property.cpp
index bfb0e446e9d8104d360e79f1ed3f90984a17ada4..1e4f0cdfacf536eaa6c2a6f4beb564535189abce 100644 (file)
--- a/src/propgrid/property.cpp
+++ b/src/propgrid/property.cpp
@@ -6,7 +6,7 @@
 // Created:     2008-08-23
 // RCS-ID:      $Id$
 // Copyright:   (c) Jaakko Salli
 // Created:     2008-08-23
 // RCS-ID:      $Id$
 // Copyright:   (c) Jaakko Salli

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 // For compilers that support precompilation, includes "wx/wx.h".
 /////////////////////////////////////////////////////////////////////////////
 
 // For compilers that support precompilation, includes "wx/wx.h".


@@ -24,6 +24,7 @@
     #include "wx/hash.h"
     #include "wx/string.h"
     #include "wx/log.h"
     #include "wx/hash.h"
     #include "wx/string.h"
     #include "wx/log.h"

+    #include "wx/math.h"

     #include "wx/event.h"
     #include "wx/window.h"
     #include "wx/panel.h"
     #include "wx/event.h"
     #include "wx/window.h"
     #include "wx/panel.h"


@@ -35,6 +36,8 @@
     #include "wx/intl.h"
 #endif
 
     #include "wx/intl.h"
 #endif
 

+#include "wx/image.h"
+

 #include "wx/propgrid/propgrid.h"
 
 
 #include "wx/propgrid/propgrid.h"
 
 


@@ -94,8 +97,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 +107,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,13 +133,14 @@ 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) )
     {

-        dc.SetPen(cell.GetBgCol());
-        dc.SetBrush(cell.GetBgCol());
+        const wxColour& bgCol = cell.GetBgCol();
+        dc.SetPen(bgCol);
+        dc.SetBrush(bgCol);

     }
 
     if ( !(flags & DontUseCellFgCol) )
     }
 
     if ( !(flags & DontUseCellFgCol) )


@@ -154,8 +153,13 @@ int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell&
     if ( !(flags & (Control|ChoicePopup)) )
         dc.DrawRectangle(rect);
 
     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();
     const wxBitmap& bmp = cell.GetBitmap();

-    if ( bmp.Ok() &&
+    if ( bmp.IsOk() &&

         // Do not draw oversized bitmap outside choice popup
          ((flags & ChoicePopup) || bmp.GetHeight() < rect.height )
         )
         // Do not draw oversized bitmap outside choice popup
          ((flags & ChoicePopup) || bmp.GetHeight() < rect.height )
         )


@@ -164,20 +168,35 @@ 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());

 }
 
 // -----------------------------------------------------------------------
 // wxPGDefaultRenderer
 // -----------------------------------------------------------------------
 
 }
 
 // -----------------------------------------------------------------------
 // wxPGDefaultRenderer
 // -----------------------------------------------------------------------
 

-void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
+bool wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,

                                   const wxPropertyGrid* propertyGrid, wxPGProperty* property,
                                   int column, int item, int flags ) const
 {
                                   const wxPropertyGrid* propertyGrid, wxPGProperty* property,
                                   int column, int item, int flags ) const
 {

+    const wxPGEditor* editor = NULL;
+    const wxPGCell* cell = NULL;
+
+    wxString text;

     bool isUnspecified = property->IsValueUnspecified();
 
     if ( column == 1 && item == -1 )
     bool isUnspecified = property->IsValueUnspecified();
 
     if ( column == 1 && item == -1 )


@@ -187,28 +206,30 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
         {
             // Common Value
             if ( !isUnspecified )
         {
             // Common Value
             if ( !isUnspecified )

-                DrawText( dc, rect, 0, propertyGrid->GetCommonValueLabel(cmnVal) );
-            return;
+            {
+                text = propertyGrid->GetCommonValueLabel(cmnVal);
+                DrawText( dc, rect, 0, text );
+                if ( !text.empty() )
+                    return true;
+            }
+            return false;

         }
     }
 
         }
     }
 

-    const wxPGEditor* editor = NULL;
-    const wxPGCell* cell = NULL;
-
-    wxString text;
-    int imageOffset = 0;
+    int imageWidth = 0;

     int preDrawFlags = flags;
     int preDrawFlags = flags;

+    bool res = false;

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

+        editor = property->GetColumnEditor(column);
+

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

-            editor = property->GetColumnEditor(column);
-

             // Regular property value
 
             wxSize imageSize = propertyGrid->GetImageSize(property, item);
             // Regular property value
 
             wxSize imageSize = propertyGrid->GetImageSize(property, item);


@@ -231,7 +252,7 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
 
                 property->OnCustomPaint( dc, imageRect, paintdata );
 
 
                 property->OnCustomPaint( dc, imageRect, paintdata );
 

-                imageOffset = paintdata.m_drawnWidth;
+                imageWidth = paintdata.m_drawnWidth;

             }
 
             text = property->GetValueAsString();
             }
 
             text = property->GetValueAsString();


@@ -240,32 +261,47 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
             if ( propertyGrid->GetColumnCount() <= 2 )
             {
                 wxString unitsString = property->GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
             if ( propertyGrid->GetColumnCount() <= 2 )
             {
                 wxString unitsString = property->GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);

-                if ( unitsString.length() )
+                if ( !unitsString.empty() )

                     text = wxString::Format(wxS("%s %s"), text.c_str(), unitsString.c_str() );
             }
         }
 
                     text = wxString::Format(wxS("%s %s"), text.c_str(), unitsString.c_str() );
             }
         }
 

-        if ( text.length() == 0 )
+        if ( text.empty() )

         {
         {

-            // Try to show inline help if no text
-            wxVariant vInlineHelp = property->GetAttribute(wxPGGlobalVars->m_strInlineHelp);
-            if ( !vInlineHelp.IsNull() )
+            text = property->GetHintText();
+            if ( !text.empty() )

             {
             {

-                text = vInlineHelp.GetString();
-                dc.SetTextForeground(propertyGrid->GetCellDisabledTextColour());
+                res = true;
+
+                const wxColour& hCol =
+                    propertyGrid->GetCellDisabledTextColour();
+                dc.SetTextForeground(hCol);
+
+                // Must make the editor NULL to override its own rendering
+                // code.
+                editor = NULL;

             }
         }
             }
         }

+        else
+        {
+            res = true;
+        }

     }
 
     }
 

+    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

-    if ( property->IsCategory() /*&& column == 0*/ )
+    if ( property->IsCategory() && column == 0 )

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


@@ -276,6 +312,10 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
                                       propertyGrid->GetFontHeight()+(wxPG_CAPRECTYMARGIN*2) );
         }
     }
                                       propertyGrid->GetFontHeight()+(wxPG_CAPRECTYMARGIN*2) );
         }
     }

+
+    PostDrawCell(dc, propertyGrid, *cell, preDrawFlags);
+
+    return res;

 }
 
 wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,
 }
 
 wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,


@@ -288,7 +328,7 @@ wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,
         {
             wxBitmap* bmp = property->GetValueImage();
 
         {
             wxBitmap* bmp = property->GetValueImage();
 

-            if ( bmp && bmp->Ok() )
+            if ( bmp && bmp->IsOk() )

                 return wxSize(bmp->GetWidth(),bmp->GetHeight());
         }
     }
                 return wxSize(bmp->GetWidth(),bmp->GetHeight());
         }
     }


@@ -362,6 +402,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();


@@ -388,6 +435,12 @@ void wxPGCell::MergeFrom( const wxPGCell& srcCell )
         data->SetBitmap(srcCell.GetBitmap());
 }
 
         data->SetBitmap(srcCell.GetBitmap());
 }
 

+void wxPGCell::SetEmptyData()
+{
+    AllocExclusive();
+}
+
+

 // -----------------------------------------------------------------------
 // wxPGProperty
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPGProperty
 // -----------------------------------------------------------------------


@@ -449,6 +502,23 @@ void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState,
     wxPGProperty* parent = m_parent;
     bool parentIsRoot = parent->IsKindOf(CLASSINFO(wxPGRootProperty));
 
     wxPGProperty* parent = m_parent;
     bool parentIsRoot = parent->IsKindOf(CLASSINFO(wxPGRootProperty));
 

+    //
+    // Convert invalid cells to default ones in this grid
+    for ( unsigned int i=0; i<m_cells.size(); i++ )
+    {
+        wxPGCell& cell = m_cells[i];
+        if ( cell.IsInvalid() )
+        {
+            const wxPGCell& propDefCell = propgrid->GetPropertyDefaultCell();
+            const wxPGCell& catDefCell = propgrid->GetCategoryDefaultCell();
+
+            if ( !HasFlag(wxPG_PROP_CATEGORY) )
+                cell = propDefCell;
+            else
+                cell = catDefCell;
+        }
+    }
+

     m_parentState = pageState;
 
 #if wxPG_COMPATIBILITY_1_4
     m_parentState = pageState;
 
 #if wxPG_COMPATIBILITY_1_4


@@ -539,10 +609,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) )
         {


@@ -569,6 +641,27 @@ void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState,
     }
 }
 
     }
 }
 

+void wxPGProperty::OnDetached(wxPropertyGridPageState* WXUNUSED(state),
+                              wxPropertyGrid* propgrid)
+{
+    if ( propgrid )
+    {
+        const wxPGCell& propDefCell = propgrid->GetPropertyDefaultCell();
+        const wxPGCell& catDefCell = propgrid->GetCategoryDefaultCell();
+
+        // Make default cells invalid
+        for ( unsigned int i=0; i<m_cells.size(); i++ )
+        {
+            wxPGCell& cell = m_cells[i];
+            if ( cell.IsSameAs(propDefCell) ||
+                 cell.IsSameAs(catDefCell) )
+            {
+                cell.UnRef();
+            }
+        }
+    }
+}
+

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


@@ -611,12 +704,21 @@ 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
 {
     wxPGProperty* parent = GetParent();
 
 
 wxString wxPGProperty::GetName() const
 {
     wxPGProperty* parent = GetParent();
 

-    if ( !m_name.length() || !parent || parent->IsCategory() || parent->IsRoot() )
+    if ( m_name.empty() || !parent || parent->IsCategory() || parent->IsRoot() )

         return m_name;
 
     return m_parent->GetName() + wxS(".") + m_name;
         return m_name;
 
     return m_parent->GetName() + wxS(".") + m_name;


@@ -631,12 +733,7 @@ wxPropertyGrid* wxPGProperty::GetGrid() const
 
 int wxPGProperty::Index( const wxPGProperty* p ) const
 {
 
 int wxPGProperty::Index( const wxPGProperty* p ) const
 {

-    for ( unsigned int i = 0; i<m_children.size(); i++ )
-    {
-        if ( p == m_children[i] )
-            return i;
-    }
-    return wxNOT_FOUND;
+    return wxPGFindInVector(m_children, p);

 }
 
 bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const
 }
 
 bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const


@@ -666,8 +763,17 @@ void wxPGProperty::GetDisplayInfo( unsigned int column,
 
     if ( !(flags & wxPGCellRenderer::ChoicePopup) )
     {
 
     if ( !(flags & wxPGCellRenderer::ChoicePopup) )
     {

-        // Not painting listi of choice popups, so get text from property
-        cell = &GetCell(column);
+        // Not painting list of choice popups, so get text from property
+        if ( column != 1 || !IsValueUnspecified() || IsCategory() )
+        {
+            cell = &GetCell(column);
+        }
+        else
+        {
+            // Use special unspecified value cell
+            cell = &GetGrid()->GetUnspecifiedValueAppearance();
+        }
+

         if ( cell->HasText() )
         {
             *pString = cell->GetText();
         if ( cell->HasText() )
         {
             *pString = cell->GetText();


@@ -710,7 +816,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);


@@ -816,12 +922,12 @@ void wxPGProperty::DoGenerateComposedValue( wxString& text,
                                             argFlags|wxPG_COMPOSITE_FRAGMENT);
             }
         }
                                             argFlags|wxPG_COMPOSITE_FRAGMENT);
             }
         }

- 
+

         if ( childResults && curChild->GetChildCount() )
             (*childResults)[curChild->GetName()] = s;
 
         bool skip = false;
         if ( childResults && curChild->GetChildCount() )
             (*childResults)[curChild->GetName()] = s;
 
         bool skip = false;

-        if ( (argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT) && !s.length() )
+        if ( (argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT) && s.empty() )

             skip = true;
 
         if ( !curChild->GetChildCount() || skip )
             skip = true;
 
         if ( !curChild->GetChildCount() || skip )


@@ -888,8 +994,10 @@ wxString wxPGProperty::GetValueAsString( int argFlags ) const
     }
 #endif
 
     }
 #endif
 

+    wxPropertyGrid* pg = GetGrid();
+

     if ( IsValueUnspecified() )
     if ( IsValueUnspecified() )

-        return wxEmptyString;
+        return pg->GetUnspecifiedValueText(argFlags);

 
     if ( m_commonValue == -1 )
     {
 
     if ( m_commonValue == -1 )
     {


@@ -899,7 +1007,6 @@ wxString wxPGProperty::GetValueAsString( int argFlags ) const
 
     //
     // Return common value's string representation
 
     //
     // Return common value's string representation

-    wxPropertyGrid* pg = GetGrid();

     const wxPGCommonValue* cv = pg->GetCommonValue(m_commonValue);
 
     if ( argFlags & wxPG_FULL_VALUE )
     const wxPGCommonValue* cv = pg->GetCommonValue(m_commonValue);
 
     if ( argFlags & wxPG_FULL_VALUE )


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


@@ -996,15 +1097,14 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                     wxVariant variant(child->GetValue());
                     wxString childName = child->GetBaseName();
 
                     wxVariant variant(child->GetValue());
                     wxString childName = child->GetBaseName();
 

-                #ifdef __WXDEBUG__
-                    if ( debug_print )
-                        wxLogDebug(wxT("token = '%s', child = %s"),
-                                   token.c_str(), childName.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) ||

-                         !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
+                         (!child->HasFlag(wxPG_PROP_DISABLED) &&
+                          !child->HasFlag(wxPG_PROP_READONLY)) )

                     {
                         if ( len > 0 )
                         {
                     {
                         if ( len > 0 )
                         {


@@ -1075,7 +1175,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
                     token = text.substr(startPos,pos-startPos-1);
 
 
                     token = text.substr(startPos,pos-startPos-1);
 

-                    if ( !token.length() )
+                    if ( token.empty() )

                         break;
 
                     const wxPGProperty* child = Item(curChild);
                         break;
 
                     const wxPGProperty* child = Item(curChild);


@@ -1084,7 +1184,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                     wxVariant variant(oldChildValue);
 
                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
                     wxVariant variant(oldChildValue);
 
                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||

-                         !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
+                         (!child->HasFlag(wxPG_PROP_DISABLED) &&
+                          !child->HasFlag(wxPG_PROP_READONLY)) )

                     {
                         wxString childName = child->GetBaseName();
 
                     {
                         wxString childName = child->GetBaseName();
 


@@ -1170,6 +1271,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;


@@ -1181,7 +1298,7 @@ void wxPGProperty::OnCustomPaint( wxDC& dc,
 {
     wxBitmap* bmp = m_valueBitmap;
 
 {
     wxBitmap* bmp = m_valueBitmap;
 

-    wxCHECK_RET( bmp && bmp->Ok(), wxT("invalid bitmap") );
+    wxCHECK_RET( bmp && bmp->IsOk(), wxT("invalid bitmap") );

 
     wxCHECK_RET( rect.x >= 0, wxT("unexpected measure call") );
 
 
     wxCHECK_RET( rect.x >= 0, wxT("unexpected measure call") );
 


@@ -1283,6 +1400,12 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
                 }
                 i++;
             }
                 }
                 i++;
             }

+
+            // Always call OnSetValue() for a parent property (do not call it
+            // here if the value is non-null because it will then be called
+            // below)
+            if ( value.IsNull() )
+                OnSetValue();

         }
 
         if ( !value.IsNull() )
         }
 
         if ( !value.IsNull() )


@@ -1322,12 +1445,24 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
         UpdateParentValues();
 
     //
         UpdateParentValues();
 
     //

-    // Update editor control
-    //
-
-    // We need to check for these, otherwise GetGrid() may fail.
+    // Update editor control.

     if ( flags & wxPG_SETVAL_REFRESH_EDITOR )
     if ( flags & wxPG_SETVAL_REFRESH_EDITOR )

-        RefreshEditor();
+    {
+        wxPropertyGrid* pg = GetGridIfDisplayed();
+        if ( pg )
+        {
+            wxPGProperty* selected = pg->GetSelectedProperty();
+
+            // Only refresh the control if this was selected, or
+            // this was some parent of selected, or vice versa)
+            if ( selected && (selected == this ||
+                              selected->IsSomeParent(this) ||
+                              this->IsSomeParent(selected)) )
+                RefreshEditor();
+
+            pg->DrawItemAndValueRelated(this);
+        }
+    }

 }
 
 
 }
 
 


@@ -1336,12 +1471,9 @@ void wxPGProperty::SetValueInEvent( wxVariant value ) const
     GetGrid()->ValueChangeInEvent(value);
 }
 
     GetGrid()->ValueChangeInEvent(value);
 }
 

-void wxPGProperty::SetFlagRecursively( FlagType flag, bool set )
+void wxPGProperty::SetFlagRecursively( wxPGPropertyFlags flag, bool set )

 {
 {

-    if ( set )
-        SetFlag(flag);
-    else
-        ClearFlag(flag);
+    ChangeFlag(flag, set);

 
     unsigned int i;
     for ( i = 0; i < GetChildCount(); i++ )
 
     unsigned int i;
     for ( i = 0; i < GetChildCount(); i++ )


@@ -1360,7 +1492,7 @@ void wxPGProperty::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;
 


@@ -1401,6 +1533,31 @@ wxVariant wxPGProperty::GetDefaultValue() const
     return wxVariant();
 }
 
     return wxVariant();
 }
 

+void wxPGProperty::Enable( bool enable )
+{
+    wxPropertyGrid* pg = GetGrid();
+
+    // Preferably call the version in the owning wxPropertyGrid,
+    // since it handles the editor de-activation.
+    if ( pg )
+        pg->EnableProperty(this, enable);
+    else
+        DoEnable(enable);
+}
+
+void wxPGProperty::DoEnable( bool enable )
+{
+    if ( enable )
+        ClearFlag(wxPG_PROP_DISABLED);
+    else
+        SetFlag(wxPG_PROP_DISABLED);
+
+    // Apply same to sub-properties as well
+    unsigned int i;
+    for ( i = 0; i < GetChildCount(); i++ )
+        Item(i)->DoEnable( enable );
+}
+

 void wxPGProperty::EnsureCells( unsigned int column )
 {
     if ( column >= m_cells.size() )
 void wxPGProperty::EnsureCells( unsigned int column )
 {
     if ( column >= m_cells.size() )


@@ -1409,10 +1566,17 @@ void wxPGProperty::EnsureCells( unsigned int column )
         wxPropertyGrid* pg = GetGrid();
         wxPGCell defaultCell;
 
         wxPropertyGrid* pg = GetGrid();
         wxPGCell defaultCell;
 

-        if ( !HasFlag(wxPG_PROP_CATEGORY) )
-            defaultCell = pg->GetPropertyDefaultCell();
-        else
-            defaultCell = pg->GetCategoryDefaultCell();
+        if ( pg )
+        {
+            // Work around possible VC6 bug by using intermediate variables
+            const wxPGCell& propDefCell = pg->GetPropertyDefaultCell();
+            const wxPGCell& catDefCell = pg->GetCategoryDefaultCell();
+
+            if ( !HasFlag(wxPG_PROP_CATEGORY) )
+                defaultCell = propDefCell;
+            else
+                defaultCell = catDefCell;
+        }

 
         // TODO: Replace with resize() call
         unsigned int cellCountMax = column+1;
 
         // TODO: Replace with resize() call
         unsigned int cellCountMax = column+1;


@@ -1490,16 +1654,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


@@ -1532,9 +1697,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


@@ -1622,18 +1788,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


@@ -1653,7 +1821,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"),


@@ -1683,7 +1851,7 @@ wxString wxPGProperty::GetFlagsAsString( FlagType flagsMask ) const
         {
             const wxChar* fs = gs_propFlagToString[i];
             wxASSERT(fs);
         {
             const wxChar* fs = gs_propFlagToString[i];
             wxASSERT(fs);

-            if ( s.length() )
+            if ( !s.empty() )

                 s << wxS("|");
             s << fs;
         }
                 s << wxS("|");
             s << fs;
         }


@@ -1813,8 +1981,14 @@ void wxPGProperty::SetChoiceSelection( int newValue )
     }
 }
 
     }
 }
 

-bool wxPGProperty::SetChoices( wxPGChoices& choices )
+bool wxPGProperty::SetChoices( const wxPGChoices& choices )

 {
 {

+    // Property must be de-selected first (otherwise choices in
+    // the control would be de-synced with true choices)
+    wxPropertyGrid* pg = GetGrid();
+    if ( pg && pg->GetSelection() == this )
+        pg->ClearSelection();
+

     m_choices.Assign(choices);
 
     {
     m_choices.Assign(choices);
 
     {


@@ -1858,6 +2032,32 @@ const wxPGEditor* wxPGProperty::GetEditorClass() const
     return editor;
 }
 
     return editor;
 }
 

+bool wxPGProperty::Hide( bool hide, int flags )
+{
+    wxPropertyGrid* pg = GetGrid();
+    if ( pg )
+        return pg->HideProperty(this, hide, flags);
+
+    return DoHide( hide, flags );
+}
+
+bool wxPGProperty::DoHide( bool hide, int flags )
+{
+    if ( !hide )
+        ClearFlag( wxPG_PROP_HIDDEN );
+    else
+        SetFlag( wxPG_PROP_HIDDEN );
+
+    if ( flags & wxPG_RECURSE )
+    {
+        unsigned int i;
+        for ( i = 0; i < GetChildCount(); i++ )
+            Item(i)->DoHide(hide, flags | wxPG_RECURSE_STARTS);
+    }
+
+    return true;
+}
+

 bool wxPGProperty::HasVisibleChildren() const
 {
     unsigned int i;
 bool wxPGProperty::HasVisibleChildren() const
 {
     unsigned int i;


@@ -1892,28 +2092,31 @@ void wxPGProperty::SetValueImage( wxBitmap& bmp )
 {
     delete m_valueBitmap;
 
 {
     delete m_valueBitmap;
 

-    if ( &bmp && bmp.Ok() )
+    if ( &bmp && bmp.IsOk() )

     {
         // Resize the image
         wxSize maxSz = GetGrid()->GetImageSize();
         wxSize imSz(bmp.GetWidth(),bmp.GetHeight());
 
     {
         // Resize the image
         wxSize maxSz = GetGrid()->GetImageSize();
         wxSize imSz(bmp.GetWidth(),bmp.GetHeight());
 

-        if ( imSz.x != maxSz.x || imSz.y != maxSz.y )
+        if ( imSz.y != maxSz.y )

         {
         {

-            // Create a memory DC
+        #if wxUSE_IMAGE
+            // Here we use high-quality wxImage scaling functions available
+            wxImage img = bmp.ConvertToImage();
+            double scaleY = (double)maxSz.y / (double)imSz.y;
+            img.Rescale(wxRound(bmp.GetWidth()*scaleY),
+                        wxRound(bmp.GetHeight()*scaleY),
+                        wxIMAGE_QUALITY_HIGH);
+            wxBitmap* bmpNew = new wxBitmap(img, 32);
+        #else
+            // This is the old, deprecated method of scaling the image

             wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth());
             wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth());

-

             wxMemoryDC dc;
             dc.SelectObject(*bmpNew);
             wxMemoryDC dc;
             dc.SelectObject(*bmpNew);

-
-            // Scale
-            // FIXME: This is ugly - use image or wait for scaling patch.
-            double scaleX = (double)maxSz.x / (double)imSz.x;

             double scaleY = (double)maxSz.y / (double)imSz.y;
             double scaleY = (double)maxSz.y / (double)imSz.y;

-
-            dc.SetUserScale(scaleX,scaleY);
-
-            dc.DrawBitmap( bmp, 0, 0 );
+            dc.SetUserScale(scaleY, scaleY);
+            dc.DrawBitmap(bmp, 0, 0);
+        #endif

 
             m_valueBitmap = bmpNew;
         }
 
             m_valueBitmap = bmpNew;
         }


@@ -1977,6 +2180,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;


@@ -2012,7 +2217,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() )
     {


@@ -2028,14 +2234,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*/ )


@@ -2044,6 +2251,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;


@@ -2053,7 +2306,7 @@ void wxPGProperty::RemoveChild( wxPGProperty* p )
     {
         if ( *it == p )
         {
     {
         if ( *it == p )
         {

-            m_children.erase(it);
+            children.erase(it);

             break;
         }
     }
             break;
         }
     }


@@ -2080,9 +2333,9 @@ void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
     else
         allChildrenSpecified = true;
 
     else
         allChildrenSpecified = true;
 

-    wxVariant childValue = list[0];

     unsigned int i;
     unsigned int n = 0;
     unsigned int i;
     unsigned int n = 0;

+    wxVariant childValue = list[n];

 
     //wxLogDebug(wxT(">> %s.AdaptListToValue()"),GetBaseName().c_str());
 
 
     //wxLogDebug(wxT(">> %s.AdaptListToValue()"),GetBaseName().c_str());
 


@@ -2102,7 +2355,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;


@@ -2213,7 +2469,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 );
 


@@ -2263,9 +2521,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;


@@ -2285,21 +2547,53 @@ void wxPGProperty::Empty()
     m_children.clear();
 }
 
     m_children.clear();
 }
 

+wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y ) const
+{
+    unsigned int nextItem;
+    return GetItemAtY( y, GetGrid()->GetRowHeight(), &nextItem);
+}
+

 void wxPGProperty::DeleteChildren()
 {
     wxPropertyGridPageState* state = m_parentState;
 
 void wxPGProperty::DeleteChildren()
 {
     wxPropertyGridPageState* state = m_parentState;
 

-    while ( GetChildCount() )
+    if ( !GetChildCount() )
+        return;
+
+    // Because deletion is sometimes deferred, we have to use
+    // this sort of code for enumerating the child properties.
+    unsigned int i = GetChildCount();
+    while ( i > 0 )

     {
     {

-        wxPGProperty* child = Item(GetChildCount()-1);
-        state->DoDelete(child, true);
+        i--;
+        state->DoDelete(Item(i), true);

     }
 }
 
     }
 }
 

-void wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
-                                 int WXUNUSED(childIndex),
-                                 wxVariant& WXUNUSED(childValue) ) const
+bool wxPGProperty::IsChildSelected( bool recursive ) const

 {
 {

+    size_t i;
+    for ( i = 0; i < GetChildCount(); i++ )
+    {
+        wxPGProperty* child = Item(i);
+
+        // Test child
+        if ( m_parentState->DoIsPropertySelected( child ) )
+            return true;
+
+        // Test sub-childs
+        if ( recursive && child->IsChildSelected( recursive ) )
+            return true;
+    }
+
+    return false;
+}
+
+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


@@ -2433,12 +2727,8 @@ IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
 wxPGRootProperty::wxPGRootProperty( const wxString& name )
     : wxPGProperty()
 {
 wxPGRootProperty::wxPGRootProperty( const wxString& name )
     : wxPGProperty()
 {

-#ifdef __WXDEBUG__

     m_name = name;
     m_label = m_name;
     m_name = name;
     m_label = m_name;

-#else
-    wxUnusedVar(name);
-#endif

     SetParentalType(0);
     m_depth = 0;
 }
     SetParentalType(0);
     m_depth = 0;
 }


@@ -2486,22 +2776,44 @@ wxPropertyCategory::~wxPropertyCategory()
 wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value),
                                             int WXUNUSED(argFlags) ) const
 {
 wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value),
                                             int WXUNUSED(argFlags) ) const
 {

+    if ( m_value.GetType() == wxPG_VARIANT_TYPE_STRING )
+        return m_value.GetString();

     return wxEmptyString;
 }
 
     return wxEmptyString;
 }
 

+wxString wxPropertyCategory::GetValueAsString( int argFlags ) const
+{
+#if wxPG_COMPATIBILITY_1_4
+    // This is backwards compatibility test
+    // That is, to make sure this function is not overridden
+    // (instead, ValueToString() should be).
+    if ( argFlags == 0xFFFF )
+    {
+        // Do not override! (for backwards compliancy)
+        return g_invalidStringContent;
+    }
+#endif
+
+    // Unspecified value is always empty string
+    if ( IsValueUnspecified() )
+        return wxEmptyString;
+
+    return wxPGProperty::GetValueAsString(argFlags);
+}
+

 int wxPropertyCategory::GetTextExtent( const wxWindow* wnd, const wxFont& font ) const
 {
     if ( m_textExtent > 0 )
         return m_textExtent;
     int x = 0, y = 0;
 int wxPropertyCategory::GetTextExtent( const wxWindow* wnd, const wxFont& font ) const
 {
     if ( m_textExtent > 0 )
         return m_textExtent;
     int x = 0, y = 0;

-       ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font );
+    ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font );

     return x;
 }
 
 void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& font )
 {
     int x = 0, y = 0;
     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;
 }
 


@@ -2569,12 +2881,12 @@ wxPGChoiceEntry& wxPGChoices::AddAsSorted( const wxString& label, int value )
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

-void wxPGChoices::Add( const wxChar** labels, const ValArrItem* values )
+void wxPGChoices::Add( const wxChar* const* labels, const ValArrItem* values )

 {
     AllocExclusive();
 
     unsigned int itemcount = 0;
 {
     AllocExclusive();
 
     unsigned int itemcount = 0;

-    const wxChar** p = &labels[0];
+    const wxChar* const* p = &labels[0];

     while ( *p ) { p++; itemcount++; }
 
     unsigned int i;
     while ( *p ) { p++; itemcount++; }
 
     unsigned int i;


@@ -2613,7 +2925,7 @@ void wxPGChoices::RemoveAt(size_t nIndex, size_t count)
 {
     AllocExclusive();
 
 {
     AllocExclusive();
 

-    wxASSERT( m_data->m_refCount != 0xFFFFFFF );
+    wxASSERT( m_data->GetRefCount() != -1 );

     m_data->m_items.erase(m_data->m_items.begin()+nIndex,
                           m_data->m_items.begin()+nIndex+count);
 }
     m_data->m_items.erase(m_data->m_items.begin()+nIndex,
                           m_data->m_items.begin()+nIndex+count);
 }


@@ -2729,7 +3041,7 @@ void wxPGChoices::AllocExclusive()
 {
     EnsureData();
 
 {
     EnsureData();
 

-    if ( m_data->m_refCount != 1 )
+    if ( m_data->GetRefCount() != 1 )

     {
         wxPGChoicesData* data = new wxPGChoicesData();
         data->CopyDataFrom(m_data);
     {
         wxPGChoicesData* data = new wxPGChoicesData();
         data->CopyDataFrom(m_data);


@@ -2747,7 +3059,7 @@ void wxPGChoices::AssignData( wxPGChoicesData* data )
     if ( data != wxPGChoicesEmptyData )
     {
         m_data = data;
     if ( data != wxPGChoicesEmptyData )
     {
         m_data = data;

-        data->m_refCount++;
+        data->IncRef();

     }
 }
 
     }
 }