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