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