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