include/wx/propgrid/propgridiface.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/propgeid/propgridiface.h
   3 // Purpose:     wxPropertyGridInterface class
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2008-08-24
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Jaakko Salli
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef __WX_PROPGRID_PROPGRIDIFACE_H__
  13 #define __WX_PROPGRID_PROPGRIDIFACE_H__
  14
  15 #if wxUSE_PROPGRID
  16
  17 #include "wx/propgrid/property.h"
  18 #include "wx/propgrid/propgridpagestate.h"
  19
  20 // -----------------------------------------------------------------------
  21
  22 #ifndef SWIG
  23
  24 /** @section wxPGPropArgCls
  25
  26     Most property grid functions have this type as their argument, as it can
  27     convey a property by either a pointer or name.
  28 */
  29 class WXDLLIMPEXP_PROPGRID wxPGPropArgCls
  30 {
  31 public:
  32     wxPGPropArgCls() { }
  33     wxPGPropArgCls( const wxPGProperty* property )
  34     {
  35         m_ptr.property = (wxPGProperty*) property;
  36         m_flags = IsProperty;
  37     }
  38     wxPGPropArgCls( const wxString& str )
  39     {
  40         m_ptr.stringName = &str;
  41         m_flags = IsWxString;
  42     }
  43     wxPGPropArgCls( const wxPGPropArgCls& id )
  44     {
  45         m_ptr = id.m_ptr;
  46         m_flags = id.m_flags;
  47     }
  48     // This is only needed for wxPython bindings
  49     wxPGPropArgCls( wxString* str, bool WXUNUSED(deallocPtr) )
  50     {
  51         m_ptr.stringName = str;
  52         m_flags = IsWxString | OwnsWxString;
  53     }
  54     ~wxPGPropArgCls()
  55     {
  56         if ( m_flags & OwnsWxString )
  57             delete m_ptr.stringName;
  58     }
  59     wxPGProperty* GetPtr() const
  60     {
  61         wxCHECK( m_flags == IsProperty, NULL );
  62         return m_ptr.property;
  63     }
  64     wxPGPropArgCls( const char* str )
  65     {
  66         m_ptr.charName = str;
  67         m_flags = IsCharPtr;
  68     }
  69 #if wxUSE_WCHAR_T
  70     wxPGPropArgCls( const wchar_t* str )
  71     {
  72         m_ptr.wcharName = str;
  73         m_flags = IsWCharPtr;
  74     }
  75 #endif
  76     /** This constructor is required for NULL. */
  77     wxPGPropArgCls( int )
  78     {
  79         m_ptr.property = (wxPGProperty*) NULL;
  80         m_flags = IsProperty;
  81     }
  82     wxPGProperty* GetPtr( wxPropertyGridInterface* iface ) const;
  83     wxPGProperty* GetPtr( const wxPropertyGridInterface* iface ) const
  84     {
  85         return GetPtr((wxPropertyGridInterface*)iface);
  86     }
  87     wxPGProperty* GetPtr0() const { return m_ptr.property; }
  88     bool HasName() const { return (m_flags != IsProperty); }
  89     const wxString& GetName() const { return *m_ptr.stringName; }
  90 private:
  91
  92     enum
  93     {
  94         IsProperty      = 0x00,
  95         IsWxString      = 0x01,
  96         IsCharPtr       = 0x02,
  97         IsWCharPtr      = 0x04,
  98         OwnsWxString    = 0x10,
  99     };
 100
 101     union
 102     {
 103         wxPGProperty* property;
 104         const char* charName;
 105 #if wxUSE_WCHAR_T
 106         const wchar_t* wcharName;
 107 #endif
 108         const wxString* stringName;
 109     } m_ptr;
 110     unsigned char m_flags;
 111 };
 112
 113 #endif
 114
 115 typedef const wxPGPropArgCls& wxPGPropArg;
 116
 117 // -----------------------------------------------------------------------
 118
 119 WXDLLIMPEXP_PROPGRID
 120 void wxPGTypeOperationFailed( const wxPGProperty* p,
 121                               const wxString& typestr,
 122                               const wxString& op );
 123 WXDLLIMPEXP_PROPGRID
 124 void wxPGGetFailed( const wxPGProperty* p, const wxString& typestr );
 125
 126 // -----------------------------------------------------------------------
 127
 128 // Helper macro that does necessary preparations when calling
 129 // some wxPGProperty's member function.
 130 #define wxPG_PROP_ARG_CALL_PROLOG_0(PROPERTY) \
 131     PROPERTY *p = (PROPERTY*)id.GetPtr(this); \
 132     if ( !p ) return;
 133
 134 #define wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(PROPERTY, RETVAL) \
 135     PROPERTY *p = (PROPERTY*)id.GetPtr(this); \
 136     if ( !p ) return RETVAL;
 137
 138 #define wxPG_PROP_ARG_CALL_PROLOG() \
 139     wxPG_PROP_ARG_CALL_PROLOG_0(wxPGProperty)
 140
 141 #define wxPG_PROP_ARG_CALL_PROLOG_RETVAL(RVAL) \
 142     wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(wxPGProperty, RVAL)
 143
 144 #define wxPG_PROP_ID_CONST_CALL_PROLOG() \
 145     wxPG_PROP_ARG_CALL_PROLOG_0(const wxPGProperty)
 146
 147 #define wxPG_PROP_ID_CONST_CALL_PROLOG_RETVAL(RVAL) \
 148     wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(const wxPGProperty, RVAL)
 149
 150 // -----------------------------------------------------------------------
 151
 152
 153 /** @class wxPropertyGridInterface
 154
 155     Most of the shared property manipulation interface shared by wxPropertyGrid,
 156     wxPropertyGridPage, and wxPropertyGridManager is defined in this class.
 157
 158     @remarks
 159     - In separate wxPropertyGrid component this class was known as
 160     wxPropertyContainerMethods.
 161
 162     @library{wxpropgrid}
 163     @category{propgrid}
 164 */
 165 class WXDLLIMPEXP_PROPGRID wxPropertyGridInterface
 166 {
 167 public:
 168
 169     /** Destructor */
 170     virtual ~wxPropertyGridInterface() { }
 171
 172     /**
 173         Appends property to the list.
 174
 175         wxPropertyGrid assumes ownership of the object.
 176         Becomes child of most recently added category.
 177         @remarks
 178         - wxPropertyGrid takes the ownership of the property pointer.
 179         - If appending a category with name identical to a category already in
 180           the wxPropertyGrid, then newly created category is deleted, and most
 181           recently added category (under which properties are appended) is set
 182           to the one with same name. This allows easier adding of items to same
 183           categories in multiple passes.
 184         - Does not automatically redraw the control, so you may need to call
 185           Refresh when calling this function after control has been shown for
 186           the first time.
 187     */
 188     wxPGProperty* Append( wxPGProperty* property );
 189
 190     wxPGProperty* AppendIn( wxPGPropArg id, wxPGProperty* newproperty );
 191
 192     /**
 193         In order to add new items into a property with fixed children (for
 194         instance, wxFlagsProperty), you need to call this method. After
 195         populating has been finished, you need to call EndAddChildren.
 196     */
 197     void BeginAddChildren( wxPGPropArg id );
 198
 199     /** Deletes all properties.
 200     */
 201     virtual void Clear() = 0;
 202
 203     /** Deselect current selection, if any. Returns true if success
 204         (ie. validator did not intercept). */
 205     bool ClearSelection();
 206
 207     /** Resets modified status of all properties.
 208     */
 209     void ClearModifiedStatus();
 210
 211     /** Collapses given category or property with children.
 212         Returns true if actually collapses.
 213     */
 214     bool Collapse( wxPGPropArg id );
 215
 216     /** Collapses all items that can be collapsed.
 217
 218         @return
 219         Return false if failed (may fail if editor value cannot be validated).
 220     */
 221     bool CollapseAll() { return ExpandAll(false); }
 222
 223     /**
 224         Changes value of a property, as if from an editor.
 225         Use this instead of SetPropertyValue() if you need the value to run
 226         through validation process, and also send the property change event.
 227
 228         @return
 229         Returns true if value was successfully changed.
 230     */
 231     bool ChangePropertyValue( wxPGPropArg id, wxVariant newValue );
 232
 233     /**
 234         Deletes a property by id. If category is deleted, all children are
 235         automatically deleted as well.
 236      */
 237     void DeleteProperty( wxPGPropArg id );
 238
 239     /** Disables property. */
 240     bool DisableProperty( wxPGPropArg id ) { return EnableProperty(id,false); }
 241
 242     /**
 243         Returns true if all property grid data changes have been committed.
 244
 245         Usually only returns false if value in active editor has been
 246         invalidated by a wxValidator.
 247     */
 248     bool EditorValidate();
 249
 250     /**
 251         Enables or disables property, depending on whether enable is true or
 252         false.
 253      */
 254     bool EnableProperty( wxPGPropArg id, bool enable = true );
 255
 256     /** Called after population of property with fixed children has finished.
 257     */
 258     void EndAddChildren( wxPGPropArg id );
 259
 260     /** Expands given category or property with children.
 261         Returns true if actually expands.
 262     */
 263     bool Expand( wxPGPropArg id );
 264
 265     /** Expands all items that can be expanded.
 266     */
 267     bool ExpandAll( bool expand = true );
 268
 269     /** Returns id of first child of given property.
 270         @remarks
 271         Does not return sub-properties!
 272     */
 273     wxPGProperty* GetFirstChild( wxPGPropArg id )
 274     {
 275         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
 276
 277         if ( !p->GetChildCount() || p->HasFlag(wxPG_PROP_AGGREGATE) )
 278             return wxNullProperty;
 279
 280         return p->Item(0);
 281     }
 282
 283     //@{
 284     /** Returns iterator class instance.
 285         @param flags
 286         See @ref propgrid_iterator_flags. Value wxPG_ITERATE_DEFAULT causes
 287         iteration over everything except private child properties.
 288         @param firstProp
 289             Property to start iteration from. If NULL, then first child of root
 290             is used.
 291         @param startPos
 292             Either wxTOP or wxBOTTOM. wxTOP will indicate that iterations start
 293             from the first property from the top, and wxBOTTOM means that the
 294             iteration will instead begin from bottommost valid item.
 295     */
 296     wxPropertyGridIterator GetIterator( int flags = wxPG_ITERATE_DEFAULT,
 297                                         wxPGProperty* firstProp = NULL )
 298     {
 299         return wxPropertyGridIterator( m_pState, flags, firstProp );
 300     }
 301
 302     wxPropertyGridConstIterator
 303     GetIterator( int flags = wxPG_ITERATE_DEFAULT,
 304                  wxPGProperty* firstProp = NULL ) const
 305     {
 306         return wxPropertyGridConstIterator( m_pState, flags, firstProp );
 307     }
 308
 309     wxPropertyGridIterator GetIterator( int flags, int startPos )
 310     {
 311         return wxPropertyGridIterator( m_pState, flags, startPos );
 312     }
 313
 314     wxPropertyGridConstIterator GetIterator( int flags, int startPos ) const
 315     {
 316         return wxPropertyGridConstIterator( m_pState, flags, startPos );
 317     }
 318     //@}
 319
 320     /** Returns id of first item, whether it is a category or property.
 321         @param flags
 322         @link iteratorflags List of iterator flags@endlink
 323     */
 324     wxPGProperty* GetFirst( int flags = wxPG_ITERATE_ALL )
 325     {
 326         wxPropertyGridIterator it( m_pState, flags, wxNullProperty, 1 );
 327         return *it;
 328     }
 329
 330     const wxPGProperty* GetFirst( int flags = wxPG_ITERATE_ALL ) const
 331     {
 332         return ((wxPropertyGridInterface*)this)->GetFirst(flags);
 333     }
 334
 335     /**
 336         Returns id of property with given name (case-sensitive).
 337
 338         If there is no property with such name, returned property id is invalid
 339         ( i.e. it will return false with IsOk method).
 340         @remarks
 341         - Sub-properties (i.e. properties which have parent that is not
 342           category or root) can not be accessed globally by their name.
 343           Instead, use "<property>.<subproperty>" in place of "<subproperty>".
 344     */
 345     wxPGProperty* GetProperty( const wxString& name ) const
 346     {
 347         return GetPropertyByName(name);
 348     }
 349
 350     /** Returns map-like storage of property's attributes.
 351         @remarks
 352         Note that if extra style wxPG_EX_WRITEONLY_BUILTIN_ATTRIBUTES is set,
 353         then builtin-attributes are not included in the storage.
 354     */
 355     const wxPGAttributeStorage& GetPropertyAttributes( wxPGPropArg id ) const
 356     {
 357         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(*((const wxPGAttributeStorage*)NULL));
 358         return p->GetAttributes();
 359     }
 360
 361     /** Adds to 'targetArr' pointers to properties that have given
 362         flags 'flags' set. However, if 'inverse' is set to true, then
 363         only properties without given flags are stored.
 364         @param flags
 365         Property flags to use.
 366         @param iterFlags
 367         Iterator flags to use. Default is everything expect private children.
 368     */
 369     void GetPropertiesWithFlag( wxArrayPGProperty* targetArr,
 370                                 wxPGProperty::FlagType flags,
 371                                 bool inverse = false,
 372                                 int iterFlags = wxPG_ITERATE_PROPERTIES |
 373                                                 wxPG_ITERATE_HIDDEN |
 374                                                 wxPG_ITERATE_CATEGORIES) const;
 375
 376     /** Returns value of given attribute. If none found, returns NULL-variant.
 377     */
 378     wxVariant GetPropertyAttribute( wxPGPropArg id,
 379                                     const wxString& attrName ) const
 380     {
 381         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullVariant)
 382         return p->GetAttribute(attrName);
 383     }
 384
 385     /** Returns pointer of property's nearest parent category. If no category
 386         found, returns NULL.
 387     */
 388     wxPropertyCategory* GetPropertyCategory( wxPGPropArg id ) const
 389     {
 390         wxPG_PROP_ID_CONST_CALL_PROLOG_RETVAL(NULL)
 391         return m_pState->GetPropertyCategory(p);
 392     }
 393
 394 #ifndef SWIG
 395     /** Returns client data (void*) of a property. */
 396     void* GetPropertyClientData( wxPGPropArg id ) const
 397     {
 398         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
 399         return p->GetClientData();
 400     }
 401 #endif
 402
 403     /**
 404         Returns first property which label matches given string.
 405
 406         NULL if none found. Note that this operation is extremely slow when
 407         compared to GetPropertyByName().
 408     */
 409     wxPGProperty* GetPropertyByLabel( const wxString& label ) const;
 410
 411     /** Returns property with given name. NULL if none found.
 412     */
 413     wxPGProperty* GetPropertyByName( const wxString& name ) const;
 414
 415     /** Returns child property 'subname' of property 'name'. Same as
 416         calling GetPropertyByName("name.subname"), albeit slightly faster.
 417     */
 418     wxPGProperty* GetPropertyByName( const wxString& name,
 419                                      const wxString& subname ) const;
 420
 421     /** Returns property's editor. */
 422     const wxPGEditor* GetPropertyEditor( wxPGPropArg id ) const
 423     {
 424         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
 425         return p->GetEditorClass();
 426     }
 427
 428     /** Returns help string associated with a property. */
 429     wxString GetPropertyHelpString( wxPGPropArg id ) const
 430     {
 431         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
 432         return p->GetHelpString();
 433     }
 434
 435     /** Returns property's custom value image (NULL of none). */
 436     wxBitmap* GetPropertyImage( wxPGPropArg id ) const
 437     {
 438         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
 439         return p->GetValueImage();
 440     }
 441
 442     /** Returns label of a property. */
 443     const wxString& GetPropertyLabel( wxPGPropArg id )
 444     {
 445         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
 446         return p->GetLabel();
 447     }
 448
 449     /** Returns name of a property, by which it is globally accessible. */
 450     wxString GetPropertyName( wxPGProperty* property )
 451     {
 452         return property->GetName();
 453     }
 454
 455     /** Returns parent item of a property. */
 456     wxPGProperty* GetPropertyParent( wxPGPropArg id )
 457     {
 458         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
 459         return p->GetParent();
 460     }
 461
 462 #if wxUSE_VALIDATORS
 463     /** Returns validator of a property as a reference, which you
 464         can pass to any number of SetPropertyValidator.
 465     */
 466     wxValidator* GetPropertyValidator( wxPGPropArg id )
 467     {
 468         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
 469         return p->GetValidator();
 470     }
 471 #endif
 472
 473     /** Returns value as wxVariant. To get wxObject pointer from it,
 474         you will have to use WX_PG_VARIANT_TO_WXOBJECT(VARIANT,CLASSNAME) macro.
 475
 476         If property value is unspecified, Null variant is returned.
 477     */
 478     wxVariant GetPropertyValue( wxPGPropArg id )
 479     {
 480         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxVariant())
 481         return p->GetValue();
 482     }
 483
 484     wxString GetPropertyValueAsString( wxPGPropArg id ) const;
 485     long GetPropertyValueAsLong( wxPGPropArg id ) const;
 486     unsigned long GetPropertyValueAsULong( wxPGPropArg id ) const
 487     {
 488         return (unsigned long) GetPropertyValueAsLong(id);
 489     }
 490 #ifndef SWIG
 491     int GetPropertyValueAsInt( wxPGPropArg id ) const
 492         { return (int)GetPropertyValueAsLong(id); }
 493 #endif
 494     bool GetPropertyValueAsBool( wxPGPropArg id ) const;
 495     double GetPropertyValueAsDouble( wxPGPropArg id ) const;
 496
 497 #define wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(TYPENAME, DEFVAL) \
 498     wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFVAL) \
 499     wxString typeName(wxS(TYPENAME)); \
 500     wxVariant value = p->GetValue(); \
 501     if ( value.GetType() != typeName ) \
 502     { \
 503         wxPGGetFailed(p, typeName); \
 504         return DEFVAL; \
 505     }
 506
 507 #define wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK(TYPENAME, DEFVAL) \
 508     wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFVAL) \
 509     wxVariant value = p->GetValue(); \
 510     if ( value.GetType() != wxS(TYPENAME) ) \
 511         return DEFVAL; \
 512
 513     wxArrayString GetPropertyValueAsArrayString( wxPGPropArg id ) const
 514     {
 515         wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL("arrstring",
 516                                                    wxArrayString())
 517         return value.GetArrayString();
 518     }
 519
 520 #if wxUSE_LONGLONG_NATIVE
 521     wxLongLong_t GetPropertyValueAsLongLong( wxPGPropArg id ) const
 522     {
 523         wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK("wxLongLong",
 524                                              (long) GetPropertyValueAsLong(id))
 525         wxLongLong ll;
 526         ll << value;
 527         return ll.GetValue();
 528     }
 529
 530     wxULongLong_t GetPropertyValueAsULongLong( wxPGPropArg id ) const
 531     {
 532         wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK("wxULongLong",
 533                                     (unsigned long) GetPropertyValueAsULong(id))
 534         wxULongLong ull;
 535         ull << value;
 536         return ull.GetValue();
 537     }
 538 #endif
 539
 540     wxArrayInt GetPropertyValueAsArrayInt( wxPGPropArg id ) const
 541     {
 542         wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL("wxArrayInt",
 543                                                    wxArrayInt())
 544         wxArrayInt arr;
 545         arr << value;
 546         return arr;
 547     }
 548
 549 #if wxUSE_DATETIME
 550     wxDateTime GetPropertyValueAsDateTime( wxPGPropArg id ) const
 551     {
 552         wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL("datetime",
 553                                                    wxDateTime())
 554         return value.GetDateTime();
 555     }
 556 #endif
 557
 558 #ifndef SWIG
 559     /** Returns a wxVariant list containing wxVariant versions of all
 560         property values. Order is not guaranteed.
 561         @param flags
 562         Use wxPG_KEEP_STRUCTURE to retain category structure; each sub
 563         category will be its own wxVariantList of wxVariant.
 564         Use wxPG_INC_ATTRIBUTES to include property attributes as well.
 565         Each attribute will be stored as list variant named
 566         "@@<propname>@@attr."
 567         @remarks
 568     */
 569     wxVariant GetPropertyValues( const wxString& listname = wxEmptyString,
 570         wxPGProperty* baseparent = NULL, long flags = 0 ) const
 571     {
 572         return m_pState->DoGetPropertyValues(listname, baseparent, flags);
 573     }
 574 #endif
 575
 576     /** Returns currently selected property. */
 577     wxPGProperty* GetSelection() const
 578     {
 579         return m_pState->GetSelection();
 580     }
 581
 582 #ifndef SWIG
 583     wxPropertyGridPageState* GetState() const { return m_pState; }
 584 #endif
 585
 586     /** Similar to GetIterator(), but instead returns wxPGVIterator instance,
 587         which can be useful for forward-iterating through arbitrary property
 588         containers.
 589
 590         @param flags
 591         See @ref propgrid_iterator_flags.
 592     */
 593     virtual wxPGVIterator GetVIterator( int flags ) const;
 594
 595     /** Hides or reveals a property.
 596         @param hide
 597             If true, hides property, otherwise reveals it.
 598         @param flags
 599             By default changes are applied recursively. Set this paramter
 600             wxPG_DONT_RECURSE to prevent this.
 601     */
 602     bool HideProperty( wxPGPropArg id,
 603                        bool hide = true,
 604                        int flags = wxPG_RECURSE );
 605
 606 #if wxPG_INCLUDE_ADVPROPS
 607     /** Initializes *all* property types. Causes references to most object
 608         files in the library, so calling this may cause significant increase
 609         in executable size when linking with static library.
 610     */
 611     static void InitAllTypeHandlers();
 612 #else
 613     static void InitAllTypeHandlers() { }
 614 #endif
 615
 616     //@{
 617     /** Inserts property to the property container.
 618
 619         @param priorThis
 620         New property is inserted just prior to this. Available only
 621         in the first variant. There are two versions of this function
 622         to allow this parameter to be either an id or name to
 623         a property.
 624
 625         @param newproperty
 626         Pointer to the inserted property. wxPropertyGrid will take
 627         ownership of this object.
 628
 629         @param parent
 630         New property is inserted under this category. Available only
 631         in the second variant. There are two versions of this function
 632         to allow this parameter to be either an id or name to
 633         a property.
 634
 635         @param index
 636         Index under category. Available only in the second variant.
 637         If index is < 0, property is appended in category.
 638
 639         @return
 640         Returns id for the property,
 641
 642         @remarks
 643
 644         - wxPropertyGrid takes the ownership of the property pointer.
 645
 646         - While Append may be faster way to add items, make note that when
 647           both types of data storage (categoric and
 648           non-categoric) are active, Insert becomes even more slow. This is
 649           especially true if current mode is non-categoric.
 650
 651         Example of use:
 652
 653         @code
 654
 655             // append category
 656             wxPGProperty* my_cat_id = propertygrid->Append(
 657                 new wxPropertyCategory("My Category") );
 658
 659             ...
 660
 661             // insert into category - using second variant
 662             wxPGProperty* my_item_id_1 = propertygrid->Insert(
 663                 my_cat_id, 0, new wxStringProperty("My String 1") );
 664
 665             // insert before to first item - using first variant
 666             wxPGProperty* my_item_id_2 = propertygrid->Insert(
 667                 my_item_id, new wxStringProperty("My String 2") );
 668
 669         @endcode
 670
 671     */
 672     wxPGProperty* Insert( wxPGPropArg priorThis, wxPGProperty* newproperty );
 673     wxPGProperty* Insert( wxPGPropArg parent,
 674                           int index,
 675                           wxPGProperty* newproperty );
 676     //@}
 677
 678     /** Returns true if property is a category. */
 679     bool IsPropertyCategory( wxPGPropArg id ) const
 680     {
 681         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 682         return p->IsCategory();
 683     }
 684
 685     /** Returns true if property is enabled. */
 686     bool IsPropertyEnabled( wxPGPropArg id ) const
 687     {
 688         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 689         return (!(p->GetFlags() & wxPG_PROP_DISABLED))?true:false;
 690     }
 691
 692     /**
 693         Returns true if given property is expanded.
 694
 695         Naturally, always returns false for properties that cannot be expanded.
 696     */
 697     bool IsPropertyExpanded( wxPGPropArg id ) const;
 698
 699     /**
 700         Returns true if property has been modified after value set or modify
 701         flag clear by software.
 702     */
 703     bool IsPropertyModified( wxPGPropArg id ) const
 704     {
 705         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 706         return ( (p->GetFlags() & wxPG_PROP_MODIFIED) ? true : false );
 707     }
 708
 709     /**
 710         Returns true if property is shown (ie hideproperty with true not
 711         called for it).
 712      */
 713     bool IsPropertyShown( wxPGPropArg id ) const
 714     {
 715         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 716         return (!(p->GetFlags() & wxPG_PROP_HIDDEN))?true:false;
 717     }
 718
 719     /** Returns true if property value is set to unspecified.
 720     */
 721     bool IsPropertyValueUnspecified( wxPGPropArg id ) const
 722     {
 723         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 724         return p->IsValueUnspecified();
 725     }
 726
 727     /**
 728         Disables (limit = true) or enables (limit = false) wxTextCtrl editor of
 729         a property, if it is not the sole mean to edit the value.
 730     */
 731     void LimitPropertyEditing( wxPGPropArg id, bool limit = true );
 732
 733     /** If state is shown in it's grid, refresh it now.
 734     */
 735     virtual void RefreshGrid( wxPropertyGridPageState* state = NULL );
 736
 737 #if wxPG_INCLUDE_ADVPROPS
 738     /**
 739         Initializes additional property editors (SpinCtrl etc.). Causes
 740         references to most object files in the library, so calling this may
 741         cause significant increase in executable size when linking with static
 742         library.
 743     */
 744     static void RegisterAdditionalEditors();
 745 #else
 746     static void RegisterAdditionalEditors() { }
 747 #endif
 748
 749     /** Replaces property with id with newly created property. For example,
 750         this code replaces existing property named "Flags" with one that
 751         will have different set of items:
 752         @code
 753             pg->ReplaceProperty("Flags",
 754                 wxFlagsProperty("Flags", wxPG_LABEL, newItems))
 755         @endcode
 756         For more info, see wxPropertyGrid::Insert.
 757     */
 758     wxPGProperty* ReplaceProperty( wxPGPropArg id, wxPGProperty* property );
 759
 760     /** @anchor propgridinterface_editablestate_flags
 761
 762         Flags for wxPropertyGridInterface::SaveEditableState() and
 763         wxPropertyGridInterface::RestoreEditableState().
 764     */
 765     enum EditableStateFlags
 766     {
 767         /** Include selected property. */
 768         SelectionState   = 0x01,
 769         /** Include expanded/collapsed property information. */
 770         ExpandedState    = 0x02,
 771         /** Include scrolled position. */
 772         ScrollPosState   = 0x04,
 773         /** Include selected page information.
 774             Only applies to wxPropertyGridManager. */
 775         PageState        = 0x08,
 776         /** Include splitter position. Stored for each page. */
 777         SplitterPosState = 0x10,
 778         /** Include description box size.
 779             Only applies to wxPropertyGridManager. */
 780         DescBoxState     = 0x20,
 781
 782         /**
 783             Include all supported user editable state information.
 784             This is usually the default value. */
 785         AllStates        = SelectionState |
 786                            ExpandedState |
 787                            ScrollPosState |
 788                            PageState |
 789                            SplitterPosState |
 790                            DescBoxState
 791     };
 792
 793     /**
 794         Restores user-editable state.
 795
 796         See also wxPropertyGridInterface::SaveEditableState().
 797
 798         @param src
 799             String generated by SaveEditableState.
 800
 801         @param restoreStates
 802             Which parts to restore from source string. See @ref
 803             propgridinterface_editablestate_flags "list of editable state
 804             flags".
 805
 806         @return
 807             False if there was problem reading the string.
 808
 809         @remarks
 810         If some parts of state (such as scrolled or splitter position) fail to
 811         restore correctly, please make sure that you call this function after
 812         wxPropertyGrid size has been set (this may sometimes be tricky when
 813         sizers are used).
 814     */
 815     bool RestoreEditableState( const wxString& src,
 816                                int restoreStates = AllStates );
 817
 818     /**
 819         Used to acquire user-editable state (selected property, expanded
 820         properties, scrolled position, splitter positions).
 821
 822         @param includedStates
 823         Which parts of state to include. See @ref
 824         propgridinterface_editablestate_flags "list of editable state flags".
 825     */
 826     wxString SaveEditableState( int includedStates = AllStates ) const;
 827
 828     /**
 829         Lets user to set the strings listed in the choice dropdown of a
 830         wxBoolProperty. Defaults are "True" and "False", so changing them to,
 831         say, "Yes" and "No" may be useful in some less technical applications.
 832     */
 833     static void SetBoolChoices( const wxString& trueChoice,
 834                                 const wxString& falseChoice );
 835
 836     /** Sets or clears flag(s) of all properties in given array.
 837         @param flags
 838         Property flags to set or clear.
 839         @param inverse
 840         Set to true if you want to clear flag instead of setting them.
 841     */
 842     void SetPropertiesFlag( const wxArrayPGProperty& srcArr,
 843                             wxPGProperty::FlagType flags,
 844                             bool inverse = false );
 845
 846     /** Sets an attribute for this property.
 847         @param name
 848             Text identifier of attribute. See @ref propgrid_property_attributes.
 849         @param value
 850             Value of attribute.
 851         @param argFlags
 852             Optional. Use wxPG_RECURSE to set the attribute to child properties
 853             recursively.
 854     */
 855     void SetPropertyAttribute( wxPGPropArg id,
 856                                const wxString& attrName,
 857                                wxVariant value,
 858                                long argFlags = 0 )
 859     {
 860         DoSetPropertyAttribute(id,attrName,value,argFlags);
 861     }
 862
 863     /** Sets property attribute for all applicapple properties.
 864         Be sure to use this method only after all properties have been
 865         added to the grid.
 866     */
 867     void SetPropertyAttributeAll( const wxString& attrName, wxVariant value );
 868
 869     /** Sets attributes from a wxPGAttributeStorage.
 870     */
 871     void SetPropertyAttributes( wxPGPropArg id,
 872                                 const wxPGAttributeStorage& attributes )
 873     {
 874         wxPG_PROP_ARG_CALL_PROLOG()
 875         p->SetAttributes(attributes);
 876     }
 877
 878     /** Sets text, bitmap, and colours for given column's cell.
 879
 880         @remarks
 881         - You can set label cell by setting column to 0.
 882         - You can use wxPG_LABEL as text to use default text for column.
 883     */
 884     void SetPropertyCell( wxPGPropArg id,
 885                           int column,
 886                           const wxString& text = wxEmptyString,
 887                           const wxBitmap& bitmap = wxNullBitmap,
 888                           const wxColour& fgCol = wxNullColour,
 889                           const wxColour& bgCol = wxNullColour )
 890     {
 891         wxPG_PROP_ARG_CALL_PROLOG()
 892         p->SetCell( column, new wxPGCell(text, bitmap, fgCol, bgCol) );
 893     }
 894
 895 #ifndef SWIG
 896     /** Sets client data (void*) of a property.
 897         @remarks
 898         This untyped client data has to be deleted manually.
 899     */
 900     void SetPropertyClientData( wxPGPropArg id, void* clientData )
 901     {
 902         wxPG_PROP_ARG_CALL_PROLOG()
 903         p->SetClientData(clientData);
 904     }
 905
 906     /** Sets editor for a property.
 907
 908         @param editor
 909         For builtin editors, use wxPGEditor_X, where X is builtin editor's
 910         name (TextCtrl, Choice, etc. see wxPGEditor documentation for full
 911         list).
 912
 913         For custom editors, use pointer you received from
 914         wxPropertyGrid::RegisterEditorClass().
 915     */
 916     void SetPropertyEditor( wxPGPropArg id, const wxPGEditor* editor )
 917     {
 918         wxPG_PROP_ARG_CALL_PROLOG()
 919         wxCHECK_RET( editor, wxT("unknown/NULL editor") );
 920         p->SetEditor(editor);
 921         RefreshProperty(p);
 922     }
 923 #endif
 924
 925     /** Sets editor control of a property. As editor argument, use
 926         editor name string, such as "TextCtrl" or "Choice".
 927     */
 928     void SetPropertyEditor( wxPGPropArg id, const wxString& editorName )
 929     {
 930         SetPropertyEditor(id,GetEditorByName(editorName));
 931     }
 932
 933     /** Sets label of a property.
 934     */
 935     void SetPropertyLabel( wxPGPropArg id, const wxString& newproplabel );
 936
 937     /**
 938         Sets name of a property.
 939
 940         @param id
 941             Name or pointer of property which name to change.
 942
 943         @param newName
 944             New name for property.
 945     */
 946     void SetPropertyName( wxPGPropArg id, const wxString& newName )
 947     {
 948         wxPG_PROP_ARG_CALL_PROLOG()
 949         m_pState->DoSetPropertyName( p, newName );
 950     }
 951
 952     /**
 953         Sets property (and, recursively, its children) to have read-only value.
 954         In other words, user cannot change the value in the editor, but they
 955         can still copy it.
 956         @remarks
 957         This is mainly for use with textctrl editor. Not all other editors fully
 958         support it.
 959         @param flags
 960         By default changes are applied recursively. Set this paramter
 961         wxPG_DONT_RECURSE to prevent this.
 962     */
 963     void SetPropertyReadOnly( wxPGPropArg id,
 964                               bool set = true,
 965                               int flags = wxPG_RECURSE )
 966     {
 967         wxPG_PROP_ARG_CALL_PROLOG()
 968         if ( flags & wxPG_RECURSE )
 969             p->SetFlagRecursively(wxPG_PROP_READONLY, set);
 970         else
 971             p->SetFlag(wxPG_PROP_READONLY);
 972     }
 973
 974     /** Sets property's value to unspecified.
 975         If it has children (it may be category), then the same thing is done to
 976         them.
 977     */
 978     void SetPropertyValueUnspecified( wxPGPropArg id );
 979
 980 #ifndef SWIG
 981     /** Sets various property values from a list of wxVariants. If property with
 982         name is missing from the grid, new property is created under given
 983         default category (or root if omitted).
 984     */
 985     void SetPropertyValues( const wxVariantList& list,
 986                             wxPGPropArg defaultCategory = wxNullProperty )
 987     {
 988         wxPGProperty *p;
 989         if ( defaultCategory.HasName() ) p = defaultCategory.GetPtr(this);
 990         else p = defaultCategory.GetPtr0();
 991         m_pState->DoSetPropertyValues(list, p);
 992     }
 993
 994     void SetPropertyValues( const wxVariant& list,
 995                             wxPGPropArg defaultCategory = wxNullProperty )
 996     {
 997         SetPropertyValues(list.GetList(),defaultCategory);
 998     }
 999 #endif
1000
1001     /** Associates the help string with property.
1002         @remarks
1003         By default, text is shown either in the manager's "description"
1004         text box or in the status bar. If extra window style
1005         wxPG_EX_HELP_AS_TOOLTIPS is used, then the text will appear as a
1006         tooltip.
1007     */
1008     void SetPropertyHelpString( wxPGPropArg id, const wxString& helpString )
1009     {
1010         wxPG_PROP_ARG_CALL_PROLOG()
1011         p->SetHelpString(helpString);
1012     }
1013
1014     /** Set wxBitmap in front of the value.
1015         @remarks
1016         - Bitmap will be scaled to a size returned by
1017         wxPropertyGrid::GetImageSize();
1018     */
1019     void SetPropertyImage( wxPGPropArg id, wxBitmap& bmp )
1020     {
1021         wxPG_PROP_ARG_CALL_PROLOG()
1022         p->SetValueImage(bmp);
1023         RefreshProperty(p);
1024     }
1025
1026     /** Sets max length of property's text.
1027     */
1028     bool SetPropertyMaxLength( wxPGPropArg id, int maxLen );
1029
1030 #if wxUSE_VALIDATORS
1031     /** Sets validator of a property.
1032     */
1033     void SetPropertyValidator( wxPGPropArg id, const wxValidator& validator )
1034     {
1035         wxPG_PROP_ARG_CALL_PROLOG()
1036         p->SetValidator(validator);
1037     }
1038 #endif
1039
1040 #ifndef SWIG
1041     /** Sets value (long integer) of a property.
1042     */
1043     void SetPropertyValue( wxPGPropArg id, long value )
1044     {
1045         wxVariant v(value);
1046         SetPropVal( id, v );
1047     }
1048
1049     /** Sets value (integer) of a property.
1050     */
1051     void SetPropertyValue( wxPGPropArg id, int value )
1052     {
1053         wxVariant v((long)value);
1054         SetPropVal( id, v );
1055     }
1056     /** Sets value (floating point) of a property.
1057     */
1058     void SetPropertyValue( wxPGPropArg id, double value )
1059     {
1060         wxVariant v(value);
1061         SetPropVal( id, v );
1062     }
1063     /** Sets value (bool) of a property.
1064     */
1065     void SetPropertyValue( wxPGPropArg id, bool value )
1066     {
1067         wxVariant v(value);
1068         SetPropVal( id, v );
1069     }
1070 #if wxUSE_WCHAR_T
1071     void SetPropertyValue( wxPGPropArg id, const wchar_t* value )
1072     {
1073         SetPropertyValueString( id, wxString(value) );
1074     }
1075 #endif
1076     void SetPropertyValue( wxPGPropArg id, const char* value )
1077     {
1078         SetPropertyValueString( id, wxString(value) );
1079     }
1080     void SetPropertyValue( wxPGPropArg id, const wxString& value )
1081     {
1082         SetPropertyValueString( id, value );
1083     }
1084
1085     /** Sets value (wxArrayString) of a property.
1086     */
1087     void SetPropertyValue( wxPGPropArg id, const wxArrayString& value )
1088     {
1089         wxVariant v(value);
1090         SetPropVal( id, v );
1091     }
1092
1093 #if wxUSE_DATETIME
1094     void SetPropertyValue( wxPGPropArg id, const wxDateTime& value )
1095     {
1096         wxVariant v(value);
1097         SetPropVal( id, v );
1098     }
1099 #endif
1100
1101     /** Sets value (wxObject*) of a property.
1102     */
1103     void SetPropertyValue( wxPGPropArg id, wxObject* value )
1104     {
1105         wxVariant v(value);
1106         SetPropVal( id, v );
1107     }
1108
1109     void SetPropertyValue( wxPGPropArg id, wxObject& value )
1110     {
1111         wxVariant v(&value);
1112         SetPropVal( id, v );
1113     }
1114
1115 #if wxUSE_LONGLONG_NATIVE
1116     /** Sets value (wxLongLong&) of a property.
1117     */
1118     void SetPropertyValue( wxPGPropArg id, wxLongLong_t value )
1119     {
1120         wxVariant v = WXVARIANT(wxLongLong(value));
1121         SetPropVal( id, v );
1122     }
1123     /** Sets value (wxULongLong&) of a property.
1124     */
1125     void SetPropertyValue( wxPGPropArg id, wxULongLong_t value )
1126     {
1127         wxVariant v = WXVARIANT(wxULongLong(value));
1128         SetPropVal( id, v );
1129     }
1130 #endif
1131
1132     /** Sets value (wxArrayInt&) of a property.
1133     */
1134     void SetPropertyValue( wxPGPropArg id, const wxArrayInt& value )
1135     {
1136         wxVariant v = WXVARIANT(value);
1137         SetPropVal( id, v );
1138     }
1139 #endif  // !SWIG
1140
1141     /** Sets value (wxString) of a property.
1142
1143         @remarks
1144         This method uses wxPGProperty::SetValueFromString, which all properties
1145         should implement. This means that there should not be a type error,
1146         and instead the string is converted to property's actual value type.
1147     */
1148     void SetPropertyValueString( wxPGPropArg id, const wxString& value );
1149
1150     /** Sets value (wxVariant&) of a property.
1151
1152         @remarks
1153         Use wxPropertyGrid::ChangePropertyValue() instead if you need to run
1154         through validation process and send property change event.
1155     */
1156     void SetPropertyValue( wxPGPropArg id, wxVariant value )
1157     {
1158         SetPropVal( id, value );
1159     }
1160
1161 #ifndef SWIG
1162     /** Sets value (wxVariant&) of a property. Same as SetPropertyValue, but
1163         accepts reference. */
1164     void SetPropVal( wxPGPropArg id, wxVariant& value );
1165 #endif
1166
1167     /** Adjusts how wxPropertyGrid behaves when invalid value is entered
1168         in a property.
1169         @param vfbFlags
1170         See @link vfbflags list of valid flags values@endlink
1171     */
1172     void SetValidationFailureBehavior( int vfbFlags );
1173
1174 #ifdef SWIG
1175     %pythoncode {
1176         def MapType(class_,factory):
1177             "Registers Python type/class to property mapping.\n\nfactory: Property builder function/class."
1178             global _type2property
1179             try:
1180                 mappings = _type2property
1181             except NameError:
1182                 raise AssertionError("call only after a propertygrid or manager instance constructed")
1183
1184             mappings[class_] = factory
1185
1186
1187         def DoDefaultTypeMappings(self):
1188             "Map built-in properties."
1189             global _type2property
1190             try:
1191                 mappings = _type2property
1192
1193                 return
1194             except NameError:
1195                 mappings = {}
1196                 _type2property = mappings
1197
1198             mappings[str] = StringProperty
1199             mappings[unicode] = StringProperty
1200             mappings[int] = IntProperty
1201             mappings[float] = FloatProperty
1202             mappings[bool] = BoolProperty
1203             mappings[list] = ArrayStringProperty
1204             mappings[tuple] = ArrayStringProperty
1205             mappings[wx.Font] = FontProperty
1206             mappings[wx.Colour] = ColourProperty
1207             "mappings[wx.Size] = SizeProperty"
1208             "mappings[wx.Point] = PointProperty"
1209             "mappings[wx.FontData] = FontDataProperty"
1210
1211         def DoDefaultValueTypeMappings(self):
1212             "Map pg value type ids to getter methods."
1213             global _vt2getter
1214             try:
1215                 vt2getter = _vt2getter
1216
1217                 return
1218             except NameError:
1219                 vt2getter = {}
1220                 _vt2getter = vt2getter
1221
1222         def GetPropertyValues(self,dict_=None, as_strings=False, inc_attributes=False):
1223             "Returns values in the grid."
1224             ""
1225             "dict_: if not given, then a new one is created. dict_ can be"
1226             "  object as well, in which case it's __dict__ is used."
1227             "as_strings: if True, then string representations of values"
1228             "  are fetched instead of native types. Useful for config and such."
1229             "inc_attributes: if True, then property attributes are added"
1230             "  as @<propname>@<attr>."
1231             ""
1232             "Return value: dictionary with values. It is always a dictionary,"
1233             "so if dict_ was object with __dict__ attribute, then that attribute"
1234             "is returned."
1235
1236             if dict_ is None:
1237                 dict_ = {}
1238             elif hasattr(dict_,'__dict__'):
1239                 dict_ = dict_.__dict__
1240
1241             if not as_strings:
1242                 getter = self.GetPropertyValue
1243             else:
1244                 getter = self.GetPropertyValueAsString
1245
1246             it = self.GetVIterator(PG_ITERATE_PROPERTIES)
1247             while not it.AtEnd():
1248                 p = it.GetProperty()
1249                 name = p.GetName()
1250
1251                 dict_[name] = getter(p)
1252
1253                 if inc_attributes:
1254                     attrs = p.GetAttributes()
1255                     if attrs and len(attrs):
1256                         dict_['@%s@attr'%name] = attrs
1257
1258                 it.Next()
1259
1260             return dict_
1261
1262         GetValues = GetPropertyValues
1263
1264
1265         def SetPropertyValues(self,dict_):
1266             "Sets property values from dict_, which can be either\ndictionary or an object with __dict__ attribute."
1267             ""
1268             "autofill: If true, keys with not relevant properties"
1269             "  are auto-created. For more info, see AutoFill."
1270             ""
1271             "Notes:"
1272             "  * Keys starting with underscore are ignored."
1273             "  * Attributes can be set with entries named @<propname>@<attr>."
1274             ""
1275
1276             autofill = False
1277
1278             if dict_ is None:
1279                 dict_ = {}
1280             elif hasattr(dict_,'__dict__'):
1281                 dict_ = dict_.__dict__
1282
1283             attr_dicts = []
1284
1285             def set_sub_obj(k0,dict_):
1286                 for k,v in dict_.iteritems():
1287                     if k[0] != '_':
1288                         if k.endswith('@attr'):
1289                             attr_dicts.append((k[1:-5],v))
1290                         else:
1291                             try:
1292                                 self.SetPropertyValue(k,v)
1293                             except:
1294                                 try:
1295                                     if autofill:
1296                                         self._AutoFillOne(k0,k,v)
1297                                         continue
1298                                 except:
1299                                     if isinstance(v,dict):
1300                                         set_sub_obj(k,v)
1301                                     elif hasattr(v,'__dict__'):
1302                                         set_sub_obj(k,v.__dict__)
1303
1304
1305             for k,v in attr_dicts:
1306                 p = GetPropertyByName(k)
1307                 if not p:
1308                     raise AssertionError("No such property: '%s'"%k)
1309                 for an,av in v.iteritems():
1310                     p.SetAttribute(an, av)
1311
1312
1313             cur_page = False
1314             is_manager = isinstance(self,PropertyGridManager)
1315
1316             try:
1317                 set_sub_obj(self.GetGrid().GetRoot(),dict_)
1318             except:
1319                 import traceback
1320                 traceback.print_exc()
1321
1322             self.Refresh()
1323
1324         SetValues = SetPropertyValues
1325
1326         def _AutoFillMany(self,cat,dict_):
1327             for k,v in dict_.iteritems():
1328                 self._AutoFillOne(cat,k,v)
1329
1330
1331         def _AutoFillOne(self,cat,k,v):
1332             global _type2property
1333
1334             factory = _type2property.get(v.__class__,None)
1335
1336             if factory:
1337                 self.AppendIn( cat, factory(k,k,v) )
1338             elif hasattr(v,'__dict__'):
1339                 cat2 = self.AppendIn( cat, PropertyCategory(k) )
1340                 self._AutoFillMany(cat2,v.__dict__)
1341             elif isinstance(v,dict):
1342                 cat2 = self.AppendIn( cat, PropertyCategory(k) )
1343                 self._AutoFillMany(cat2,v)
1344             elif not k.startswith('_'):
1345                 raise AssertionError("member '%s' is of unregisted type/class '%s'"%(k,v.__class__))
1346
1347
1348         def AutoFill(self,obj,parent=None):
1349             "Clears properties and re-fills to match members and\nvalues of given object or dictionary obj."
1350
1351             self.edited_objects[parent] = obj
1352
1353             cur_page = False
1354             is_manager = isinstance(self,PropertyGridManager)
1355
1356             if not parent:
1357                 if is_manager:
1358                     page = self.GetCurrentPage()
1359                     page.Clear()
1360                     parent = page.GetRoot()
1361                 else:
1362                     self.Clear()
1363                     parent = self.GetGrid().GetRoot()
1364             else:
1365                 it = self.GetIterator(PG_ITERATE_PROPERTIES, parent)
1366                 it.Next()  # Skip the parent
1367                 while not it.AtEnd():
1368                     p = it.GetProperty()
1369                     if not p.IsSomeParent(parent):
1370                         break
1371
1372                     self.DeleteProperty(p)
1373
1374                     name = p.GetName()
1375                     it.Next()
1376
1377             if not is_manager or page == self.GetCurrentPage():
1378                 self.Freeze()
1379                 cur_page = True
1380
1381             try:
1382                 self._AutoFillMany(parent,obj.__dict__)
1383             except:
1384                 import traceback
1385                 traceback.print_exc()
1386
1387             if cur_page:
1388                 self.Thaw()
1389
1390         def RegisterEditor(self, editor, editorName=None):
1391             "Transform class into instance, if necessary."
1392             if not isinstance(editor, PGEditor):
1393                 editor = editor()
1394             if not editorName:
1395                 editorName = editor.__class__.__name__
1396             try:
1397                 self._editor_instances.append(editor)
1398             except:
1399                 self._editor_instances = [editor]
1400             RegisterEditor(editor, editorName)
1401
1402         def GetPropertyClientData(self, p):
1403             if isinstance(p, basestring):
1404                 p = self.GetPropertyByName(p)
1405             return p.GetClientData()
1406
1407         def SetPropertyClientData(self, p, data):
1408             if isinstance(p, basestring):
1409                 p = self.GetPropertyByName(p)
1410             return p.SetClientData(data)
1411     }
1412 #endif
1413
1414     // GetPropertyByName With nice assertion error message.
1415     wxPGProperty* GetPropertyByNameA( const wxString& name ) const;
1416
1417     static wxPGEditor* GetEditorByName( const wxString& editorName );
1418
1419     virtual void RefreshProperty( wxPGProperty* p ) = 0;
1420
1421 protected:
1422
1423     /**
1424         In derived class, implement to set editable state component with
1425         given name to given value.
1426     */
1427     virtual bool SetEditableStateItem( const wxString& name, wxVariant value )
1428     {
1429         wxUnusedVar(name);
1430         wxUnusedVar(value);
1431         return false;
1432     }
1433
1434     /**
1435         In derived class, implement to return editable state component with
1436         given name.
1437     */
1438     virtual wxVariant GetEditableStateItem( const wxString& name ) const
1439     {
1440         wxUnusedVar(name);
1441         return wxNullVariant;
1442     }
1443
1444     // Returns page state data for given (sub) page (-1 means current page).
1445     virtual wxPropertyGridPageState* GetPageState( int pageIndex ) const
1446     {
1447         if ( pageIndex <= 0 )
1448             return m_pState;
1449         return NULL;
1450     }
1451
1452     virtual bool DoSelectPage( int WXUNUSED(index) ) { return true; }
1453
1454     // Default call's m_pState's BaseGetPropertyByName
1455     virtual wxPGProperty* DoGetPropertyByName( const wxString& name ) const;
1456
1457 #ifndef SWIG
1458
1459     // Deriving classes must set this (it must be only or current page).
1460     wxPropertyGridPageState*         m_pState;
1461
1462     // Intermediate version needed due to wxVariant copying inefficiency
1463     void DoSetPropertyAttribute( wxPGPropArg id,
1464                                  const wxString& name,
1465                                  wxVariant& value, long argFlags );
1466
1467     // Empty string object to return from member functions returning const
1468     // wxString&.
1469     wxString                    m_emptyString;
1470
1471 private:
1472     // Cannot be GetGrid() due to ambiguity issues.
1473     wxPropertyGrid* GetPropertyGrid()
1474     {
1475         return m_pState->GetGrid();
1476     }
1477
1478     // Cannot be GetGrid() due to ambiguity issues.
1479     const wxPropertyGrid* GetPropertyGrid() const
1480     {
1481         return (const wxPropertyGrid*) m_pState->GetGrid();
1482     }
1483 #endif // #ifndef SWIG
1484
1485     friend class wxPropertyGrid;
1486     friend class wxPropertyGridManager;
1487 };
1488
1489 #endif // wxUSE_PROPGRID
1490
1491 #endif // __WX_PROPGRID_PROPGRIDIFACE_H__