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 or clears flag(s) of all properties in given array.
 569
 570         @param flags
 571             Property flags to set or clear.
 572
 573         @param inverse
 574             Set to true if you want to clear flag instead of setting them.
 575     */
 576     void SetPropertiesFlag( const wxArrayPGProperty& srcArr, wxPGProperty::FlagType flags,
 577                             bool inverse = false );
 578
 579     /**
 580         Sets an attribute for this property.
 581
 582         @param name
 583             Text identifier of attribute. See @ref propgrid_property_attributes.
 584
 585         @param value
 586             Value of attribute.
 587
 588         @param argFlags
 589             Optional. Use wxPG_RECURSE to set the attribute to child properties
 590             recursively.
 591
 592         @remarks Setting attribute's value to Null variant will simply remove it
 593                 from property's set of attributes.
 594     */
 595     void SetPropertyAttribute( wxPGPropArg id, const wxString& attrName,
 596                                wxVariant value, long argFlags = 0 );
 597
 598     /**
 599         Sets property attribute for all applicapple properties.
 600         Be sure to use this method only after all properties have been
 601         added to the grid.
 602     */
 603     void SetPropertyAttributeAll( const wxString& attrName, wxVariant value );
 604
 605     /**
 606         Sets text, bitmap, and colours for given column's cell.
 607
 608         @remarks
 609         - You can set label cell by using column 0.
 610         - You can use wxPG_LABEL as text to use default text for column.
 611     */
 612     void SetPropertyCell( wxPGPropArg id,
 613                           int column,
 614                           const wxString& text = wxEmptyString,
 615                           const wxBitmap& bitmap = wxNullBitmap,
 616                           const wxColour& fgCol = wxNullColour,
 617                           const wxColour& bgCol = wxNullColour );
 618
 619     /**
 620         Sets client data (void*) of a property.
 621
 622         @remarks
 623         This untyped client data has to be deleted manually.
 624     */
 625     void SetPropertyClientData( wxPGPropArg id, void* clientData );
 626
 627     /**
 628         Sets editor for a property.
 629
 630         @param editor
 631             For builtin editors, use wxPGEditor_X, where X is builtin editor's
 632             name (TextCtrl, Choice, etc. see wxPGEditor documentation for full
 633             list).
 634
 635         For custom editors, use pointer you received from wxPropertyGrid::RegisterEditorClass().
 636     */
 637     void SetPropertyEditor( wxPGPropArg id, const wxPGEditor* editor );
 638
 639     /**
 640         Sets editor control of a property. As editor argument, use
 641         editor name string, such as "TextCtrl" or "Choice".
 642     */
 643     void SetPropertyEditor( wxPGPropArg id, const wxString& editorName );
 644
 645     /**
 646         Sets label of a property.
 647
 648         @remarks
 649         - Properties under same parent may have same labels. However,
 650         property names must still remain unique.
 651     */
 652     void SetPropertyLabel( wxPGPropArg id, const wxString& newproplabel );
 653
 654     /**
 655         Sets name of a property.
 656
 657         @param id
 658             Name or pointer of property which name to change.
 659
 660         @param newName
 661             New name for property.
 662     */
 663     void SetPropertyName( wxPGPropArg id, const wxString& newName );
 664
 665     /**
 666         Sets property (and, recursively, its children) to have read-only value.
 667         In other words, user cannot change the value in the editor, but they can
 668         still copy it.
 669
 670         @remarks This is mainly for use with textctrl editor. Only some other
 671                 editors fully support it.
 672
 673         @param id
 674             Property name or pointer.
 675
 676         @param set
 677             Use @true to enable read-only, @false to disable it.
 678
 679         @param flags
 680             By default changes are applied recursively. Set this parameter
 681             wxPG_DONT_RECURSE to prevent this.
 682     */
 683     void SetPropertyReadOnly( wxPGPropArg id, bool set = true,
 684                               int flags = wxPG_RECURSE );
 685
 686     /**
 687         Sets property's value to unspecified. If it has children (it may be
 688         category), then the same thing is done to them.
 689     */
 690     void SetPropertyValueUnspecified( wxPGPropArg id );
 691
 692     /**
 693         Sets various property values from a list of wxVariants. If property with
 694         name is missing from the grid, new property is created under given
 695         default category (or root if omitted).
 696     */
 697     void SetPropertyValues( const wxVariantList& list,
 698                             wxPGPropArg defaultCategory = wxNullProperty );
 699
 700     void SetPropertyValues( const wxVariant& list,
 701                             wxPGPropArg defaultCategory = wxNullProperty );
 702
 703     /**
 704         Associates the help string with property.
 705
 706         @remarks By default, text is shown either in the manager's "description"
 707                 text box or in the status bar. If extra window style
 708                 wxPG_EX_HELP_AS_TOOLTIPS is used, then the text will appear as
 709                 a tooltip.
 710     */
 711     void SetPropertyHelpString( wxPGPropArg id, const wxString& helpString );
 712
 713     /**
 714         Set wxBitmap in front of the value.
 715
 716         @remarks Bitmap will be scaled to a size returned by
 717                 wxPropertyGrid::GetImageSize();
 718     */
 719     void SetPropertyImage( wxPGPropArg id, wxBitmap& bmp );
 720
 721     /**
 722         Sets max length of property's text.
 723     */
 724     bool SetPropertyMaxLength( wxPGPropArg id, int maxLen );
 725
 726     /**
 727         Sets validator of a property.
 728     */
 729     void SetPropertyValidator( wxPGPropArg id, const wxValidator& validator );
 730
 731     /** Sets value (integer) of a property. */
 732     void SetPropertyValue( wxPGPropArg id, long value );
 733
 734     /** Sets value (integer) of a property. */
 735     void SetPropertyValue( wxPGPropArg id, int value );
 736
 737     /** Sets value (floating point) of a property. */
 738     void SetPropertyValue( wxPGPropArg id, double value );
 739
 740     /** Sets value (bool) of a property. */
 741     void SetPropertyValue( wxPGPropArg id, bool value );
 742
 743     /** Sets value (string) of a property. */
 744     void SetPropertyValue( wxPGPropArg id, const wxString& value );
 745
 746     /** Sets value (wxArrayString) of a property. */
 747     void SetPropertyValue( wxPGPropArg id, const wxArrayString& value );
 748
 749     /** Sets value (wxDateTime) of a property. */
 750     void SetPropertyValue( wxPGPropArg id, const wxDateTime& value );
 751
 752     /** Sets value (wxObject*) of a property. */
 753     void SetPropertyValue( wxPGPropArg id, wxObject* value );
 754
 755     /** Sets value (wxObject&) of a property. */
 756     void SetPropertyValue( wxPGPropArg id, wxObject& value );
 757
 758     /** Sets value (native 64-bit int) of a property. */
 759     void SetPropertyValue( wxPGPropArg id, wxLongLong_t value );
 760
 761     /** Sets value (native 64-bit unsigned int) of a property. */
 762     void SetPropertyValue( wxPGPropArg id, wxULongLong_t value );
 763
 764     /** Sets value (wxArrayInt&) of a property. */
 765     void SetPropertyValue( wxPGPropArg id, const wxArrayInt& value );
 766
 767     /**
 768         Sets value (wxString) of a property.
 769
 770         @remarks This method uses wxPGProperty::SetValueFromString(), which all
 771                 properties should implement. This means that there should not be
 772                 a type error, and instead the string is converted to property's
 773                 actual value type.
 774     */
 775     void SetPropertyValueString( wxPGPropArg id, const wxString& value );
 776
 777     /**
 778         Sets value (wxVariant&) of a property.
 779
 780         @remarks Use wxPropertyGrid::ChangePropertyValue() instead if you need to
 781                 run through validation process and send property change event.
 782     */
 783     void SetPropertyValue( wxPGPropArg id, wxVariant value );
 784
 785     /**
 786         Adjusts how wxPropertyGrid behaves when invalid value is entered
 787         in a property.
 788
 789         @param vfbFlags
 790             See @ref propgrid_vfbflags for possible values.
 791     */
 792     void SetValidationFailureBehavior( int vfbFlags );
 793
 794     /**
 795         Returns editor pointer of editor with given name;
 796     */
 797     static wxPGEditor* GetEditorByName( const wxString& editorName );
 798 };
 799