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 name of a property.
 966
 967         @param id
 968             Name or pointer of property which name to change.
 969
 970         @param newName
 971             New name for property.
 972     */
 973     void SetPropertyName( wxPGPropArg id, const wxString& newName )
 974     {
 975         wxPG_PROP_ARG_CALL_PROLOG()
 976         m_pState->DoSetPropertyName( p, newName );
 977     }
 978
 979     /**
 980         Sets property (and, recursively, its children) to have read-only value.
 981         In other words, user cannot change the value in the editor, but they
 982         can still copy it.
 983         @remarks
 984         This is mainly for use with textctrl editor. Not all other editors fully
 985         support it.
 986         @param flags
 987         By default changes are applied recursively. Set this paramter
 988         wxPG_DONT_RECURSE to prevent this.
 989     */
 990     void SetPropertyReadOnly( wxPGPropArg id,
 991                               bool set = true,
 992                               int flags = wxPG_RECURSE )
 993     {
 994         wxPG_PROP_ARG_CALL_PROLOG()
 995         if ( flags & wxPG_RECURSE )
 996             p->SetFlagRecursively(wxPG_PROP_READONLY, set);
 997         else
 998             p->SetFlag(wxPG_PROP_READONLY);
 999     }
1000
1001     /** Sets property's value to unspecified.
1002         If it has children (it may be category), then the same thing is done to
1003         them.
1004     */
1005     void SetPropertyValueUnspecified( wxPGPropArg id );
1006
1007 #ifndef SWIG
1008     /** Sets various property values from a list of wxVariants. If property with
1009         name is missing from the grid, new property is created under given
1010         default category (or root if omitted).
1011     */
1012     void SetPropertyValues( const wxVariantList& list,
1013                             wxPGPropArg defaultCategory = wxNullProperty )
1014     {
1015         wxPGProperty *p;
1016         if ( defaultCategory.HasName() ) p = defaultCategory.GetPtr(this);
1017         else p = defaultCategory.GetPtr0();
1018         m_pState->DoSetPropertyValues(list, p);
1019     }
1020
1021     void SetPropertyValues( const wxVariant& list,
1022                             wxPGPropArg defaultCategory = wxNullProperty )
1023     {
1024         SetPropertyValues(list.GetList(),defaultCategory);
1025     }
1026 #endif
1027
1028     /** Associates the help string with property.
1029         @remarks
1030         By default, text is shown either in the manager's "description"
1031         text box or in the status bar. If extra window style
1032         wxPG_EX_HELP_AS_TOOLTIPS is used, then the text will appear as a
1033         tooltip.
1034     */
1035     void SetPropertyHelpString( wxPGPropArg id, const wxString& helpString )
1036     {
1037         wxPG_PROP_ARG_CALL_PROLOG()
1038         p->SetHelpString(helpString);
1039     }
1040
1041     /** Set wxBitmap in front of the value.
1042         @remarks
1043         - Bitmap will be scaled to a size returned by
1044         wxPropertyGrid::GetImageSize();
1045     */
1046     void SetPropertyImage( wxPGPropArg id, wxBitmap& bmp )
1047     {
1048         wxPG_PROP_ARG_CALL_PROLOG()
1049         p->SetValueImage(bmp);
1050         RefreshProperty(p);
1051     }
1052
1053     /** Sets max length of property's text.
1054     */
1055     bool SetPropertyMaxLength( wxPGPropArg id, int maxLen );
1056
1057 #if wxUSE_VALIDATORS
1058     /** Sets validator of a property.
1059     */
1060     void SetPropertyValidator( wxPGPropArg id, const wxValidator& validator )
1061     {
1062         wxPG_PROP_ARG_CALL_PROLOG()
1063         p->SetValidator(validator);
1064     }
1065 #endif
1066
1067 #ifndef SWIG
1068     /** Sets value (long integer) of a property.
1069     */
1070     void SetPropertyValue( wxPGPropArg id, long value )
1071     {
1072         wxVariant v(value);
1073         SetPropVal( id, v );
1074     }
1075
1076     /** Sets value (integer) of a property.
1077     */
1078     void SetPropertyValue( wxPGPropArg id, int value )
1079     {
1080         wxVariant v((long)value);
1081         SetPropVal( id, v );
1082     }
1083     /** Sets value (floating point) of a property.
1084     */
1085     void SetPropertyValue( wxPGPropArg id, double value )
1086     {
1087         wxVariant v(value);
1088         SetPropVal( id, v );
1089     }
1090     /** Sets value (bool) of a property.
1091     */
1092     void SetPropertyValue( wxPGPropArg id, bool value )
1093     {
1094         wxVariant v(value);
1095         SetPropVal( id, v );
1096     }
1097 #if wxUSE_WCHAR_T
1098     void SetPropertyValue( wxPGPropArg id, const wchar_t* value )
1099     {
1100         SetPropertyValueString( id, wxString(value) );
1101     }
1102 #endif
1103     void SetPropertyValue( wxPGPropArg id, const char* value )
1104     {
1105         SetPropertyValueString( id, wxString(value) );
1106     }
1107     void SetPropertyValue( wxPGPropArg id, const wxString& value )
1108     {
1109         SetPropertyValueString( id, value );
1110     }
1111
1112     /** Sets value (wxArrayString) of a property.
1113     */
1114     void SetPropertyValue( wxPGPropArg id, const wxArrayString& value )
1115     {
1116         wxVariant v(value);
1117         SetPropVal( id, v );
1118     }
1119
1120 #if wxUSE_DATETIME
1121     void SetPropertyValue( wxPGPropArg id, const wxDateTime& value )
1122     {
1123         wxVariant v(value);
1124         SetPropVal( id, v );
1125     }
1126 #endif
1127
1128     /** Sets value (wxObject*) of a property.
1129     */
1130     void SetPropertyValue( wxPGPropArg id, wxObject* value )
1131     {
1132         wxVariant v(value);
1133         SetPropVal( id, v );
1134     }
1135
1136     void SetPropertyValue( wxPGPropArg id, wxObject& value )
1137     {
1138         wxVariant v(&value);
1139         SetPropVal( id, v );
1140     }
1141
1142 #if wxUSE_LONGLONG_NATIVE
1143     /** Sets value (wxLongLong&) of a property.
1144     */
1145     void SetPropertyValue( wxPGPropArg id, wxLongLong_t value )
1146     {
1147         wxVariant v = WXVARIANT(wxLongLong(value));
1148         SetPropVal( id, v );
1149     }
1150     /** Sets value (wxULongLong&) of a property.
1151     */
1152     void SetPropertyValue( wxPGPropArg id, wxULongLong_t value )
1153     {
1154         wxVariant v = WXVARIANT(wxULongLong(value));
1155         SetPropVal( id, v );
1156     }
1157 #endif
1158
1159     /** Sets value (wxArrayInt&) of a property.
1160     */
1161     void SetPropertyValue( wxPGPropArg id, const wxArrayInt& value )
1162     {
1163         wxVariant v = WXVARIANT(value);
1164         SetPropVal( id, v );
1165     }
1166 #endif  // !SWIG
1167
1168     /** Sets value (wxString) of a property.
1169
1170         @remarks
1171         This method uses wxPGProperty::SetValueFromString, which all properties
1172         should implement. This means that there should not be a type error,
1173         and instead the string is converted to property's actual value type.
1174     */
1175     void SetPropertyValueString( wxPGPropArg id, const wxString& value );
1176
1177     /** Sets value (wxVariant&) of a property.
1178
1179         @remarks
1180         Use wxPropertyGrid::ChangePropertyValue() instead if you need to run
1181         through validation process and send property change event.
1182     */
1183     void SetPropertyValue( wxPGPropArg id, wxVariant value )
1184     {
1185         SetPropVal( id, value );
1186     }
1187
1188 #ifndef SWIG
1189     /** Sets value (wxVariant&) of a property. Same as SetPropertyValue, but
1190         accepts reference. */
1191     void SetPropVal( wxPGPropArg id, wxVariant& value );
1192 #endif
1193
1194     /** Adjusts how wxPropertyGrid behaves when invalid value is entered
1195         in a property.
1196         @param vfbFlags
1197         See @link vfbflags list of valid flags values@endlink
1198     */
1199     void SetValidationFailureBehavior( int vfbFlags );
1200
1201 #ifdef SWIG
1202     %pythoncode {
1203         def MapType(class_,factory):
1204             "Registers Python type/class to property mapping.\n\nfactory: Property builder function/class."
1205             global _type2property
1206             try:
1207                 mappings = _type2property
1208             except NameError:
1209                 raise AssertionError("call only after a propertygrid or manager instance constructed")
1210
1211             mappings[class_] = factory
1212
1213
1214         def DoDefaultTypeMappings(self):
1215             "Map built-in properties."
1216             global _type2property
1217             try:
1218                 mappings = _type2property
1219
1220                 return
1221             except NameError:
1222                 mappings = {}
1223                 _type2property = mappings
1224
1225             mappings[str] = StringProperty
1226             mappings[unicode] = StringProperty
1227             mappings[int] = IntProperty
1228             mappings[float] = FloatProperty
1229             mappings[bool] = BoolProperty
1230             mappings[list] = ArrayStringProperty
1231             mappings[tuple] = ArrayStringProperty
1232             mappings[wx.Font] = FontProperty
1233             mappings[wx.Colour] = ColourProperty
1234             "mappings[wx.Size] = SizeProperty"
1235             "mappings[wx.Point] = PointProperty"
1236             "mappings[wx.FontData] = FontDataProperty"
1237
1238         def DoDefaultValueTypeMappings(self):
1239             "Map pg value type ids to getter methods."
1240             global _vt2getter
1241             try:
1242                 vt2getter = _vt2getter
1243
1244                 return
1245             except NameError:
1246                 vt2getter = {}
1247                 _vt2getter = vt2getter
1248
1249         def GetPropertyValues(self,dict_=None, as_strings=False, inc_attributes=False):
1250             "Returns values in the grid."
1251             ""
1252             "dict_: if not given, then a new one is created. dict_ can be"
1253             "  object as well, in which case it's __dict__ is used."
1254             "as_strings: if True, then string representations of values"
1255             "  are fetched instead of native types. Useful for config and such."
1256             "inc_attributes: if True, then property attributes are added"
1257             "  as @<propname>@<attr>."
1258             ""
1259             "Return value: dictionary with values. It is always a dictionary,"
1260             "so if dict_ was object with __dict__ attribute, then that attribute"
1261             "is returned."
1262
1263             if dict_ is None:
1264                 dict_ = {}
1265             elif hasattr(dict_,'__dict__'):
1266                 dict_ = dict_.__dict__
1267
1268             if not as_strings:
1269                 getter = self.GetPropertyValue
1270             else:
1271                 getter = self.GetPropertyValueAsString
1272
1273             it = self.GetVIterator(PG_ITERATE_PROPERTIES)
1274             while not it.AtEnd():
1275                 p = it.GetProperty()
1276                 name = p.GetName()
1277
1278                 dict_[name] = getter(p)
1279
1280                 if inc_attributes:
1281                     attrs = p.GetAttributes()
1282                     if attrs and len(attrs):
1283                         dict_['@%s@attr'%name] = attrs
1284
1285                 it.Next()
1286
1287             return dict_
1288
1289         GetValues = GetPropertyValues
1290
1291
1292         def SetPropertyValues(self,dict_):
1293             "Sets property values from dict_, which can be either\ndictionary or an object with __dict__ attribute."
1294             ""
1295             "autofill: If true, keys with not relevant properties"
1296             "  are auto-created. For more info, see AutoFill."
1297             ""
1298             "Notes:"
1299             "  * Keys starting with underscore are ignored."
1300             "  * Attributes can be set with entries named @<propname>@<attr>."
1301             ""
1302
1303             autofill = False
1304
1305             if dict_ is None:
1306                 dict_ = {}
1307             elif hasattr(dict_,'__dict__'):
1308                 dict_ = dict_.__dict__
1309
1310             attr_dicts = []
1311
1312             def set_sub_obj(k0,dict_):
1313                 for k,v in dict_.iteritems():
1314                     if k[0] != '_':
1315                         if k.endswith('@attr'):
1316                             attr_dicts.append((k[1:-5],v))
1317                         else:
1318                             try:
1319                                 self.SetPropertyValue(k,v)
1320                             except:
1321                                 try:
1322                                     if autofill:
1323                                         self._AutoFillOne(k0,k,v)
1324                                         continue
1325                                 except:
1326                                     if isinstance(v,dict):
1327                                         set_sub_obj(k,v)
1328                                     elif hasattr(v,'__dict__'):
1329                                         set_sub_obj(k,v.__dict__)
1330
1331
1332             for k,v in attr_dicts:
1333                 p = GetPropertyByName(k)
1334                 if not p:
1335                     raise AssertionError("No such property: '%s'"%k)
1336                 for an,av in v.iteritems():
1337                     p.SetAttribute(an, av)
1338
1339
1340             cur_page = False
1341             is_manager = isinstance(self,PropertyGridManager)
1342
1343             try:
1344                 set_sub_obj(self.GetGrid().GetRoot(),dict_)
1345             except:
1346                 import traceback
1347                 traceback.print_exc()
1348
1349             self.Refresh()
1350
1351         SetValues = SetPropertyValues
1352
1353         def _AutoFillMany(self,cat,dict_):
1354             for k,v in dict_.iteritems():
1355                 self._AutoFillOne(cat,k,v)
1356
1357
1358         def _AutoFillOne(self,cat,k,v):
1359             global _type2property
1360
1361             factory = _type2property.get(v.__class__,None)
1362
1363             if factory:
1364                 self.AppendIn( cat, factory(k,k,v) )
1365             elif hasattr(v,'__dict__'):
1366                 cat2 = self.AppendIn( cat, PropertyCategory(k) )
1367                 self._AutoFillMany(cat2,v.__dict__)
1368             elif isinstance(v,dict):
1369                 cat2 = self.AppendIn( cat, PropertyCategory(k) )
1370                 self._AutoFillMany(cat2,v)
1371             elif not k.startswith('_'):
1372                 raise AssertionError("member '%s' is of unregisted type/class '%s'"%(k,v.__class__))
1373
1374
1375         def AutoFill(self,obj,parent=None):
1376             "Clears properties and re-fills to match members and\nvalues of given object or dictionary obj."
1377
1378             self.edited_objects[parent] = obj
1379
1380             cur_page = False
1381             is_manager = isinstance(self,PropertyGridManager)
1382
1383             if not parent:
1384                 if is_manager:
1385                     page = self.GetCurrentPage()
1386                     page.Clear()
1387                     parent = page.GetRoot()
1388                 else:
1389                     self.Clear()
1390                     parent = self.GetGrid().GetRoot()
1391             else:
1392                 it = self.GetIterator(PG_ITERATE_PROPERTIES, parent)
1393                 it.Next()  # Skip the parent
1394                 while not it.AtEnd():
1395                     p = it.GetProperty()
1396                     if not p.IsSomeParent(parent):
1397                         break
1398
1399                     self.DeleteProperty(p)
1400
1401                     name = p.GetName()
1402                     it.Next()
1403
1404             if not is_manager or page == self.GetCurrentPage():
1405                 self.Freeze()
1406                 cur_page = True
1407
1408             try:
1409                 self._AutoFillMany(parent,obj.__dict__)
1410             except:
1411                 import traceback
1412                 traceback.print_exc()
1413
1414             if cur_page:
1415                 self.Thaw()
1416
1417         def RegisterEditor(self, editor, editorName=None):
1418             "Transform class into instance, if necessary."
1419             if not isinstance(editor, PGEditor):
1420                 editor = editor()
1421             if not editorName:
1422                 editorName = editor.__class__.__name__
1423             try:
1424                 self._editor_instances.append(editor)
1425             except:
1426                 self._editor_instances = [editor]
1427             RegisterEditor(editor, editorName)
1428
1429         def GetPropertyClientData(self, p):
1430             if isinstance(p, basestring):
1431                 p = self.GetPropertyByName(p)
1432             return p.GetClientData()
1433
1434         def SetPropertyClientData(self, p, data):
1435             if isinstance(p, basestring):
1436                 p = self.GetPropertyByName(p)
1437             return p.SetClientData(data)
1438     }
1439 #endif
1440
1441     // GetPropertyByName With nice assertion error message.
1442     wxPGProperty* GetPropertyByNameA( const wxString& name ) const;
1443
1444     static wxPGEditor* GetEditorByName( const wxString& editorName );
1445
1446     virtual void RefreshProperty( wxPGProperty* p ) = 0;
1447
1448 protected:
1449
1450     // Returns page state data for given (sub) page (-1 means current page).
1451     virtual wxPropertyGridPageState* GetPageState( int pageIndex ) const
1452     {
1453         if ( pageIndex <= 0 )
1454             return m_pState;
1455         return NULL;
1456     }
1457
1458     virtual bool DoSelectPage( int WXUNUSED(index) ) { return true; }
1459
1460     // Default call's m_pState's BaseGetPropertyByName
1461     virtual wxPGProperty* DoGetPropertyByName( const wxString& name ) const;
1462
1463 #ifndef SWIG
1464
1465     // Deriving classes must set this (it must be only or current page).
1466     wxPropertyGridPageState*         m_pState;
1467
1468     // Intermediate version needed due to wxVariant copying inefficiency
1469     void DoSetPropertyAttribute( wxPGPropArg id,
1470                                  const wxString& name,
1471                                  wxVariant& value, long argFlags );
1472
1473     // Empty string object to return from member functions returning const
1474     // wxString&.
1475     wxString                    m_emptyString;
1476
1477 private:
1478     // Cannot be GetGrid() due to ambiguity issues.
1479     wxPropertyGrid* GetPropertyGrid()
1480     {
1481         return m_pState->GetGrid();
1482     }
1483
1484     // Cannot be GetGrid() due to ambiguity issues.
1485     const wxPropertyGrid* GetPropertyGrid() const
1486     {
1487         return (const wxPropertyGrid*) m_pState->GetGrid();
1488     }
1489 #endif // #ifndef SWIG
1490
1491     friend class wxPropertyGrid;
1492     friend class wxPropertyGridManager;
1493 };
1494
1495 #endif // wxUSE_PROPGRID
1496
1497 #endif // __WX_PROPGRID_PROPGRIDIFACE_H__