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