interface/wx/propgrid/propgridiface.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        property.h
   3 // Purpose:     interface of wxPGProperty
   4 // Author:      wxWidgets team
   5 // RCS-ID:      $Id$
   6 // Licence:     wxWindows license
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 // -----------------------------------------------------------------------
  10
  11 /**
  12     @class wxPropertyGridInterface
  13
  14     Most of the shared property manipulation interface shared by wxPropertyGrid,
  15     wxPropertyGridPage, and wxPropertyGridManager is defined in this class.
  16
  17     @remarks
  18     - In separate wxPropertyGrid component this class was known as
  19       wxPropertyContainerMethods.
  20
  21     - wxPropertyGridInterface's property operation member functions all accept
  22       a special wxPGPropArg id argument, using which you can refer to properties
  23       either by their pointer (for performance) or by their name (for conveniency).
  24
  25     @library{wxpropgrid}
  26     @category{propgrid}
  27 */
  28 class WXDLLIMPEXP_PROPGRID wxPropertyGridInterface
  29 {
  30 public:
  31
  32     /** Destructor */
  33     virtual ~wxPropertyGridInterface() { }
  34
  35     /**
  36         Appends property to the list. wxPropertyGrid assumes ownership of the
  37         object. Becomes child of most recently added category.
  38
  39         @remarks
  40         - wxPropertyGrid takes the ownership of the property pointer.
  41         - If appending a category with name identical to a category already in
  42           the wxPropertyGrid, then newly created category is deleted, and most
  43           recently added category (under which properties are appended) is set
  44           to the one with same name. This allows easier adding of items to same
  45           categories in multiple passes.
  46         - Does not automatically redraw the control, so you may need to call
  47           Refresh() when calling this function after control has been shown for
  48           the first time.
  49     */
  50     wxPGProperty* Append( wxPGProperty* property );
  51
  52     /**
  53         Same as Append(), but appends under given parent property.
  54
  55         @param id
  56             Name or pointer to parent property.
  57
  58         @param newProperty
  59             Property to be added.
  60     */
  61     wxPGProperty* AppendIn( wxPGPropArg id, wxPGProperty* newProperty );
  62
  63     /**
  64         In order to add new items into a property with private children (for
  65         instance, wxFlagsProperty), you need to call this method. After
  66         populating has been finished, you need to call EndAddChildren().
  67
  68         @see EndAddChildren()
  69     */
  70     void BeginAddChildren( wxPGPropArg id );
  71
  72     /**
  73         Deletes all properties.
  74     */
  75     virtual void Clear() = 0;
  76
  77     /**
  78         Deselect current selection, if any.
  79
  80         @return Returns @true if success (ie. validator did not intercept).
  81     */
  82     bool ClearSelection();
  83
  84     /**
  85         Resets modified status of all properties.
  86     */
  87     void ClearModifiedStatus();
  88
  89     /**
  90         Collapses given category or property with children.
  91
  92         @return Returns @true if actually collapsed.
  93     */
  94     bool Collapse( wxPGPropArg id );
  95
  96     /**
  97         Collapses all items that can be collapsed.
  98
  99         @return Returns @false if failed (may fail if value in active
 100                editor cannot be validated).
 101     */
 102     bool CollapseAll();
 103
 104     /**
 105         Changes value of a property, as if by user. Use this instead of
 106         SetPropertyValue() if you need the value to run through validation
 107         process, and also send the property change event.
 108
 109         @return Returns @true if value was successfully changed.
 110     */
 111     bool ChangePropertyValue( wxPGPropArg id, wxVariant newValue );
 112
 113     /**
 114         Deletes a property.
 115     */
 116     void DeleteProperty( wxPGPropArg id );
 117
 118     /**
 119         Disables a property.
 120     */
 121     bool DisableProperty( wxPGPropArg id );
 122
 123     /**
 124         Returns true if all property grid data changes have been committed. Usually
 125         only returns false if value in active editor has been invalidated by a
 126         wxValidator.
 127     */
 128     bool EditorValidate();
 129
 130     /**
 131         Enables or disables property.
 132
 133         @param id
 134             Name or pointer to a property.
 135
 136         @param enable
 137             If @false, property is disabled instead.
 138     */
 139     bool EnableProperty( wxPGPropArg id, bool enable = true );
 140
 141     /**
 142         Called after population of property with fixed children has finished.
 143
 144         @see BeginAddChildren()
 145     */
 146     void EndAddChildren( wxPGPropArg id );
 147
 148     /**
 149         Expands given category or property with children.
 150
 151         @return Returns @true if actually expanded.
 152     */
 153     bool Expand( wxPGPropArg id );
 154
 155     /**
 156         Expands all items that can be expanded.
 157     */
 158     bool ExpandAll( bool expand = true );
 159
 160     /**
 161         Returns id of first child of given property.
 162
 163         @remarks Does not return private children!
 164     */
 165     wxPGProperty* GetFirstChild( wxPGPropArg id );
 166
 167     //@{
 168     /** Returns iterator class instance.
 169
 170         @param flags
 171             See @ref propgrid_iterator_flags. Value wxPG_ITERATE_DEFAULT causes
 172             iteration over everything except private child properties.
 173
 174         @param firstProp
 175             Property to start iteration from. If NULL, then first child of root
 176             is used.
 177
 178         @param startPos
 179             Either wxTOP or wxBOTTOM. wxTOP will indicate that iterations start
 180             from the first property from the top, and wxBOTTOM means that the
 181             iteration will instead begin from bottommost valid item.
 182
 183         <b>wxPython Note:</b> Instead of ++ operator, use Next() method, and
 184         instead of * operator, use GetProperty() method.
 185     */
 186     wxPropertyGridIterator GetIterator( int flags = wxPG_ITERATE_DEFAULT,
 187                                         wxPGProperty* firstProp = NULL );
 188     wxPropertyGridConstIterator GetIterator( int flags = wxPG_ITERATE_DEFAULT,
 189                                              wxPGProperty* firstProp = NULL ) const;
 190     wxPropertyGridIterator GetIterator( int flags, int startPos );
 191     wxPropertyGridConstIterator GetIterator( int flags, int startPos ) const;
 192     //@}
 193
 194     /**
 195         Returns id of first item that matches given criteria.
 196
 197         @param flags
 198             See @ref propgrid_iterator_flags.
 199     */
 200     wxPGProperty* GetFirst( int flags = wxPG_ITERATE_ALL );
 201
 202     /**
 203         Returns id of property with given name (case-sensitive).
 204     */
 205     wxPGProperty* GetProperty( const wxString& name ) const
 206     {
 207         return GetPropertyByName(name);
 208     }
 209
 210     /**
 211         Adds to 'targetArr' pointers to properties that have given
 212         flags 'flags' set. However, if 'inverse' is set to true, then
 213         only properties without given flags are stored.
 214
 215         @param flags
 216             Property flags to use.
 217
 218         @param iterFlags
 219             Iterator flags to use. Default is everything expect private children.
 220             See @ref propgrid_iterator_flags.
 221     */
 222     void GetPropertiesWithFlag( wxArrayPGProperty* targetArr,
 223                                 wxPGProperty::FlagType flags,
 224                                 bool inverse = false,
 225                                 int iterFlags = (wxPG_ITERATE_PROPERTIES|wxPG_ITERATE_HIDDEN|wxPG_ITERATE_CATEGORIES) ) const;
 226
 227     /**
 228         Returns value of given attribute. If none found, returns wxNullVariant.
 229     */
 230     wxVariant GetPropertyAttribute( wxPGPropArg id, const wxString& attrName ) const;
 231
 232     /**
 233         Returns pointer of property's nearest parent category. If no category
 234         found, returns NULL.
 235     */
 236     wxPropertyCategory* GetPropertyCategory( wxPGPropArg id ) const;
 237
 238     /** Returns client data (void*) of a property. */
 239     void* GetPropertyClientData( wxPGPropArg id ) const;
 240
 241     /**
 242         Returns first property which label matches given string. NULL if none
 243         found. Note that this operation is very slow when compared to
 244         GetPropertyByName().
 245     */
 246     wxPGProperty* GetPropertyByLabel( const wxString& label ) const;
 247
 248     /**
 249         Returns property with given name. NULL if none found.
 250     */
 251     wxPGProperty* GetPropertyByName( const wxString& name ) const;
 252
 253     /**
 254         Returns child property 'subname' of property 'name'. Same as
 255         calling GetPropertyByName("name.subname"), albeit slightly faster.
 256     */
 257     wxPGProperty* GetPropertyByName( const wxString& name,
 258                                      const wxString& subname ) const;
 259
 260     /**
 261         Returns property's editor.
 262     */
 263     const wxPGEditor* GetPropertyEditor( wxPGPropArg id ) const;
 264
 265     /**
 266         Returns help string associated with a property.
 267     */
 268     wxString GetPropertyHelpString( wxPGPropArg id ) const;
 269
 270     /**
 271         Returns property's custom value image (NULL of none).
 272     */
 273     wxBitmap* GetPropertyImage( wxPGPropArg id ) const;
 274
 275     /** Returns label of a property. */
 276     const wxString& GetPropertyLabel( wxPGPropArg id );
 277
 278     /** Returns property's name, by which it is globally accessible. */
 279     wxString GetPropertyName( wxPGProperty* property );
 280
 281     /**
 282         Returns validator of a property as a reference, which you
 283         can pass to any number of SetPropertyValidator.
 284     */
 285     wxValidator* GetPropertyValidator( wxPGPropArg id );
 286
 287     /**
 288         Returns property's value as wxVariant.
 289
 290         If property value is unspecified, Null variant is returned.
 291     */
 292     wxVariant GetPropertyValue( wxPGPropArg id );
 293
 294     /** Return's property's value as wxArrayInt. */
 295     wxArrayInt GetPropertyValueAsArrayInt( wxPGPropArg id ) const;
 296
 297     /** Returns property's value as wxArrayString. */
 298     wxArrayString GetPropertyValueAsArrayString( wxPGPropArg id ) const;
 299
 300     /** Returns property's value as bool */
 301     bool GetPropertyValueAsBool( wxPGPropArg id ) const;
 302
 303     /** Return's property's value as wxDateTime. */
 304     wxDateTime GetPropertyValueAsDateTime( wxPGPropArg id ) const;
 305
 306     /** Returns property's value as double-precision floating point number. */
 307     double GetPropertyValueAsDouble( wxPGPropArg id ) const;
 308
 309     /** Returns property's value as integer */
 310     int GetPropertyValueAsInt( wxPGPropArg id ) const;
 311
 312     /** Returns property's value as integer */
 313     long GetPropertyValueAsLong( wxPGPropArg id ) const;
 314
 315     /** Returns property's value as native signed 64-bit integer. */
 316     wxLongLong_t GetPropertyValueAsLongLong( wxPGPropArg id ) const;
 317
 318     /**
 319         Returns property's value as wxString. If property does not
 320         use string value type, then its value is converted using
 321         wxPGProperty::GetValueAsString().
 322     */
 323     wxString GetPropertyValueAsString( wxPGPropArg id ) const;
 324
 325     /** Returns property's value as unsigned integer */
 326     unsigned long GetPropertyValueAsULong( wxPGPropArg id ) const;
 327
 328     /** Returns property's value as native unsigned 64-bit integer. */
 329     wxULongLong_t GetPropertyValueAsULongLong( wxPGPropArg id ) const;
 330
 331     /**
 332         Returns a wxVariant list containing wxVariant versions of all
 333         property values. Order is not guaranteed.
 334
 335         @param flags
 336             Use wxPG_KEEP_STRUCTURE to retain category structure; each sub
 337             category will be its own wxVariantList of wxVariant.
 338
 339             Use wxPG_INC_ATTRIBUTES to include property attributes as well.
 340             Each attribute will be stored as list variant named
 341             "@@<propname>@@attr."
 342     */
 343     wxVariant GetPropertyValues( const wxString& listname = wxEmptyString,
 344         wxPGProperty* baseparent = NULL, long flags = 0 ) const;
 345
 346     /** Returns currently selected property. */
 347     wxPGProperty* GetSelection() const;
 348
 349     /**
 350         Similar to GetIterator(), but instead returns wxPGVIterator instance,
 351         which can be useful for forward-iterating through arbitrary property
 352         containers.
 353
 354         @param flags
 355             See @ref propgrid_iterator_flags.
 356
 357         <b>wxPython Note:</b> Instead of ++ operator, use Next() method, and
 358             instead of * operator, use GetProperty() method.
 359     */
 360     virtual wxPGVIterator GetVIterator( int flags ) const;
 361
 362     /**
 363         Hides or reveals a property.
 364
 365         @param hide
 366             If @true, hides property, otherwise reveals it.
 367
 368         @param flags
 369             By default changes are applied recursively. Set this parameter
 370             wxPG_DONT_RECURSE to prevent this.
 371     */
 372     bool HideProperty( wxPGPropArg id, bool hide = true, int flags = wxPG_RECURSE );
 373
 374     /**
 375         Initializes *all* property types. Causes references to most object
 376         files in the library, so calling this may cause significant increase
 377         in executable size when linking with static library.
 378     */
 379     static void InitAllTypeHandlers();
 380
 381     //@{
 382     /** Inserts property to the property container.
 383
 384         @param priorThis
 385             New property is inserted just prior to this. Available only
 386             in the first variant. There are two versions of this function
 387             to allow this parameter to be either an id or name to
 388             a property.
 389
 390         @param newProperty
 391             Pointer to the inserted property. wxPropertyGrid will take
 392             ownership of this object.
 393
 394         @param parent
 395             New property is inserted under this category. Available only
 396             in the second variant. There are two versions of this function
 397             to allow this parameter to be either an id or name to
 398             a property.
 399
 400         @param index
 401             Index under category. Available only in the second variant.
 402             If index is < 0, property is appended in category.
 403
 404         @return Returns newProperty.
 405
 406         @remarks
 407
 408         - wxPropertyGrid takes the ownership of the property pointer.
 409
 410         - While Append may be faster way to add items, make note that when
 411           both types of data storage (categoric and
 412           non-categoric) are active, Insert becomes even more slow. This is
 413           especially true if current mode is non-categoric.
 414
 415         Example of use:
 416
 417         @code
 418
 419             // append category
 420             wxPGProperty* my_cat_id = propertygrid->Append( new wxPropertyCategory("My Category") );
 421
 422             ...
 423
 424             // insert into category - using second variant
 425             wxPGProperty* my_item_id_1 = propertygrid->Insert( my_cat_id, 0, new wxStringProperty("My String 1") );
 426
 427             // insert before to first item - using first variant
 428             wxPGProperty* my_item_id_2 = propertygrid->Insert( my_item_id, new wxStringProperty("My String 2") );
 429
 430         @endcode
 431
 432     */
 433     wxPGProperty* Insert( wxPGPropArg priorThis, wxPGProperty* newProperty );
 434     wxPGProperty* Insert( wxPGPropArg parent, int index, wxPGProperty* newProperty );
 435     //@}
 436
 437     /** Returns @true if property is a category. */
 438     bool IsPropertyCategory( wxPGPropArg id ) const;
 439
 440     /** Returns @true if property is enabled. */
 441     bool IsPropertyEnabled( wxPGPropArg id ) const;
 442
 443     /**
 444         Returns true if given property is expanded. Naturally, always returns
 445         @false for properties that cannot be expanded.
 446     */
 447     bool IsPropertyExpanded( wxPGPropArg id ) const;
 448
 449     /**
 450         Returns @true if property has been modified after value set or modify
 451         flag clear by software.
 452     */
 453     bool IsPropertyModified( wxPGPropArg id ) const;
 454
 455     /**
 456         Returns true if property is shown (ie. HideProperty() with @true not
 457         called for it).
 458     */
 459     bool IsPropertyShown( wxPGPropArg id ) const;
 460
 461     /**
 462         Returns true if property value is set to unspecified.
 463     */
 464     bool IsPropertyValueUnspecified( wxPGPropArg id ) const;
 465
 466     /**
 467         Disables (limit = @true) or enables (limit = @false) wxTextCtrl editor
 468         of a property, if it is not the sole mean to edit the value.
 469     */
 470     void LimitPropertyEditing( wxPGPropArg id, bool limit = true );
 471
 472     /**
 473         Initializes additional property editors (SpinCtrl etc.). Causes
 474         references to most object files in the library, so calling this may
 475         cause significant increase in executable size when linking with static
 476         library.
 477     */
 478     static void RegisterAdditionalEditors();
 479
 480     /**
 481         Replaces property with id with newly created one. For example,
 482         this code replaces existing property named "Flags" with one that
 483         will have different set of items:
 484
 485         @code
 486             pg->ReplaceProperty("Flags",
 487                 wxFlagsProperty("Flags", wxPG_LABEL, newItems))
 488         @endcode
 489
 490         @see Insert()
 491     */
 492     wxPGProperty* ReplaceProperty( wxPGPropArg id, wxPGProperty* property );
 493
 494     /**
 495         @anchor propgridinterface_editablestate_flags
 496
 497         Flags for wxPropertyGridInterface::SaveEditableState() and
 498         wxPropertyGridInterface::RestoreEditableState().
 499     */
 500     enum EditableStateFlags
 501     {
 502         /** Include selected property. */
 503         SelectionState   = 0x01,
 504         /** Include expanded/collapsed property information. */
 505         ExpandedState    = 0x02,
 506         /** Include scrolled position. */
 507         ScrollPosState   = 0x04,
 508         /** Include selected page information. Only applies to
 509             wxPropertyGridManager. */
 510         PageState        = 0x08,
 511         /** Include splitter position. Stored for each page. */
 512         SplitterPosState = 0x10,
 513         /** Include description box size.
 514             Only applies to wxPropertyGridManager. */
 515         DescBoxState     = 0x20,
 516
 517         /**
 518             Include all supported user editable state information.
 519             This is usually the default value. */
 520         AllStates        = SelectionState |
 521                            ExpandedState |
 522                            ScrollPosState |
 523                            PageState |
 524                            SplitterPosState |
 525                            DescBoxState
 526     };
 527
 528     /**
 529         Restores user-editable state. See also wxPropertyGridInterface::SaveEditableState().
 530
 531         @param src
 532         String generated by SaveEditableState.
 533
 534         @param restoreStates
 535         Which parts to restore from source string. See @ref propgridinterface_editablestate_flags
 536         "list of editable state flags".
 537
 538         @return Returns @false if there was problem reading the string.
 539
 540         @remarks If some parts of state (such as scrolled or splitter position)
 541                 fail to restore correctly, please make sure that you call this
 542                 function after wxPropertyGrid size has been set (this may
 543                 sometimes be tricky when sizers are used).
 544     */
 545     bool RestoreEditableState( const wxString& src,
 546                                int restoreStates = AllStates );
 547
 548     /**
 549         Used to acquire user-editable state (selected property, expanded
 550         properties, scrolled position, splitter positions).
 551
 552         @param includedStates
 553         Which parts of state to include. See @ref propgridinterface_editablestate_flags
 554         "list of editable state flags".
 555     */
 556     wxString SaveEditableState( int includedStates = AllStates ) const;
 557
 558     /**
 559         Sets strings listed in the choice dropdown of a wxBoolProperty.
 560
 561         Defaults are "True" and "False", so changing them to, say, "Yes" and
 562         "No" may be useful in some less technical applications.
 563     */
 564     static void SetBoolChoices( const wxString& trueChoice,
 565                                 const wxString& falseChoice );
 566
 567     /**
 568         Sets an attribute for this property.
 569
 570         @param name
 571             Text identifier of attribute. See @ref propgrid_property_attributes.
 572
 573         @param value
 574             Value of attribute.
 575
 576         @param argFlags
 577             Optional. Use wxPG_RECURSE to set the attribute to child properties
 578             recursively.
 579
 580         @remarks Setting attribute's value to Null variant will simply remove it
 581                 from property's set of attributes.
 582     */
 583     void SetPropertyAttribute( wxPGPropArg id, const wxString& attrName,
 584                                wxVariant value, long argFlags = 0 );
 585
 586     /**
 587         Sets property attribute for all applicapple properties.
 588         Be sure to use this method only after all properties have been
 589         added to the grid.
 590     */
 591     void SetPropertyAttributeAll( const wxString& attrName, wxVariant value );
 592
 593     /**
 594         Sets text, bitmap, and colours for given column's cell.
 595
 596         @remarks
 597         - You can set label cell by using column 0.
 598         - You can use wxPG_LABEL as text to use default text for column.
 599     */
 600     void SetPropertyCell( wxPGPropArg id,
 601                           int column,
 602                           const wxString& text = wxEmptyString,
 603                           const wxBitmap& bitmap = wxNullBitmap,
 604                           const wxColour& fgCol = wxNullColour,
 605                           const wxColour& bgCol = wxNullColour );
 606
 607     /**
 608         Sets client data (void*) of a property.
 609
 610         @remarks
 611         This untyped client data has to be deleted manually.
 612     */
 613     void SetPropertyClientData( wxPGPropArg id, void* clientData );
 614
 615     /**
 616         Sets editor for a property.
 617
 618         @param editor
 619             For builtin editors, use wxPGEditor_X, where X is builtin editor's
 620             name (TextCtrl, Choice, etc. see wxPGEditor documentation for full
 621             list).
 622
 623         For custom editors, use pointer you received from wxPropertyGrid::RegisterEditorClass().
 624     */
 625     void SetPropertyEditor( wxPGPropArg id, const wxPGEditor* editor );
 626
 627     /**
 628         Sets editor control of a property. As editor argument, use
 629         editor name string, such as "TextCtrl" or "Choice".
 630     */
 631     void SetPropertyEditor( wxPGPropArg id, const wxString& editorName );
 632
 633     /**
 634         Sets label of a property.
 635
 636         @remarks
 637         - Properties under same parent may have same labels. However,
 638         property names must still remain unique.
 639     */
 640     void SetPropertyLabel( wxPGPropArg id, const wxString& newproplabel );
 641
 642     /**
 643         Sets name of a property.
 644
 645         @param id
 646             Name or pointer of property which name to change.
 647
 648         @param newName
 649             New name for property.
 650     */
 651     void SetPropertyName( wxPGPropArg id, const wxString& newName );
 652
 653     /**
 654         Sets property (and, recursively, its children) to have read-only value.
 655         In other words, user cannot change the value in the editor, but they can
 656         still copy it.
 657
 658         @remarks This is mainly for use with textctrl editor. Only some other
 659                 editors fully support it.
 660
 661         @param id
 662             Property name or pointer.
 663
 664         @param set
 665             Use @true to enable read-only, @false to disable it.
 666
 667         @param flags
 668             By default changes are applied recursively. Set this parameter
 669             wxPG_DONT_RECURSE to prevent this.
 670     */
 671     void SetPropertyReadOnly( wxPGPropArg id, bool set = true,
 672                               int flags = wxPG_RECURSE );
 673
 674     /**
 675         Sets property's value to unspecified. If it has children (it may be
 676         category), then the same thing is done to them.
 677     */
 678     void SetPropertyValueUnspecified( wxPGPropArg id );
 679
 680     /**
 681         Sets various property values from a list of wxVariants. If property with
 682         name is missing from the grid, new property is created under given
 683         default category (or root if omitted).
 684     */
 685     void SetPropertyValues( const wxVariantList& list,
 686                             wxPGPropArg defaultCategory = wxNullProperty );
 687
 688     void SetPropertyValues( const wxVariant& list,
 689                             wxPGPropArg defaultCategory = wxNullProperty );
 690
 691     /**
 692         Associates the help string with property.
 693
 694         @remarks By default, text is shown either in the manager's "description"
 695                 text box or in the status bar. If extra window style
 696                 wxPG_EX_HELP_AS_TOOLTIPS is used, then the text will appear as
 697                 a tooltip.
 698     */
 699     void SetPropertyHelpString( wxPGPropArg id, const wxString& helpString );
 700
 701     /**
 702         Set wxBitmap in front of the value.
 703
 704         @remarks Bitmap will be scaled to a size returned by
 705                 wxPropertyGrid::GetImageSize();
 706     */
 707     void SetPropertyImage( wxPGPropArg id, wxBitmap& bmp );
 708
 709     /**
 710         Sets max length of property's text.
 711     */
 712     bool SetPropertyMaxLength( wxPGPropArg id, int maxLen );
 713
 714     /**
 715         Sets validator of a property.
 716     */
 717     void SetPropertyValidator( wxPGPropArg id, const wxValidator& validator );
 718
 719     /** Sets value (integer) of a property. */
 720     void SetPropertyValue( wxPGPropArg id, long value );
 721
 722     /** Sets value (integer) of a property. */
 723     void SetPropertyValue( wxPGPropArg id, int value );
 724
 725     /** Sets value (floating point) of a property. */
 726     void SetPropertyValue( wxPGPropArg id, double value );
 727
 728     /** Sets value (bool) of a property. */
 729     void SetPropertyValue( wxPGPropArg id, bool value );
 730
 731     /** Sets value (string) of a property. */
 732     void SetPropertyValue( wxPGPropArg id, const wxString& value );
 733
 734     /** Sets value (wxArrayString) of a property. */
 735     void SetPropertyValue( wxPGPropArg id, const wxArrayString& value );
 736
 737     /** Sets value (wxDateTime) of a property. */
 738     void SetPropertyValue( wxPGPropArg id, const wxDateTime& value );
 739
 740     /** Sets value (wxObject*) of a property. */
 741     void SetPropertyValue( wxPGPropArg id, wxObject* value );
 742
 743     /** Sets value (wxObject&) of a property. */
 744     void SetPropertyValue( wxPGPropArg id, wxObject& value );
 745
 746     /** Sets value (native 64-bit int) of a property. */
 747     void SetPropertyValue( wxPGPropArg id, wxLongLong_t value );
 748
 749     /** Sets value (native 64-bit unsigned int) of a property. */
 750     void SetPropertyValue( wxPGPropArg id, wxULongLong_t value );
 751
 752     /** Sets value (wxArrayInt&) of a property. */
 753     void SetPropertyValue( wxPGPropArg id, const wxArrayInt& value );
 754
 755     /**
 756         Sets value (wxString) of a property.
 757
 758         @remarks This method uses wxPGProperty::SetValueFromString(), which all
 759                 properties should implement. This means that there should not be
 760                 a type error, and instead the string is converted to property's
 761                 actual value type.
 762     */
 763     void SetPropertyValueString( wxPGPropArg id, const wxString& value );
 764
 765     /**
 766         Sets value (wxVariant&) of a property.
 767
 768         @remarks Use wxPropertyGrid::ChangePropertyValue() instead if you need to
 769                 run through validation process and send property change event.
 770     */
 771     void SetPropertyValue( wxPGPropArg id, wxVariant value );
 772
 773     /**
 774         Adjusts how wxPropertyGrid behaves when invalid value is entered
 775         in a property.
 776
 777         @param vfbFlags
 778             See @ref propgrid_vfbflags for possible values.
 779     */
 780     void SetValidationFailureBehavior( int vfbFlags );
 781
 782     /**
 783         Returns editor pointer of editor with given name;
 784     */
 785     static wxPGEditor* GetEditorByName( const wxString& editorName );
 786 };
 787