]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/propgrid/property.h
Implement wxCOL_WIDTH_AUTOSIZE on OS X.
[wxWidgets.git] / include / wx / propgrid / property.h
index 1986c326bdc8777186a66f55615ee5696a18fde2..dea6f5c63a6502236e631b2f88554507caa65795 100644 (file)
@@ -4,14 +4,18 @@
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2008-08-23
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2008-08-23
-// RCS-ID:      $Id:
+// RCS-ID:      $Id$
 // Copyright:   (c) Jaakko Salli
 // Copyright:   (c) Jaakko Salli
-// Licence:     wxWindows license
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_PROPGRID_PROPERTY_H_
 #define _WX_PROPGRID_PROPERTY_H_
 
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_PROPGRID_PROPERTY_H_
 #define _WX_PROPGRID_PROPERTY_H_
 
+#include "wx/defs.h"
+
+#if wxUSE_PROPGRID
+
 #include "wx/propgrid/propgriddefs.h"
 
 // -----------------------------------------------------------------------
 #include "wx/propgrid/propgriddefs.h"
 
 // -----------------------------------------------------------------------
@@ -45,16 +49,6 @@ struct wxPGPaintData
 };
 
 
 };
 
 
-// Structure for relaying choice/list info.
-struct wxPGChoiceInfo
-{
-    wxPGChoices*    m_choices;
-};
-
-
-#ifndef SWIG
-
-
 // space between vertical sides of a custom image
 #define wxPG_CUSTOM_IMAGE_SPACINGY      1
 
 // space between vertical sides of a custom image
 #define wxPG_CUSTOM_IMAGE_SPACINGY      1
 
@@ -69,22 +63,45 @@ struct wxPGChoiceInfo
 
     Base class for wxPropertyGrid cell renderers.
 */
 
     Base class for wxPropertyGrid cell renderers.
 */
-class WXDLLIMPEXP_PROPGRID wxPGCellRenderer
+class WXDLLIMPEXP_PROPGRID wxPGCellRenderer : public wxObjectRefData
 {
 public:
 
 {
 public:
 
-    wxPGCellRenderer( unsigned int refCount = 1 )
-        : m_refCount(refCount) { }
+    wxPGCellRenderer()
+        : wxObjectRefData() { }
     virtual ~wxPGCellRenderer() { }
 
     // Render flags
     enum
     {
     virtual ~wxPGCellRenderer() { }
 
     // Render flags
     enum
     {
+        // We are painting selected item
         Selected        = 0x00010000,
         Selected        = 0x00010000,
-        Control         = 0x00020000
+
+        // We are painting item in choice popup
+        ChoicePopup     = 0x00020000,
+
+        // We are rendering wxOwnerDrawnComboBox control
+        // (or other owner drawn control, but that is only
+        // officially supported one ATM).
+        Control         = 0x00040000,
+
+        // We are painting a disable property
+        Disabled        = 0x00080000,
+
+        // We are painting selected, disabled, or similar
+        // item that dictates fore- and background colours,
+        // overriding any cell values.
+        DontUseCellFgCol    = 0x00100000,
+        DontUseCellBgCol    = 0x00200000,
+        DontUseCellColours  = DontUseCellFgCol |
+                              DontUseCellBgCol
     };
 
     };
 
-    virtual void Render( wxDC& dc,
+    /**
+        Returns @true if rendered something in the foreground (text or
+        bitmap.
+    */
+    virtual bool Render( wxDC& dc,
                          const wxRect& rect,
                          const wxPropertyGrid* propertyGrid,
                          wxPGProperty* property,
                          const wxRect& rect,
                          const wxPropertyGrid* propertyGrid,
                          wxPGProperty* property,
@@ -123,87 +140,184 @@ public:
                           wxPGProperty* property,
                           const wxPGEditor* editor ) const;
 
                           wxPGProperty* property,
                           const wxPGEditor* editor ) const;
 
-    /** Utility to render cell bitmap and set text colour plus bg brush colour.
+    /** Utility to render cell bitmap and set text colour plus bg brush
+        colour.
 
 
-        Returns image width that, for instance, can be passed to DrawText.
+        @return Returns image width, which, for instance, can be passed to
+                DrawText.
     */
     int PreDrawCell( wxDC& dc,
                      const wxRect& rect,
                      const wxPGCell& cell,
                      int flags ) const;
 
     */
     int PreDrawCell( wxDC& dc,
                      const wxRect& rect,
                      const wxPGCell& cell,
                      int flags ) const;
 
-    void IncRef()
-    {
-        m_refCount++;
-    }
-
-    void DecRef()
-    {
-        m_refCount--;
-        if ( !m_refCount )
-            delete this;
-    }
-protected:
+    /**
+        Utility to be called after drawing is done, to revert whatever
+        changes PreDrawCell() did.
 
 
-private:
-    unsigned int    m_refCount;
+        @param flags
+            Same as those passed to PreDrawCell().
+    */
+    void PostDrawCell( wxDC& dc,
+                       const wxPropertyGrid* propGrid,
+                       const wxPGCell& cell,
+                       int flags ) const;
 };
 
 
 };
 
 
-/** @class wxPGCell
+/**
+    @class wxPGDefaultRenderer
 
 
-    Base class for simple wxPropertyGrid cell information.
+    Default cell renderer, that can handles the common
+    scenarios.
 */
 */
-class WXDLLIMPEXP_PROPGRID wxPGCell
+class WXDLLIMPEXP_PROPGRID wxPGDefaultRenderer : public wxPGCellRenderer
 {
 public:
 {
 public:
-    wxPGCell();
-    wxPGCell( const wxString& text,
-              const wxBitmap& bitmap = wxNullBitmap,
-              const wxColour& fgCol = wxNullColour,
-              const wxColour& bgCol = wxNullColour );
+    virtual bool Render( wxDC& dc,
+                         const wxRect& rect,
+                         const wxPropertyGrid* propertyGrid,
+                         wxPGProperty* property,
+                         int column,
+                         int item,
+                         int flags ) const;
 
 
-    virtual ~wxPGCell() { }
+    virtual wxSize GetImageSize( const wxPGProperty* property,
+                                 int column,
+                                 int item ) const;
+
+protected:
+};
+
+
+class WXDLLIMPEXP_PROPGRID wxPGCellData : public wxObjectRefData
+{
+    friend class wxPGCell;
+public:
+    wxPGCellData();
 
 
-    void SetText( const wxString& text ) { m_text = text; }
+    void SetText( const wxString& text )
+    {
+        m_text = text;
+        m_hasValidText = true;
+    }
     void SetBitmap( const wxBitmap& bitmap ) { m_bitmap = bitmap; }
     void SetFgCol( const wxColour& col ) { m_fgCol = col; }
     void SetBgCol( const wxColour& col ) { m_bgCol = col; }
     void SetBitmap( const wxBitmap& bitmap ) { m_bitmap = bitmap; }
     void SetFgCol( const wxColour& col ) { m_fgCol = col; }
     void SetBgCol( const wxColour& col ) { m_bgCol = col; }
-
-    const wxString& GetText() const { return m_text; }
-    const wxBitmap& GetBitmap() const { return m_bitmap; }
-    const wxColour& GetFgCol() const { return m_fgCol; }
-    const wxColour& GetBgCol() const { return m_bgCol; }
+    void SetFont( const wxFont& font ) { m_font = font; }
 
 protected:
 
 protected:
+    virtual ~wxPGCellData() { }
+
     wxString    m_text;
     wxBitmap    m_bitmap;
     wxColour    m_fgCol;
     wxColour    m_bgCol;
     wxString    m_text;
     wxBitmap    m_bitmap;
     wxColour    m_fgCol;
     wxColour    m_bgCol;
+    wxFont      m_font;
+
+    // True if m_text is valid and specified
+    bool        m_hasValidText;
 };
 
 
 };
 
 
-/** @class wxPGDefaultRenderer
+/**
+    @class wxPGCell
 
 
-    Default cell renderer, that can handles the common
-    scenarios.
+    Base class for wxPropertyGrid cell information.
 */
 */
-class WXDLLIMPEXP_PROPGRID wxPGDefaultRenderer : public wxPGCellRenderer
+class WXDLLIMPEXP_PROPGRID wxPGCell : public wxObject
 {
 public:
 {
 public:
-    virtual void Render( wxDC& dc,
-                         const wxRect& rect,
-                         const wxPropertyGrid* propertyGrid,
-                         wxPGProperty* property,
-                         int column,
-                         int item,
-                         int flags ) const;
+    wxPGCell();
+    wxPGCell(const wxPGCell& other)
+        : wxObject(other)
+    {
+    }
 
 
-    virtual wxSize GetImageSize( const wxPGProperty* property,
-                                 int column,
-                                 int item ) const;
+    wxPGCell( const wxString& text,
+              const wxBitmap& bitmap = wxNullBitmap,
+              const wxColour& fgCol = wxNullColour,
+              const wxColour& bgCol = wxNullColour );
 
 
-protected:
+    virtual ~wxPGCell() { }
+
+    wxPGCellData* GetData()
+    {
+        return (wxPGCellData*) m_refData;
+    }
+
+    const wxPGCellData* GetData() const
+    {
+        return (const wxPGCellData*) m_refData;
+    }
+
+    bool HasText() const
+    {
+        return (m_refData && GetData()->m_hasValidText);
+    }
+
+    /**
+        Sets empty but valid data to this cell object.
+    */
+    void SetEmptyData();
+
+    /**
+        Merges valid data from srcCell into this.
+    */
+    void MergeFrom( const wxPGCell& srcCell );
+
+    void SetText( const wxString& text );
+    void SetBitmap( const wxBitmap& bitmap );
+    void SetFgCol( const wxColour& col );
+
+    /**
+        Sets font of the cell.
+
+        @remarks Because wxPropertyGrid does not support rows of
+                 different height, it makes little sense to change
+                 size of the font. Therefore it is recommended
+                 to use return value of wxPropertyGrid::GetFont()
+                 or wxPropertyGrid::GetCaptionFont() as a basis
+                 for the font that, after modifications, is passed
+                 to this member function.
+    */
+    void SetFont( const wxFont& font );
+
+    void SetBgCol( const wxColour& col );
+
+    const wxString& GetText() const { return GetData()->m_text; }
+    const wxBitmap& GetBitmap() const { return GetData()->m_bitmap; }
+    const wxColour& GetFgCol() const { return GetData()->m_fgCol; }
+
+    /**
+        Returns font of the cell. If no specific font is set for this
+        cell, then the font will be invalid.
+    */
+    const wxFont& GetFont() const { return GetData()->m_font; }
+
+    const wxColour& GetBgCol() const { return GetData()->m_bgCol; }
+
+    wxPGCell& operator=( const wxPGCell& other )
+    {
+        if ( this != &other )
+        {
+            Ref(other);
+        }
+        return *this;
+    }
+
+    // Used mostly internally to figure out if this cell is supposed
+    // to have default values when attached to a grid.
+    bool IsInvalid() const
+    {
+        return ( m_refData == NULL );
+    }
+
+private:
+    virtual wxObjectRefData *CreateRefData() const
+        { return new wxPGCellData(); }
+
+    virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
 };
 
 // -----------------------------------------------------------------------
 };
 
 // -----------------------------------------------------------------------
@@ -220,7 +334,7 @@ public:
     ~wxPGAttributeStorage();
 
     void Set( const wxString& name, const wxVariant& value );
     ~wxPGAttributeStorage();
 
     void Set( const wxString& name, const wxVariant& value );
-    size_t GetCount() const { return m_map.size(); }
+    unsigned int GetCount() const { return (unsigned int) m_map.size(); }
     wxVariant FindValue( const wxString& name ) const
     {
         wxPGHashMapS2P::const_iterator it = m_map.find(name);
     wxVariant FindValue( const wxString& name ) const
     {
         wxPGHashMapS2P::const_iterator it = m_map.find(name);
@@ -247,7 +361,7 @@ public:
         data->IncRef();
         variant.SetData(data);
         variant.SetName(it->first);
         data->IncRef();
         variant.SetData(data);
         variant.SetName(it->first);
-        it++;
+        ++it;
         return true;
     }
 
         return true;
     }
 
@@ -255,7 +369,6 @@ protected:
     wxPGHashMapS2P  m_map;
 };
 
     wxPGHashMapS2P  m_map;
 };
 
-#endif  // !SWIG
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 
@@ -263,7 +376,7 @@ protected:
     @{
 */
 
     @{
 */
 
-enum wxPG_PROPERTY_FLAGS
+enum wxPGPropertyFlags
 {
 
 /** Indicates bold font.
 {
 
 /** Indicates bold font.
@@ -340,7 +453,9 @@ wxPG_PROP_CATEGORY                  = 0x2000,
 */
 wxPG_PROP_MISC_PARENT               = 0x4000,
 
 */
 wxPG_PROP_MISC_PARENT               = 0x4000,
 
-/** Property is read-only. Editor is still created.
+/** Property is read-only. Editor is still created for wxTextCtrl-based
+    property editors. For others, editor is not usually created because
+    they do implement wxTE_READONLY style or equivalent.
 */
 wxPG_PROP_READONLY                  = 0x8000,
 
 */
 wxPG_PROP_READONLY                  = 0x8000,
 
@@ -367,6 +482,8 @@ wxPG_PROP_USES_COMMON_VALUE         = 0x00020000,
 
     @remarks
     This flag cannot be used with property iterators.
 
     @remarks
     This flag cannot be used with property iterators.
+
+    @see wxPGProperty::SetAutoUnspecified()
 */
 wxPG_PROP_AUTO_UNSPECIFIED          = 0x00040000,
 
 */
 wxPG_PROP_AUTO_UNSPECIFIED          = 0x00040000,
 
@@ -376,7 +493,11 @@ wxPG_PROP_CLASS_SPECIFIC_1          = 0x00080000,
 
 /** Indicates the bit useable by derived properties.
 */
 
 /** Indicates the bit useable by derived properties.
 */
-wxPG_PROP_CLASS_SPECIFIC_2          = 0x00100000
+wxPG_PROP_CLASS_SPECIFIC_2          = 0x00100000,
+
+/** Indicates that the property is being deleted and should be ignored.
+*/
+wxPG_PROP_BEING_DELETED             = 0x00200000
 
 };
 
 
 };
 
@@ -389,28 +510,25 @@ wxPG_PROP_CLASS_SPECIFIC_2          = 0x00100000
     Code should automatically take care of this, however.
 */
 #define wxPG_PROP_PARENTAL_FLAGS \
     Code should automatically take care of this, however.
 */
 #define wxPG_PROP_PARENTAL_FLAGS \
-    (wxPG_PROP_AGGREGATE|wxPG_PROP_CATEGORY|wxPG_PROP_MISC_PARENT)
+    ((wxPGPropertyFlags)(wxPG_PROP_AGGREGATE | \
+                         wxPG_PROP_CATEGORY | \
+                         wxPG_PROP_MISC_PARENT))
 
 /** @}
 */
 
 
 /** @}
 */
 
-// Amalgam of flags that should be inherited by sub-properties
-#define wxPG_INHERITED_PROPFLAGS        (wxPG_PROP_HIDDEN|wxPG_PROP_NOEDITOR)
-
 // Combination of flags that can be stored by GetFlagsAsString
 #define wxPG_STRING_STORED_FLAGS \
     (wxPG_PROP_DISABLED|wxPG_PROP_HIDDEN|wxPG_PROP_NOEDITOR|wxPG_PROP_COLLAPSED)
 
 // -----------------------------------------------------------------------
 
 // Combination of flags that can be stored by GetFlagsAsString
 #define wxPG_STRING_STORED_FLAGS \
     (wxPG_PROP_DISABLED|wxPG_PROP_HIDDEN|wxPG_PROP_NOEDITOR|wxPG_PROP_COLLAPSED)
 
 // -----------------------------------------------------------------------
 
-#ifndef SWIG
-
 /**
     @section propgrid_property_attributes wxPropertyGrid Property Attribute
     Identifiers.
 
     wxPGProperty::SetAttribute() and
 /**
     @section propgrid_property_attributes wxPropertyGrid Property Attribute
     Identifiers.
 
     wxPGProperty::SetAttribute() and
-    wxPropertyGridInterfaces::SetPropertyAttribute() accept one of these as
+    wxPropertyGridInterface::SetPropertyAttribute() accept one of these as
     attribute name argument.
 
     You can use strings instead of constants. However, some of these
     attribute name argument.
 
     You can use strings instead of constants. However, some of these
@@ -438,18 +556,40 @@ wxPG_PROP_CLASS_SPECIFIC_2          = 0x00100000
 */
 #define wxPG_ATTR_UNITS                     wxS("Units")
 
 */
 #define wxPG_ATTR_UNITS                     wxS("Units")
 
-/** Universal, string. When set, will be shown in property's value cell
-    when displayed value string is empty, or value is unspecified.
+/** When set, will be shown as 'greyed' text in property's value cell when
+    the actual displayed value is blank.
+*/
+#define wxPG_ATTR_HINT                      wxS("Hint")
+
+#if wxPG_COMPATIBILITY_1_4
+/**
+    @deprecated Use "Hint" (wxPG_ATTR_HINT) instead.
 */
 #define wxPG_ATTR_INLINE_HELP               wxS("InlineHelp")
 */
 #define wxPG_ATTR_INLINE_HELP               wxS("InlineHelp")
+#endif
+
+/** Universal, wxArrayString. Set to enable auto-completion in any
+    wxTextCtrl-based property editor.
+*/
+#define wxPG_ATTR_AUTOCOMPLETE              wxS("AutoComplete")
+
+/** wxBoolProperty and wxFlagsProperty specific. Value type is bool.
+    Default value is False.
 
 
-/** wxBoolProperty specific, int, default 0. When 1 sets bool property to
-    use checkbox instead of choice.
+    When set to True, bool property will use check box instead of a
+    combo box as its editor control. If you set this attribute
+    for a wxFlagsProperty, it is automatically applied to child
+    bool properties.
 */
 #define wxPG_BOOL_USE_CHECKBOX              wxS("UseCheckbox")
 
 */
 #define wxPG_BOOL_USE_CHECKBOX              wxS("UseCheckbox")
 
-/** wxBoolProperty specific, int, default 0. When 1 sets bool property value
-    to cycle on double click (instead of showing the popup listbox).
+/** wxBoolProperty and wxFlagsProperty specific. Value type is bool.
+    Default value is False.
+
+    Set to True for the bool property to cycle value on double click
+    (instead of showing the popup listbox). If you set this attribute
+    for a wxFlagsProperty, it is automatically applied to child
+    bool properties.
 */
 #define wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING  wxS("UseDClickCycling")
 
 */
 #define wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING  wxS("UseDClickCycling")
 
@@ -515,6 +655,15 @@ wxPG_PROP_CLASS_SPECIFIC_2          = 0x00100000
 */
 #define wxPG_DIR_DIALOG_MESSAGE             wxS("DialogMessage")
 
 */
 #define wxPG_DIR_DIALOG_MESSAGE             wxS("DialogMessage")
 
+/**
+    wxArrayStringProperty's string delimiter character. If this is aquotation
+    mark or hyphen, then strings will be quoted instead (with given
+    character).
+
+    Default delimiter is quotation mark.
+*/
+#define wxPG_ARRAY_DELIMITER                wxS("Delimiter")
+
 /** Sets displayed date format for wxDateProperty.
 */
 #define wxPG_DATE_FORMAT                    wxS("DateFormat")
 /** Sets displayed date format for wxDateProperty.
 */
 #define wxPG_DATE_FORMAT                    wxS("DateFormat")
@@ -548,286 +697,412 @@ wxPG_PROP_CLASS_SPECIFIC_2          = 0x00100000
 */
 #define wxPG_COLOUR_ALLOW_CUSTOM            wxS("AllowCustom")
 
 */
 #define wxPG_COLOUR_ALLOW_CUSTOM            wxS("AllowCustom")
 
-/** First attribute id that is guaranteed not to be used built-in
-    properties.
+/**
+    wxColourProperty and its kind: Set to True in order to support editing
+    alpha colour component.
 */
 */
-//#define wxPG_USER_ATTRIBUTE                 192
+#define wxPG_COLOUR_HAS_ALPHA               wxS("HasAlpha")
 
 /** @}
 */
 
 
 /** @}
 */
 
-#ifndef DOXYGEN
-
 // Redefine attribute macros to use cached strings
 // Redefine attribute macros to use cached strings
+#undef wxPG_ATTR_DEFAULT_VALUE
+#define wxPG_ATTR_DEFAULT_VALUE           wxPGGlobalVars->m_strDefaultValue
 #undef wxPG_ATTR_MIN
 #define wxPG_ATTR_MIN                     wxPGGlobalVars->m_strMin
 #undef wxPG_ATTR_MAX
 #define wxPG_ATTR_MAX                     wxPGGlobalVars->m_strMax
 #undef wxPG_ATTR_UNITS
 #define wxPG_ATTR_UNITS                   wxPGGlobalVars->m_strUnits
 #undef wxPG_ATTR_MIN
 #define wxPG_ATTR_MIN                     wxPGGlobalVars->m_strMin
 #undef wxPG_ATTR_MAX
 #define wxPG_ATTR_MAX                     wxPGGlobalVars->m_strMax
 #undef wxPG_ATTR_UNITS
 #define wxPG_ATTR_UNITS                   wxPGGlobalVars->m_strUnits
+#undef wxPG_ATTR_HINT
+#define wxPG_ATTR_HINT                    wxPGGlobalVars->m_strHint
+#if wxPG_COMPATIBILITY_1_4
 #undef wxPG_ATTR_INLINE_HELP
 #define wxPG_ATTR_INLINE_HELP             wxPGGlobalVars->m_strInlineHelp
 #undef wxPG_ATTR_INLINE_HELP
 #define wxPG_ATTR_INLINE_HELP             wxPGGlobalVars->m_strInlineHelp
-
-#endif  // !DOXYGEN
-
-#endif  // !SWIG
+#endif
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 
-/** @class wxPGProperty
+/** @class wxPGChoiceEntry
+    Data of a single wxPGChoices choice.
+*/
+class WXDLLIMPEXP_PROPGRID wxPGChoiceEntry : public wxPGCell
+{
+public:
+    wxPGChoiceEntry();
+    wxPGChoiceEntry(const wxPGChoiceEntry& other)
+        : wxPGCell(other)
+    {
+        m_value = other.m_value;
+    }
+    wxPGChoiceEntry( const wxString& label,
+                     int value = wxPG_INVALID_VALUE )
+        : wxPGCell(), m_value(value)
+    {
+        SetText(label);
+    }
 
 
-    wxPGProperty is base class for all wxPropertyGrid properties. In
-    sections below we cover few related topics.
+    virtual ~wxPGChoiceEntry() { }
 
 
-    @li @ref pgproperty_properties
-    @li @ref pgproperty_creating
+    void SetValue( int value ) { m_value = value; }
+    int GetValue() const { return m_value; }
 
 
-    @section pgproperty_properties Supplied Ready-to-use Property Classes
+    wxPGChoiceEntry& operator=( const wxPGChoiceEntry& other )
+    {
+        if ( this != &other )
+        {
+            Ref(other);
+        }
+        m_value = other.m_value;
+        return *this;
+    }
 
 
-    Here is a list and short description of supplied fully-functional
-    property classes. They are located in either props.h or advprops.h.
+protected:
+    int m_value;
+};
 
 
-    @li @ref wxArrayStringProperty
-    @li @ref wxBoolProperty
-    @li @ref wxColourProperty
-    @li @ref wxCursorProperty
-    @li @ref wxDateProperty
-    @li @ref wxDirProperty
-    @li @ref wxEditEnumProperty
-    @li @ref wxEnumProperty
-    @li @ref wxFileProperty
-    @li @ref wxFlagsProperty
-    @li @ref wxFloatProperty
-    @li @ref wxFontProperty
-    @li @ref wxImageFileProperty
-    @li @ref wxIntProperty
-    @li @ref wxLongStringProperty
-    @li @ref wxMultiChoiceProperty
-    @li @ref wxPropertyCategory
-    @li @ref wxStringProperty
-    @li @ref wxSystemColourProperty
-    @li @ref wxUIntProperty
 
 
-    @subsection wxPropertyCategory
+typedef void* wxPGChoicesId;
 
 
-    Not an actual property per se, but a header for a group of properties.
-    Regardless inherits from wxPGProperty.
+class WXDLLIMPEXP_PROPGRID wxPGChoicesData : public wxObjectRefData
+{
+    friend class wxPGChoices;
+public:
+    // Constructor sets m_refCount to 1.
+    wxPGChoicesData();
 
 
-    @subsection wxStringProperty
+    void CopyDataFrom( wxPGChoicesData* data );
 
 
-    Simple string property. wxPG_STRING_PASSWORD attribute may be used
-    to echo value as asterisks and use wxTE_PASSWORD for wxTextCtrl.
+    wxPGChoiceEntry& Insert( int index, const wxPGChoiceEntry& item );
 
 
-    @remarks
-    * wxStringProperty has a special trait: if it has value of "<composed>",
-      and also has child properties, then its displayed value becomes
-      composition of child property values, similar as with wxFontProperty,
-      for instance.
+    // Delete all entries
+    void Clear();
 
 
-    @subsection wxIntProperty
+    unsigned int GetCount() const
+    {
+        return (unsigned int) m_items.size();
+    }
 
 
-    Like wxStringProperty, but converts text to a signed long integer.
-    wxIntProperty seamlessly supports 64-bit integers (ie. wxLongLong).
+    const wxPGChoiceEntry& Item( unsigned int i ) const
+    {
+        wxASSERT_MSG( i < GetCount(), "invalid index" );
+        return m_items[i];
+    }
 
 
-    @subsection wxUIntProperty
+    wxPGChoiceEntry& Item( unsigned int i )
+    {
+        wxASSERT_MSG( i < GetCount(), "invalid index" );
+        return m_items[i];
+    }
 
 
-    Like wxIntProperty, but displays value as unsigned int. To set
-    the prefix used globally, manipulate wxPG_UINT_PREFIX string attribute.
-    To set the globally used base, manipulate wxPG_UINT_BASE int
-    attribute. Regardless of current prefix, understands (hex) values starting
-    with both "0x" and "$".
-    wxUIntProperty seamlessly supports 64-bit unsigned integers (ie.
-    wxULongLong).
+private:
+    wxVector<wxPGChoiceEntry>   m_items;
 
 
-    @subsection wxFloatProperty
+    virtual ~wxPGChoicesData();
+};
 
 
-    Like wxStringProperty, but converts text to a double-precision floating
-    point. Default float-to-text precision is 6 decimals, but this can be
-    changed by modifying wxPG_FLOAT_PRECISION attribute.
+#define wxPGChoicesEmptyData    ((wxPGChoicesData*)NULL)
 
 
-    @subsection wxBoolProperty
 
 
-    Represents a boolean value. wxChoice is used as editor control, by the
-    default. wxPG_BOOL_USE_CHECKBOX attribute can be set to true inorder to use
-    check box instead.
+/** @class wxPGChoices
 
 
-    @subsection wxLongStringProperty
+    Helper class for managing choices of wxPropertyGrid properties.
+    Each entry can have label, value, bitmap, text colour, and background
+    colour.
 
 
-    Like wxStringProperty, but has a button that triggers a small text editor
-    dialog. Note that in long string values, tabs are represented by "\t" and
-    line break by "\n".
+    wxPGChoices uses reference counting, similar to other wxWidgets classes.
+    This means that assignment operator and copy constructor only copy the
+    reference and not the actual data. Use Copy() member function to create a
+    real copy.
 
 
-    @subsection wxDirProperty
+    @remarks If you do not specify value for entry, index is used.
 
 
-    Like wxLongStringProperty, but the button triggers dir selector instead.
-    Supported properties (all with string value): wxPG_DIR_DIALOG_MESSAGE.
+    @library{wxpropgrid}
+    @category{propgrid}
+*/
+class WXDLLIMPEXP_PROPGRID wxPGChoices
+{
+public:
+    typedef long ValArrItem;
 
 
-    @subsection wxFileProperty
+    /** Default constructor. */
+    wxPGChoices()
+    {
+        Init();
+    }
 
 
-    Like wxLongStringProperty, but the button triggers file selector instead.
-    Default wildcard is "All files..." but this can be changed by setting
-    wxPG_FILE_WILDCARD attribute (see wxFileDialog for format details).
-    Attribute wxPG_FILE_SHOW_FULL_PATH can be set to false inorder to show
-    only the filename, not the entire path.
+    /**
+        Copy constructor, uses reference counting. To create a real copy,
+        use Copy() member function instead.
+    */
+    wxPGChoices( const wxPGChoices& a )
+    {
+        if ( a.m_data != wxPGChoicesEmptyData )
+        {
+            m_data = a.m_data;
+            m_data->IncRef();
+        }
+    }
 
 
-    @subsection wxEnumProperty
+    /**
+        Constructor.
 
 
-    Represents a single selection from a list of choices -
-    wxOwnerDrawnComboBox is used to edit the value.
+        @param labels
+            Labels for choices
 
 
-    @subsection wxFlagsProperty
+        @param values
+            Values for choices. If NULL, indexes are used.
+    */
+    wxPGChoices( const wxChar* const* labels, const long* values = NULL )
+    {
+        Init();
+        Set(labels,values);
+    }
 
 
-    Represents a bit set that fits in a long integer. wxBoolProperty
-    sub-properties are created for editing individual bits. Textctrl is created
-    to manually edit the flags as a text; a continous sequence of spaces,
-    commas and semicolons is considered as a flag id separator.
-    <b>Note: </b> When changing "choices" (ie. flag labels) of wxFlagsProperty,
-    you will need to use SetPropertyChoices - otherwise they will not get
-    updated properly.
+    /**
+        Constructor.
 
 
-    @subsection wxArrayStringProperty
+        @param labels
+            Labels for choices
 
 
-    Allows editing of a list of strings in wxTextCtrl and in a separate dialog.
+        @param values
+            Values for choices. If empty, indexes are used.
+    */
+    wxPGChoices( const wxArrayString& labels,
+                 const wxArrayInt& values = wxArrayInt() )
+    {
+        Init();
+        Set(labels,values);
+    }
 
 
-    @subsection wxDateProperty
+    /** Simple interface constructor. */
+    wxPGChoices( wxPGChoicesData* data )
+    {
+        wxASSERT(data);
+        m_data = data;
+        data->IncRef();
+    }
 
 
-    wxDateTime property. Default editor is DatePickerCtrl, altough TextCtrl
-    should work as well. wxPG_DATE_FORMAT attribute can be used to change
-    string wxDateTime::Format uses (altough default is recommended as it is
-    locale-dependant), and wxPG_DATE_PICKER_STYLE allows changing window
-    style given to DatePickerCtrl (default is wxDP_DEFAULT|wxDP_SHOWCENTURY).
+    /** Destructor. */
+    ~wxPGChoices()
+    {
+        Free();
+    }
 
 
-    @subsection wxEditEnumProperty
+    /**
+        Adds to current.
 
 
-    Represents a string that can be freely edited or selected from list of
-    choices - custom combobox control is used to edit the value.
+        If did not have own copies, creates them now. If was empty, identical
+        to set except that creates copies.
 
 
-    @subsection wxMultiChoiceProperty
+        @param labels
+            Labels for added choices.
 
 
-    Allows editing a multiple selection from a list of strings. This is
-    property is pretty much built around concept of wxMultiChoiceDialog.
-    It uses wxArrayString value.
+        @param values
+            Values for added choices. If empty, relevant entry indexes are used.
+    */
+    void Add( const wxChar* const* labels, const ValArrItem* values = NULL );
 
 
-    @subsection wxImageFileProperty
+    /** Version that works with wxArrayString and wxArrayInt. */
+    void Add( const wxArrayString& arr, const wxArrayInt& arrint = wxArrayInt() );
 
 
-    Like wxFileProperty, but has thumbnail of the image in front of
-    the filename and autogenerates wildcard from available image handlers.
+    /**
+        Adds a single choice.
 
 
-    @subsection wxColourProperty
+        @param label
+            Label for added choice.
 
 
-    <b>Useful alternate editor:</b> Choice.
+        @param value
+            Value for added choice. If unspecified, index is used.
+    */
+    wxPGChoiceEntry& Add( const wxString& label,
+                          int value = wxPG_INVALID_VALUE );
 
 
-    Represents wxColour. wxButton is used to trigger a colour picker dialog.
+    /** Adds a single item, with bitmap. */
+    wxPGChoiceEntry& Add( const wxString& label,
+                          const wxBitmap& bitmap,
+                          int value = wxPG_INVALID_VALUE );
 
 
-    @subsection wxFontProperty
+    /** Adds a single item with full entry information. */
+    wxPGChoiceEntry& Add( const wxPGChoiceEntry& entry )
+    {
+        return Insert(entry, -1);
+    }
 
 
-    Represents wxFont. Various sub-properties are used to edit individual
-    subvalues.
+    /** Adds single item. */
+    wxPGChoiceEntry& AddAsSorted( const wxString& label,
+                                  int value = wxPG_INVALID_VALUE );
 
 
-    @subsection wxSystemColourProperty
+    /**
+        Assigns choices data, using reference counting. To create a real copy,
+        use Copy() member function instead.
+    */
+    void Assign( const wxPGChoices& a )
+    {
+        AssignData(a.m_data);
+    }
 
 
-    Represents wxColour and a system colour index. wxChoice is used to edit
-    the value. Drop-down list has color images. Note that value type
-    is wxColourPropertyValue instead of wxColour.
-    @code
-        class wxColourPropertyValue : public wxObject
-        {
-        public:
-            //  An integer value relating to the colour, and which exact
-            //  meaning depends on the property with which it is used.
-            //
-            //  For wxSystemColourProperty:
-            //  Any of wxSYS_COLOUR_XXX, or any web-colour (use
-            //  wxPG_TO_WEB_COLOUR macro - (currently unsupported) ),
-            //  or wxPG_COLOUR_CUSTOM.
-            wxUint32    m_type;
+    void AssignData( wxPGChoicesData* data );
 
 
-            // Resulting colour. Should be correct regardless of type.
-            wxColour    m_colour;
-        };
-    @endcode
+    /** Delete all choices. */
+    void Clear();
+
+    /**
+        Returns a real copy of the choices.
+    */
+    wxPGChoices Copy() const
+    {
+        wxPGChoices dst;
+        dst.EnsureData();
+        dst.m_data->CopyDataFrom(m_data);
+        return dst;
+    }
 
 
-    @subsection wxCursorProperty
+    void EnsureData()
+    {
+        if ( m_data == wxPGChoicesEmptyData )
+            m_data = new wxPGChoicesData();
+    }
 
 
-    Represents a wxCursor. wxChoice is used to edit the value.
-    Drop-down list has cursor images under some (wxMSW) platforms.
+    /** Gets a unsigned number identifying this list. */
+    wxPGChoicesId GetId() const { return (wxPGChoicesId) m_data; };
 
 
+    const wxString& GetLabel( unsigned int ind ) const
+    {
+        return Item(ind).GetText();
+    }
 
 
-    @section pgproperty_creating Creating Custom Properties
+    unsigned int GetCount () const
+    {
+        if ( !m_data )
+            return 0;
 
 
-    New properties can be created by subclassing wxPGProperty or one
-    of the provided property classes, and (re)implementing necessary
-    member functions. Below, each virtual member function has ample
-    documentation about its purpose and any odd details which to keep
-    in mind.
+        return m_data->GetCount();
+    }
 
 
-    Here is a very simple 'template' code:
+    int GetValue( unsigned int ind ) const { return Item(ind).GetValue(); }
 
 
-    @code
-        class MyProperty : public wxPGProperty
-        {
-        public:
-            // All arguments of ctor must have a default value -
-            // use wxPG_LABEL for label and name
-            MyProperty( const wxString& label = wxPG_LABEL,
-                        const wxString& name = wxPG_LABEL,
-                        const wxString& value = wxEmptyString )
-            {
-                // m_value is wxVariant
-                m_value = value;
-            }
+    /** Returns array of values matching the given strings. Unmatching strings
+        result in wxPG_INVALID_VALUE entry in array.
+    */
+    wxArrayInt GetValuesForStrings( const wxArrayString& strings ) const;
 
 
-            virtual ~MyProperty() { }
+    /** Returns array of indices matching given strings. Unmatching strings
+        are added to 'unmatched', if not NULL.
+    */
+    wxArrayInt GetIndicesForStrings( const wxArrayString& strings,
+                                     wxArrayString* unmatched = NULL ) const;
 
 
-            const wxPGEditor* DoGetEditorClass() const
-            {
-                // Determines editor used by property.
-                // You can replace 'TextCtrl' below with any of these
-                // builtin-in property editor identifiers: Choice, ComboBox,
-                // TextCtrlAndButton, ChoiceAndButton, CheckBox, SpinCtrl,
-                // DatePickerCtrl.
-                return wxPGEditor_TextCtrl;
-            }
+    int Index( const wxString& str ) const;
+    int Index( int val ) const;
 
 
-            virtual wxString GetValueAsString( int argFlags ) const
-            {
-                // TODO: Return property value in string format
-            }
+    /** Inserts single item. */
+    wxPGChoiceEntry& Insert( const wxString& label,
+                             int index,
+                             int value = wxPG_INVALID_VALUE );
 
 
-            virtual bool StringToValue( wxVariant& variant,
-                                        const wxString& text,
-                                        int argFlags )
-            {
-                // TODO: Adapt string to property value.
-            }
+    /** Inserts a single item with full entry information. */
+    wxPGChoiceEntry& Insert( const wxPGChoiceEntry& entry, int index );
+
+    /** Returns false if this is a constant empty set of choices,
+        which should not be modified.
+    */
+    bool IsOk() const
+    {
+        return ( m_data != wxPGChoicesEmptyData );
+    }
+
+    const wxPGChoiceEntry& Item( unsigned int i ) const
+    {
+        wxASSERT( IsOk() );
+        return m_data->Item(i);
+    }
+
+    wxPGChoiceEntry& Item( unsigned int i )
+    {
+        wxASSERT( IsOk() );
+        return m_data->Item(i);
+    }
+
+    /** Removes count items starting at position nIndex. */
+    void RemoveAt(size_t nIndex, size_t count = 1);
+
+    /** Does not create copies for itself.
+        TODO: Deprecate.
+    */
+    void Set( const wxChar* const* labels, const long* values = NULL )
+    {
+        Free();
+        Add(labels,values);
+    }
+
+    /** Version that works with wxArrayString and wxArrayInt. */
+    void Set( const wxArrayString& labels,
+              const wxArrayInt& values = wxArrayInt() )
+    {
+        Free();
+        if ( &values )
+            Add(labels,values);
+        else
+            Add(labels);
+    }
+
+    // Creates exclusive copy of current choices
+    void AllocExclusive();
+
+    // Returns data, increases refcount.
+    wxPGChoicesData* GetData()
+    {
+        wxASSERT( m_data->GetRefCount() != -1 );
+        m_data->IncRef();
+        return m_data;
+    }
+
+    // Returns plain data ptr - no refcounting stuff is done.
+    wxPGChoicesData* GetDataPtr() const { return m_data; }
+
+    // Changes ownership of data to you.
+    wxPGChoicesData* ExtractData()
+    {
+        wxPGChoicesData* data = m_data;
+        m_data = wxPGChoicesEmptyData;
+        return data;
+    }
+
+    wxArrayString GetLabels() const;
+
+    void operator= (const wxPGChoices& a)
+    {
+        if (this != &a)
+            AssignData(a.m_data);
+    }
+
+    wxPGChoiceEntry& operator[](unsigned int i)
+    {
+        return Item(i);
+    }
+
+    const wxPGChoiceEntry& operator[](unsigned int i) const
+    {
+        return Item(i);
+    }
 
 
-        protected:
-        };
-    @endcode
+protected:
+    wxPGChoicesData*    m_data;
 
 
-    Since wxPGProperty derives from wxObject, you can use standard
-    DECLARE_DYNAMIC_CLASS and IMPLEMENT_DYNAMIC_CLASS macros. From the
-    above example they were omitted for sake of simplicity, and besides,
-    they are only really needed if you need to use wxRTTI with your
-    property class.
+    void Init();
+    void Free();
+};
 
 
-    You can change the 'value type' of a property by simply assigning different
-    type of variant with SetValue. <b>It is mandatory to implement
-    wxVariantData class for all data types used as property values.</b>
-    You can use macros declared in wxPropertyGrid headers. For instance:
+// -----------------------------------------------------------------------
 
 
-    @code
-        // In header file:
-        // (If you need to have export declaration, use version of macros
-        // with _EXPORTED postfix)
-        WX_PG_DECLARE_VARIANT_DATA(MyDataClass)
+/** @class wxPGProperty
 
 
-        // In sources file:
-        WX_PG_IMPLEMENT_VARIANT_DATA(MyDataClass)
+    wxPGProperty is base class for all wxPropertyGrid properties.
 
 
-        // Or, if you don't have valid == operator:
-        WX_PG_IMPLEMENT_VARIANT_DATA_DUMMY_EQ(MyDataClass)
-    @endcode
+    NB: Full class overview is now only present in
+        interface/wx/propgrid/property.h.
 
     @library{wxpropgrid}
     @category{propgrid}
 
     @library{wxpropgrid}
     @category{propgrid}
@@ -839,39 +1114,21 @@ class WXDLLIMPEXP_PROPGRID wxPGProperty : public wxObject
     friend class wxPropertyGridPageState;
     friend class wxPropertyGridPopulator;
     friend class wxStringProperty;  // Proper "<composed>" support requires this
     friend class wxPropertyGridPageState;
     friend class wxPropertyGridPopulator;
     friend class wxStringProperty;  // Proper "<composed>" support requires this
-#ifndef SWIG
+
     DECLARE_ABSTRACT_CLASS(wxPGProperty)
     DECLARE_ABSTRACT_CLASS(wxPGProperty)
-#endif
 public:
     typedef wxUint32 FlagType;
 
 public:
     typedef wxUint32 FlagType;
 
-    /** Basic constructor.
+    /**
+        Default constructor.
     */
     wxPGProperty();
 
     */
     wxPGProperty();
 
-    /** Constructor.
-        Non-abstract property classes should have constructor of this style:
-
-        @code
-
-        // If T is a class, then it should be a constant reference
-        // (e.g. const T& ) instead.
-        MyProperty( const wxString& label, const wxString& name, T value )
-            : wxPGProperty()
-        {
-            // Generally recommended way to set the initial value
-            // (as it should work in pretty much 100% of cases).
-            wxVariant variant;
-            variant << value;
-            SetValue(variant);
-
-            // If has private child properties then create them here, e.g.:
-            //     AddChild( new wxStringProperty( "Subprop 1",
-            //                                     wxPG_LABEL,
-            //                                     value.GetSubProp1() ) );
-        }
+    /**
+        Constructor.
 
 
-        @endcode
+        All non-abstract property classes should have a constructor with
+        the same first two arguments as this one.
     */
     wxPGProperty( const wxString& label, const wxString& name );
 
     */
     wxPGProperty( const wxString& label, const wxString& name );
 
@@ -898,7 +1155,6 @@ public:
     */
     virtual wxVariant DoGetValue() const { return m_value; }
 
     */
     virtual wxVariant DoGetValue() const { return m_value; }
 
-#if !defined(SWIG) || defined(CREATE_VCW)
     /** Implement this function in derived class to check the value.
         Return true if it is ok. Returning false prevents property change events
         from occurring.
     /** Implement this function in derived class to check the value.
         Return true if it is ok. Returning false prevents property change events
         from occurring.
@@ -910,35 +1166,52 @@ public:
                                 wxPGValidationInfo& validationInfo ) const;
 
     /**
                                 wxPGValidationInfo& validationInfo ) const;
 
     /**
-        Converts 'text' into proper value 'variant'.
-        Returns true if new (different than m_value) value could be interpreted
-        from the text.
+        Converts text into wxVariant value appropriate for this property.
+
+        @param variant
+            On function entry this is the old value (should not be wxNullVariant
+            in normal cases). Translated value must be assigned back to it.
+
+        @param text
+            Text to be translated into variant.
+
         @param argFlags
             If wxPG_FULL_VALUE is set, returns complete, storable value instead
             of displayable one (they may be different).
             If wxPG_COMPOSITE_FRAGMENT is set, text is interpreted as a part of
         @param argFlags
             If wxPG_FULL_VALUE is set, returns complete, storable value instead
             of displayable one (they may be different).
             If wxPG_COMPOSITE_FRAGMENT is set, text is interpreted as a part of
-            composite property string value (as generated by GetValueAsString()
+            composite property string value (as generated by ValueToString()
             called with this same flag).
 
             called with this same flag).
 
-        @remarks
-        Default implementation converts semicolon delimited tokens into child
-        values. Only works for properties with children.
+        @return Returns @true if resulting wxVariant value was different.
+
+        @remarks Default implementation converts semicolon delimited tokens into
+                child values. Only works for properties with children.
+
+                You might want to take into account that m_value is Null variant
+                if property value is unspecified (which is usually only case if
+                you explicitly enabled that sort behavior).
     */
     virtual bool StringToValue( wxVariant& variant,
                                 const wxString& text,
                                 int argFlags = 0 ) const;
 
     /**
     */
     virtual bool StringToValue( wxVariant& variant,
                                 const wxString& text,
                                 int argFlags = 0 ) const;
 
     /**
-        Converts 'number' (including choice selection) into proper value
-        'variant'.
+        Converts integer (possibly a choice selection) into wxVariant value
+        appropriate for this property.
+
+        @param variant
+            On function entry this is the old value (should not be wxNullVariant
+            in normal cases). Translated value must be assigned back to it.
 
 
-        Returns true if new (different than m_value) value could be interpreted
-        from the integer.
+        @param number
+            Integer to be translated into variant.
 
         @param argFlags
             If wxPG_FULL_VALUE is set, returns complete, storable value instead
             of displayable one.
 
 
         @param argFlags
             If wxPG_FULL_VALUE is set, returns complete, storable value instead
             of displayable one.
 
+        @return Returns @true if resulting wxVariant value was different.
+
         @remarks
         - If property is not supposed to use choice or spinctrl or other editor
           with int-based value, it is not necessary to implement this method.
         @remarks
         - If property is not supposed to use choice or spinctrl or other editor
           with int-based value, it is not necessary to implement this method.
@@ -946,27 +1219,32 @@ public:
         - If property uses choice control, and displays a dialog on some choice
           items, then it is preferred to display that dialog in IntToValue
           instead of OnEvent.
         - If property uses choice control, and displays a dialog on some choice
           items, then it is preferred to display that dialog in IntToValue
           instead of OnEvent.
+        - You might want to take into account that m_value is Null variant if
+          property value is unspecified (which is usually only case if you
+          explicitly enabled that sort behavior).
     */
     virtual bool IntToValue( wxVariant& value,
                              int number,
                              int argFlags = 0 ) const;
     */
     virtual bool IntToValue( wxVariant& value,
                              int number,
                              int argFlags = 0 ) const;
-#endif  // !defined(SWIG) || defined(CREATE_VCW)
 
 
-public:
-    /** Returns text representation of property's value.
+    /**
+        Converts property value into a text representation.
+
+        @param value
+            Value to be converted.
 
         @param argFlags
 
         @param argFlags
+            If 0 (default value), then displayed string is returned.
             If wxPG_FULL_VALUE is set, returns complete, storable string value
             instead of displayable. If wxPG_EDITABLE_VALUE is set, returns
             string value that must be editable in textctrl. If
             wxPG_COMPOSITE_FRAGMENT is set, returns text that is appropriate to
             If wxPG_FULL_VALUE is set, returns complete, storable string value
             instead of displayable. If wxPG_EDITABLE_VALUE is set, returns
             string value that must be editable in textctrl. If
             wxPG_COMPOSITE_FRAGMENT is set, returns text that is appropriate to
-            display as a part of composite property string value.
+            display as a part of string property's composite text
+            representation.
 
 
-        @remarks
-        Default implementation returns string composed from text
-        representations of child properties.
+        @remarks Default implementation calls GenerateComposedValue().
     */
     */
-    virtual wxString GetValueAsString( int argFlags = 0 ) const;
+    virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 
     /** Converts string to a value, and if successful, calls SetValue() on it.
         Default behavior is to do nothing.
 
     /** Converts string to a value, and if successful, calls SetValue() on it.
         Default behavior is to do nothing.
@@ -975,7 +1253,7 @@ public:
         @return
         true if value was changed.
     */
         @return
         true if value was changed.
     */
-    bool SetValueFromString( const wxString& text, int flags = 0 );
+    bool SetValueFromString( const wxString& text, int flags = wxPG_PROGRAMMATIC_VALUE );
 
     /** Converts integer to a value, and if succesful, calls SetValue() on it.
         Default behavior is to do nothing.
 
     /** Converts integer to a value, and if succesful, calls SetValue() on it.
         Default behavior is to do nothing.
@@ -1030,17 +1308,21 @@ public:
                           wxEvent& event );
 
     /**
                           wxEvent& event );
 
     /**
-        Called after value of a child property has been altered.
+        Called after value of a child property has been altered. Must return
+        new value of the whole property (after any alterations warrented by
+        child's new value).
 
         Note that this function is usually called at the time that value of
 
         Note that this function is usually called at the time that value of
-        this property, or given child property, is still pending for change.
+        this property, or given child property, is still pending for change,
+        and as such, result of GetValue() or m_value should not be relied
+        on.
 
         Sample pseudo-code implementation:
 
         @code
 
         Sample pseudo-code implementation:
 
         @code
-        void MyProperty::ChildChanged( wxVariant& thisValue,
-                                       int childIndex,
-                                       wxVariant& childValue ) const
+        wxVariant MyProperty::ChildChanged( wxVariant& thisValue,
+                                            int childIndex,
+                                            wxVariant& childValue ) const
         {
             // Acquire reference to actual type of data stored in variant
             // (TFromVariant only exists if wxPropertyGrid's wxVariant-macros
         {
             // Acquire reference to actual type of data stored in variant
             // (TFromVariant only exists if wxPropertyGrid's wxVariant-macros
@@ -1058,19 +1340,28 @@ public:
                     break;
                 ...
             }
                     break;
                 ...
             }
+
+            // Return altered data
+            return data;
         }
         @endcode
 
         @param thisValue
         }
         @endcode
 
         @param thisValue
-            Value of this property, that should be altered.
+            Value of this property. Changed value should be returned (in
+            previous versions of wxPropertyGrid it was only necessary to
+            write value back to this argument).
         @param childIndex
         @param childIndex
-            Index of child changed (you can use Item(childIndex) to get).
+            Index of child changed (you can use Item(childIndex) to get
+            child property).
         @param childValue
         @param childValue
-            Value of the child property.
+            (Pending) value of the child property.
+
+        @return
+            Modified value of the whole property.
     */
     */
-    virtual void ChildChanged( wxVariant& thisValue,
-                               int childIndex,
-                               wxVariant& childValue ) const;
+    virtual wxVariant ChildChanged( wxVariant& thisValue,
+                                    int childIndex,
+                                    wxVariant& childValue ) const;
 
     /** Returns pointer to an instance of used editor.
     */
 
     /** Returns pointer to an instance of used editor.
     */
@@ -1108,21 +1399,6 @@ public:
     */
     virtual wxValidator* DoGetValidator () const;
 
     */
     virtual wxValidator* DoGetValidator () const;
 
-    /**
-        Returns current value's index to the choice control.
-
-        May also return, through pointer arguments, strings that should be
-        inserted to that control. Irrelevant to classes which do not employ
-        wxPGEditor_Choice or similar.
-
-        @remarks
-        - If returns NULL in choiceinfo.m_choices, then this class must be
-          derived from wxBaseEnumProperty.
-        - Must be able to cope situation where property's set of choices is
-          uninitialized.
-    */
-    virtual int GetChoiceInfo( wxPGChoiceInfo* choiceinfo );
-
     /**
         Override to paint an image in front of the property value text or
         drop-down list item (but only if wxPGProperty::OnMeasureImage is
     /**
         Override to paint an image in front of the property value text or
         drop-down list item (but only if wxPGProperty::OnMeasureImage is
@@ -1164,7 +1440,7 @@ public:
               colour) pen for drawing framing rectangle. It can be changed as
               well.
 
               colour) pen for drawing framing rectangle. It can be changed as
               well.
 
-        @see GetValueAsString()
+        @see ValueToString()
     */
     virtual void OnCustomPaint( wxDC& dc,
                                 const wxRect& rect,
     */
     virtual void OnCustomPaint( wxDC& dc,
                                 const wxRect& rect,
@@ -1178,6 +1454,14 @@ public:
     */
     virtual wxPGCellRenderer* GetCellRenderer( int column ) const;
 
     */
     virtual wxPGCellRenderer* GetCellRenderer( int column ) const;
 
+    /** Returns which choice is currently selected. Only applies to properties
+        which have choices.
+
+        Needs to reimplemented in derived class if property value does not
+        map directly to a choice. Integer as index, bool, and string usually do.
+    */
+    virtual int GetChoiceSelection() const;
+
     /**
         Refresh values of child properties.
 
     /**
         Refresh values of child properties.
 
@@ -1185,12 +1469,16 @@ public:
     */
     virtual void RefreshChildren();
 
     */
     virtual void RefreshChildren();
 
-    /** Special handling for attributes of this property.
+    /**
+        Reimplement this member function to add special handling for
+        attributes of this property.
 
 
-        If returns false, then the attribute will be automatically stored in
-        m_attributes.
+        @return Return @false to have the attribute automatically stored in
+                m_attributes. Default implementation simply does that and
+                nothing else.
 
 
-        Default implementation simply returns false.
+        @remarks To actually set property attribute values from the
+                 application, use wxPGProperty::SetAttribute() instead.
     */
     virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
 
     */
     virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
 
@@ -1211,27 +1499,19 @@ public:
     virtual wxPGEditorDialogAdapter* GetEditorDialog() const;
 
     /**
     virtual wxPGEditorDialogAdapter* GetEditorDialog() const;
 
     /**
-        Adds entry to property's wxPGChoices and editor control (if it is
-        active).
+        Called whenever validation has failed with given pending value.
 
 
-        Returns index of item added.
+        @remarks If you implement this in your custom property class, please
+                 remember to call the baser implementation as well, since they
+                 may use it to revert property into pre-change state.
     */
     */
-    int AppendChoice( const wxString& label, int value = wxPG_INVALID_VALUE )
-    {
-        return InsertChoice(label,-1,value);
-    }
+    virtual void OnValidationFailure( wxVariant& pendingValue );
 
 
-    /** Returns wxPGCell of given column, NULL if none. If valid
-        object is returned, caller will gain its ownership.
+    /** Append a new choice to property's list of choices.
     */
     */
-    wxPGCell* AcquireCell( unsigned int column )
+    int AddChoice( const wxString& label, int value = wxPG_INVALID_VALUE )
     {
     {
-        if ( column >= m_cells.size() )
-            return NULL;
-
-        wxPGCell* cell = (wxPGCell*) m_cells[column];
-        m_cells[column] = NULL;
-        return cell;
+        return InsertChoice(label, wxNOT_FOUND, value);
     }
 
     /**
     }
 
     /**
@@ -1247,6 +1527,11 @@ public:
         return false;
     }
 
         return false;
     }
 
+    /**
+        Deletes children of the property.
+    */
+    void DeleteChildren();
+
     /**
         Removes entry from property's wxPGChoices and editor control (if it is
         active).
     /**
         Removes entry from property's wxPGChoices and editor control (if it is
         active).
@@ -1255,6 +1540,17 @@ public:
     */
     void DeleteChoice( int index );
 
     */
     void DeleteChoice( int index );
 
+    /**
+        Enables or disables the property. Disabled property usually appears
+        as having grey text.
+
+        @param enable
+            If @false, property is disabled instead.
+
+        @see wxPropertyGridInterface::EnableProperty()
+    */
+    void Enable( bool enable = true );
+
     /**
         Call to enable or disable usage of common value (integer value that can
         be selected for properties instead of their normal values) for this
     /**
         Call to enable or disable usage of common value (integer value that can
         be selected for properties instead of their normal values) for this
@@ -1268,8 +1564,15 @@ public:
         else ClearFlag( wxPG_PROP_USES_COMMON_VALUE );
     }
 
         else ClearFlag( wxPG_PROP_USES_COMMON_VALUE );
     }
 
-    /** Composes text from values of child properties. */
-    void GenerateComposedValue( wxString& text, int argFlags = 0 ) const;
+    /**
+        Composes text from values of child properties.
+    */
+    wxString GenerateComposedValue() const
+    {
+        wxString s;
+        DoGenerateComposedValue(s);
+        return s;
+    }
 
     /** Returns property's label. */
     const wxString& GetLabel() const { return m_label; }
 
     /** Returns property's label. */
     const wxString& GetLabel() const { return m_label; }
@@ -1283,11 +1586,12 @@ public:
      */
     const wxString& GetBaseName() const { return m_name; }
 
      */
     const wxString& GetBaseName() const { return m_name; }
 
-    wxPGChoices& GetChoices();
-
-    const wxPGChoices& GetChoices() const;
-
-    const wxPGChoiceEntry* GetCurrentChoice() const;
+    /** Returns read-only reference to property's list of choices.
+    */
+    const wxPGChoices& GetChoices() const
+    {
+        return m_choices;
+    }
 
     /** Returns coordinate to the top y of the property. Note that the
         position of scrollbars is not taken into account.
 
     /** Returns coordinate to the top y of the property. Note that the
         position of scrollbars is not taken into account.
@@ -1299,7 +1603,6 @@ public:
         return DoGetValue();
     }
 
         return DoGetValue();
     }
 
-#ifndef SWIG
     /** Returns reference to the internal stored value. GetValue is preferred
         way to get the actual value, since GetValueRef ignores DoGetValue,
         which may override stored value.
     /** Returns reference to the internal stored value. GetValue is preferred
         way to get the actual value, since GetValueRef ignores DoGetValue,
         which may override stored value.
@@ -1313,28 +1616,61 @@ public:
     {
         return m_value;
     }
     {
         return m_value;
     }
-#endif
 
 
-    /** Same as GetValueAsString, except takes common value into account.
+    // Helper function (for wxPython bindings and such) for settings protected
+    // m_value.
+    wxVariant GetValuePlain() const
+    {
+        return m_value;
+    }
+
+    /** Returns text representation of property's value.
+
+        @param argFlags
+            If 0 (default value), then displayed string is returned.
+            If wxPG_FULL_VALUE is set, returns complete, storable string value
+            instead of displayable. If wxPG_EDITABLE_VALUE is set, returns
+            string value that must be editable in textctrl. If
+            wxPG_COMPOSITE_FRAGMENT is set, returns text that is appropriate to
+            display as a part of string property's composite text
+            representation.
+
+        @remarks In older versions, this function used to be overridden to convert
+                 property's value into a string representation. This function is
+                 now handled by ValueToString(), and overriding this function now
+                 will result in run-time assertion failure.
     */
     */
-    wxString GetValueString( int argFlags = 0 ) const;
+    virtual wxString GetValueAsString( int argFlags = 0 ) const;
+
+    /** Synonymous to GetValueAsString().
 
 
-    void UpdateControl( wxWindow* primary );
+        @deprecated Use GetValueAsString() instead.
 
 
-    /** Returns wxPGCell of given column, NULL if none. wxPGProperty
-        will retain ownership of the cell object.
+        @see GetValueAsString()
     */
     */
-    wxPGCell* GetCell( unsigned int column ) const
-    {
-        if ( column >= m_cells.size() )
-            return NULL;
+    wxDEPRECATED( wxString GetValueString( int argFlags = 0 ) const );
 
 
-        return (wxPGCell*) m_cells[column];
-    }
+    /**
+        Returns wxPGCell of given column.
+
+        @remarks const version of this member function returns 'default'
+                 wxPGCell object if the property itself didn't hold
+                 cell data.
+    */
+    const wxPGCell& GetCell( unsigned int column ) const;
 
 
-    unsigned int GetChoiceCount() const;
+    /**
+        Returns wxPGCell of given column, creating one if necessary.
+    */
+    wxPGCell& GetCell( unsigned int column )
+    {
+        return GetOrCreateCell(column);
+    }
 
 
-    wxString GetChoiceString( unsigned int index );
+    /**
+        Returns wxPGCell of given column, creating one if necessary.
+    */
+    wxPGCell& GetOrCreateCell( unsigned int column );
 
     /** Return number of displayed common values for this property.
     */
 
     /** Return number of displayed common values for this property.
     */
@@ -1342,9 +1678,14 @@ public:
 
     wxString GetDisplayedString() const
     {
 
     wxString GetDisplayedString() const
     {
-        return GetValueString(0);
+        return GetValueAsString(0);
     }
 
     }
 
+    /**
+        Returns property's hint text (shown in empty value cell).
+    */
+    inline wxString GetHintText() const;
+
     /** Returns property grid where property lies. */
     wxPropertyGrid* GetGrid() const;
 
     /** Returns property grid where property lies. */
     wxPropertyGrid* GetGrid() const;
 
@@ -1377,7 +1718,12 @@ public:
         return m_value.IsNull();
     }
 
         return m_value.IsNull();
     }
 
-    FlagType HasFlag( FlagType flag ) const
+    /**
+        Returns non-zero if property has given flag set.
+
+        @see propgrid_propflags
+    */
+    FlagType HasFlag( wxPGPropertyFlags flag ) const
     {
         return ( m_flags & flag );
     }
     {
         return ( m_flags & flag );
     }
@@ -1393,6 +1739,9 @@ public:
     */
     wxVariant GetAttributesAsList() const;
 
     */
     wxVariant GetAttributesAsList() const;
 
+    /**
+        Returns property flags.
+    */
     FlagType GetFlags() const
     {
         return m_flags;
     FlagType GetFlags() const
     {
         return m_flags;
@@ -1427,14 +1776,21 @@ public:
     bool HasVisibleChildren() const;
 
     /**
     bool HasVisibleChildren() const;
 
     /**
-        Adds entry to property's wxPGChoices and editor control (if it is
-        active).
+        Use this member function to add independent (ie. regular) children to
+        a property.
+
+        @return Inserted childProperty.
 
 
-        Returns index of item added.
+        @remarks wxPropertyGrid is not automatically refreshed by this
+                 function.
+
+        @see AddPrivateChild()
+    */
+    wxPGProperty* InsertChild( int index, wxPGProperty* childProperty );
+
+    /** Inserts a new choice to property's list of choices.
     */
     */
-    int InsertChoice( const wxString& label,
-                      int index,
-                      int value = wxPG_INVALID_VALUE );
+    int InsertChoice( const wxString& label, int index, int value = wxPG_INVALID_VALUE );
 
     /**
         Returns true if this property is actually a wxPropertyCategory.
 
     /**
         Returns true if this property is actually a wxPropertyCategory.
@@ -1468,7 +1824,9 @@ public:
     /**
         Determines, recursively, if all children are not unspecified.
 
     /**
         Determines, recursively, if all children are not unspecified.
 
-        Takes values in given list into account.
+        @param pendingList
+            Assumes members in this wxVariant list as pending
+            replacement values.
     */
     bool AreAllChildrenSpecified( wxVariant* pendingList = NULL ) const;
 
     */
     bool AreAllChildrenSpecified( wxVariant* pendingList = NULL ) const;
 
@@ -1482,9 +1840,9 @@ public:
 
     /** Returns true if containing grid uses wxPG_EX_AUTO_UNSPECIFIED_VALUES.
     */
 
     /** Returns true if containing grid uses wxPG_EX_AUTO_UNSPECIFIED_VALUES.
     */
-    FlagType UsesAutoUnspecified() const
+    bool UsesAutoUnspecified() const
     {
     {
-        return HasFlag(wxPG_PROP_AUTO_UNSPECIFIED);
+        return HasFlag(wxPG_PROP_AUTO_UNSPECIFIED)?true:false;
     }
 
     wxBitmap* GetValueImage() const
     }
 
     wxBitmap* GetValueImage() const
@@ -1515,8 +1873,6 @@ public:
     */
     double GetAttributeAsDouble( const wxString& name, double defVal ) const;
 
     */
     double GetAttributeAsDouble( const wxString& name, double defVal ) const;
 
-    unsigned int GetArrIndex() const { return m_arrIndex; }
-
     unsigned int GetDepth() const { return (unsigned int)m_depth; }
 
     /** Gets flags as a'|' delimited string. Note that flag names are not
     unsigned int GetDepth() const { return (unsigned int)m_depth; }
 
     /** Gets flags as a'|' delimited string. Note that flag names are not
@@ -1539,7 +1895,7 @@ public:
             By default changes are applied recursively. Set this paramter
             wxPG_DONT_RECURSE to prevent this.
     */
             By default changes are applied recursively. Set this paramter
             wxPG_DONT_RECURSE to prevent this.
     */
-    inline bool Hide( bool hide, int flags = wxPG_RECURSE );
+    bool Hide( bool hide, int flags = wxPG_RECURSE );
 
     bool IsExpanded() const
         { return (!(m_flags & wxPG_PROP_COLLAPSED) && GetChildCount()); }
 
     bool IsExpanded() const
         { return (!(m_flags & wxPG_PROP_COLLAPSED) && GetChildCount()); }
@@ -1569,39 +1925,83 @@ public:
 
     void SetAttributes( const wxPGAttributeStorage& attributes );
 
 
     void SetAttributes( const wxPGAttributeStorage& attributes );
 
-#ifndef SWIG
-    /** Sets editor for a property.
-
-        @param editor
-            For builtin editors, use wxPGEditor_X, where X is builtin editor's
-            name (TextCtrl, Choice, etc. see wxPGEditor documentation for full
-            list).
+    /**
+        Set if user can change the property's value to unspecified by
+        modifying the value of the editor control (usually by clearing
+        it).  Currently, this can work with following properties:
+        wxIntProperty, wxUIntProperty, wxFloatProperty, wxEditEnumProperty.
 
 
-        For custom editors, use pointer you received from
-        wxPropertyGrid::RegisterEditorClass().
+        @param enable
+            Whether to enable or disable this behavior (it is disabled by
+            default).
     */
     */
-    void SetEditor( const wxPGEditor* editor )
+    void SetAutoUnspecified( bool enable = true )
     {
     {
-        m_customEditor = editor;
+        ChangeFlag(wxPG_PROP_AUTO_UNSPECIFIED, enable);
     }
     }
-#endif
 
 
-    /** Sets editor for a property.
-    */
-    inline void SetEditor( const wxString& editorName );
+    /**
+        Sets property's background colour.
 
 
-    /** Sets cell information for given column.
+        @param colour
+            Background colour to use.
 
 
-        Note that the property takes ownership of given wxPGCell instance.
+        @param flags
+            Default is wxPG_RECURSE which causes colour to be set recursively.
+            Omit this flag to only set colour for the property in question
+            and not any of its children.
     */
     */
-    void SetCell( int column, wxPGCell* cellObj );
+    void SetBackgroundColour( const wxColour& colour,
+                              int flags = wxPG_RECURSE );
 
 
-    /** Changes value of a property with choices, but only
-        works if the value type is long or string. */
-    void SetChoiceSelection( int newValue, const wxPGChoiceInfo& choiceInfo );
+    /**
+        Sets property's text colour.
 
 
-    /** Sets common value selected for this property. -1 for none.
-    */
+        @param colour
+            Text colour to use.
+
+        @param flags
+            Default is wxPG_RECURSE which causes colour to be set recursively.
+            Omit this flag to only set colour for the property in question
+            and not any of its children.
+    */
+    void SetTextColour( const wxColour& colour,
+                        int flags = wxPG_RECURSE );
+
+    /** Set default value of a property. Synonymous to
+
+        @code
+            SetAttribute("DefaultValue", value);
+        @endcode
+    */
+    void SetDefaultValue( wxVariant& value );
+
+    /** Sets editor for a property.
+
+        @param editor
+            For builtin editors, use wxPGEditor_X, where X is builtin editor's
+            name (TextCtrl, Choice, etc. see wxPGEditor documentation for full
+            list).
+
+        For custom editors, use pointer you received from
+        wxPropertyGrid::RegisterEditorClass().
+    */
+    void SetEditor( const wxPGEditor* editor )
+    {
+        m_customEditor = editor;
+    }
+
+    /** Sets editor for a property.
+    */
+    inline void SetEditor( const wxString& editorName );
+
+    /**
+        Sets cell information for given column.
+    */
+    void SetCell( int column, const wxPGCell& cell );
+
+    /** Sets common value selected for this property. -1 for none.
+    */
     void SetCommonValue( int commonValue )
     {
         m_commonValue = commonValue;
     void SetCommonValue( int commonValue )
     {
         m_commonValue = commonValue;
@@ -1642,22 +2042,27 @@ public:
         SetValueInEvent() instead.
 
         @param pList
         SetValueInEvent() instead.
 
         @param pList
-        Pointer to list variant that contains child values. Used to indicate
-        which children should be marked as modified.
+            Pointer to list variant that contains child values. Used to
+            indicate which children should be marked as modified.
+
         @param flags
         @param flags
-        Various flags (for instance, wxPG_SETVAL_REFRESH_EDITOR).
+            Various flags (for instance, wxPG_SETVAL_REFRESH_EDITOR, which is
+            enabled by default).
     */
     */
-    void SetValue( wxVariant value, wxVariant* pList = NULL, int flags = 0 );
+    void SetValue( wxVariant value, wxVariant* pList = NULL,
+                   int flags = wxPG_SETVAL_REFRESH_EDITOR );
 
     /** Set wxBitmap in front of the value. This bitmap may be ignored
         by custom cell renderers.
     */
     void SetValueImage( wxBitmap& bmp );
 
 
     /** Set wxBitmap in front of the value. This bitmap may be ignored
         by custom cell renderers.
     */
     void SetValueImage( wxBitmap& bmp );
 
-    /** If property has choices and they are not yet exclusive, new such copy
-        of them will be created.
+    /** Sets selected choice and changes property value.
+
+        Tries to retain value type, although currently if it is not string,
+        then it is forced to integer.
     */
     */
-    void SetChoicesExclusive();
+    void SetChoiceSelection( int newValue );
 
     void SetExpanded( bool expanded )
     {
 
     void SetExpanded( bool expanded )
     {
@@ -1665,9 +2070,31 @@ public:
         else m_flags &= ~wxPG_PROP_COLLAPSED;
     }
 
         else m_flags &= ~wxPG_PROP_COLLAPSED;
     }
 
-    void SetFlag( FlagType flag ) { m_flags |= flag; }
+    /**
+        Sets or clears given property flag. Mainly for internal use.
+
+        @remarks Setting a property flag never has any side-effect, and is
+                 intended almost exclusively for internal use. So, for
+                 example, if you want to disable a property, call
+                 Enable(false) instead of setting wxPG_PROP_DISABLED flag.
+
+        @see HasFlag(), GetFlags()
+    */
+    void ChangeFlag( wxPGPropertyFlags flag, bool set )
+    {
+        if ( set )
+            m_flags |= flag;
+        else
+            m_flags &= ~flag;
+    }
+
+    /**
+        Sets or clears given property flag, recursively. This function is
+        primarily intended for internal use.
 
 
-    void SetFlagRecursively( FlagType flag, bool set );
+        @see ChangeFlag()
+    */
+    void SetFlagRecursively( wxPGPropertyFlags flag, bool set );
 
     void SetHelpString( const wxString& helpString )
     {
 
     void SetHelpString( const wxString& helpString )
     {
@@ -1676,12 +2103,36 @@ public:
 
     void SetLabel( const wxString& label ) { m_label = label; }
 
 
     void SetLabel( const wxString& label ) { m_label = label; }
 
-    inline void SetName( const wxString& newName );
+    void SetName( const wxString& newName );
+
+    /**
+        Changes what sort of parent this property is for its children.
+
+        @param flag
+            Use one of the following values: wxPG_PROP_MISC_PARENT (for
+            generic parents), wxPG_PROP_CATEGORY (for categories), or
+            wxPG_PROP_AGGREGATE (for derived property classes with private
+            children).
+
+        @remarks You generally do not need to call this function.
+    */
+    void SetParentalType( int flag )
+    {
+        m_flags &= ~(wxPG_PROP_PROPERTY|wxPG_PROP_PARENTAL_FLAGS);
+        m_flags |= flag;
+    }
 
     void SetValueToUnspecified()
     {
         wxVariant val;  // Create NULL variant
 
     void SetValueToUnspecified()
     {
         wxVariant val;  // Create NULL variant
-        SetValue(val);
+        SetValue(val, NULL, wxPG_SETVAL_REFRESH_EDITOR);
+    }
+
+    // Helper function (for wxPython bindings and such) for settings protected
+    // m_value.
+    void SetValuePlain( wxVariant value )
+    {
+        m_value = value;
     }
 
 #if wxUSE_VALIDATORS
     }
 
 #if wxUSE_VALIDATORS
@@ -1698,26 +2149,8 @@ public:
             return m_validator;
         return DoGetValidator();
     }
             return m_validator;
         return DoGetValidator();
     }
-#endif // #if wxUSE_VALIDATORS
-
-    /** Updates property value in case there were last minute
-        changes. If value was unspecified, it will be set to default.
-        Use only for properties that have TextCtrl-based editor.
-        @remarks
-        If you have code similar to
-        @code
-            // Update the value in case of last minute changes
-            if ( primary && propgrid->IsEditorsValueModified() )
-                 GetEditorClass()->CopyValueFromControl( this, primary );
-        @endcode
-        in wxPGProperty::OnEvent wxEVT_COMMAND_BUTTON_CLICKED handler,
-        then replace it with call to this method.
-        @return
-        True if value changed.
-    */
-    bool PrepareValueForDialogEditing( wxPropertyGrid* propgrid );
+#endif // wxUSE_VALIDATORS
 
 
-#ifndef SWIG
     /** Returns client data (void*) of a property.
     */
     void* GetClientData() const
     /** Returns client data (void*) of a property.
     */
     void* GetClientData() const
@@ -1745,19 +2178,14 @@ public:
     /** Sets managed client object of a property.
     */
     wxClientData *GetClientObject() const { return m_clientObject; }
     /** Sets managed client object of a property.
     */
     wxClientData *GetClientObject() const { return m_clientObject; }
-#endif
 
 
-    /** Sets new set of choices for property.
-
-        @remarks
-        This operation clears the property value.
-    */
-    bool SetChoices( wxPGChoices& choices );
+    /**
+        Sets new set of choices for the property.
 
 
-    /** Sets new set of choices for property.
+        @remarks This operation deselects the property and clears its
+                 value.
     */
     */
-    inline bool SetChoices( const wxArrayString& labels,
-                            const wxArrayInt& values = wxArrayInt() );
+    bool SetChoices( const wxPGChoices& choices );
 
     /** Set max length of text in text editor.
     */
 
     /** Set max length of text in text editor.
     */
@@ -1777,8 +2205,6 @@ public:
         return m_helpString;
     }
 
         return m_helpString;
     }
 
-    void ClearFlag( FlagType flag ) { m_flags &= ~(flag); }
-
     // Use, for example, to detect if item is inside collapsed section.
     bool IsSomeParent( wxPGProperty* candidate_parent ) const;
 
     // Use, for example, to detect if item is inside collapsed section.
     bool IsSomeParent( wxPGProperty* candidate_parent ) const;
 
@@ -1788,8 +2214,33 @@ public:
     */
     void AdaptListToValue( wxVariant& list, wxVariant* value ) const;
 
     */
     void AdaptListToValue( wxVariant& list, wxVariant* value ) const;
 
-    /** This is used by properties that have fixed sub-properties. */
-    void AddChild( wxPGProperty* prop );
+#if wxPG_COMPATIBILITY_1_4
+    /**
+        Adds a private child property.
+
+        @deprecated Use AddPrivateChild() instead.
+
+        @see AddPrivateChild()
+    */
+    wxDEPRECATED( void AddChild( wxPGProperty* prop ) );
+#endif
+
+    /**
+        Adds a private child property. If you use this instead of
+        wxPropertyGridInterface::Insert() or
+        wxPropertyGridInterface::AppendIn(), then property's parental
+        type will automatically be set up to wxPG_PROP_AGGREGATE. In other
+        words, all properties of this property will become private.
+    */
+    void AddPrivateChild( wxPGProperty* prop );
+
+    /**
+        Appends a new child property.
+    */
+    wxPGProperty* AppendChild( wxPGProperty* prop )
+    {
+        return InsertChild(-1, prop);
+    }
 
     /** Returns height of children, recursively, and
         by taking expanded/collapsed status into account.
 
     /** Returns height of children, recursively, and
         by taking expanded/collapsed status into account.
@@ -1799,68 +2250,51 @@ public:
     int GetChildrenHeight( int lh, int iMax = -1 ) const;
 
     /** Returns number of child properties */
     int GetChildrenHeight( int lh, int iMax = -1 ) const;
 
     /** Returns number of child properties */
-    unsigned int GetChildCount() const { return m_children.GetCount(); }
+    unsigned int GetChildCount() const
+    {
+        return (unsigned int) m_children.size();
+    }
 
     /** Returns sub-property at index i. */
 
     /** Returns sub-property at index i. */
-    wxPGProperty* Item( size_t i ) const
-        { return (wxPGProperty*)m_children.Item(i); }
+    wxPGProperty* Item( unsigned int i ) const
+        { return m_children[i]; }
 
     /** Returns last sub-property.
     */
 
     /** Returns last sub-property.
     */
-    wxPGProperty* Last() const { return (wxPGProperty*)m_children.Last(); }
+    wxPGProperty* Last() const { return m_children.back(); }
 
 
-    /** Returns index of given sub-property. */
-    int Index( const wxPGProperty* p ) const
-        { return m_children.Index((wxPGProperty*)p); }
-
-    /** Deletes all sub-properties. */
-    void Empty();
+    /** Returns index of given child property. */
+    int Index( const wxPGProperty* p ) const;
 
     // Puts correct indexes to children
 
     // Puts correct indexes to children
-    void FixIndexesOfChildren( size_t starthere = 0 );
+    void FixIndicesOfChildren( unsigned int starthere = 0 );
+
+    /**
+        Converts image width into full image offset, with margins.
+    */
+    int GetImageOffset( int imageWidth ) const;
 
 
-#ifndef SWIG
     // Returns wxPropertyGridPageState in which this property resides.
     wxPropertyGridPageState* GetParentState() const { return m_parentState; }
     // Returns wxPropertyGridPageState in which this property resides.
     wxPropertyGridPageState* GetParentState() const { return m_parentState; }
-#endif
 
     wxPGProperty* GetItemAtY( unsigned int y,
                               unsigned int lh,
                               unsigned int* nextItemY ) const;
 
 
     wxPGProperty* GetItemAtY( unsigned int y,
                               unsigned int lh,
                               unsigned int* nextItemY ) const;
 
+    /** Returns property at given virtual y coordinate.
+    */
+    wxPGProperty* GetItemAtY( unsigned int y ) const;
+
     /** Returns (direct) child property with given name (or NULL if not found).
     */
     wxPGProperty* GetPropertyByName( const wxString& name ) const;
 
     /** Returns (direct) child property with given name (or NULL if not found).
     */
     wxPGProperty* GetPropertyByName( const wxString& name ) const;
 
-#ifdef SWIG
-     %extend {
-        DocStr(GetClientData,
-               "Returns the client data object for a property", "");
-        PyObject* GetClientData() {
-            wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
-            if (data) {
-                Py_INCREF(data->m_obj);
-                return data->m_obj;
-            } else {
-                Py_INCREF(Py_None);
-                return Py_None;
-            }
-        }
-
-        DocStr(SetClientData,
-               "Associate the given client data.", "");
-        void SetClientData(PyObject* clientData) {
-            wxPyClientData* data = new wxPyClientData(clientData);
-            self->SetClientObject(data);
-        }
-    }
-    %pythoncode {
-         GetClientObject = GetClientData
-         SetClientObject = SetClientData
-    }
-#endif
-
-#ifndef SWIG
+    // Returns various display-related information for given column
+    void GetDisplayInfo( unsigned int column,
+                         int choiceIndex,
+                         int flags,
+                         wxString* pString,
+                         const wxPGCell** pCell );
 
     static wxString*            sm_wxPG_LABEL;
 
 
     static wxString*            sm_wxPG_LABEL;
 
@@ -1870,9 +2304,49 @@ public:
     void*                       m_clientData;
 
 protected:
     void*                       m_clientData;
 
 protected:
-    /** Returns text for given column.
+
+    /**
+        Sets property cell in fashion that reduces number of exclusive
+        copies of cell data. Used when setting, for instance, same
+        background colour for a number of properties.
+
+        @param firstCol
+            First column to affect.
+
+        @param lastCol
+            Last column to affect.
+
+        @param preparedCell
+            Pre-prepared cell that is used for those which cell data
+            before this matched unmodCellData.
+
+        @param srcData
+            If unmodCellData did not match, valid cell data from this
+            is merged into cell (usually generating new exclusive copy
+            of cell's data).
+
+        @param unmodCellData
+            If cell's cell data matches this, its cell is now set to
+            preparedCell.
+
+        @param ignoreWithFlags
+            Properties with any one of these flags are skipped.
+
+        @param recursively
+            If @true, apply this operation recursively in child properties.
     */
     */
-    wxString GetColumnText( unsigned int col ) const;
+    void AdaptiveSetCell( unsigned int firstCol,
+                          unsigned int lastCol,
+                          const wxPGCell& preparedCell,
+                          const wxPGCell& srcData,
+                          wxPGCellData* unmodCellData,
+                          FlagType ignoreWithFlags,
+                          bool recursively );
+
+    /**
+        Makes sure m_cells has size of column+1 (or more).
+    */
+    void EnsureCells( unsigned int column );
 
     /** Returns (direct) child property with given name (or NULL if not found),
         with hint index.
 
     /** Returns (direct) child property with given name (or NULL if not found),
         with hint index.
@@ -1887,24 +2361,58 @@ protected:
                                        unsigned int hintIndex ) const;
 
     /** This is used by Insert etc. */
                                        unsigned int hintIndex ) const;
 
     /** This is used by Insert etc. */
-    void AddChild2( wxPGProperty* prop,
-                    int index = -1,
-                    bool correct_mode = true );
+    void DoAddChild( wxPGProperty* prop,
+                     int index = -1,
+                     bool correct_mode = true );
+
+    void DoGenerateComposedValue( wxString& text,
+                                  int argFlags = wxPG_VALUE_IS_CURRENT,
+                                  const wxVariantList* valueOverrides = NULL,
+                                  wxPGHashMapS2S* childResults = NULL ) const;
+
+    bool DoHide( bool hide, int flags );
 
     void DoSetName(const wxString& str) { m_name = str; }
 
 
     void DoSetName(const wxString& str) { m_name = str; }
 
-    // Call for after sub-properties added with AddChild
-    void PrepareSubProperties();
+    /** Deletes all sub-properties. */
+    void Empty();
 
 
-    void SetParentalType( int flag )
+    bool HasCell( unsigned int column ) const
     {
     {
-        m_flags &= ~(wxPG_PROP_PROPERTY|wxPG_PROP_PARENTAL_FLAGS);
-        m_flags |= flag;
+        if ( m_cells.size() > column )
+            return true;
+        return false;
     }
 
     }
 
+    void InitAfterAdded( wxPropertyGridPageState* pageState,
+                         wxPropertyGrid* propgrid );
+
+    // Removes child property with given pointer. Does not delete it.
+    void RemoveChild( wxPGProperty* p );
+
+    void DoEnable( bool enable );
+
+    void DoPreAddChild( int index, wxPGProperty* prop );
+
     void SetParentState( wxPropertyGridPageState* pstate )
         { m_parentState = pstate; }
 
     void SetParentState( wxPropertyGridPageState* pstate )
         { m_parentState = pstate; }
 
+    void SetFlag( wxPGPropertyFlags flag )
+    {
+        //
+        // NB: While using wxPGPropertyFlags here makes it difficult to
+        //     combine different flags, it usefully prevents user from
+        //     using incorrect flags (say, wxWindow styles).
+        m_flags |= flag;
+    }
+
+    void ClearFlag( FlagType flag ) { m_flags &= ~(flag); }
+
+    // Called when the property is being removed from the grid and/or
+    // page state (but *not* when it is also deleted).
+    void OnDetached(wxPropertyGridPageState* state,
+                    wxPropertyGrid* propgrid);
+
     // Call after fixed sub-properties added/removed after creation.
     // if oldSelInd >= 0 and < new max items, then selection is
     // moved to it.
     // Call after fixed sub-properties added/removed after creation.
     // if oldSelInd >= 0 and < new max items, then selection is
     // moved to it.
@@ -1915,7 +2423,7 @@ protected:
     wxString                    m_label;
     wxString                    m_name;
     wxPGProperty*               m_parent;
     wxString                    m_label;
     wxString                    m_name;
     wxPGProperty*               m_parent;
-    wxPropertyGridPageState*        m_parentState;
+    wxPropertyGridPageState*    m_parentState;
 
     wxClientData*               m_clientObject;
 
 
     wxClientData*               m_clientObject;
 
@@ -1932,10 +2440,13 @@ protected:
 
     wxVariant                   m_value;
     wxPGAttributeStorage        m_attributes;
 
     wxVariant                   m_value;
     wxPGAttributeStorage        m_attributes;
-    wxArrayPtrVoid              m_children;
+    wxArrayPGProperty           m_children;
 
     // Extended cell information
 
     // Extended cell information
-    wxArrayPtrVoid              m_cells;
+    wxVector<wxPGCell>          m_cells;
+
+    // Choices shown in drop-down list of editor control.
+    wxPGChoices                 m_choices;
 
     // Help shown in statusbar or help box.
     wxString                    m_helpString;
 
     // Help shown in statusbar or help box.
     wxString                    m_helpString;
@@ -1961,14 +2472,10 @@ protected:
     // (essentially this is category's depth, if none then equals m_depth).
     unsigned char               m_depthBgCol;
 
     // (essentially this is category's depth, if none then equals m_depth).
     unsigned char               m_depthBgCol;
 
-    unsigned char               m_bgColIndex; // Background brush index.
-    unsigned char               m_fgColIndex; // Foreground colour index.
-
 private:
     // Called in constructors.
     void Init();
     void Init( const wxString& label, const wxString& name );
 private:
     // Called in constructors.
     void Init();
     void Init( const wxString& label, const wxString& name );
-#endif // #ifndef SWIG
 };
 
 // -----------------------------------------------------------------------
 };
 
 // -----------------------------------------------------------------------
@@ -1981,14 +2488,12 @@ private:
 #define WX_PG_DECLARE_DOGETEDITORCLASS \
     virtual const wxPGEditor* DoGetEditorClass() const;
 
 #define WX_PG_DECLARE_DOGETEDITORCLASS \
     virtual const wxPGEditor* DoGetEditorClass() const;
 
-#ifndef SWIG
+#ifndef WX_PG_DECLARE_PROPERTY_CLASS
     #define WX_PG_DECLARE_PROPERTY_CLASS(CLASSNAME) \
         public: \
             DECLARE_DYNAMIC_CLASS(CLASSNAME) \
             WX_PG_DECLARE_DOGETEDITORCLASS \
         private:
     #define WX_PG_DECLARE_PROPERTY_CLASS(CLASSNAME) \
         public: \
             DECLARE_DYNAMIC_CLASS(CLASSNAME) \
             WX_PG_DECLARE_DOGETEDITORCLASS \
         private:
-#else
-    #define WX_PG_DECLARE_PROPERTY_CLASS(CLASSNAME)
 #endif
 
 // Implements sans constructor function. Also, first arg is class name, not
 #endif
 
 // Implements sans constructor function. Also, first arg is class name, not
@@ -2001,8 +2506,6 @@ const wxPGEditor* PROPNAME::DoGetEditorClass() const \
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 
-#ifndef SWIG
-
 /** @class wxPGRootProperty
     @ingroup classes
     Root parent property.
 /** @class wxPGRootProperty
     @ingroup classes
     Root parent property.
@@ -2014,7 +2517,7 @@ public:
 public:
 
     /** Constructor. */
 public:
 
     /** Constructor. */
-    wxPGRootProperty();
+    wxPGRootProperty( const wxString& name = wxS("<Root>") );
     virtual ~wxPGRootProperty();
 
     virtual bool StringToValue( wxVariant&, const wxString&, int ) const
     virtual ~wxPGRootProperty();
 
     virtual bool StringToValue( wxVariant&, const wxString&, int ) const
@@ -2047,9 +2550,10 @@ public:
 
     int GetTextExtent( const wxWindow* wnd, const wxFont& font ) const;
 
 
     int GetTextExtent( const wxWindow* wnd, const wxFont& font ) const;
 
-protected:
-    virtual wxString GetValueAsString( int argFlags ) const;
+    virtual wxString ValueToString( wxVariant& value, int argFlags ) const;
+    virtual wxString GetValueAsString( int argFlags = 0 ) const;
 
 
+protected:
     void SetTextColIndex( unsigned int colInd )
         { m_capFgColIndex = (wxByte) colInd; }
     unsigned int GetTextColIndex() const
     void SetTextColIndex( unsigned int colInd )
         { m_capFgColIndex = (wxByte) colInd; }
     unsigned int GetTextColIndex() const
@@ -2064,392 +2568,8 @@ private:
     void Init();
 };
 
     void Init();
 };
 
-#endif  // !SWIG
-
 // -----------------------------------------------------------------------
 
 // -----------------------------------------------------------------------
 
-#ifndef SWIG
-
-/** @class wxPGChoiceEntry
-    Data of a single wxPGChoices choice.
-*/
-class WXDLLIMPEXP_PROPGRID wxPGChoiceEntry : public wxPGCell
-{
-public:
-    wxPGChoiceEntry();
-    wxPGChoiceEntry( const wxPGChoiceEntry& entry );
-    wxPGChoiceEntry( const wxString& label,
-                     int value = wxPG_INVALID_VALUE )
-        : wxPGCell(), m_value(value)
-    {
-        m_text = label;
-    }
-
-    wxPGChoiceEntry( const wxString& label,
-                     int value,
-                     const wxBitmap& bitmap,
-                     const wxColour& fgCol = wxNullColour,
-                     const wxColour& bgCol = wxNullColour )
-        : wxPGCell(label, bitmap, fgCol, bgCol), m_value(value)
-    {
-    }
-
-    virtual ~wxPGChoiceEntry()
-    {
-    }
-
-    void SetValue( int value ) { m_value = value; }
-
-    int GetValue() const { return m_value; }
-
-    bool HasValue() const { return (m_value != wxPG_INVALID_VALUE); }
-
-protected:
-    int m_value;
-};
-
-
-typedef void* wxPGChoicesId;
-
-class WXDLLIMPEXP_PROPGRID wxPGChoicesData
-{
-    friend class wxPGChoices;
-public:
-    // Constructor sets m_refCount to 1.
-    wxPGChoicesData();
-
-    void CopyDataFrom( wxPGChoicesData* data );
-
-    // Takes ownership of 'item'
-    void Insert( int index, wxPGChoiceEntry* item )
-    {
-        wxArrayPtrVoid::iterator it;
-        if ( index == -1 )
-        {
-            it = m_items.end();
-            index = m_items.size();
-        }
-        else
-        {
-            it = m_items.begin() + index;
-        }
-
-        // Need to fix value?
-        if ( item->GetValue() == wxPG_INVALID_VALUE )
-            item->SetValue(index);
-
-        m_items.insert(it, item);
-    }
-
-    // Delete all entries
-    void Clear();
-
-    size_t GetCount() const { return m_items.size(); }
-
-    wxPGChoiceEntry* Item( unsigned int i ) const
-    {
-        wxCHECK_MSG( i < GetCount(), NULL, "invalid index" );
-
-        return (wxPGChoiceEntry*) m_items[i];
-    }
-
-    void DecRef()
-    {
-        m_refCount--;
-        wxASSERT( m_refCount >= 0 );
-        if ( m_refCount == 0 )
-            delete this;
-    }
-
-private:
-    wxArrayPtrVoid  m_items;
-
-    // So that multiple properties can use the same set
-    int             m_refCount;
-
-    virtual ~wxPGChoicesData();
-};
-
-#define wxPGChoicesEmptyData    ((wxPGChoicesData*)NULL)
-
-#endif // SWIG
-
-
-/** @class wxPGChoices
-
-    Helper class for managing choices of wxPropertyGrid properties.
-    Each entry can have label, value, bitmap, text colour, and background
-    colour.
-
-    @library{wxpropgrid}
-    @category{propgrid}
-*/
-class WXDLLIMPEXP_PROPGRID wxPGChoices
-{
-public:
-    typedef long ValArrItem;
-
-    /** Default constructor. */
-    wxPGChoices()
-    {
-        Init();
-    }
-
-    /** Copy constructor. */
-    wxPGChoices( const wxPGChoices& a )
-    {
-        if ( a.m_data != wxPGChoicesEmptyData )
-        {
-            m_data = a.m_data;
-            m_data->m_refCount++;
-        }
-    }
-
-    /** Constructor. */
-    wxPGChoices( const wxChar** labels, const long* values = NULL )
-    {
-        Init();
-        Set(labels,values);
-    }
-
-    /** Constructor. */
-    wxPGChoices( const wxArrayString& labels,
-                 const wxArrayInt& values = wxArrayInt() )
-    {
-        Init();
-        Set(labels,values);
-    }
-
-    /** Simple interface constructor. */
-    wxPGChoices( wxPGChoicesData* data )
-    {
-        wxASSERT(data);
-        m_data = data;
-        data->m_refCount++;
-    }
-
-    /** Destructor. */
-    ~wxPGChoices()
-    {
-        Free();
-    }
-
-    /**
-        Adds to current.
-
-        If did not have own copies, creates them now. If was empty, identical
-        to set except that creates copies.
-    */
-    void Add( const wxChar** labels, const ValArrItem* values = NULL );
-
-    /** Version that works with wxArrayString. */
-    void Add( const wxArrayString& arr, const ValArrItem* values = NULL );
-
-    /** Version that works with wxArrayString and wxArrayInt. */
-    void Add( const wxArrayString& arr, const wxArrayInt& arrint );
-
-    /** Adds single item. */
-    wxPGChoiceEntry& Add( const wxString& label,
-                          int value = wxPG_INVALID_VALUE );
-
-    /** Adds a single item, with bitmap. */
-    wxPGChoiceEntry& Add( const wxString& label,
-                          const wxBitmap& bitmap,
-                          int value = wxPG_INVALID_VALUE );
-
-    /** Adds a single item with full entry information. */
-    wxPGChoiceEntry& Add( const wxPGChoiceEntry& entry )
-    {
-        return Insert(entry, -1);
-    }
-
-    /** Adds single item. */
-    wxPGChoiceEntry& AddAsSorted( const wxString& label,
-                                  int value = wxPG_INVALID_VALUE );
-
-    void Assign( const wxPGChoices& a )
-    {
-        AssignData(a.m_data);
-    }
-
-    void AssignData( wxPGChoicesData* data );
-
-    /** Delete all choices. */
-    void Clear()
-    {
-        if ( m_data != wxPGChoicesEmptyData )
-            m_data->Clear();
-    }
-
-    void EnsureData()
-    {
-        if ( m_data == wxPGChoicesEmptyData )
-            m_data = new wxPGChoicesData();
-    }
-
-    /** Gets a unsigned number identifying this list. */
-    wxPGChoicesId GetId() const { return (wxPGChoicesId) m_data; };
-
-    const wxString& GetLabel( size_t ind ) const
-    {
-        return Item(ind).GetText();
-    }
-
-    size_t GetCount () const
-    {
-        wxASSERT_MSG( m_data, "When checking if wxPGChoices is valid, "
-                              "use IsOk() instead of GetCount()" );
-        return m_data->GetCount();
-    }
-
-    int GetValue( size_t ind ) const { return Item(ind).GetValue(); }
-
-    /** Returns array of values matching the given strings. Unmatching strings
-        result in wxPG_INVALID_VALUE entry in array.
-    */
-    wxArrayInt GetValuesForStrings( const wxArrayString& strings ) const;
-
-    /** Returns array of indices matching given strings. Unmatching strings
-        are added to 'unmatched', if not NULL.
-    */
-    wxArrayInt GetIndicesForStrings( const wxArrayString& strings,
-                                     wxArrayString* unmatched = NULL ) const;
-
-    /** Returns true if choices in general are likely to have values
-        (depens on that all entries have values or none has)
-    */
-    bool HasValues() const;
-
-    bool HasValue( unsigned int i ) const
-        { return (i < m_data->GetCount()) && m_data->Item(i)->HasValue(); }
-
-    int Index( const wxString& str ) const;
-    int Index( int val ) const;
-
-    /** Inserts single item. */
-    wxPGChoiceEntry& Insert( const wxString& label,
-                             int index,
-                             int value = wxPG_INVALID_VALUE );
-
-    /** Inserts a single item with full entry information. */
-    wxPGChoiceEntry& Insert( const wxPGChoiceEntry& entry, int index );
-
-    /** Returns false if this is a constant empty set of choices,
-        which should not be modified.
-    */
-    bool IsOk() const
-    {
-        return ( m_data != wxPGChoicesEmptyData );
-    }
-
-    const wxPGChoiceEntry& Item( unsigned int i ) const
-    {
-        wxASSERT( IsOk() );
-        return *m_data->Item(i);
-    }
-
-    wxPGChoiceEntry& Item( unsigned int i )
-    {
-        wxASSERT( IsOk() );
-        return *m_data->Item(i);
-    }
-
-    /** Removes count items starting at position nIndex. */
-    void RemoveAt(size_t nIndex, size_t count = 1);
-
-#ifndef SWIG
-    /** Does not create copies for itself. */
-    void Set( const wxChar** labels, const long* values = NULL )
-    {
-        Free();
-        Add(labels,values);
-    }
-
-    /** Version that works with wxArrayString.
-        TODO: Deprecate this.
-    */
-    void Set( wxArrayString& arr, const long* values = (const long*) NULL )
-    {
-        Free();
-        Add(arr,values);
-    }
-#endif // SWIG
-
-    /** Version that works with wxArrayString and wxArrayInt. */
-    void Set( const wxArrayString& labels,
-              const wxArrayInt& values = wxArrayInt() )
-    {
-        Free();
-        if ( &values )
-            Add(labels,values);
-        else
-            Add(labels);
-    }
-
-    // Creates exclusive copy of current choices
-    void SetExclusive()
-    {
-        if ( m_data->m_refCount != 1 )
-        {
-            wxPGChoicesData* data = new wxPGChoicesData();
-            data->CopyDataFrom(m_data);
-            Free();
-            m_data = data;
-        }
-    }
-
-    // Returns data, increases refcount.
-    wxPGChoicesData* GetData()
-    {
-        wxASSERT( m_data->m_refCount != 0xFFFFFFF );
-        m_data->m_refCount++;
-        return m_data;
-    }
-
-    // Returns plain data ptr - no refcounting stuff is done.
-    wxPGChoicesData* GetDataPtr() const { return m_data; }
-
-    // Changes ownership of data to you.
-    wxPGChoicesData* ExtractData()
-    {
-        wxPGChoicesData* data = m_data;
-        m_data = wxPGChoicesEmptyData;
-        return data;
-    }
-
-    wxArrayString GetLabels() const;
-
-#ifndef SWIG
-    void operator= (const wxPGChoices& a)
-    {
-        AssignData(a.m_data);
-    }
-
-    wxPGChoiceEntry& operator[](unsigned int i)
-    {
-        return Item(i);
-    }
-
-    const wxPGChoiceEntry& operator[](unsigned int i) const
-    {
-        return Item(i);
-    }
-
-protected:
-    wxPGChoicesData*    m_data;
-
-    void Init();
-    void Free();
-#endif  // !SWIG
-};
-
-inline bool wxPGProperty::SetChoices( const wxArrayString& labels,
-                                      const wxArrayInt& values )
-{
-    wxPGChoices chs(labels, values);
-    return SetChoices(chs);
-}
-
-// -----------------------------------------------------------------------
+#endif // wxUSE_PROPGRID
 
 #endif // _WX_PROPGRID_PROPERTY_H_
 
 #endif // _WX_PROPGRID_PROPERTY_H_