include/wx/propgrid/property.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/propgrid/property.h
   3 // Purpose:     wxPGProperty and related support classes
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2008-08-23
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Jaakko Salli
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_PROPGRID_PROPERTY_H_
  13 #define _WX_PROPGRID_PROPERTY_H_
  14
  15 #if wxUSE_PROPGRID
  16
  17 #include "wx/propgrid/propgriddefs.h"
  18
  19 // -----------------------------------------------------------------------
  20
  21 #define wxNullProperty  ((wxPGProperty*)NULL)
  22
  23
  24 /** @class wxPGPaintData
  25
  26     Contains information relayed to property's OnCustomPaint.
  27 */
  28 struct wxPGPaintData
  29 {
  30     /** wxPropertyGrid. */
  31     const wxPropertyGrid*   m_parent;
  32
  33     /**
  34         Normally -1, otherwise index to drop-down list item that has to be
  35         drawn.
  36      */
  37     int                     m_choiceItem;
  38
  39     /** Set to drawn width in OnCustomPaint (optional). */
  40     int                     m_drawnWidth;
  41
  42     /**
  43         In a measure item call, set this to the height of item at m_choiceItem
  44         index.
  45      */
  46     int                     m_drawnHeight;
  47 };
  48
  49
  50 #ifndef SWIG
  51
  52
  53 // space between vertical sides of a custom image
  54 #define wxPG_CUSTOM_IMAGE_SPACINGY      1
  55
  56 // space between caption and selection rectangle,
  57 #define wxPG_CAPRECTXMARGIN             2
  58
  59 // horizontally and vertically
  60 #define wxPG_CAPRECTYMARGIN             1
  61
  62
  63 /** @class wxPGCellRenderer
  64
  65     Base class for wxPropertyGrid cell renderers.
  66 */
  67 class WXDLLIMPEXP_PROPGRID wxPGCellRenderer
  68 {
  69 public:
  70
  71     wxPGCellRenderer( unsigned int refCount = 1 )
  72         : m_refCount(refCount) { }
  73     virtual ~wxPGCellRenderer() { }
  74
  75     // Render flags
  76     enum
  77     {
  78         // We are painting selected item
  79         Selected        = 0x00010000,
  80
  81         // We are painting item in choice popup
  82         ChoicePopup     = 0x00020000,
  83
  84         // We are rendering wxOwnerDrawnComboBox control
  85         // (or other owner drawn control, but that is only
  86         // officially supported one ATM).
  87         Control         = 0x00040000,
  88
  89         // We are painting a disable property
  90         Disabled        = 0x00080000,
  91
  92         // We are painting selected, disabled, or similar
  93         // item that dictates fore- and background colours,
  94         // overriding any cell values.
  95         DontUseCellFgCol    = 0x00100000,
  96         DontUseCellBgCol    = 0x00200000,
  97         DontUseCellColours  = DontUseCellFgCol |
  98                               DontUseCellBgCol
  99     };
 100
 101     virtual void Render( wxDC& dc,
 102                          const wxRect& rect,
 103                          const wxPropertyGrid* propertyGrid,
 104                          wxPGProperty* property,
 105                          int column,
 106                          int item,
 107                          int flags ) const = 0;
 108
 109     /** Returns size of the image in front of the editable area.
 110         @remarks
 111         If property is NULL, then this call is for a custom value. In that case
 112         the item is index to wxPropertyGrid's custom values.
 113     */
 114     virtual wxSize GetImageSize( const wxPGProperty* property,
 115                                  int column,
 116                                  int item ) const;
 117
 118     /** Paints property category selection rectangle.
 119     */
 120     virtual void DrawCaptionSelectionRect( wxDC& dc,
 121                                            int x, int y,
 122                                            int w, int h ) const;
 123
 124     /** Utility to draw vertically centered text.
 125     */
 126     void DrawText( wxDC& dc,
 127                    const wxRect& rect,
 128                    int imageWidth,
 129                    const wxString& text ) const;
 130
 131     /**
 132         Utility to draw editor's value, or vertically aligned text if editor is
 133         NULL.
 134     */
 135     void DrawEditorValue( wxDC& dc, const wxRect& rect,
 136                           int xOffset, const wxString& text,
 137                           wxPGProperty* property,
 138                           const wxPGEditor* editor ) const;
 139
 140     /** Utility to render cell bitmap and set text colour plus bg brush colour.
 141
 142         Returns image width that, for instance, can be passed to DrawText.
 143     */
 144     int PreDrawCell( wxDC& dc,
 145                      const wxRect& rect,
 146                      const wxPGCell& cell,
 147                      int flags ) const;
 148
 149     void IncRef()
 150     {
 151         m_refCount++;
 152     }
 153
 154     void DecRef()
 155     {
 156         m_refCount--;
 157         if ( !m_refCount )
 158             delete this;
 159     }
 160 protected:
 161
 162 private:
 163     unsigned int    m_refCount;
 164 };
 165
 166
 167 class WXDLLIMPEXP_PROPGRID wxPGCellData : public wxObjectRefData
 168 {
 169     friend class wxPGCell;
 170 public:
 171     wxPGCellData();
 172
 173     void SetText( const wxString& text )
 174     {
 175         m_text = text;
 176         m_hasValidText = true;
 177     }
 178     void SetBitmap( const wxBitmap& bitmap ) { m_bitmap = bitmap; }
 179     void SetFgCol( const wxColour& col ) { m_fgCol = col; }
 180     void SetBgCol( const wxColour& col ) { m_bgCol = col; }
 181
 182 protected:
 183     virtual ~wxPGCellData() { }
 184
 185     wxString    m_text;
 186     wxBitmap    m_bitmap;
 187     wxColour    m_fgCol;
 188     wxColour    m_bgCol;
 189
 190     // True if m_text is valid and specified
 191     bool        m_hasValidText;
 192 };
 193
 194 /** @class wxPGCell
 195
 196     Base class for simple wxPropertyGrid cell information.
 197 */
 198 class WXDLLIMPEXP_PROPGRID wxPGCell : public wxObject
 199 {
 200 public:
 201     wxPGCell();
 202     wxPGCell(const wxPGCell& other)
 203         : wxObject(other)
 204     {
 205     }
 206
 207     wxPGCell( const wxString& text,
 208               const wxBitmap& bitmap = wxNullBitmap,
 209               const wxColour& fgCol = wxNullColour,
 210               const wxColour& bgCol = wxNullColour );
 211
 212     virtual ~wxPGCell() { }
 213
 214     wxPGCellData* GetData()
 215     {
 216         return (wxPGCellData*) m_refData;
 217     }
 218
 219     const wxPGCellData* GetData() const
 220     {
 221         return (const wxPGCellData*) m_refData;
 222     }
 223
 224     bool HasText() const
 225     {
 226         return (m_refData && GetData()->m_hasValidText);
 227     }
 228
 229     /**
 230         Merges valid data from srcCell into this.
 231     */
 232     void MergeFrom( const wxPGCell& srcCell );
 233
 234     void SetText( const wxString& text );
 235     void SetBitmap( const wxBitmap& bitmap );
 236     void SetFgCol( const wxColour& col );
 237     void SetBgCol( const wxColour& col );
 238
 239     const wxString& GetText() const { return GetData()->m_text; }
 240     const wxBitmap& GetBitmap() const { return GetData()->m_bitmap; }
 241     const wxColour& GetFgCol() const { return GetData()->m_fgCol; }
 242     const wxColour& GetBgCol() const { return GetData()->m_bgCol; }
 243
 244     wxPGCell& operator=( const wxPGCell& other )
 245     {
 246         if ( this != &other )
 247         {
 248             Ref(other);
 249         }
 250         return *this;
 251     }
 252
 253 protected:
 254     virtual wxObjectRefData *CreateRefData() const
 255         { return new wxPGCellData(); }
 256
 257     virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
 258 };
 259
 260
 261 /** @class wxPGDefaultRenderer
 262
 263     Default cell renderer, that can handles the common
 264     scenarios.
 265 */
 266 class WXDLLIMPEXP_PROPGRID wxPGDefaultRenderer : public wxPGCellRenderer
 267 {
 268 public:
 269     virtual void Render( wxDC& dc,
 270                          const wxRect& rect,
 271                          const wxPropertyGrid* propertyGrid,
 272                          wxPGProperty* property,
 273                          int column,
 274                          int item,
 275                          int flags ) const;
 276
 277     virtual wxSize GetImageSize( const wxPGProperty* property,
 278                                  int column,
 279                                  int item ) const;
 280
 281 protected:
 282 };
 283
 284 // -----------------------------------------------------------------------
 285
 286 /** @class wxPGAttributeStorage
 287
 288     wxPGAttributeStorage is somewhat optimized storage for
 289       key=variant pairs (ie. a map).
 290 */
 291 class WXDLLIMPEXP_PROPGRID wxPGAttributeStorage
 292 {
 293 public:
 294     wxPGAttributeStorage();
 295     ~wxPGAttributeStorage();
 296
 297     void Set( const wxString& name, const wxVariant& value );
 298     unsigned int GetCount() const { return (unsigned int) m_map.size(); }
 299     wxVariant FindValue( const wxString& name ) const
 300     {
 301         wxPGHashMapS2P::const_iterator it = m_map.find(name);
 302         if ( it != m_map.end() )
 303         {
 304             wxVariantData* data = (wxVariantData*) it->second;
 305             data->IncRef();
 306             return wxVariant(data, it->first);
 307         }
 308         return wxVariant();
 309     }
 310
 311     typedef wxPGHashMapS2P::const_iterator const_iterator;
 312     const_iterator StartIteration() const
 313     {
 314         return m_map.begin();
 315     }
 316     bool GetNext( const_iterator& it, wxVariant& variant ) const
 317     {
 318         if ( it == m_map.end() )
 319             return false;
 320
 321         wxVariantData* data = (wxVariantData*) it->second;
 322         data->IncRef();
 323         variant.SetData(data);
 324         variant.SetName(it->first);
 325         ++it;
 326         return true;
 327     }
 328
 329 protected:
 330     wxPGHashMapS2P  m_map;
 331 };
 332
 333 #endif  // !SWIG
 334
 335 // -----------------------------------------------------------------------
 336
 337 /** @section propgrid_propflags wxPGProperty Flags
 338     @{
 339 */
 340
 341 enum wxPG_PROPERTY_FLAGS
 342 {
 343
 344 /** Indicates bold font.
 345 */
 346 wxPG_PROP_MODIFIED                  = 0x0001,
 347
 348 /** Disables ('greyed' text and editor does not activate) property.
 349 */
 350 wxPG_PROP_DISABLED                  = 0x0002,
 351
 352 /** Hider button will hide this property.
 353 */
 354 wxPG_PROP_HIDDEN                    = 0x0004,
 355
 356 /** This property has custom paint image just in front of its value.
 357     If property only draws custom images into a popup list, then this
 358     flag should not be set.
 359 */
 360 wxPG_PROP_CUSTOMIMAGE               = 0x0008,
 361
 362 /** Do not create text based editor for this property (but button-triggered
 363     dialog and choice are ok).
 364 */
 365 wxPG_PROP_NOEDITOR                  = 0x0010,
 366
 367 /** Property is collapsed, ie. it's children are hidden.
 368 */
 369 wxPG_PROP_COLLAPSED                 = 0x0020,
 370
 371 /**
 372     If property is selected, then indicates that validation failed for pending
 373     value.
 374
 375     If property is not selected, then indicates that the the actual property
 376     value has failed validation (NB: this behavior is not currently supported,
 377     but may be used in future).
 378 */
 379 wxPG_PROP_INVALID_VALUE             = 0x0040,
 380
 381 // 0x0080,
 382
 383 /** Switched via SetWasModified(). Temporary flag - only used when
 384     setting/changing property value.
 385 */
 386 wxPG_PROP_WAS_MODIFIED              = 0x0200,
 387
 388 /**
 389     If set, then child properties (if any) are private, and should be
 390     "invisible" to the application.
 391 */
 392 wxPG_PROP_AGGREGATE                 = 0x0400,
 393
 394 /** If set, then child properties (if any) are copies and should not
 395     be deleted in dtor.
 396 */
 397 wxPG_PROP_CHILDREN_ARE_COPIES       = 0x0800,
 398
 399 /**
 400     Classifies this item as a non-category.
 401
 402     Used for faster item type identification.
 403 */
 404 wxPG_PROP_PROPERTY                  = 0x1000,
 405
 406 /**
 407     Classifies this item as a category.
 408
 409     Used for faster item type identification.
 410 */
 411 wxPG_PROP_CATEGORY                  = 0x2000,
 412
 413 /** Classifies this item as a property that has children, but is not aggregate
 414     (ie children are not private).
 415 */
 416 wxPG_PROP_MISC_PARENT               = 0x4000,
 417
 418 /** Property is read-only. Editor is still created.
 419 */
 420 wxPG_PROP_READONLY                  = 0x8000,
 421
 422 //
 423 // NB: FLAGS ABOVE 0x8000 CANNOT BE USED WITH PROPERTY ITERATORS
 424 //
 425
 426 /** Property's value is composed from values of child properties.
 427     @remarks
 428     This flag cannot be used with property iterators.
 429 */
 430 wxPG_PROP_COMPOSED_VALUE            = 0x00010000,
 431
 432 /** Common value of property is selectable in editor.
 433     @remarks
 434     This flag cannot be used with property iterators.
 435 */
 436 wxPG_PROP_USES_COMMON_VALUE         = 0x00020000,
 437
 438 /** Property can be set to unspecified value via editor.
 439     Currently, this applies to following properties:
 440     - wxIntProperty, wxUIntProperty, wxFloatProperty, wxEditEnumProperty:
 441       Clear the text field
 442
 443     @remarks
 444     This flag cannot be used with property iterators.
 445 */
 446 wxPG_PROP_AUTO_UNSPECIFIED          = 0x00040000,
 447
 448 /** Indicates the bit useable by derived properties.
 449 */
 450 wxPG_PROP_CLASS_SPECIFIC_1          = 0x00080000,
 451
 452 /** Indicates the bit useable by derived properties.
 453 */
 454 wxPG_PROP_CLASS_SPECIFIC_2          = 0x00100000
 455
 456 };
 457
 458 /** Topmost flag.
 459 */
 460 #define wxPG_PROP_MAX               wxPG_PROP_AUTO_UNSPECIFIED
 461
 462 /** Property with children must have one of these set, otherwise iterators
 463     will not work correctly.
 464     Code should automatically take care of this, however.
 465 */
 466 #define wxPG_PROP_PARENTAL_FLAGS \
 467     (wxPG_PROP_AGGREGATE|wxPG_PROP_CATEGORY|wxPG_PROP_MISC_PARENT)
 468
 469 /** @}
 470 */
 471
 472 // Combination of flags that can be stored by GetFlagsAsString
 473 #define wxPG_STRING_STORED_FLAGS \
 474     (wxPG_PROP_DISABLED|wxPG_PROP_HIDDEN|wxPG_PROP_NOEDITOR|wxPG_PROP_COLLAPSED)
 475
 476 // -----------------------------------------------------------------------
 477
 478 #ifndef SWIG
 479
 480 /**
 481     @section propgrid_property_attributes wxPropertyGrid Property Attribute
 482     Identifiers.
 483
 484     wxPGProperty::SetAttribute() and
 485     wxPropertyGridInterface::SetPropertyAttribute() accept one of these as
 486     attribute name argument.
 487
 488     You can use strings instead of constants. However, some of these
 489     constants are redefined to use cached strings which may reduce
 490     your binary size by some amount.
 491
 492     @{
 493 */
 494
 495 /** Set default value for property.
 496 */
 497 #define wxPG_ATTR_DEFAULT_VALUE           wxS("DefaultValue")
 498
 499 /** Universal, int or double. Minimum value for numeric properties.
 500 */
 501 #define wxPG_ATTR_MIN                     wxS("Min")
 502
 503 /** Universal, int or double. Maximum value for numeric properties.
 504 */
 505 #define wxPG_ATTR_MAX                     wxS("Max")
 506
 507 /** Universal, string. When set, will be shown as text after the displayed
 508     text value. Alternatively, if third column is enabled, text will be shown
 509     there (for any type of property).
 510 */
 511 #define wxPG_ATTR_UNITS                     wxS("Units")
 512
 513 /** Universal, string. When set, will be shown in property's value cell
 514     when displayed value string is empty, or value is unspecified.
 515 */
 516 #define wxPG_ATTR_INLINE_HELP               wxS("InlineHelp")
 517
 518 /** wxBoolProperty specific, int, default 0. When 1 sets bool property to
 519     use checkbox instead of choice.
 520 */
 521 #define wxPG_BOOL_USE_CHECKBOX              wxS("UseCheckbox")
 522
 523 /** wxBoolProperty specific, int, default 0. When 1 sets bool property value
 524     to cycle on double click (instead of showing the popup listbox).
 525 */
 526 #define wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING  wxS("UseDClickCycling")
 527
 528 /**
 529     wxFloatProperty (and similar) specific, int, default -1.
 530
 531     Sets the (max) precision used when floating point value is rendered as
 532     text. The default -1 means infinite precision.
 533 */
 534 #define wxPG_FLOAT_PRECISION                wxS("Precision")
 535
 536 /**
 537     The text will be echoed as asterisks (wxTE_PASSWORD will be passed to
 538     textctrl etc).
 539 */
 540 #define wxPG_STRING_PASSWORD                wxS("Password")
 541
 542 /** Define base used by a wxUIntProperty. Valid constants are
 543     wxPG_BASE_OCT, wxPG_BASE_DEC, wxPG_BASE_HEX and wxPG_BASE_HEXL
 544     (lowercase characters).
 545 */
 546 #define wxPG_UINT_BASE                      wxS("Base")
 547
 548 /** Define prefix rendered to wxUIntProperty. Accepted constants
 549     wxPG_PREFIX_NONE, wxPG_PREFIX_0x, and wxPG_PREFIX_DOLLAR_SIGN.
 550     <b>Note:</b> Only wxPG_PREFIX_NONE works with Decimal and Octal
 551     numbers.
 552 */
 553 #define wxPG_UINT_PREFIX                    wxS("Prefix")
 554
 555 /**
 556     wxFileProperty/wxImageFileProperty specific, wxChar*, default is
 557     detected/varies.
 558     Sets the wildcard used in the triggered wxFileDialog. Format is the same.
 559 */
 560 #define wxPG_FILE_WILDCARD                  wxS("Wildcard")
 561
 562 /** wxFileProperty/wxImageFileProperty specific, int, default 1.
 563     When 0, only the file name is shown (i.e. drive and directory are hidden).
 564 */
 565 #define wxPG_FILE_SHOW_FULL_PATH            wxS("ShowFullPath")
 566
 567 /** Specific to wxFileProperty and derived properties, wxString, default empty.
 568     If set, then the filename is shown relative to the given path string.
 569 */
 570 #define wxPG_FILE_SHOW_RELATIVE_PATH        wxS("ShowRelativePath")
 571
 572 /**
 573     Specific to wxFileProperty and derived properties, wxString, default is
 574     empty.
 575
 576     Sets the initial path of where to look for files.
 577 */
 578 #define wxPG_FILE_INITIAL_PATH              wxS("InitialPath")
 579
 580 /** Specific to wxFileProperty and derivatives, wxString, default is empty.
 581     Sets a specific title for the dir dialog.
 582 */
 583 #define wxPG_FILE_DIALOG_TITLE              wxS("DialogTitle")
 584
 585 /** Specific to wxDirProperty, wxString, default is empty.
 586     Sets a specific message for the dir dialog.
 587 */
 588 #define wxPG_DIR_DIALOG_MESSAGE             wxS("DialogMessage")
 589
 590 /** Sets displayed date format for wxDateProperty.
 591 */
 592 #define wxPG_DATE_FORMAT                    wxS("DateFormat")
 593
 594 /** Sets wxDatePickerCtrl window style used with wxDateProperty. Default
 595     is wxDP_DEFAULT | wxDP_SHOWCENTURY.
 596 */
 597 #define wxPG_DATE_PICKER_STYLE              wxS("PickerStyle")
 598
 599 /** SpinCtrl editor, int or double. How much number changes when button is
 600     pressed (or up/down on keybard).
 601 */
 602 #define wxPG_ATTR_SPINCTRL_STEP             wxS("Step")
 603
 604 /** SpinCtrl editor, bool. If true, value wraps at Min/Max.
 605 */
 606 #define wxPG_ATTR_SPINCTRL_WRAP             wxS("Wrap")
 607
 608 /**
 609     wxMultiChoiceProperty, int.
 610     If 0, no user strings allowed. If 1, user strings appear before list
 611     strings. If 2, user strings appear after list string.
 612 */
 613 #define wxPG_ATTR_MULTICHOICE_USERSTRINGMODE    wxS("UserStringMode")
 614
 615 /**
 616     wxColourProperty and its kind, int, default 1.
 617
 618     Setting this attribute to 0 hides custom colour from property's list of
 619     choices.
 620 */
 621 #define wxPG_COLOUR_ALLOW_CUSTOM            wxS("AllowCustom")
 622
 623 /** @}
 624 */
 625
 626 // Redefine attribute macros to use cached strings
 627 #undef wxPG_ATTR_MIN
 628 #define wxPG_ATTR_MIN                     wxPGGlobalVars->m_strMin
 629 #undef wxPG_ATTR_MAX
 630 #define wxPG_ATTR_MAX                     wxPGGlobalVars->m_strMax
 631 #undef wxPG_ATTR_UNITS
 632 #define wxPG_ATTR_UNITS                   wxPGGlobalVars->m_strUnits
 633 #undef wxPG_ATTR_INLINE_HELP
 634 #define wxPG_ATTR_INLINE_HELP             wxPGGlobalVars->m_strInlineHelp
 635
 636 #endif  // !SWIG
 637
 638 // -----------------------------------------------------------------------
 639
 640 #ifndef SWIG
 641
 642 /** @class wxPGChoiceEntry
 643     Data of a single wxPGChoices choice.
 644 */
 645 class WXDLLIMPEXP_PROPGRID wxPGChoiceEntry : public wxPGCell
 646 {
 647 public:
 648     wxPGChoiceEntry();
 649     wxPGChoiceEntry(const wxPGChoiceEntry& other)
 650         : wxPGCell(other)
 651     {
 652         m_value = other.m_value;
 653     }
 654     wxPGChoiceEntry( const wxString& label,
 655                      int value = wxPG_INVALID_VALUE )
 656         : wxPGCell(), m_value(value)
 657     {
 658         SetText(label);
 659     }
 660
 661     virtual ~wxPGChoiceEntry() { }
 662
 663     void SetValue( int value ) { m_value = value; }
 664     int GetValue() const { return m_value; }
 665
 666     wxPGChoiceEntry& operator=( const wxPGChoiceEntry& other )
 667     {
 668         if ( this != &other )
 669         {
 670             Ref(other);
 671         }
 672         m_value = other.m_value;
 673         return *this;
 674     }
 675
 676 protected:
 677     int m_value;
 678 };
 679
 680
 681 typedef void* wxPGChoicesId;
 682
 683 class WXDLLIMPEXP_PROPGRID wxPGChoicesData
 684 {
 685     friend class wxPGChoices;
 686 public:
 687     // Constructor sets m_refCount to 1.
 688     wxPGChoicesData();
 689
 690     void CopyDataFrom( wxPGChoicesData* data );
 691
 692     wxPGChoiceEntry& Insert( int index, const wxPGChoiceEntry& item );
 693
 694     // Delete all entries
 695     void Clear();
 696
 697     unsigned int GetCount() const
 698     {
 699         return (unsigned int) m_items.size();
 700     }
 701
 702     const wxPGChoiceEntry& Item( unsigned int i ) const
 703     {
 704         wxASSERT_MSG( i < GetCount(), "invalid index" );
 705         return m_items[i];
 706     }
 707
 708     wxPGChoiceEntry& Item( unsigned int i )
 709     {
 710         wxASSERT_MSG( i < GetCount(), "invalid index" );
 711         return m_items[i];
 712     }
 713
 714     void DecRef()
 715     {
 716         m_refCount--;
 717         wxASSERT( m_refCount >= 0 );
 718         if ( m_refCount == 0 )
 719             delete this;
 720     }
 721
 722 private:
 723     wxVector<wxPGChoiceEntry>   m_items;
 724
 725     // So that multiple properties can use the same set
 726     int             m_refCount;
 727
 728     virtual ~wxPGChoicesData();
 729 };
 730
 731 #define wxPGChoicesEmptyData    ((wxPGChoicesData*)NULL)
 732
 733 #endif // SWIG
 734
 735 /** @class wxPGChoices
 736
 737     Helper class for managing choices of wxPropertyGrid properties.
 738     Each entry can have label, value, bitmap, text colour, and background
 739     colour.
 740
 741     @remarks If you do not specify value for entry, index is used.
 742
 743     @library{wxpropgrid}
 744     @category{propgrid}
 745 */
 746 class WXDLLIMPEXP_PROPGRID wxPGChoices
 747 {
 748 public:
 749     typedef long ValArrItem;
 750
 751     /** Default constructor. */
 752     wxPGChoices()
 753     {
 754         Init();
 755     }
 756
 757     /** Copy constructor. */
 758     wxPGChoices( const wxPGChoices& a )
 759     {
 760         if ( a.m_data != wxPGChoicesEmptyData )
 761         {
 762             m_data = a.m_data;
 763             m_data->m_refCount++;
 764         }
 765     }
 766
 767     /**
 768         Constructor.
 769
 770         @param labels
 771             Labels for choices
 772
 773         @param values
 774             Values for choices. If NULL, indexes are used.
 775     */
 776     wxPGChoices( const wxChar** labels, const long* values = NULL )
 777     {
 778         Init();
 779         Set(labels,values);
 780     }
 781
 782     /**
 783         Constructor.
 784
 785         @param labels
 786             Labels for choices
 787
 788         @param values
 789             Values for choices. If empty, indexes are used.
 790     */
 791     wxPGChoices( const wxArrayString& labels,
 792                  const wxArrayInt& values = wxArrayInt() )
 793     {
 794         Init();
 795         Set(labels,values);
 796     }
 797
 798     /** Simple interface constructor. */
 799     wxPGChoices( wxPGChoicesData* data )
 800     {
 801         wxASSERT(data);
 802         m_data = data;
 803         data->m_refCount++;
 804     }
 805
 806     /** Destructor. */
 807     ~wxPGChoices()
 808     {
 809         Free();
 810     }
 811
 812     /**
 813         Adds to current.
 814
 815         If did not have own copies, creates them now. If was empty, identical
 816         to set except that creates copies.
 817
 818         @param labels
 819             Labels for added choices.
 820
 821         @param values
 822             Values for added choices. If empty, relevant entry indexes are used.
 823     */
 824     void Add( const wxChar** labels, const ValArrItem* values = NULL );
 825
 826     /** Version that works with wxArrayString and wxArrayInt. */
 827     void Add( const wxArrayString& arr, const wxArrayInt& arrint = wxArrayInt() );
 828
 829     /**
 830         Adds a single choice.
 831
 832         @param label
 833             Label for added choice.
 834
 835         @param value
 836             Value for added choice. If unspecified, index is used.
 837     */
 838     wxPGChoiceEntry& Add( const wxString& label,
 839                           int value = wxPG_INVALID_VALUE );
 840
 841     /** Adds a single item, with bitmap. */
 842     wxPGChoiceEntry& Add( const wxString& label,
 843                           const wxBitmap& bitmap,
 844                           int value = wxPG_INVALID_VALUE );
 845
 846     /** Adds a single item with full entry information. */
 847     wxPGChoiceEntry& Add( const wxPGChoiceEntry& entry )
 848     {
 849         return Insert(entry, -1);
 850     }
 851
 852     /** Adds single item. */
 853     wxPGChoiceEntry& AddAsSorted( const wxString& label,
 854                                   int value = wxPG_INVALID_VALUE );
 855
 856     void Assign( const wxPGChoices& a )
 857     {
 858         AssignData(a.m_data);
 859     }
 860
 861     void AssignData( wxPGChoicesData* data );
 862
 863     /** Delete all choices. */
 864     void Clear()
 865     {
 866         if ( m_data != wxPGChoicesEmptyData )
 867             m_data->Clear();
 868     }
 869
 870     void EnsureData()
 871     {
 872         if ( m_data == wxPGChoicesEmptyData )
 873             m_data = new wxPGChoicesData();
 874     }
 875
 876     /** Gets a unsigned number identifying this list. */
 877     wxPGChoicesId GetId() const { return (wxPGChoicesId) m_data; };
 878
 879     const wxString& GetLabel( unsigned int ind ) const
 880     {
 881         return Item(ind).GetText();
 882     }
 883
 884     unsigned int GetCount () const
 885     {
 886         if ( !m_data )
 887             return 0;
 888
 889         return m_data->GetCount();
 890     }
 891
 892     int GetValue( unsigned int ind ) const { return Item(ind).GetValue(); }
 893
 894     /** Returns array of values matching the given strings. Unmatching strings
 895         result in wxPG_INVALID_VALUE entry in array.
 896     */
 897     wxArrayInt GetValuesForStrings( const wxArrayString& strings ) const;
 898
 899     /** Returns array of indices matching given strings. Unmatching strings
 900         are added to 'unmatched', if not NULL.
 901     */
 902     wxArrayInt GetIndicesForStrings( const wxArrayString& strings,
 903                                      wxArrayString* unmatched = NULL ) const;
 904
 905     int Index( const wxString& str ) const;
 906     int Index( int val ) const;
 907
 908     /** Inserts single item. */
 909     wxPGChoiceEntry& Insert( const wxString& label,
 910                              int index,
 911                              int value = wxPG_INVALID_VALUE );
 912
 913     /** Inserts a single item with full entry information. */
 914     wxPGChoiceEntry& Insert( const wxPGChoiceEntry& entry, int index );
 915
 916     /** Returns false if this is a constant empty set of choices,
 917         which should not be modified.
 918     */
 919     bool IsOk() const
 920     {
 921         return ( m_data != wxPGChoicesEmptyData );
 922     }
 923
 924     const wxPGChoiceEntry& Item( unsigned int i ) const
 925     {
 926         wxASSERT( IsOk() );
 927         return m_data->Item(i);
 928     }
 929
 930     wxPGChoiceEntry& Item( unsigned int i )
 931     {
 932         wxASSERT( IsOk() );
 933         return m_data->Item(i);
 934     }
 935
 936     /** Removes count items starting at position nIndex. */
 937     void RemoveAt(size_t nIndex, size_t count = 1);
 938
 939 #ifndef SWIG
 940     /** Does not create copies for itself. */
 941     void Set( const wxChar** labels, const long* values = NULL )
 942     {
 943         Free();
 944         Add(labels,values);
 945     }
 946 #endif // SWIG
 947
 948     /** Version that works with wxArrayString and wxArrayInt. */
 949     void Set( const wxArrayString& labels,
 950               const wxArrayInt& values = wxArrayInt() )
 951     {
 952         Free();
 953         if ( &values )
 954             Add(labels,values);
 955         else
 956             Add(labels);
 957     }
 958
 959     // Creates exclusive copy of current choices
 960     void SetExclusive()
 961     {
 962         if ( m_data->m_refCount != 1 )
 963         {
 964             wxPGChoicesData* data = new wxPGChoicesData();
 965             data->CopyDataFrom(m_data);
 966             Free();
 967             m_data = data;
 968         }
 969     }
 970
 971     // Returns data, increases refcount.
 972     wxPGChoicesData* GetData()
 973     {
 974         wxASSERT( m_data->m_refCount != 0xFFFFFFF );
 975         m_data->m_refCount++;
 976         return m_data;
 977     }
 978
 979     // Returns plain data ptr - no refcounting stuff is done.
 980     wxPGChoicesData* GetDataPtr() const { return m_data; }
 981
 982     // Changes ownership of data to you.
 983     wxPGChoicesData* ExtractData()
 984     {
 985         wxPGChoicesData* data = m_data;
 986         m_data = wxPGChoicesEmptyData;
 987         return data;
 988     }
 989
 990     wxArrayString GetLabels() const;
 991
 992 #ifndef SWIG
 993     void operator= (const wxPGChoices& a)
 994     {
 995         if (this != &a)
 996             AssignData(a.m_data);
 997     }
 998
 999     wxPGChoiceEntry& operator[](unsigned int i)
1000     {
1001         return Item(i);
1002     }
1003
1004     const wxPGChoiceEntry& operator[](unsigned int i) const
1005     {
1006         return Item(i);
1007     }
1008
1009 protected:
1010     wxPGChoicesData*    m_data;
1011
1012     void Init();
1013     void Free();
1014 #endif  // !SWIG
1015 };
1016
1017 // -----------------------------------------------------------------------
1018
1019 /** @class wxPGProperty
1020
1021     wxPGProperty is base class for all wxPropertyGrid properties.
1022
1023     NB: Full class overview is now only present in
1024         interface/wx/propgrid/property.h.
1025
1026     @library{wxpropgrid}
1027     @category{propgrid}
1028 */
1029 class WXDLLIMPEXP_PROPGRID wxPGProperty : public wxObject
1030 {
1031     friend class wxPropertyGrid;
1032     friend class wxPropertyGridInterface;
1033     friend class wxPropertyGridPageState;
1034     friend class wxPropertyGridPopulator;
1035     friend class wxStringProperty;  // Proper "<composed>" support requires this
1036 #ifndef SWIG
1037     DECLARE_ABSTRACT_CLASS(wxPGProperty)
1038 #endif
1039 public:
1040     typedef wxUint32 FlagType;
1041
1042     /** Basic constructor.
1043     */
1044     wxPGProperty();
1045
1046     /** Constructor.
1047         Non-abstract property classes should have constructor of this style:
1048
1049         @code
1050
1051         // If T is a class, then it should be a constant reference
1052         // (e.g. const T& ) instead.
1053         MyProperty( const wxString& label, const wxString& name, T value )
1054             : wxPGProperty()
1055         {
1056             // Generally recommended way to set the initial value
1057             // (as it should work in pretty much 100% of cases).
1058             wxVariant variant;
1059             variant << value;
1060             SetValue(variant);
1061
1062             // If has private child properties then create them here. Also
1063             // set flag that indicates presence of private children. E.g.:
1064             //
1065             //     SetParentalType(wxPG_PROP_AGGREGATE);
1066             //
1067             //     AddChild( new wxStringProperty( "Subprop 1",
1068             //                                     wxPG_LABEL,
1069             //                                     value.GetSubProp1() ) );
1070         }
1071
1072         @endcode
1073     */
1074     wxPGProperty( const wxString& label, const wxString& name );
1075
1076     /**
1077         Virtual destructor.
1078         It is customary for derived properties to implement this.
1079     */
1080     virtual ~wxPGProperty();
1081
1082     /** This virtual function is called after m_value has been set.
1083
1084         @remarks
1085         - If m_value was set to Null variant (ie. unspecified value),
1086           OnSetValue() will not be called.
1087         - m_value may be of any variant type. Typically properties internally
1088           support only one variant type, and as such OnSetValue() provides a
1089           good opportunity to convert
1090           supported values into internal type.
1091         - Default implementation does nothing.
1092     */
1093     virtual void OnSetValue();
1094
1095     /** Override this to return something else than m_value as the value.
1096     */
1097     virtual wxVariant DoGetValue() const { return m_value; }
1098
1099 #if !defined(SWIG) || defined(CREATE_VCW)
1100     /** Implement this function in derived class to check the value.
1101         Return true if it is ok. Returning false prevents property change events
1102         from occurring.
1103
1104         @remarks
1105         - Default implementation always returns true.
1106     */
1107     virtual bool ValidateValue( wxVariant& value,
1108                                 wxPGValidationInfo& validationInfo ) const;
1109
1110     /**
1111         Converts text into wxVariant value appropriate for this property.
1112
1113         @param variant
1114             On function entry this is the old value (should not be wxNullVariant
1115             in normal cases). Translated value must be assigned back to it.
1116
1117         @param text
1118             Text to be translated into variant.
1119
1120         @param argFlags
1121             If wxPG_FULL_VALUE is set, returns complete, storable value instead
1122             of displayable one (they may be different).
1123             If wxPG_COMPOSITE_FRAGMENT is set, text is interpreted as a part of
1124             composite property string value (as generated by ValueToString()
1125             called with this same flag).
1126
1127         @return Returns @true if resulting wxVariant value was different.
1128
1129         @remarks Default implementation converts semicolon delimited tokens into
1130                 child values. Only works for properties with children.
1131
1132                 You might want to take into account that m_value is Null variant
1133                 if property value is unspecified (which is usually only case if
1134                 you explicitly enabled that sort behavior).
1135     */
1136     virtual bool StringToValue( wxVariant& variant,
1137                                 const wxString& text,
1138                                 int argFlags = 0 ) const;
1139
1140     /**
1141         Converts integer (possibly a choice selection) into wxVariant value
1142         appropriate for this property.
1143
1144         @param variant
1145             On function entry this is the old value (should not be wxNullVariant
1146             in normal cases). Translated value must be assigned back to it.
1147
1148         @param number
1149             Integer to be translated into variant.
1150
1151         @param argFlags
1152             If wxPG_FULL_VALUE is set, returns complete, storable value instead
1153             of displayable one.
1154
1155         @return Returns @true if resulting wxVariant value was different.
1156
1157         @remarks
1158         - If property is not supposed to use choice or spinctrl or other editor
1159           with int-based value, it is not necessary to implement this method.
1160         - Default implementation simply assign given int to m_value.
1161         - If property uses choice control, and displays a dialog on some choice
1162           items, then it is preferred to display that dialog in IntToValue
1163           instead of OnEvent.
1164         - You might want to take into account that m_value is Null variant if
1165           property value is unspecified (which is usually only case if you
1166           explicitly enabled that sort behavior).
1167     */
1168     virtual bool IntToValue( wxVariant& value,
1169                              int number,
1170                              int argFlags = 0 ) const;
1171 #endif  // !defined(SWIG) || defined(CREATE_VCW)
1172     /**
1173         Converts property value into a text representation.
1174
1175         @param value
1176             Value to be converted.
1177
1178         @param argFlags
1179             If 0 (default value), then displayed string is returned.
1180             If wxPG_FULL_VALUE is set, returns complete, storable string value
1181             instead of displayable. If wxPG_EDITABLE_VALUE is set, returns
1182             string value that must be editable in textctrl. If
1183             wxPG_COMPOSITE_FRAGMENT is set, returns text that is appropriate to
1184             display as a part of string property's composite text
1185             representation.
1186
1187         @remarks Default implementation calls GenerateComposedValue().
1188     */
1189     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
1190
1191     /** Converts string to a value, and if successful, calls SetValue() on it.
1192         Default behavior is to do nothing.
1193         @param text
1194         String to get the value from.
1195         @return
1196         true if value was changed.
1197     */
1198     bool SetValueFromString( const wxString& text, int flags = wxPG_PROGRAMMATIC_VALUE );
1199
1200     /** Converts integer to a value, and if succesful, calls SetValue() on it.
1201         Default behavior is to do nothing.
1202         @param value
1203             Int to get the value from.
1204         @param flags
1205             If has wxPG_FULL_VALUE, then the value given is a actual value and
1206             not an index.
1207         @return
1208             True if value was changed.
1209     */
1210     bool SetValueFromInt( long value, int flags = 0 );
1211
1212     /**
1213         Returns size of the custom painted image in front of property.
1214
1215         This method must be overridden to return non-default value if
1216         OnCustomPaint is to be called.
1217         @param item
1218             Normally -1, but can be an index to the property's list of items.
1219         @remarks
1220         - Default behavior is to return wxSize(0,0), which means no image.
1221         - Default image width or height is indicated with dimension -1.
1222         - You can also return wxPG_DEFAULT_IMAGE_SIZE, i.e. wxSize(-1, -1).
1223     */
1224     virtual wxSize OnMeasureImage( int item = -1 ) const;
1225
1226     /**
1227         Events received by editor widgets are processed here.
1228
1229         Note that editor class usually processes most events. Some, such as
1230         button press events of TextCtrlAndButton class, can be handled here.
1231         Also, if custom handling for regular events is desired, then that can
1232         also be done (for example, wxSystemColourProperty custom handles
1233         wxEVT_COMMAND_CHOICE_SELECTED to display colour picker dialog when
1234         'custom' selection is made).
1235
1236         If the event causes value to be changed, SetValueInEvent()
1237         should be called to set the new value.
1238
1239         @param event
1240         Associated wxEvent.
1241         @return
1242         Should return true if any changes in value should be reported.
1243         @remarks
1244         If property uses choice control, and displays a dialog on some choice
1245         items, then it is preferred to display that dialog in IntToValue
1246         instead of OnEvent.
1247     */
1248     virtual bool OnEvent( wxPropertyGrid* propgrid,
1249                           wxWindow* wnd_primary,
1250                           wxEvent& event );
1251
1252     /**
1253         Called after value of a child property has been altered.
1254
1255         Note that this function is usually called at the time that value of
1256         this property, or given child property, is still pending for change.
1257
1258         Sample pseudo-code implementation:
1259
1260         @code
1261         void MyProperty::ChildChanged( wxVariant& thisValue,
1262                                        int childIndex,
1263                                        wxVariant& childValue ) const
1264         {
1265             // Acquire reference to actual type of data stored in variant
1266             // (TFromVariant only exists if wxPropertyGrid's wxVariant-macros
1267             // were used to create the variant class).
1268             T& data = TFromVariant(thisValue);
1269
1270             // Copy childValue into data.
1271             switch ( childIndex )
1272             {
1273                 case 0:
1274                     data.SetSubProp1( childvalue.GetLong() );
1275                     break;
1276                 case 1:
1277                     data.SetSubProp2( childvalue.GetString() );
1278                     break;
1279                 ...
1280             }
1281         }
1282         @endcode
1283
1284         @param thisValue
1285             Value of this property, that should be altered.
1286         @param childIndex
1287             Index of child changed (you can use Item(childIndex) to get).
1288         @param childValue
1289             Value of the child property.
1290     */
1291     virtual void ChildChanged( wxVariant& thisValue,
1292                                int childIndex,
1293                                wxVariant& childValue ) const;
1294
1295     /** Returns pointer to an instance of used editor.
1296     */
1297     virtual const wxPGEditor* DoGetEditorClass() const;
1298
1299     /** Returns pointer to the wxValidator that should be used
1300         with the editor of this property (NULL for no validator).
1301         Setting validator explicitly via SetPropertyValidator
1302         will override this.
1303
1304         In most situations, code like this should work well
1305         (macros are used to maintain one actual validator instance,
1306         so on the second call the function exits within the first
1307         macro):
1308
1309         @code
1310
1311         wxValidator* wxMyPropertyClass::DoGetValidator () const
1312         {
1313             WX_PG_DOGETVALIDATOR_ENTRY()
1314
1315             wxMyValidator* validator = new wxMyValidator(...);
1316
1317             ... prepare validator...
1318
1319             WX_PG_DOGETVALIDATOR_EXIT(validator)
1320         }
1321
1322         @endcode
1323
1324         @remarks
1325         You can get common filename validator by returning
1326         wxFileProperty::GetClassValidator(). wxDirProperty,
1327         for example, uses it.
1328     */
1329     virtual wxValidator* DoGetValidator () const;
1330
1331     /**
1332         Override to paint an image in front of the property value text or
1333         drop-down list item (but only if wxPGProperty::OnMeasureImage is
1334         overridden as well).
1335
1336         If property's OnMeasureImage() returns size that has height != 0 but
1337         less than row height ( < 0 has special meanings), wxPropertyGrid calls
1338         this method to draw a custom image in a limited area in front of the
1339         editor control or value text/graphics, and if control has drop-down
1340         list, then the image is drawn there as well (even in the case
1341         OnMeasureImage() returned higher height than row height).
1342
1343         NOTE: Following applies when OnMeasureImage() returns a "flexible"
1344         height ( using wxPG_FLEXIBLE_SIZE(W,H) macro), which implies variable
1345         height items: If rect.x is < 0, then this is a measure item call, which
1346         means that dc is invalid and only thing that should be done is to set
1347         paintdata.m_drawnHeight to the height of the image of item at index
1348         paintdata.m_choiceItem. This call may be done even as often as once
1349         every drop-down popup show.
1350
1351         @param dc
1352             wxDC to paint on.
1353         @param rect
1354             Box reserved for custom graphics. Includes surrounding rectangle,
1355             if any. If x is < 0, then this is a measure item call (see above).
1356         @param paintdata
1357             wxPGPaintData structure with much useful data.
1358
1359         @remarks
1360             - You can actually exceed rect width, but if you do so then
1361               paintdata.m_drawnWidth must be set to the full width drawn in
1362               pixels.
1363             - Due to technical reasons, rect's height will be default even if
1364               custom height was reported during measure call.
1365             - Brush is guaranteed to be default background colour. It has been
1366               already used to clear the background of area being painted. It
1367               can be modified.
1368             - Pen is guaranteed to be 1-wide 'black' (or whatever is the proper
1369               colour) pen for drawing framing rectangle. It can be changed as
1370               well.
1371
1372         @see ValueToString()
1373     */
1374     virtual void OnCustomPaint( wxDC& dc,
1375                                 const wxRect& rect,
1376                                 wxPGPaintData& paintdata );
1377
1378     /**
1379         Returns used wxPGCellRenderer instance for given property column
1380         (label=0, value=1).
1381
1382         Default implementation returns editor's renderer for all columns.
1383     */
1384     virtual wxPGCellRenderer* GetCellRenderer( int column ) const;
1385
1386     /** Returns which choice is currently selected. Only applies to properties
1387         which have choices.
1388
1389         Needs to reimplemented in derived class if property value does not
1390         map directly to a choice. Integer as index, bool, and string usually do.
1391     */
1392     virtual int GetChoiceSelection() const;
1393
1394     /**
1395         Refresh values of child properties.
1396
1397         Automatically called after value is set.
1398     */
1399     virtual void RefreshChildren();
1400
1401     /** Special handling for attributes of this property.
1402
1403         If returns false, then the attribute will be automatically stored in
1404         m_attributes.
1405
1406         Default implementation simply returns false.
1407     */
1408     virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
1409
1410     /** Returns value of an attribute.
1411
1412         Override if custom handling of attributes is needed.
1413
1414         Default implementation simply return NULL variant.
1415     */
1416     virtual wxVariant DoGetAttribute( const wxString& name ) const;
1417
1418     /** Returns instance of a new wxPGEditorDialogAdapter instance, which is
1419         used when user presses the (optional) button next to the editor control;
1420
1421         Default implementation returns NULL (ie. no action is generated when
1422         button is pressed).
1423     */
1424     virtual wxPGEditorDialogAdapter* GetEditorDialog() const;
1425
1426     /**
1427         Called whenever validation has failed with given pending value.
1428
1429         @remarks If you implement this in your custom property class, please
1430                  remember to call the baser implementation as well, since they
1431                  may use it to revert property into pre-change state.
1432     */
1433     virtual void OnValidationFailure( wxVariant& pendingValue );
1434
1435     /** Append a new choice to property's list of choices.
1436     */
1437     int AddChoice( const wxString& label, int value = wxPG_INVALID_VALUE )
1438     {
1439         return InsertChoice(label, wxNOT_FOUND, value);
1440     }
1441
1442     /**
1443         Returns true if children of this property are component values (for
1444         instance, points size, face name, and is_underlined are component
1445         values of a font).
1446     */
1447     bool AreChildrenComponents() const
1448     {
1449         if ( m_flags & (wxPG_PROP_COMPOSED_VALUE|wxPG_PROP_AGGREGATE) )
1450             return true;
1451
1452         return false;
1453     }
1454
1455     /**
1456         Deletes children of the property.
1457     */
1458     void DeleteChildren();
1459
1460     /**
1461         Removes entry from property's wxPGChoices and editor control (if it is
1462         active).
1463
1464         If selected item is deleted, then the value is set to unspecified.
1465     */
1466     void DeleteChoice( int index );
1467
1468     /**
1469         Call to enable or disable usage of common value (integer value that can
1470         be selected for properties instead of their normal values) for this
1471         property.
1472
1473         Common values are disabled by the default for all properties.
1474     */
1475     void EnableCommonValue( bool enable = true )
1476     {
1477         if ( enable ) SetFlag( wxPG_PROP_USES_COMMON_VALUE );
1478         else ClearFlag( wxPG_PROP_USES_COMMON_VALUE );
1479     }
1480
1481     /**
1482         Composes text from values of child properties.
1483     */
1484     wxString GenerateComposedValue() const
1485     {
1486         wxString s;
1487         DoGenerateComposedValue(s);
1488         return s;
1489     }
1490
1491     /** Returns property's label. */
1492     const wxString& GetLabel() const { return m_label; }
1493
1494     /** Returns property's name with all (non-category, non-root) parents. */
1495     wxString GetName() const;
1496
1497     /**
1498         Returns property's base name (ie parent's name is not added in any
1499         case)
1500      */
1501     const wxString& GetBaseName() const { return m_name; }
1502
1503     /** Returns read-only reference to property's list of choices.
1504     */
1505     const wxPGChoices& GetChoices() const
1506     {
1507         return m_choices;
1508     }
1509
1510     /** Returns coordinate to the top y of the property. Note that the
1511         position of scrollbars is not taken into account.
1512     */
1513     int GetY() const;
1514
1515     wxVariant GetValue() const
1516     {
1517         return DoGetValue();
1518     }
1519
1520 #ifndef SWIG
1521     /** Returns reference to the internal stored value. GetValue is preferred
1522         way to get the actual value, since GetValueRef ignores DoGetValue,
1523         which may override stored value.
1524     */
1525     wxVariant& GetValueRef()
1526     {
1527         return m_value;
1528     }
1529
1530     const wxVariant& GetValueRef() const
1531     {
1532         return m_value;
1533     }
1534 #endif
1535
1536     /** Returns text representation of property's value.
1537
1538         @param argFlags
1539             If 0 (default value), then displayed string is returned.
1540             If wxPG_FULL_VALUE is set, returns complete, storable string value
1541             instead of displayable. If wxPG_EDITABLE_VALUE is set, returns
1542             string value that must be editable in textctrl. If
1543             wxPG_COMPOSITE_FRAGMENT is set, returns text that is appropriate to
1544             display as a part of string property's composite text
1545             representation.
1546
1547         @remarks In older versions, this function used to be overridden to convert
1548                  property's value into a string representation. This function is
1549                  now handled by ValueToString(), and overriding this function now
1550                  will result in run-time assertion failure.
1551     */
1552     virtual wxString GetValueAsString( int argFlags = 0 ) const;
1553
1554     /** Synonymous to GetValueAsString().
1555
1556         @deprecated Use GetValueAsString() instead.
1557
1558         @see GetValueAsString()
1559     */
1560     wxDEPRECATED( wxString GetValueString( int argFlags = 0 ) const );
1561
1562     /**
1563         Returns wxPGCell of given column.
1564     */
1565     const wxPGCell& GetCell( unsigned int column ) const;
1566
1567     wxPGCell& GetCell( unsigned int column );
1568
1569     /** Return number of displayed common values for this property.
1570     */
1571     int GetDisplayedCommonValueCount() const;
1572
1573     wxString GetDisplayedString() const
1574     {
1575         return GetValueAsString(0);
1576     }
1577
1578     /** Returns property grid where property lies. */
1579     wxPropertyGrid* GetGrid() const;
1580
1581     /** Returns owner wxPropertyGrid, but only if one is currently on a page
1582         displaying this property. */
1583     wxPropertyGrid* GetGridIfDisplayed() const;
1584
1585     /** Returns highest level non-category, non-root parent. Useful when you
1586         have nested wxCustomProperties/wxParentProperties.
1587         @remarks
1588         Thus, if immediate parent is root or category, this will return the
1589         property itself.
1590     */
1591     wxPGProperty* GetMainParent() const;
1592
1593     /** Return parent of property */
1594     wxPGProperty* GetParent() const { return m_parent; }
1595
1596     /** Returns true if property has editable wxTextCtrl when selected.
1597
1598         @remarks
1599         Altough disabled properties do not displayed editor, they still
1600         return True here as being disabled is considered a temporary
1601         condition (unlike being read-only or having limited editing enabled).
1602     */
1603     bool IsTextEditable() const;
1604
1605     bool IsValueUnspecified() const
1606     {
1607         return m_value.IsNull();
1608     }
1609
1610     FlagType HasFlag( FlagType flag ) const
1611     {
1612         return ( m_flags & flag );
1613     }
1614
1615     /** Returns comma-delimited string of property attributes.
1616     */
1617     const wxPGAttributeStorage& GetAttributes() const
1618     {
1619         return m_attributes;
1620     }
1621
1622     /** Returns m_attributes as list wxVariant.
1623     */
1624     wxVariant GetAttributesAsList() const;
1625
1626     FlagType GetFlags() const
1627     {
1628         return m_flags;
1629     }
1630
1631     const wxPGEditor* GetEditorClass() const;
1632
1633     wxString GetValueType() const
1634     {
1635         return m_value.GetType();
1636     }
1637
1638     /** Returns editor used for given column. NULL for no editor.
1639     */
1640     const wxPGEditor* GetColumnEditor( int column ) const
1641     {
1642         if ( column == 1 )
1643             return GetEditorClass();
1644
1645         return NULL;
1646     }
1647
1648     /** Returns common value selected for this property. -1 for none.
1649     */
1650     int GetCommonValue() const
1651     {
1652         return m_commonValue;
1653     }
1654
1655     /** Returns true if property has even one visible child.
1656     */
1657     bool HasVisibleChildren() const;
1658
1659     /** Inserts a new choice to property's list of choices.
1660     */
1661     int InsertChoice( const wxString& label, int index, int value = wxPG_INVALID_VALUE );
1662
1663     /**
1664         Returns true if this property is actually a wxPropertyCategory.
1665     */
1666     bool IsCategory() const { return HasFlag(wxPG_PROP_CATEGORY)?true:false; }
1667
1668     /** Returns true if this property is actually a wxRootProperty.
1669     */
1670     bool IsRoot() const { return (m_parent == NULL); }
1671
1672     /** Returns true if this is a sub-property. */
1673     bool IsSubProperty() const
1674     {
1675         wxPGProperty* parent = (wxPGProperty*)m_parent;
1676         if ( parent && !parent->IsCategory() )
1677             return true;
1678         return false;
1679     }
1680
1681     /** Returns last visible sub-property, recursively.
1682     */
1683     const wxPGProperty* GetLastVisibleSubItem() const;
1684
1685     wxVariant GetDefaultValue() const;
1686
1687     int GetMaxLength() const
1688     {
1689         return (int) m_maxLen;
1690     }
1691
1692     /**
1693         Determines, recursively, if all children are not unspecified.
1694
1695         @param pendingList
1696             Assumes members in this wxVariant list as pending
1697             replacement values.
1698     */
1699     bool AreAllChildrenSpecified( wxVariant* pendingList = NULL ) const;
1700
1701     /** Updates composed values of parent non-category properties, recursively.
1702         Returns topmost property updated.
1703
1704         @remarks
1705         - Must not call SetValue() (as can be called in it).
1706     */
1707     wxPGProperty* UpdateParentValues();
1708
1709     /** Returns true if containing grid uses wxPG_EX_AUTO_UNSPECIFIED_VALUES.
1710     */
1711     bool UsesAutoUnspecified() const
1712     {
1713         return HasFlag(wxPG_PROP_AUTO_UNSPECIFIED)?true:false;
1714     }
1715
1716     wxBitmap* GetValueImage() const
1717     {
1718         return m_valueBitmap;
1719     }
1720
1721     wxVariant GetAttribute( const wxString& name ) const;
1722
1723     /**
1724         Returns named attribute, as string, if found.
1725
1726         Otherwise defVal is returned.
1727     */
1728     wxString GetAttribute( const wxString& name, const wxString& defVal ) const;
1729
1730     /**
1731         Returns named attribute, as long, if found.
1732
1733         Otherwise defVal is returned.
1734     */
1735     long GetAttributeAsLong( const wxString& name, long defVal ) const;
1736
1737     /**
1738         Returns named attribute, as double, if found.
1739
1740         Otherwise defVal is returned.
1741     */
1742     double GetAttributeAsDouble( const wxString& name, double defVal ) const;
1743
1744     unsigned int GetDepth() const { return (unsigned int)m_depth; }
1745
1746     /** Gets flags as a'|' delimited string. Note that flag names are not
1747         prepended with 'wxPG_PROP_'.
1748         @param flagsMask
1749         String will only be made to include flags combined by this parameter.
1750     */
1751     wxString GetFlagsAsString( FlagType flagsMask ) const;
1752
1753     /** Returns position in parent's array. */
1754     unsigned int GetIndexInParent() const
1755     {
1756         return (unsigned int)m_arrIndex;
1757     }
1758
1759     /** Hides or reveals the property.
1760         @param hide
1761             true for hide, false for reveal.
1762         @param flags
1763             By default changes are applied recursively. Set this paramter
1764             wxPG_DONT_RECURSE to prevent this.
1765     */
1766     inline bool Hide( bool hide, int flags = wxPG_RECURSE );
1767
1768     bool IsExpanded() const
1769         { return (!(m_flags & wxPG_PROP_COLLAPSED) && GetChildCount()); }
1770
1771     /** Returns true if all parents expanded.
1772     */
1773     bool IsVisible() const;
1774
1775     bool IsEnabled() const { return !(m_flags & wxPG_PROP_DISABLED); }
1776
1777     /** If property's editor is created this forces its recreation.
1778         Useful in SetAttribute etc. Returns true if actually did anything.
1779     */
1780     bool RecreateEditor();
1781
1782     /** If property's editor is active, then update it's value.
1783     */
1784     void RefreshEditor();
1785
1786     /** Sets an attribute for this property.
1787         @param name
1788         Text identifier of attribute. See @ref propgrid_property_attributes.
1789         @param value
1790         Value of attribute.
1791     */
1792     void SetAttribute( const wxString& name, wxVariant value );
1793
1794     void SetAttributes( const wxPGAttributeStorage& attributes );
1795
1796     /**
1797         Sets property's background colour.
1798
1799         @param colour
1800             Background colour to use.
1801
1802         @param recursively
1803             If @true, children are affected recursively, and any categories
1804             are not.
1805     */
1806     void SetBackgroundColour( const wxColour& colour,
1807                               bool recursively = false );
1808
1809     /**
1810         Sets property's text colour.
1811
1812         @param colour
1813             Text colour to use.
1814
1815         @param recursively
1816             If @true, children are affected recursively, and any categories
1817             are not.
1818     */
1819     void SetTextColour( const wxColour& colour,
1820                         bool recursively = false );
1821
1822 #ifndef SWIG
1823     /** Sets editor for a property.
1824
1825         @param editor
1826             For builtin editors, use wxPGEditor_X, where X is builtin editor's
1827             name (TextCtrl, Choice, etc. see wxPGEditor documentation for full
1828             list).
1829
1830         For custom editors, use pointer you received from
1831         wxPropertyGrid::RegisterEditorClass().
1832     */
1833     void SetEditor( const wxPGEditor* editor )
1834     {
1835         m_customEditor = editor;
1836     }
1837 #endif
1838
1839     /** Sets editor for a property.
1840     */
1841     inline void SetEditor( const wxString& editorName );
1842
1843     /**
1844         Sets cell information for given column.
1845     */
1846     void SetCell( int column, const wxPGCell& cell );
1847
1848     /** Sets common value selected for this property. -1 for none.
1849     */
1850     void SetCommonValue( int commonValue )
1851     {
1852         m_commonValue = commonValue;
1853     }
1854
1855     /** Sets flags from a '|' delimited string. Note that flag names are not
1856         prepended with 'wxPG_PROP_'.
1857     */
1858     void SetFlagsFromString( const wxString& str );
1859
1860     /** Sets property's "is it modified?" flag. Affects children recursively.
1861     */
1862     void SetModifiedStatus( bool modified )
1863     {
1864         SetFlagRecursively(wxPG_PROP_MODIFIED, modified);
1865     }
1866
1867     /** Call in OnEvent(), OnButtonClick() etc. to change the property value
1868         based on user input.
1869
1870         @remarks
1871         This method is const since it doesn't actually modify value, but posts
1872         given variant as pending value, stored in wxPropertyGrid.
1873     */
1874     void SetValueInEvent( wxVariant value ) const;
1875
1876     /**
1877         Call this to set value of the property.
1878
1879         Unlike methods in wxPropertyGrid, this does not automatically update
1880         the display.
1881
1882         @remarks
1883         Use wxPropertyGrid::ChangePropertyValue() instead if you need to run
1884         through validation process and send property change event.
1885
1886         If you need to change property value in event, based on user input, use
1887         SetValueInEvent() instead.
1888
1889         @param pList
1890         Pointer to list variant that contains child values. Used to indicate
1891         which children should be marked as modified.
1892         @param flags
1893         Various flags (for instance, wxPG_SETVAL_REFRESH_EDITOR).
1894     */
1895     void SetValue( wxVariant value, wxVariant* pList = NULL, int flags = 0 );
1896
1897     /** Set wxBitmap in front of the value. This bitmap may be ignored
1898         by custom cell renderers.
1899     */
1900     void SetValueImage( wxBitmap& bmp );
1901
1902     /** If property has choices and they are not yet exclusive, new such copy
1903         of them will be created.
1904     */
1905     void SetChoicesExclusive()
1906     {
1907         m_choices.SetExclusive();
1908     }
1909
1910     /** Sets selected choice and changes property value.
1911
1912         Tries to retain value type, although currently if it is not string,
1913         then it is forced to integer.
1914     */
1915     void SetChoiceSelection( int newValue );
1916
1917     void SetExpanded( bool expanded )
1918     {
1919         if ( !expanded ) m_flags |= wxPG_PROP_COLLAPSED;
1920         else m_flags &= ~wxPG_PROP_COLLAPSED;
1921     }
1922
1923     void SetFlag( FlagType flag ) { m_flags |= flag; }
1924
1925     void SetFlagRecursively( FlagType flag, bool set );
1926
1927     void SetHelpString( const wxString& helpString )
1928     {
1929         m_helpString = helpString;
1930     }
1931
1932     void SetLabel( const wxString& label ) { m_label = label; }
1933
1934     inline void SetName( const wxString& newName );
1935
1936     /**
1937         Changes what sort of parent this property is for its children.
1938
1939         @param flag
1940             Use one of the following values: wxPG_PROP_MISC_PARENT (for generic
1941             parents), wxPG_PROP_CATEGORY (for categories), or
1942             wxPG_PROP_AGGREGATE (for derived property classes with private
1943             children).
1944
1945         @remarks You only need to call this if you use AddChild() to add
1946                  child properties. Adding properties with
1947                  wxPropertyGridInterface::Insert() or
1948                  wxPropertyGridInterface::AppendIn() will automatically set
1949                  property to use wxPG_PROP_MISC_PARENT style.
1950     */
1951     void SetParentalType( int flag )
1952     {
1953         m_flags &= ~(wxPG_PROP_PROPERTY|wxPG_PROP_PARENTAL_FLAGS);
1954         m_flags |= flag;
1955     }
1956
1957     void SetValueToUnspecified()
1958     {
1959         wxVariant val;  // Create NULL variant
1960         SetValue(val);
1961     }
1962
1963 #if wxUSE_VALIDATORS
1964     /** Sets wxValidator for a property*/
1965     void SetValidator( const wxValidator& validator )
1966     {
1967         m_validator = wxDynamicCast(validator.Clone(),wxValidator);
1968     }
1969
1970     /** Gets assignable version of property's validator. */
1971     wxValidator* GetValidator() const
1972     {
1973         if ( m_validator )
1974             return m_validator;
1975         return DoGetValidator();
1976     }
1977 #endif // #if wxUSE_VALIDATORS
1978
1979 #ifndef SWIG
1980     /** Returns client data (void*) of a property.
1981     */
1982     void* GetClientData() const
1983     {
1984         return m_clientData;
1985     }
1986
1987     /** Sets client data (void*) of a property.
1988         @remarks
1989         This untyped client data has to be deleted manually.
1990     */
1991     void SetClientData( void* clientData )
1992     {
1993         m_clientData = clientData;
1994     }
1995
1996     /** Returns client object of a property.
1997     */
1998     void SetClientObject(wxClientData* clientObject)
1999     {
2000         delete m_clientObject;
2001         m_clientObject = clientObject;
2002     }
2003
2004     /** Sets managed client object of a property.
2005     */
2006     wxClientData *GetClientObject() const { return m_clientObject; }
2007 #endif
2008
2009     /** Sets new set of choices for property.
2010
2011         @remarks
2012         This operation clears the property value.
2013     */
2014     bool SetChoices( wxPGChoices& choices );
2015
2016     /** Set max length of text in text editor.
2017     */
2018     inline bool SetMaxLength( int maxLen );
2019
2020     /** Call with 'false' in OnSetValue to cancel value changes after all
2021         (ie. cancel 'true' returned by StringToValue() or IntToValue()).
2022     */
2023     void SetWasModified( bool set = true )
2024     {
2025         if ( set ) m_flags |= wxPG_PROP_WAS_MODIFIED;
2026         else m_flags &= ~wxPG_PROP_WAS_MODIFIED;
2027     }
2028
2029     const wxString& GetHelpString() const
2030     {
2031         return m_helpString;
2032     }
2033
2034     void ClearFlag( FlagType flag ) { m_flags &= ~(flag); }
2035
2036     // Use, for example, to detect if item is inside collapsed section.
2037     bool IsSomeParent( wxPGProperty* candidate_parent ) const;
2038
2039     /**
2040         Adapts list variant into proper value using consecutive
2041         ChildChanged-calls.
2042     */
2043     void AdaptListToValue( wxVariant& list, wxVariant* value ) const;
2044
2045     /**
2046         Adds a child property. If you use this instead of
2047         wxPropertyGridInterface::Insert() or
2048         wxPropertyGridInterface::AppendIn(), then you must set up
2049         property's parental type before making the call. To do this,
2050         call property's SetParentalType() function with either
2051         wxPG_PROP_MISC_PARENT (normal, public children) or with
2052         wxPG_PROP_AGGREGATE (private children for subclassed property).
2053         For instance:
2054
2055         @code
2056             wxPGProperty* prop = new wxStringProperty(wxS("Property"));
2057             prop->SetParentalType(wxPG_PROP_MISC_PARENT);
2058             wxPGProperty* prop2 = new wxStringProperty(wxS("Property2"));
2059             prop->AddChild(prop2);
2060         @endcode
2061     */
2062     void AddChild( wxPGProperty* prop );
2063
2064     /** Returns height of children, recursively, and
2065         by taking expanded/collapsed status into account.
2066
2067         iMax is used when finding property y-positions.
2068     */
2069     int GetChildrenHeight( int lh, int iMax = -1 ) const;
2070
2071     /** Returns number of child properties */
2072     unsigned int GetChildCount() const
2073     {
2074         return (unsigned int) m_children.size();
2075     }
2076
2077     /** Returns sub-property at index i. */
2078     wxPGProperty* Item( unsigned int i ) const
2079         { return m_children[i]; }
2080
2081     /** Returns last sub-property.
2082     */
2083     wxPGProperty* Last() const { return m_children.back(); }
2084
2085     /** Returns index of given child property. */
2086     int Index( const wxPGProperty* p ) const;
2087
2088     // Puts correct indexes to children
2089     void FixIndicesOfChildren( unsigned int starthere = 0 );
2090
2091 #ifndef SWIG
2092     // Returns wxPropertyGridPageState in which this property resides.
2093     wxPropertyGridPageState* GetParentState() const { return m_parentState; }
2094 #endif
2095
2096     wxPGProperty* GetItemAtY( unsigned int y,
2097                               unsigned int lh,
2098                               unsigned int* nextItemY ) const;
2099
2100     /** Returns (direct) child property with given name (or NULL if not found).
2101     */
2102     wxPGProperty* GetPropertyByName( const wxString& name ) const;
2103
2104 #ifdef SWIG
2105      %extend {
2106         DocStr(GetClientData,
2107                "Returns the client data object for a property", "");
2108         PyObject* GetClientData() {
2109             wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
2110             if (data) {
2111                 Py_INCREF(data->m_obj);
2112                 return data->m_obj;
2113             } else {
2114                 Py_INCREF(Py_None);
2115                 return Py_None;
2116             }
2117         }
2118
2119         DocStr(SetClientData,
2120                "Associate the given client data.", "");
2121         void SetClientData(PyObject* clientData) {
2122             wxPyClientData* data = new wxPyClientData(clientData);
2123             self->SetClientObject(data);
2124         }
2125     }
2126     %pythoncode {
2127          GetClientObject = GetClientData
2128          SetClientObject = SetClientData
2129     }
2130 #endif
2131
2132 #ifndef SWIG
2133
2134     // Returns various display-related information for given column
2135     void GetDisplayInfo( unsigned int column,
2136                          int choiceIndex,
2137                          int flags,
2138                          wxString* pString,
2139                          const wxPGCell** pCell );
2140
2141     static wxString*            sm_wxPG_LABEL;
2142
2143     /** This member is public so scripting language bindings
2144         wrapper code can access it freely.
2145     */
2146     void*                       m_clientData;
2147
2148 protected:
2149
2150     /**
2151         Sets property cell in fashion that reduces number of exclusive
2152         copies of cell data. Used when setting, for instance, same
2153         background colour for a number of properties.
2154
2155         @param firstCol
2156             First column to affect.
2157
2158         @param lastCol
2159             Last column to affect.
2160
2161         @param preparedCell
2162             Pre-prepared cell that is used for those which cell data
2163             before this matched unmodCellData.
2164
2165         @param srcData
2166             If unmodCellData did not match, valid cell data from this
2167             is merged into cell (usually generating new exclusive copy
2168             of cell's data).
2169
2170         @param unmodCellData
2171             If cell's cell data matches this, its cell is now set to
2172             preparedCell.
2173
2174         @param ignoreWithFlags
2175             Properties with any one of these flags are skipped.
2176
2177         @param recursively
2178             If @true, apply this operation recursively in child properties.
2179     */
2180     void AdaptiveSetCell( unsigned int firstCol,
2181                           unsigned int lastCol,
2182                           const wxPGCell& preparedCell,
2183                           const wxPGCell& srcData,
2184                           wxPGCellData* unmodCellData,
2185                           FlagType ignoreWithFlags,
2186                           bool recursively );
2187
2188     /**
2189         Makes sure m_cells has size of column+1 (or more).
2190     */
2191     void EnsureCells( unsigned int column );
2192
2193     /** Returns (direct) child property with given name (or NULL if not found),
2194         with hint index.
2195
2196         @param hintIndex
2197         Start looking for the child at this index.
2198
2199         @remarks
2200         Does not support scope (ie. Parent.Child notation).
2201     */
2202     wxPGProperty* GetPropertyByNameWH( const wxString& name,
2203                                        unsigned int hintIndex ) const;
2204
2205     /** This is used by Insert etc. */
2206     void AddChild2( wxPGProperty* prop,
2207                     int index = -1,
2208                     bool correct_mode = true );
2209
2210     void DoGenerateComposedValue( wxString& text,
2211                                   int argFlags = wxPG_VALUE_IS_CURRENT,
2212                                   const wxVariantList* valueOverrides = NULL,
2213                                   wxPGHashMapS2S* childResults = NULL ) const;
2214
2215     void DoSetName(const wxString& str) { m_name = str; }
2216
2217     /** Deletes all sub-properties. */
2218     void Empty();
2219
2220     void InitAfterAdded( wxPropertyGridPageState* pageState,
2221                          wxPropertyGrid* propgrid );
2222
2223     // Removes child property with given pointer. Does not delete it.
2224     void RemoveChild( wxPGProperty* p );
2225
2226     void SetParentState( wxPropertyGridPageState* pstate )
2227         { m_parentState = pstate; }
2228
2229     // Call after fixed sub-properties added/removed after creation.
2230     // if oldSelInd >= 0 and < new max items, then selection is
2231     // moved to it.
2232     void SubPropsChanged( int oldSelInd = -1 );
2233
2234     int GetY2( int lh ) const;
2235
2236     wxString                    m_label;
2237     wxString                    m_name;
2238     wxPGProperty*               m_parent;
2239     wxPropertyGridPageState*    m_parentState;
2240
2241     wxClientData*               m_clientObject;
2242
2243     // Overrides editor returned by property class
2244     const wxPGEditor*           m_customEditor;
2245 #if wxUSE_VALIDATORS
2246     // Editor is going to get this validator
2247     wxValidator*                m_validator;
2248 #endif
2249     // Show this in front of the value
2250     //
2251     // TODO: Can bitmap be implemented with wxPGCell?
2252     wxBitmap*                   m_valueBitmap;
2253
2254     wxVariant                   m_value;
2255     wxPGAttributeStorage        m_attributes;
2256     wxArrayPGProperty           m_children;
2257
2258     // Extended cell information
2259     wxVector<wxPGCell>          m_cells;
2260
2261     // Choices shown in drop-down list of editor control.
2262     wxPGChoices                 m_choices;
2263
2264     // Help shown in statusbar or help box.
2265     wxString                    m_helpString;
2266
2267     // Index in parent's property array.
2268     unsigned int                m_arrIndex;
2269
2270     // If not -1, then overrides m_value
2271     int                         m_commonValue;
2272
2273     FlagType                    m_flags;
2274
2275     // Maximum length (mainly for string properties). Could be in some sort of
2276     // wxBaseStringProperty, but currently, for maximum flexibility and
2277     // compatibility, we'll stick it here. Anyway, we had 3 excess bytes to use
2278     // so short int will fit in just fine.
2279     short                       m_maxLen;
2280
2281     // Root has 0, categories etc. at that level 1, etc.
2282     unsigned char               m_depth;
2283
2284     // m_depthBgCol indicates width of background colour between margin and item
2285     // (essentially this is category's depth, if none then equals m_depth).
2286     unsigned char               m_depthBgCol;
2287
2288 private:
2289     // Called in constructors.
2290     void Init();
2291     void Init( const wxString& label, const wxString& name );
2292 #endif // #ifndef SWIG
2293 };
2294
2295 // -----------------------------------------------------------------------
2296
2297 //
2298 // Property class declaration helper macros
2299 // (wxPGRootPropertyClass and wxPropertyCategory require this).
2300 //
2301
2302 #define WX_PG_DECLARE_DOGETEDITORCLASS \
2303     virtual const wxPGEditor* DoGetEditorClass() const;
2304
2305 #ifndef SWIG
2306     #define WX_PG_DECLARE_PROPERTY_CLASS(CLASSNAME) \
2307         public: \
2308             DECLARE_DYNAMIC_CLASS(CLASSNAME) \
2309             WX_PG_DECLARE_DOGETEDITORCLASS \
2310         private:
2311 #else
2312     #define WX_PG_DECLARE_PROPERTY_CLASS(CLASSNAME)
2313 #endif
2314
2315 // Implements sans constructor function. Also, first arg is class name, not
2316 // property name.
2317 #define WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(PROPNAME,T,EDITOR) \
2318 const wxPGEditor* PROPNAME::DoGetEditorClass() const \
2319 { \
2320     return wxPGEditor_##EDITOR; \
2321 }
2322
2323 // -----------------------------------------------------------------------
2324
2325 #ifndef SWIG
2326
2327 /** @class wxPGRootProperty
2328     @ingroup classes
2329     Root parent property.
2330 */
2331 class WXDLLIMPEXP_PROPGRID wxPGRootProperty : public wxPGProperty
2332 {
2333 public:
2334     WX_PG_DECLARE_PROPERTY_CLASS(wxPGRootProperty)
2335 public:
2336
2337     /** Constructor. */
2338     wxPGRootProperty();
2339     virtual ~wxPGRootProperty();
2340
2341     virtual bool StringToValue( wxVariant&, const wxString&, int ) const
2342     {
2343         return false;
2344     }
2345
2346 protected:
2347 };
2348
2349 // -----------------------------------------------------------------------
2350
2351 /** @class wxPropertyCategory
2352     @ingroup classes
2353     Category (caption) property.
2354 */
2355 class WXDLLIMPEXP_PROPGRID wxPropertyCategory : public wxPGProperty
2356 {
2357     friend class wxPropertyGrid;
2358     friend class wxPropertyGridPageState;
2359     WX_PG_DECLARE_PROPERTY_CLASS(wxPropertyCategory)
2360 public:
2361
2362     /** Default constructor is only used in special cases. */
2363     wxPropertyCategory();
2364
2365     wxPropertyCategory( const wxString& label,
2366                         const wxString& name = wxPG_LABEL );
2367     ~wxPropertyCategory();
2368
2369     int GetTextExtent( const wxWindow* wnd, const wxFont& font ) const;
2370
2371     virtual wxString ValueToString( wxVariant& value, int argFlags ) const;
2372
2373 protected:
2374     void SetTextColIndex( unsigned int colInd )
2375         { m_capFgColIndex = (wxByte) colInd; }
2376     unsigned int GetTextColIndex() const
2377         { return (unsigned int) m_capFgColIndex; }
2378
2379     void CalculateTextExtent( wxWindow* wnd, const wxFont& font );
2380
2381     int     m_textExtent;  // pre-calculated length of text
2382     wxByte  m_capFgColIndex;  // caption text colour index
2383
2384 private:
2385     void Init();
2386 };
2387
2388 #endif  // !SWIG
2389
2390 // -----------------------------------------------------------------------
2391
2392 #endif // wxUSE_PROPGRID
2393
2394 #endif // _WX_PROPGRID_PROPERTY_H_