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 #include "wx/propgrid/property.h"
  16 #include "wx/propgrid/propgridpagestate.h"
  17
  18 // -----------------------------------------------------------------------
  19
  20 #ifndef SWIG
  21
  22 /** @section wxPGPropArgCls
  23
  24     Most property grid functions have this type as their argument, as it can
  25     convey a property by either a pointer or name.
  26 */
  27 class WXDLLIMPEXP_PROPGRID wxPGPropArgCls
  28 {
  29 public:
  30     wxPGPropArgCls() { }
  31     wxPGPropArgCls( const wxPGProperty* property )
  32     {
  33         m_ptr.property = (wxPGProperty*) property;
  34         m_isName = false;
  35     }
  36     wxPGPropArgCls( const wxString& str )
  37     {
  38         m_ptr.name = &str;
  39         m_isName = 1;
  40     }
  41     wxPGPropArgCls( const wxPGPropArgCls& id )
  42     {
  43         m_ptr = id.m_ptr;
  44         m_isName = id.m_isName;
  45     }
  46     // This is only needed for wxPython bindings
  47     wxPGPropArgCls( wxString* str, bool WXUNUSED(deallocPtr) )
  48     {
  49         m_ptr.name = str;
  50         m_isName = 3;  // Like 1, but causes ptr to be deallocated in dtor
  51     }
  52     ~wxPGPropArgCls()
  53     {
  54         if ( m_isName == 3 )
  55             delete m_ptr.name;
  56     }
  57     wxPGProperty* GetPtr() const
  58     {
  59         wxCHECK( !m_isName, NULL );
  60         return m_ptr.property;
  61     }
  62     wxPGPropArgCls( const wxChar* str )
  63     {
  64         m_ptr.rawname = str;
  65         m_isName = 2;
  66     }
  67     /** This constructor is required for NULL. */
  68     wxPGPropArgCls( int )
  69     {
  70         m_ptr.property = (wxPGProperty*) NULL;
  71         m_isName = false;
  72     }
  73     wxPGProperty* GetPtr( wxPropertyGridInterface* methods ) const;
  74     wxPGProperty* GetPtr( const wxPropertyGridInterface* methods ) const
  75     {
  76         return GetPtr((wxPropertyGridInterface*)methods);
  77     }
  78     wxPGProperty* GetPtr0() const { return m_ptr.property; }
  79     unsigned char HasName() const { return m_isName; }
  80     const wxString& GetName() const { return *m_ptr.name; }
  81 private:
  82     union
  83     {
  84         wxPGProperty* property;
  85         const wxChar* rawname;
  86         const wxString* name;
  87     } m_ptr;
  88     unsigned char m_isName;
  89 };
  90
  91 #endif
  92
  93 typedef const wxPGPropArgCls& wxPGPropArg;
  94
  95 // -----------------------------------------------------------------------
  96
  97 WXDLLIMPEXP_PROPGRID
  98 void wxPGTypeOperationFailed( const wxPGProperty* p,
  99                               const wxChar* typestr,
 100                               const wxChar* op );
 101 WXDLLIMPEXP_PROPGRID
 102 void wxPGGetFailed( const wxPGProperty* p, const wxChar* typestr );
 103
 104 // -----------------------------------------------------------------------
 105
 106 // Helper macro that does necessary preparations when calling
 107 // some wxPGProperty's member function.
 108 #define wxPG_PROP_ARG_CALL_PROLOG_0(PROPERTY) \
 109     PROPERTY *p = (PROPERTY*)id.GetPtr(this); \
 110     if ( !p ) return;
 111
 112 #define wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(PROPERTY, RETVAL) \
 113     PROPERTY *p = (PROPERTY*)id.GetPtr(this); \
 114     if ( !p ) return RETVAL;
 115
 116 #define wxPG_PROP_ARG_CALL_PROLOG() \
 117     wxPG_PROP_ARG_CALL_PROLOG_0(wxPGProperty)
 118
 119 #define wxPG_PROP_ARG_CALL_PROLOG_RETVAL(RVAL) \
 120     wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(wxPGProperty, RVAL)
 121
 122 #define wxPG_PROP_ID_CONST_CALL_PROLOG() \
 123     wxPG_PROP_ARG_CALL_PROLOG_0(const wxPGProperty)
 124
 125 #define wxPG_PROP_ID_CONST_CALL_PROLOG_RETVAL(RVAL) \
 126     wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(const wxPGProperty, RVAL)
 127
 128 // -----------------------------------------------------------------------
 129
 130
 131 /** @class wxPropertyGridInterface
 132
 133     Most of the shared property manipulation interface shared by wxPropertyGrid,
 134     wxPropertyGridPage, and wxPropertyGridManager is defined in this class.
 135
 136     @remarks
 137     - In separate wxPropertyGrid component this class was known as
 138     wxPropertyContainerMethods.
 139
 140     @library{wxpropgrid}
 141     @category{propgrid}
 142 */
 143 class WXDLLIMPEXP_PROPGRID wxPropertyGridInterface
 144 {
 145 public:
 146
 147     /** Destructor */
 148     virtual ~wxPropertyGridInterface() { }
 149
 150     /** Adds choice to a property that can accept one.
 151         @remarks
 152         - If you need to make sure that you modify only the set of choices of
 153           a single property (and not also choices of other properties with
 154           initially identical set), call
 155           wxPropertyGrid::SetPropertyChoicesPrivate.
 156         - This usually only works for wxEnumProperty and derivatives
 157           (wxFlagsProperty can get accept new items but its items may not get
 158           updated).
 159     */
 160     void AddPropertyChoice( wxPGPropArg id,
 161                             const wxString& label,
 162                             int value = wxPG_INVALID_VALUE );
 163
 164     /**
 165         Appends property to the list.
 166
 167         wxPropertyGrid assumes ownership of the object.
 168         Becomes child of most recently added category.
 169         @remarks
 170         - wxPropertyGrid takes the ownership of the property pointer.
 171         - If appending a category with name identical to a category already in
 172           the wxPropertyGrid, then newly created category is deleted, and most
 173           recently added category (under which properties are appended) is set
 174           to the one with same name. This allows easier adding of items to same
 175           categories in multiple passes.
 176         - Does not automatically redraw the control, so you may need to call
 177           Refresh when calling this function after control has been shown for
 178           the first time.
 179     */
 180     wxPGProperty* Append( wxPGProperty* property );
 181
 182     wxPGProperty* AppendIn( wxPGPropArg id, wxPGProperty* newproperty );
 183
 184     /**
 185         In order to add new items into a property with fixed children (for
 186         instance, wxFlagsProperty), you need to call this method. After
 187         populating has been finished, you need to call EndAddChildren.
 188     */
 189     void BeginAddChildren( wxPGPropArg id );
 190
 191     /** Deletes all properties.
 192     */
 193     virtual void Clear() = 0;
 194
 195     /** Deselect current selection, if any. Returns true if success
 196         (ie. validator did not intercept). */
 197     bool ClearSelection();
 198
 199     /** Resets modified status of all properties.
 200     */
 201     void ClearModifiedStatus()
 202     {
 203         SetPropertyModifiedStatus(m_pState->m_properties, false);
 204         m_pState->m_anyModified = false;
 205     }
 206
 207     /** Collapses given category or property with children.
 208         Returns true if actually collapses.
 209     */
 210     bool Collapse( wxPGPropArg id );
 211
 212     /** Collapses all items that can be collapsed.
 213
 214         @return
 215         Return false if failed (may fail if editor value cannot be validated).
 216     */
 217     bool CollapseAll() { return ExpandAll(false); }
 218
 219     /**
 220         Changes value of a property, as if from an editor.
 221         Use this instead of SetPropertyValue() if you need the value to run
 222         through validation process, and also send the property change event.
 223
 224         @return
 225         Returns true if value was successfully changed.
 226     */
 227     bool ChangePropertyValue( wxPGPropArg id, wxVariant newValue );
 228
 229     /** Resets value of a property to its default. */
 230     bool ClearPropertyValue( wxPGPropArg id )
 231     {
 232         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 233         p->SetValue(p->GetDefaultValue());
 234         RefreshProperty(p);
 235         return true;
 236     }
 237
 238     /**
 239         Deletes a property by id. If category is deleted, all children are
 240         automatically deleted as well.
 241      */
 242     void DeleteProperty( wxPGPropArg id );
 243
 244     /** Deletes choice from a property.
 245
 246         If selected item is deleted, then the value is set to unspecified.
 247
 248         See AddPropertyChoice for more details.
 249     */
 250     void DeletePropertyChoice( wxPGPropArg id, int index );
 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 writable reference to property's list of choices (and relevant
 445         values). If property does not have any choices, will return reference
 446         to an invalid set of choices that will return false on IsOk call.
 447     */
 448     wxPGChoices& GetPropertyChoices( wxPGPropArg id );
 449
 450     /** Returns property's editor. */
 451     const wxPGEditor* GetPropertyEditor( wxPGPropArg id ) const
 452     {
 453         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
 454         return p->GetEditorClass();
 455     }
 456
 457     /** Returns help string associated with a property. */
 458     wxString GetPropertyHelpString( wxPGPropArg id ) const
 459     {
 460         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
 461         return p->GetHelpString();
 462     }
 463
 464     /** Returns property's custom value image (NULL of none). */
 465     wxBitmap* GetPropertyImage( wxPGPropArg id ) const
 466     {
 467         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
 468         return p->GetValueImage();
 469     }
 470
 471     /** Returns property's position under its parent. */
 472     unsigned int GetPropertyIndex( wxPGPropArg id )
 473     {
 474         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(INT_MAX)
 475         return p->GetIndexInParent();
 476     }
 477
 478     /** Returns label of a property. */
 479     const wxString& GetPropertyLabel( wxPGPropArg id )
 480     {
 481         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
 482         return p->GetLabel();
 483     }
 484
 485     /** Returns name of a property, by which it is globally accessible. */
 486     wxString GetPropertyName( wxPGPropArg id )
 487     {
 488         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
 489         return p->GetName();
 490     }
 491
 492     /** Returns parent item of a property. */
 493     wxPGProperty* GetPropertyParent( wxPGPropArg id )
 494     {
 495         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
 496         return p->GetParent();
 497     }
 498
 499 #if wxUSE_VALIDATORS
 500     /** Returns validator of a property as a reference, which you
 501         can pass to any number of SetPropertyValidator.
 502     */
 503     wxValidator* GetPropertyValidator( wxPGPropArg id )
 504     {
 505         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
 506         return p->GetValidator();
 507     }
 508 #endif
 509
 510     /** Returns value as wxVariant. To get wxObject pointer from it,
 511         you will have to use WX_PG_VARIANT_TO_WXOBJECT(VARIANT,CLASSNAME) macro.
 512
 513         If property value is unspecified, Null variant is returned.
 514     */
 515     wxVariant GetPropertyValue( wxPGPropArg id )
 516     {
 517         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxVariant())
 518         return p->GetValue();
 519     }
 520
 521     wxString GetPropertyValueAsString( wxPGPropArg id ) const;
 522     long GetPropertyValueAsLong( wxPGPropArg id ) const;
 523     unsigned long GetPropertyValueAsULong( wxPGPropArg id ) const
 524     {
 525         return (unsigned long) GetPropertyValueAsLong(id);
 526     }
 527 #ifndef SWIG
 528     int GetPropertyValueAsInt( wxPGPropArg id ) const
 529         { return (int)GetPropertyValueAsLong(id); }
 530 #endif
 531     bool GetPropertyValueAsBool( wxPGPropArg id ) const;
 532     double GetPropertyValueAsDouble( wxPGPropArg id ) const;
 533     wxObject* GetPropertyValueAsWxObjectPtr( wxPGPropArg id ) const;
 534     void* GetPropertyValueAsVoidPtr( wxPGPropArg id ) const;
 535
 536 #define wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(TYPENAME, DEFVAL) \
 537     wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFVAL) \
 538     if ( p->m_value.GetType() != TYPENAME ) \
 539     { \
 540         wxPGGetFailed(p, TYPENAME); \
 541         return DEFVAL; \
 542     }
 543
 544 #define wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK(TYPENAME, DEFVAL) \
 545     wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFVAL) \
 546     if ( p->m_value.GetType() != TYPENAME ) \
 547         return DEFVAL; \
 548
 549     wxArrayString GetPropertyValueAsArrayString( wxPGPropArg id ) const
 550     {
 551         wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxT("arrstring"),
 552                                                    wxArrayString())
 553         return p->m_value.GetArrayString();
 554     }
 555
 556     wxPoint GetPropertyValueAsPoint( wxPGPropArg id ) const
 557     {
 558         wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxT("wxPoint"), wxPoint())
 559         return WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxPoint);
 560     }
 561
 562     wxSize GetPropertyValueAsSize( wxPGPropArg id ) const
 563     {
 564         wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxT("wxSize"), wxSize())
 565         return WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxSize);
 566     }
 567
 568     wxLongLong_t GetPropertyValueAsLongLong( wxPGPropArg id ) const
 569     {
 570         wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK(wxT("wxLongLong"),
 571                                              (long) GetPropertyValueAsLong(id))
 572         return WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxLongLong).GetValue();
 573     }
 574
 575     wxULongLong_t GetPropertyValueAsULongLong( wxPGPropArg id ) const
 576     {
 577         wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK(wxT("wxULongLong"),
 578                                     (unsigned long) GetPropertyValueAsULong(id))
 579         return WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxULongLong).GetValue();
 580     }
 581
 582     wxArrayInt GetPropertyValueAsArrayInt( wxPGPropArg id ) const
 583     {
 584         wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxT("wxArrayInt"),
 585                                                    wxArrayInt())
 586         wxArrayInt arr = WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxArrayInt);
 587         return arr;
 588     }
 589
 590 #if wxUSE_DATETIME
 591     wxDateTime GetPropertyValueAsDateTime( wxPGPropArg id ) const
 592     {
 593         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxDateTime())
 594
 595         if ( wxStrcmp(p->m_value.GetType(), wxT("datetime")) != 0 )
 596         {
 597             wxPGGetFailed(p, wxT("datetime"));
 598             return wxDateTime();
 599         }
 600         return p->m_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     /** Inserts choice to a property that can accept one.
 738
 739         See AddPropertyChoice for more details.
 740     */
 741     void InsertPropertyChoice( wxPGPropArg id,
 742                                const wxString& label,
 743                                int index,
 744                                int value = wxPG_INVALID_VALUE );
 745
 746     /** Returns true if property is enabled. */
 747     bool IsPropertyEnabled( wxPGPropArg id ) const
 748     {
 749         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 750         return (!(p->GetFlags() & wxPG_PROP_DISABLED))?true:false;
 751     }
 752
 753     /**
 754         Returns true if given property is expanded.
 755
 756         Naturally, always returns false for properties that cannot be expanded.
 757     */
 758     bool IsPropertyExpanded( wxPGPropArg id ) const;
 759
 760     /**
 761         Returns true if property has been modified after value set or modify
 762         flag clear by software.
 763     */
 764     bool IsPropertyModified( wxPGPropArg id ) const
 765     {
 766         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 767         return ( (p->GetFlags() & wxPG_PROP_MODIFIED) ? true : false );
 768     }
 769
 770     /**
 771         Returns true if property is shown (ie hideproperty with true not
 772         called for it).
 773      */
 774     bool IsPropertyShown( wxPGPropArg id ) const
 775     {
 776         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 777         return (!(p->GetFlags() & wxPG_PROP_HIDDEN))?true:false;
 778     }
 779
 780     /** Returns true if property value is set to unspecified.
 781     */
 782     bool IsPropertyValueUnspecified( wxPGPropArg id ) const
 783     {
 784         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 785         return p->IsValueUnspecified();
 786     }
 787
 788     /**
 789         Disables (limit = true) or enables (limit = false) wxTextCtrl editor of
 790         a property, if it is not the sole mean to edit the value.
 791     */
 792     void LimitPropertyEditing( wxPGPropArg id, bool limit = true );
 793
 794     /** If state is shown in it's grid, refresh it now.
 795     */
 796     virtual void RefreshGrid( wxPropertyGridPageState* state = NULL );
 797
 798 #if wxPG_INCLUDE_ADVPROPS
 799     /**
 800         Initializes additional property editors (SpinCtrl etc.). Causes
 801         references to most object files in the library, so calling this may
 802         cause significant increase in executable size when linking with static
 803         library.
 804     */
 805     static void RegisterAdditionalEditors();
 806 #else
 807     static void RegisterAdditionalEditors() { }
 808 #endif
 809
 810     /** Replaces property with id with newly created property. For example,
 811         this code replaces existing property named "Flags" with one that
 812         will have different set of items:
 813         @code
 814             pg->ReplaceProperty("Flags",
 815                 wxFlagsProperty("Flags", wxPG_LABEL, newItems))
 816         @endcode
 817         For more info, see wxPropertyGrid::Insert.
 818     */
 819     wxPGProperty* ReplaceProperty( wxPGPropArg id, wxPGProperty* property );
 820
 821     /** @anchor propgridinterface_editablestate_flags
 822
 823         Flags for wxPropertyGridInterface::SaveEditableState() and
 824         wxPropertyGridInterface::RestoreEditableState().
 825     */
 826     enum EditableStateFlags
 827     {
 828         /** Include selected property. */
 829         SelectionState   = 0x01,
 830         /** Include expanded/collapsed property information. */
 831         ExpandedState    = 0x02,
 832         /** Include scrolled position. */
 833         ScrollPosState   = 0x04,
 834         /** Include selected page information.
 835             Only applies to wxPropertyGridManager. */
 836         PageState        = 0x08,
 837         /** Include splitter position. Stored for each page. */
 838         SplitterPosState = 0x10,
 839
 840         /**
 841             Include all supported user editable state information.
 842             This is usually the default value. */
 843         AllStates        = SelectionState |
 844                            ExpandedState |
 845                            ScrollPosState |
 846                            PageState |
 847                            SplitterPosState
 848     };
 849
 850     /**
 851         Restores user-editable state.
 852
 853         See also wxPropertyGridInterface::SaveEditableState().
 854
 855         @param src
 856             String generated by SaveEditableState.
 857
 858         @param restoreStates
 859             Which parts to restore from source string. See @ref
 860             propgridinterface_editablestate_flags "list of editable state
 861             flags".
 862
 863         @return
 864             False if there was problem reading the string.
 865
 866         @remarks
 867         If some parts of state (such as scrolled or splitter position) fail to
 868         restore correctly, please make sure that you call this function after
 869         wxPropertyGrid size has been set (this may sometimes be tricky when
 870         sizers are used).
 871     */
 872     bool RestoreEditableState( const wxString& src,
 873                                int restoreStates = AllStates );
 874
 875     /**
 876         Used to acquire user-editable state (selected property, expanded
 877         properties, scrolled position, splitter positions).
 878
 879         @param includedStates
 880         Which parts of state to include. See @ref
 881         propgridinterface_editablestate_flags "list of editable state flags".
 882     */
 883     wxString SaveEditableState( int includedStates = AllStates ) const;
 884
 885     /**
 886         Lets user to set the strings listed in the choice dropdown of a
 887         wxBoolProperty. Defaults are "True" and "False", so changing them to,
 888         say, "Yes" and "No" may be useful in some less technical applications.
 889     */
 890     static void SetBoolChoices( const wxString& trueChoice,
 891                                 const wxString& falseChoice );
 892
 893     /** Sets or clears flag(s) of all properties in given array.
 894         @param flags
 895         Property flags to set or clear.
 896         @param inverse
 897         Set to true if you want to clear flag instead of setting them.
 898     */
 899     void SetPropertiesFlag( const wxArrayPGProperty& srcArr,
 900                             wxPGProperty::FlagType flags,
 901                             bool inverse = false );
 902
 903     /** Sets an attribute for this property.
 904         @param name
 905             Text identifier of attribute. See @ref propgrid_property_attributes.
 906         @param value
 907             Value of attribute.
 908         @param argFlags
 909             Optional. Use wxPG_RECURSE to set the attribute to child properties
 910             recursively.
 911     */
 912     void SetPropertyAttribute( wxPGPropArg id,
 913                                const wxString& attrName,
 914                                wxVariant value,
 915                                long argFlags = 0 )
 916     {
 917         DoSetPropertyAttribute(id,attrName,value,argFlags);
 918     }
 919
 920     /** Sets attributes from a wxPGAttributeStorage.
 921     */
 922     void SetPropertyAttributes( wxPGPropArg id,
 923                                 const wxPGAttributeStorage& attributes )
 924     {
 925         wxPG_PROP_ARG_CALL_PROLOG()
 926         p->SetAttributes(attributes);
 927     }
 928
 929     /** Sets text, bitmap, and colours for given column's cell.
 930
 931         @remarks
 932         - You can set label cell by setting column to 0.
 933         - You can use wxPG_LABEL as text to use default text for column.
 934     */
 935     void SetPropertyCell( wxPGPropArg id,
 936                           int column,
 937                           const wxString& text = wxEmptyString,
 938                           const wxBitmap& bitmap = wxNullBitmap,
 939                           const wxColour& fgCol = wxNullColour,
 940                           const wxColour& bgCol = wxNullColour )
 941     {
 942         wxPG_PROP_ARG_CALL_PROLOG()
 943         p->SetCell( column, new wxPGCell(text, bitmap, fgCol, bgCol) );
 944     }
 945
 946     /** Set choices of a property to specified set of labels and values.
 947
 948         @remarks
 949         This operation clears the property value.
 950     */
 951     void SetPropertyChoices( wxPGPropArg id, wxPGChoices& choices)
 952     {
 953         wxPG_PROP_ARG_CALL_PROLOG()
 954         p->SetChoices(choices);
 955     }
 956
 957
 958     /**
 959         If property's set of choices is shared, then calling this method
 960         converts it to private.
 961     */
 962     void SetPropertyChoicesExclusive( wxPGPropArg id )
 963     {
 964         wxPG_PROP_ARG_CALL_PROLOG()
 965         p->SetChoicesExclusive();
 966     }
 967
 968 #ifndef SWIG
 969     /** Sets client data (void*) of a property.
 970         @remarks
 971         This untyped client data has to be deleted manually.
 972     */
 973     void SetPropertyClientData( wxPGPropArg id, void* clientData )
 974     {
 975         wxPG_PROP_ARG_CALL_PROLOG()
 976         p->SetClientData(clientData);
 977     }
 978
 979     /** Sets editor for a property.
 980
 981         @param editor
 982         For builtin editors, use wxPGEditor_X, where X is builtin editor's
 983         name (TextCtrl, Choice, etc. see wxPGEditor documentation for full
 984         list).
 985
 986         For custom editors, use pointer you received from
 987         wxPropertyGrid::RegisterEditorClass().
 988     */
 989     void SetPropertyEditor( wxPGPropArg id, const wxPGEditor* editor )
 990     {
 991         wxPG_PROP_ARG_CALL_PROLOG()
 992         wxCHECK_RET( editor, wxT("unknown/NULL editor") );
 993         p->SetEditor(editor);
 994         RefreshProperty(p);
 995     }
 996 #endif
 997
 998     /** Sets editor control of a property. As editor argument, use
 999         editor name string, such as "TextCtrl" or "Choice".
1000     */
1001     void SetPropertyEditor( wxPGPropArg id, const wxString& editorName )
1002     {
1003         SetPropertyEditor(id,GetEditorByName(editorName));
1004     }
1005
1006     /** Sets label of a property.
1007         @remarks
1008         This is the only way to set property's name. There is not
1009         wxPGProperty::SetLabel() method.
1010     */
1011     void SetPropertyLabel( wxPGPropArg id, const wxString& newproplabel );
1012
1013     /** Set modified status of a property and all its children.
1014     */
1015     void SetPropertyModifiedStatus( wxPGPropArg id, bool modified )
1016     {
1017         wxPG_PROP_ARG_CALL_PROLOG()
1018         p->SetModifiedStatus(modified);
1019     }
1020
1021     /**
1022         Sets property (and, recursively, its children) to have read-only value.
1023         In other words, user cannot change the value in the editor, but they
1024         can still copy it.
1025         @remarks
1026         This is mainly for use with textctrl editor. Not all other editors fully
1027         support it.
1028         @param flags
1029         By default changes are applied recursively. Set this paramter
1030         wxPG_DONT_RECURSE to prevent this.
1031     */
1032     void SetPropertyReadOnly( wxPGPropArg id,
1033                               bool set = true,
1034                               int flags = wxPG_RECURSE )
1035     {
1036         wxPG_PROP_ARG_CALL_PROLOG()
1037         if ( flags & wxPG_RECURSE )
1038             p->SetFlagRecursively(wxPG_PROP_READONLY, set);
1039         else
1040             p->SetFlag(wxPG_PROP_READONLY);
1041     }
1042
1043     /** Sets property's value to unspecified.
1044         If it has children (it may be category), then the same thing is done to
1045         them.
1046     */
1047     void SetPropertyValueUnspecified( wxPGPropArg id );
1048
1049 #ifndef SWIG
1050     /** Sets various property values from a list of wxVariants. If property with
1051         name is missing from the grid, new property is created under given
1052         default category (or root if omitted).
1053     */
1054     void SetPropertyValues( const wxVariantList& list,
1055                             wxPGPropArg defaultCategory = wxNullProperty )
1056     {
1057         wxPGProperty *p;
1058         if ( defaultCategory.HasName() ) p = defaultCategory.GetPtr(this);
1059         else p = defaultCategory.GetPtr0();
1060         m_pState->DoSetPropertyValues(list, p);
1061     }
1062
1063     void SetPropertyValues( const wxVariant& list,
1064                             wxPGPropArg defaultCategory = wxNullProperty )
1065     {
1066         SetPropertyValues(list.GetList(),defaultCategory);
1067     }
1068 #endif
1069
1070     /** Associates the help string with property.
1071         @remarks
1072         By default, text is shown either in the manager's "description"
1073         text box or in the status bar. If extra window style
1074         wxPG_EX_HELP_AS_TOOLTIPS is used, then the text will appear as a
1075         tooltip.
1076     */
1077     void SetPropertyHelpString( wxPGPropArg id, const wxString& helpString )
1078     {
1079         wxPG_PROP_ARG_CALL_PROLOG()
1080         p->SetHelpString(helpString);
1081     }
1082
1083     /** Set wxBitmap in front of the value.
1084         @remarks
1085         - Bitmap will be scaled to a size returned by
1086         wxPropertyGrid::GetImageSize();
1087     */
1088     void SetPropertyImage( wxPGPropArg id, wxBitmap& bmp )
1089     {
1090         wxPG_PROP_ARG_CALL_PROLOG()
1091         p->SetValueImage(bmp);
1092         RefreshProperty(p);
1093     }
1094
1095     /** Sets max length of property's text.
1096     */
1097     bool SetPropertyMaxLength( wxPGPropArg id, int maxLen );
1098
1099 #if wxUSE_VALIDATORS
1100     /** Sets validator of a property.
1101     */
1102     void SetPropertyValidator( wxPGPropArg id, const wxValidator& validator )
1103     {
1104         wxPG_PROP_ARG_CALL_PROLOG()
1105         p->SetValidator(validator);
1106     }
1107 #endif
1108
1109 #ifndef SWIG
1110     /** Sets value (long integer) of a property.
1111     */
1112     void SetPropertyValue( wxPGPropArg id, long value )
1113     {
1114         wxVariant v(value);
1115         SetPropVal( id, v );
1116     }
1117
1118     /** Sets value (integer) of a property.
1119     */
1120     void SetPropertyValue( wxPGPropArg id, int value )
1121     {
1122         wxVariant v((long)value);
1123         SetPropVal( id, v );
1124     }
1125     /** Sets value (floating point) of a property.
1126     */
1127     void SetPropertyValue( wxPGPropArg id, double value )
1128     {
1129         wxVariant v(value);
1130         SetPropVal( id, v );
1131     }
1132     /** Sets value (bool) of a property.
1133     */
1134     void SetPropertyValue( wxPGPropArg id, bool value )
1135     {
1136         wxVariant v(value);
1137         SetPropVal( id, v );
1138     }
1139     void SetPropertyValue( wxPGPropArg id, const wxChar* value )
1140     {
1141         SetPropertyValueString( id, wxString(value) );
1142     }
1143     void SetPropertyValue( wxPGPropArg id, const wxString& value )
1144     {
1145         SetPropertyValueString( id, value );
1146     }
1147
1148     /** Sets value (wxArrayString) of a property.
1149     */
1150     void SetPropertyValue( wxPGPropArg id, const wxArrayString& value )
1151     {
1152         wxVariant v(value);
1153         SetPropVal( id, v );
1154     }
1155
1156 #if wxUSE_DATETIME
1157     void SetPropertyValue( wxPGPropArg id, const wxDateTime& value )
1158     {
1159         wxVariant v(value);
1160         SetPropVal( id, v );
1161     }
1162 #endif
1163
1164     /** Sets value (wxObject*) of a property.
1165     */
1166     void SetPropertyValue( wxPGPropArg id, wxObject* value )
1167     {
1168         wxVariant v(value);
1169         SetPropVal( id, v );
1170     }
1171
1172     void SetPropertyValue( wxPGPropArg id, wxObject& value )
1173     {
1174         wxVariant v(&value);
1175         SetPropVal( id, v );
1176     }
1177
1178     /** Sets value (wxPoint&) of a property.
1179     */
1180     void SetPropertyValue( wxPGPropArg id, const wxPoint& value )
1181     {
1182         wxVariant v = WXVARIANT(value);
1183         SetPropVal( id, v );
1184     }
1185     /** Sets value (wxSize&) of a property.
1186     */
1187     void SetPropertyValue( wxPGPropArg id, const wxSize& value )
1188     {
1189         wxVariant v = WXVARIANT(value);
1190         SetPropVal( id, v );
1191     }
1192     /** Sets value (wxLongLong&) of a property.
1193     */
1194     void SetPropertyValue( wxPGPropArg id, wxLongLong_t value )
1195     {
1196         wxVariant v = WXVARIANT(wxLongLong(value));
1197         SetPropVal( id, v );
1198     }
1199     /** Sets value (wxULongLong&) of a property.
1200     */
1201     void SetPropertyValue( wxPGPropArg id, wxULongLong_t value )
1202     {
1203         wxVariant v = WXVARIANT(wxULongLong(value));
1204         SetPropVal( id, v );
1205     }
1206     /** Sets value (wxArrayInt&) of a property.
1207     */
1208     void SetPropertyValue( wxPGPropArg id, const wxArrayInt& value )
1209     {
1210         wxVariant v = WXVARIANT(value);
1211         SetPropVal( id, v );
1212     }
1213 #endif  // !SWIG
1214
1215     /** Sets value (wxString) of a property.
1216
1217         @remarks
1218         This method uses wxPGProperty::SetValueFromString, which all properties
1219         should implement. This means that there should not be a type error,
1220         and instead the string is converted to property's actual value type.
1221     */
1222     void SetPropertyValueString( wxPGPropArg id, const wxString& value );
1223
1224     /** Sets value (wxVariant&) of a property.
1225
1226         @remarks
1227         Use wxPropertyGrid::ChangePropertyValue() instead if you need to run
1228         through validation process and send property change event.
1229     */
1230     void SetPropertyValue( wxPGPropArg id, wxVariant value )
1231     {
1232         SetPropVal( id, value );
1233     }
1234
1235 #ifndef SWIG
1236     /** Sets value (wxVariant&) of a property. Same as SetPropertyValue, but
1237         accepts reference. */
1238     void SetPropVal( wxPGPropArg id, wxVariant& value );
1239 #endif
1240
1241     /** Adjusts how wxPropertyGrid behaves when invalid value is entered
1242         in a property.
1243         @param vfbFlags
1244         See @link vfbflags list of valid flags values@endlink
1245     */
1246     void SetValidationFailureBehavior( int vfbFlags );
1247
1248 #ifdef SWIG
1249     %pythoncode {
1250         def MapType(class_,factory):
1251             "Registers Python type/class to property mapping.\n\nfactory: Property builder function/class."
1252             global _type2property
1253             try:
1254                 mappings = _type2property
1255             except NameError:
1256                 raise AssertionError("call only after a propertygrid or manager instance constructed")
1257
1258             mappings[class_] = factory
1259
1260
1261         def DoDefaultTypeMappings(self):
1262             "Map built-in properties."
1263             global _type2property
1264             try:
1265                 mappings = _type2property
1266
1267                 return
1268             except NameError:
1269                 mappings = {}
1270                 _type2property = mappings
1271
1272             mappings[str] = StringProperty
1273             mappings[unicode] = StringProperty
1274             mappings[int] = IntProperty
1275             mappings[float] = FloatProperty
1276             mappings[bool] = BoolProperty
1277             mappings[list] = ArrayStringProperty
1278             mappings[tuple] = ArrayStringProperty
1279             mappings[wx.Font] = FontProperty
1280             mappings[wx.Colour] = ColourProperty
1281             "mappings[wx.Size] = SizeProperty"
1282             "mappings[wx.Point] = PointProperty"
1283             "mappings[wx.FontData] = FontDataProperty"
1284
1285         def DoDefaultValueTypeMappings(self):
1286             "Map pg value type ids to getter methods."
1287             global _vt2getter
1288             try:
1289                 vt2getter = _vt2getter
1290
1291                 return
1292             except NameError:
1293                 vt2getter = {}
1294                 _vt2getter = vt2getter
1295
1296         def GetPropertyValues(self,dict_=None, as_strings=False, inc_attributes=False):
1297             "Returns values in the grid."
1298             ""
1299             "dict_: if not given, then a new one is created. dict_ can be"
1300             "  object as well, in which case it's __dict__ is used."
1301             "as_strings: if True, then string representations of values"
1302             "  are fetched instead of native types. Useful for config and such."
1303             "inc_attributes: if True, then property attributes are added"
1304             "  as @<propname>@<attr>."
1305             ""
1306             "Return value: dictionary with values. It is always a dictionary,"
1307             "so if dict_ was object with __dict__ attribute, then that attribute"
1308             "is returned."
1309
1310             if dict_ is None:
1311                 dict_ = {}
1312             elif hasattr(dict_,'__dict__'):
1313                 dict_ = dict_.__dict__
1314
1315             if not as_strings:
1316                 getter = self.GetPropertyValue
1317             else:
1318                 getter = self.GetPropertyValueAsString
1319
1320             it = self.GetVIterator(PG_ITERATE_PROPERTIES)
1321             while not it.AtEnd():
1322                 p = it.GetProperty()
1323                 name = p.GetName()
1324
1325                 dict_[name] = getter(p)
1326
1327                 if inc_attributes:
1328                     attrs = p.GetAttributes()
1329                     if attrs and len(attrs):
1330                         dict_['@%s@attr'%name] = attrs
1331
1332                 it.Next()
1333
1334             return dict_
1335
1336         GetValues = GetPropertyValues
1337
1338
1339         def SetPropertyValues(self,dict_):
1340             "Sets property values from dict_, which can be either\ndictionary or an object with __dict__ attribute."
1341             ""
1342             "autofill: If true, keys with not relevant properties"
1343             "  are auto-created. For more info, see AutoFill."
1344             ""
1345             "Notes:"
1346             "  * Keys starting with underscore are ignored."
1347             "  * Attributes can be set with entries named @<propname>@<attr>."
1348             ""
1349
1350             autofill = False
1351
1352             if dict_ is None:
1353                 dict_ = {}
1354             elif hasattr(dict_,'__dict__'):
1355                 dict_ = dict_.__dict__
1356
1357             attr_dicts = []
1358
1359             def set_sub_obj(k0,dict_):
1360                 for k,v in dict_.iteritems():
1361                     if k[0] != '_':
1362                         if k.endswith('@attr'):
1363                             attr_dicts.append((k[1:-5],v))
1364                         else:
1365                             try:
1366                                 self.SetPropertyValue(k,v)
1367                             except:
1368                                 try:
1369                                     if autofill:
1370                                         self._AutoFillOne(k0,k,v)
1371                                         continue
1372                                 except:
1373                                     if isinstance(v,dict):
1374                                         set_sub_obj(k,v)
1375                                     elif hasattr(v,'__dict__'):
1376                                         set_sub_obj(k,v.__dict__)
1377
1378
1379             for k,v in attr_dicts:
1380                 p = GetPropertyByName(k)
1381                 if not p:
1382                     raise AssertionError("No such property: '%s'"%k)
1383                 for an,av in v.iteritems():
1384                     p.SetAttribute(an, av)
1385
1386
1387             cur_page = False
1388             is_manager = isinstance(self,PropertyGridManager)
1389
1390             try:
1391                 set_sub_obj(self.GetGrid().GetRoot(),dict_)
1392             except:
1393                 import traceback
1394                 traceback.print_exc()
1395
1396             self.Refresh()
1397
1398         SetValues = SetPropertyValues
1399
1400         def _AutoFillMany(self,cat,dict_):
1401             for k,v in dict_.iteritems():
1402                 self._AutoFillOne(cat,k,v)
1403
1404
1405         def _AutoFillOne(self,cat,k,v):
1406             global _type2property
1407
1408             factory = _type2property.get(v.__class__,None)
1409
1410             if factory:
1411                 self.AppendIn( cat, factory(k,k,v) )
1412             elif hasattr(v,'__dict__'):
1413                 cat2 = self.AppendIn( cat, PropertyCategory(k) )
1414                 self._AutoFillMany(cat2,v.__dict__)
1415             elif isinstance(v,dict):
1416                 cat2 = self.AppendIn( cat, PropertyCategory(k) )
1417                 self._AutoFillMany(cat2,v)
1418             elif not k.startswith('_'):
1419                 raise AssertionError("member '%s' is of unregisted type/class '%s'"%(k,v.__class__))
1420
1421
1422         def AutoFill(self,obj,parent=None):
1423             "Clears properties and re-fills to match members and\nvalues of given object or dictionary obj."
1424
1425             self.edited_objects[parent] = obj
1426
1427             cur_page = False
1428             is_manager = isinstance(self,PropertyGridManager)
1429
1430             if not parent:
1431                 if is_manager:
1432                     page = self.GetCurrentPage()
1433                     page.Clear()
1434                     parent = page.GetRoot()
1435                 else:
1436                     self.Clear()
1437                     parent = self.GetGrid().GetRoot()
1438             else:
1439                 it = self.GetIterator(PG_ITERATE_PROPERTIES, parent)
1440                 it.Next()  # Skip the parent
1441                 while not it.AtEnd():
1442                     p = it.GetProperty()
1443                     if not p.IsSomeParent(parent):
1444                         break
1445
1446                     self.DeleteProperty(p)
1447
1448                     name = p.GetName()
1449                     it.Next()
1450
1451             if not is_manager or page == self.GetCurrentPage():
1452                 self.Freeze()
1453                 cur_page = True
1454
1455             try:
1456                 self._AutoFillMany(parent,obj.__dict__)
1457             except:
1458                 import traceback
1459                 traceback.print_exc()
1460
1461             if cur_page:
1462                 self.Thaw()
1463
1464         def RegisterEditor(self, editor, editorName=None):
1465             "Transform class into instance, if necessary."
1466             if not isinstance(editor, PGEditor):
1467                 editor = editor()
1468             if not editorName:
1469                 editorName = editor.__class__.__name__
1470             try:
1471                 self._editor_instances.append(editor)
1472             except:
1473                 self._editor_instances = [editor]
1474             RegisterEditor(editor, editorName)
1475
1476         def GetPropertyClientData(self, p):
1477             if isinstance(p, basestring):
1478                 p = self.GetPropertyByName(p)
1479             return p.GetClientData()
1480
1481         def SetPropertyClientData(self, p, data):
1482             if isinstance(p, basestring):
1483                 p = self.GetPropertyByName(p)
1484             return p.SetClientData(data)
1485     }
1486 #endif
1487
1488     // GetPropertyByName With nice assertion error message.
1489     wxPGProperty* GetPropertyByNameA( const wxString& name ) const;
1490
1491     static wxPGEditor* GetEditorByName( const wxString& editorName );
1492
1493     virtual void RefreshProperty( wxPGProperty* p ) = 0;
1494
1495 protected:
1496
1497     // Returns page state data for given (sub) page (-1 means current page).
1498     virtual wxPropertyGridPageState* GetPageState( int pageIndex ) const
1499     {
1500         if ( pageIndex <= 0 )
1501             return m_pState;
1502         return NULL;
1503     }
1504
1505     virtual bool DoSelectPage( int WXUNUSED(index) ) { return true; }
1506
1507     // Default call's m_pState's BaseGetPropertyByName
1508     virtual wxPGProperty* DoGetPropertyByName( const wxString& name ) const;
1509
1510 #ifndef SWIG
1511
1512     // Deriving classes must set this (it must be only or current page).
1513     wxPropertyGridPageState*         m_pState;
1514
1515     // Intermediate version needed due to wxVariant copying inefficiency
1516     void DoSetPropertyAttribute( wxPGPropArg id,
1517                                  const wxString& name,
1518                                  wxVariant& value, long argFlags );
1519
1520     // Empty string object to return from member functions returning const
1521     // wxString&.
1522     wxString                    m_emptyString;
1523
1524 private:
1525     // Cannot be GetGrid() due to ambiguity issues.
1526     wxPropertyGrid* GetPropertyGrid()
1527     {
1528         return m_pState->GetGrid();
1529     }
1530
1531     // Cannot be GetGrid() due to ambiguity issues.
1532     const wxPropertyGrid* GetPropertyGrid() const
1533     {
1534         return (const wxPropertyGrid*) m_pState->GetGrid();
1535     }
1536 #endif // #ifndef SWIG
1537
1538     friend class wxPropertyGrid;
1539     friend class wxPropertyGridManager;
1540 };
1541
1542 #endif // __WX_PROPGRID_PROPGRIDIFACE_H__