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