include/wx/propgrid/propgridpagestate.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/propgrid/propgridpagestate.h
   3 // Purpose:     wxPropertyGridPageState class
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2008-08-24
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Jaakko Salli
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_PROPGRID_PROPGRIDPAGESTATE_H_
  13 #define _WX_PROPGRID_PROPGRIDPAGESTATE_H_
  14
  15 #if wxUSE_PROPGRID
  16
  17 #include "wx/propgrid/property.h"
  18
  19 // -----------------------------------------------------------------------
  20
  21 /** @section propgrid_hittestresult wxPropertyGridHitTestResult
  22
  23     A return value from wxPropertyGrid::HitTest(),
  24     contains all you need to know about an arbitrary location on the grid.
  25 */
  26 struct WXDLLIMPEXP_PROPGRID wxPropertyGridHitTestResult
  27 {
  28     friend class wxPropertyGridPageState;
  29 public:
  30
  31     wxPGProperty* GetProperty() const { return property; }
  32
  33     /** Column. -1 for margin. */
  34     int             column;
  35
  36     /** Index of splitter hit, -1 for none. */
  37     int             splitter;
  38
  39     /** If splitter hit, offset to that */
  40     int             splitterHitOffset;
  41
  42 private:
  43     /** Property. NULL if empty space below properties was hit */
  44     wxPGProperty*   property;
  45 };
  46
  47 // -----------------------------------------------------------------------
  48
  49 #define wxPG_IT_CHILDREN(A)         ((A)<<16)
  50
  51 /** @section propgrid_iterator_flags wxPropertyGridIterator Flags
  52     @{
  53
  54     NOTES: At lower 16-bits, there are flags to check if item will be included.
  55     At higher 16-bits, there are same flags, but to instead check if children
  56     will be included.
  57 */
  58
  59 enum wxPG_ITERATOR_FLAGS
  60 {
  61
  62 /**
  63     Iterate through 'normal' property items (does not include children of
  64     aggregate or hidden items by default).
  65 */
  66 wxPG_ITERATE_PROPERTIES = wxPG_PROP_PROPERTY |
  67                           wxPG_PROP_MISC_PARENT |
  68                           wxPG_PROP_AGGREGATE |
  69                           wxPG_PROP_COLLAPSED |
  70                           wxPG_IT_CHILDREN(wxPG_PROP_MISC_PARENT) |
  71                           wxPG_IT_CHILDREN(wxPG_PROP_CATEGORY),
  72
  73 /** Iterate children of collapsed parents, and individual items that are hidden.
  74 */
  75 wxPG_ITERATE_HIDDEN = wxPG_PROP_HIDDEN |
  76                       wxPG_IT_CHILDREN(wxPG_PROP_COLLAPSED),
  77
  78 /**
  79     Iterate children of parent that is an aggregate property (ie has fixed
  80     children).
  81 */
  82 wxPG_ITERATE_FIXED_CHILDREN = wxPG_IT_CHILDREN(wxPG_PROP_AGGREGATE) |
  83                               wxPG_ITERATE_PROPERTIES,
  84
  85 /** Iterate categories.
  86     Note that even without this flag, children of categories are still iterated
  87     through.
  88 */
  89 wxPG_ITERATE_CATEGORIES = wxPG_PROP_CATEGORY |
  90                           wxPG_IT_CHILDREN(wxPG_PROP_CATEGORY) |
  91                           wxPG_PROP_COLLAPSED,
  92
  93 wxPG_ITERATE_ALL_PARENTS = wxPG_PROP_MISC_PARENT |
  94                            wxPG_PROP_AGGREGATE |
  95                            wxPG_PROP_CATEGORY,
  96
  97 wxPG_ITERATE_ALL_PARENTS_RECURSIVELY = wxPG_ITERATE_ALL_PARENTS |
  98                                        wxPG_IT_CHILDREN(
  99                                                 wxPG_ITERATE_ALL_PARENTS),
 100
 101 wxPG_ITERATOR_FLAGS_ALL = wxPG_PROP_PROPERTY |
 102                           wxPG_PROP_MISC_PARENT |
 103                           wxPG_PROP_AGGREGATE |
 104                           wxPG_PROP_HIDDEN |
 105                           wxPG_PROP_CATEGORY |
 106                           wxPG_PROP_COLLAPSED,
 107
 108 wxPG_ITERATOR_MASK_OP_ITEM = wxPG_ITERATOR_FLAGS_ALL,
 109
 110 // (wxPG_PROP_MISC_PARENT|wxPG_PROP_AGGREGATE|wxPG_PROP_CATEGORY)
 111 wxPG_ITERATOR_MASK_OP_PARENT = wxPG_ITERATOR_FLAGS_ALL,
 112
 113 /** Combines all flags needed to iterate through visible properties
 114     (ie hidden properties and children of collapsed parents are skipped).
 115 */
 116 wxPG_ITERATE_VISIBLE = wxPG_ITERATE_PROPERTIES |
 117                        wxPG_PROP_CATEGORY |
 118                        wxPG_IT_CHILDREN(wxPG_PROP_AGGREGATE),
 119
 120 /** Iterate all items.
 121 */
 122 wxPG_ITERATE_ALL = wxPG_ITERATE_VISIBLE |
 123                    wxPG_ITERATE_HIDDEN,
 124
 125 /** Iterate through individual properties (ie categories and children of
 126     aggregate properties are skipped).
 127 */
 128 wxPG_ITERATE_NORMAL = wxPG_ITERATE_PROPERTIES |
 129                       wxPG_ITERATE_HIDDEN,
 130
 131 /** Default iterator flags.
 132 */
 133 wxPG_ITERATE_DEFAULT = wxPG_ITERATE_NORMAL
 134
 135 };
 136
 137 /** @}
 138 */
 139
 140
 141 #define wxPG_ITERATOR_CREATE_MASKS(FLAGS, A, B) \
 142     A = (FLAGS ^ wxPG_ITERATOR_MASK_OP_ITEM) & \
 143         wxPG_ITERATOR_MASK_OP_ITEM & 0xFFFF; \
 144     B = ((FLAGS>>16) ^ wxPG_ITERATOR_MASK_OP_PARENT) & \
 145         wxPG_ITERATOR_MASK_OP_PARENT & 0xFFFF;
 146
 147
 148 // Macro to test if children of PWC should be iterated through
 149 #define wxPG_ITERATOR_PARENTEXMASK_TEST(PWC, PARENTMASK) \
 150         ( \
 151         !(PWC->GetFlags() & PARENTMASK) && \
 152         PWC->GetChildCount() \
 153         )
 154
 155
 156 // Base for wxPropertyGridIterator classes.
 157 class WXDLLIMPEXP_PROPGRID wxPropertyGridIteratorBase
 158 {
 159 public:
 160     wxPropertyGridIteratorBase()
 161     {
 162     }
 163
 164     void Assign( const wxPropertyGridIteratorBase& it );
 165
 166     bool AtEnd() const { return m_property == NULL; }
 167
 168     /** Get current property.
 169     */
 170     wxPGProperty* GetProperty() const { return m_property; }
 171
 172     void Init( wxPropertyGridPageState* state,
 173                int flags,
 174                wxPGProperty* property,
 175                int dir = 1 );
 176
 177     void Init( wxPropertyGridPageState* state,
 178                int flags,
 179                int startPos = wxTOP,
 180                int dir = 0 );
 181
 182     /** Iterate to the next property.
 183     */
 184     void Next( bool iterateChildren = true );
 185
 186     /** Iterate to the previous property.
 187     */
 188     void Prev();
 189
 190     /**
 191         Set base parent, ie a property when, in which iteration returns, it
 192         ends.
 193
 194         Default base parent is the root of the used wxPropertyGridPageState.
 195     */
 196     void SetBaseParent( wxPGProperty* baseParent )
 197         { m_baseParent = baseParent; }
 198
 199 protected:
 200
 201     wxPGProperty*               m_property;
 202
 203 private:
 204     wxPropertyGridPageState*        m_state;
 205     wxPGProperty*               m_baseParent;
 206
 207     // Masks are used to quickly exclude items
 208     int                         m_itemExMask;
 209     int                         m_parentExMask;
 210 };
 211
 212
 213 #define wxPG_IMPLEMENT_ITERATOR(CLASS, PROPERTY, STATE) \
 214     CLASS( STATE* state, int flags = wxPG_ITERATE_DEFAULT, \
 215            PROPERTY* property = NULL, int dir = 1 ) \
 216         : wxPropertyGridIteratorBase() \
 217         { Init( (wxPropertyGridPageState*)state, flags, \
 218                 (wxPGProperty*)property, dir ); } \
 219     CLASS( STATE* state, int flags, int startPos, int dir = 0 ) \
 220         : wxPropertyGridIteratorBase() \
 221         { Init( (wxPropertyGridPageState*)state, flags, startPos, dir ); } \
 222     CLASS() \
 223         : wxPropertyGridIteratorBase() \
 224     { \
 225         m_property = NULL; \
 226     } \
 227     CLASS( const CLASS& it ) \
 228         : wxPropertyGridIteratorBase( ) \
 229     { \
 230         Assign(it); \
 231     } \
 232     ~CLASS() \
 233     { \
 234     } \
 235     const CLASS& operator=( const CLASS& it ) \
 236     { \
 237         Assign(it); \
 238         return *this; \
 239     } \
 240     CLASS& operator++() { Next(); return *this; } \
 241     CLASS operator++(int) { CLASS it=*this;Next();return it; } \
 242     CLASS& operator--() { Prev(); return *this; } \
 243     CLASS operator--(int) { CLASS it=*this;Prev();return it; } \
 244     PROPERTY* operator *() const { return (PROPERTY*)m_property; } \
 245     static PROPERTY* OneStep( STATE* state, \
 246                               int flags = wxPG_ITERATE_DEFAULT, \
 247                               PROPERTY* property = NULL, \
 248                               int dir = 1 ) \
 249     { \
 250         CLASS it( state, flags, property, dir ); \
 251         if ( property ) \
 252         { \
 253             if ( dir == 1 ) it.Next(); \
 254             else it.Prev(); \
 255         } \
 256         return *it; \
 257     }
 258
 259
 260 /** @class wxPropertyGridIterator
 261
 262     Preferable way to iterate through contents of wxPropertyGrid,
 263     wxPropertyGridManager, and wxPropertyGridPage.
 264
 265     See wxPropertyGridInterface::GetIterator() for more information about usage.
 266
 267     @library{wxpropgrid}
 268     @category{propgrid}
 269 */
 270 class WXDLLIMPEXP_PROPGRID
 271     wxPropertyGridIterator : public wxPropertyGridIteratorBase
 272 {
 273 public:
 274
 275     wxPG_IMPLEMENT_ITERATOR(wxPropertyGridIterator,
 276                             wxPGProperty,
 277                             wxPropertyGridPageState)
 278
 279 protected:
 280 };
 281
 282
 283 // Const version of wxPropertyGridIterator.
 284 class WXDLLIMPEXP_PROPGRID
 285     wxPropertyGridConstIterator : public wxPropertyGridIteratorBase
 286 {
 287 public:
 288     wxPG_IMPLEMENT_ITERATOR(wxPropertyGridConstIterator,
 289                             const wxPGProperty,
 290                             const wxPropertyGridPageState)
 291
 292     /**
 293         Additional copy constructor.
 294     */
 295     wxPropertyGridConstIterator( const wxPropertyGridIterator& other )
 296     {
 297         Assign(other);
 298     }
 299
 300 protected:
 301 };
 302
 303 // -----------------------------------------------------------------------
 304
 305 /** Base class to derive new viterators.
 306 */
 307 class WXDLLIMPEXP_PROPGRID wxPGVIteratorBase
 308 {
 309     friend class wxPGVIterator;
 310 public:
 311     wxPGVIteratorBase() { m_refCount = 1; }
 312     virtual void Next() = 0;
 313     void IncRef()
 314     {
 315         m_refCount++;
 316     }
 317     void DecRef()
 318     {
 319         m_refCount--;
 320         if ( m_refCount <= 0 )
 321             delete this;
 322     }
 323 protected:
 324     virtual ~wxPGVIteratorBase() { }
 325
 326     wxPropertyGridIterator  m_it;
 327 private:
 328     int     m_refCount;
 329 };
 330
 331 /** @class wxPGVIterator
 332
 333     Abstract implementation of a simple iterator. Can only be used
 334     to iterate in forward order, and only through the entire container.
 335     Used to have functions dealing with all properties work with both
 336     wxPropertyGrid and wxPropertyGridManager.
 337 */
 338 class WXDLLIMPEXP_PROPGRID wxPGVIterator
 339 {
 340 public:
 341     wxPGVIterator() { m_pIt = NULL; }
 342     wxPGVIterator( wxPGVIteratorBase* obj ) { m_pIt = obj; }
 343     ~wxPGVIterator() { UnRef(); }
 344     void UnRef() { if (m_pIt) m_pIt->DecRef(); }
 345     wxPGVIterator( const wxPGVIterator& it )
 346     {
 347         m_pIt = it.m_pIt;
 348         m_pIt->IncRef();
 349     }
 350 #ifndef SWIG
 351     const wxPGVIterator& operator=( const wxPGVIterator& it )
 352     {
 353         UnRef();
 354         m_pIt = it.m_pIt;
 355         m_pIt->IncRef();
 356         return *this;
 357     }
 358 #endif
 359     void Next() { m_pIt->Next(); }
 360     bool AtEnd() const { return m_pIt->m_it.AtEnd(); }
 361     wxPGProperty* GetProperty() const { return m_pIt->m_it.GetProperty(); }
 362 protected:
 363     wxPGVIteratorBase*  m_pIt;
 364 };
 365
 366 // -----------------------------------------------------------------------
 367
 368 #ifndef SWIG
 369 // We won't need this class from wxPython
 370
 371 /** @class wxPropertyGridPageState
 372
 373     Contains low-level property page information (properties, column widths,
 374     etc) of a single wxPropertyGrid or single wxPropertyGridPage. Generally you
 375     should not use this class directly, but instead member functions in
 376     wxPropertyGridInterface, wxPropertyGrid, wxPropertyGridPage, and
 377     wxPropertyGridManager.
 378
 379     @remarks
 380     - In separate wxPropertyGrid component this class was known as
 381     wxPropertyGridState.
 382     - Currently this class is not implemented in wxPython.
 383
 384     @library{wxpropgrid}
 385     @category{propgrid}
 386 */
 387 class WXDLLIMPEXP_PROPGRID wxPropertyGridPageState
 388 {
 389     friend class wxPGProperty;
 390     friend class wxPropertyGrid;
 391     friend class wxPGCanvas;
 392     friend class wxPropertyGridInterface;
 393     friend class wxPropertyGridPage;
 394     friend class wxPropertyGridManager;
 395 public:
 396
 397     /** Default constructor. */
 398     wxPropertyGridPageState();
 399
 400     /** Destructor. */
 401     virtual ~wxPropertyGridPageState();
 402
 403     /** Makes sure all columns have minimum width.
 404     */
 405     void CheckColumnWidths( int widthChange = 0 );
 406
 407     /**
 408         Override this member function to add custom behavior on property
 409         deletion.
 410     */
 411     virtual void DoDelete( wxPGProperty* item );
 412
 413     wxSize DoFitColumns( bool allowGridResize = false );
 414
 415     wxPGProperty* DoGetItemAtY( int y ) const;
 416
 417     /**
 418         Override this member function to add custom behavior on property
 419         insertion.
 420     */
 421     virtual wxPGProperty* DoInsert( wxPGProperty* parent,
 422                                     int index,
 423                                     wxPGProperty* property );
 424
 425     /**
 426         This needs to be overridden in grid used the manager so that splitter
 427         changes can be propagated to other pages.
 428     */
 429     virtual void DoSetSplitterPosition( int pos,
 430                                         int splitterColumn = 0,
 431                                         bool allPages = false,
 432                                         bool fromAutoCenter = false );
 433
 434     bool EnableCategories( bool enable );
 435
 436     /** Make sure virtual height is up-to-date.
 437     */
 438     void EnsureVirtualHeight()
 439     {
 440         if ( m_vhCalcPending )
 441         {
 442             RecalculateVirtualHeight();
 443             m_vhCalcPending = 0;
 444         }
 445     }
 446
 447     /** Enables or disables given property and its subproperties. */
 448     bool DoEnableProperty( wxPGProperty* p, bool enable );
 449
 450     /** Returns (precalculated) height of contained visible properties.
 451     */
 452     unsigned int GetVirtualHeight() const
 453     {
 454         wxASSERT( !m_vhCalcPending );
 455         return m_virtualHeight;
 456     }
 457
 458     /** Returns (precalculated) height of contained visible properties.
 459     */
 460     unsigned int GetVirtualHeight()
 461     {
 462         EnsureVirtualHeight();
 463         return m_virtualHeight;
 464     }
 465
 466     /** Returns actual height of contained visible properties.
 467         @remarks
 468         Mostly used for internal diagnostic purposes.
 469     */
 470     inline unsigned int GetActualVirtualHeight() const;
 471
 472     unsigned int GetColumnCount() const
 473     {
 474         return (unsigned int) m_colWidths.size();
 475     }
 476
 477     wxPGProperty* GetSelection() const
 478     {
 479         return m_selected;
 480     }
 481
 482     int GetColumnMinWidth( int column ) const;
 483
 484     int GetColumnWidth( unsigned int column ) const
 485     {
 486         return m_colWidths[column];
 487     }
 488
 489     wxPropertyGrid* GetGrid() const { return m_pPropGrid; }
 490
 491     /** Returns last item which could be iterated using given flags.
 492         @param flags
 493         @link iteratorflags List of iterator flags@endlink
 494     */
 495     wxPGProperty* GetLastItem( int flags = wxPG_ITERATE_DEFAULT );
 496
 497     const wxPGProperty* GetLastItem( int flags = wxPG_ITERATE_DEFAULT ) const
 498     {
 499         return ((wxPropertyGridPageState*)this)->GetLastItem(flags);
 500     }
 501
 502     wxPropertyCategory* GetPropertyCategory( const wxPGProperty* p ) const;
 503
 504     wxPGProperty* GetPropertyByLabel( const wxString& name,
 505                                       wxPGProperty* parent = NULL ) const;
 506
 507     wxVariant DoGetPropertyValues( const wxString& listname,
 508                                    wxPGProperty* baseparent,
 509                                    long flags ) const;
 510
 511     wxPGProperty* DoGetRoot() const { return m_properties; }
 512
 513     void DoSetPropertyName( wxPGProperty* p, const wxString& newName );
 514
 515     // Returns combined width of margin and all the columns
 516     int GetVirtualWidth() const
 517     {
 518         return m_width;
 519     }
 520
 521     /**
 522         Returns minimal width for given column so that all images and texts
 523         will fit entirely.
 524
 525         Used by SetSplitterLeft() and DoFitColumns().
 526     */
 527     int GetColumnFitWidth(wxClientDC& dc,
 528                           wxPGProperty* pwc,
 529                           unsigned int col,
 530                           bool subProps) const;
 531
 532     /** Returns information about arbitrary position in the grid.
 533
 534         wxPropertyGridHitTestResult definition:
 535         @code
 536             struct wxPropertyGridHitTestResult
 537             {
 538                 wxPGProperty* GetProperty() const;
 539
 540                 // column. -1 for margin
 541                 int             column;
 542
 543                 // Index of splitter hit, -1 for none.
 544                 int             splitter;
 545
 546                 // If splitter hit, then offset to that.
 547                 int             splitterHitOffset;
 548             };
 549         @endcode
 550     */
 551     wxPropertyGridHitTestResult HitTest( const wxPoint& pt ) const;
 552
 553     /** Returns true if page is visibly displayed.
 554     */
 555     inline bool IsDisplayed() const;
 556
 557     bool IsInNonCatMode() const { return (bool)(m_properties == m_abcArray); }
 558
 559     /** Only inits arrays, doesn't migrate things or such. */
 560     void InitNonCatMode ();
 561
 562     void DoLimitPropertyEditing( wxPGProperty* p, bool limit = true )
 563     {
 564         p->SetFlagRecursively(wxPG_PROP_NOEDITOR, limit);
 565     }
 566
 567     bool DoSelectProperty( wxPGProperty* p, unsigned int flags = 0 );
 568
 569     /** widthChange is non-client.
 570     */
 571     void OnClientWidthChange( int newWidth,
 572                               int widthChange,
 573                               bool fromOnResize = false );
 574
 575     /** Recalculates m_virtualHeight.
 576     */
 577     void RecalculateVirtualHeight()
 578     {
 579         m_virtualHeight = GetActualVirtualHeight();
 580     }
 581
 582     void SetColumnCount( int colCount );
 583
 584     void PropagateColSizeDec( int column, int decrease, int dir );
 585
 586     bool DoHideProperty( wxPGProperty* p, bool hide, int flags = wxPG_RECURSE );
 587
 588     bool DoSetPropertyValueString( wxPGProperty* p, const wxString& value );
 589
 590     bool DoSetPropertyValue( wxPGProperty* p, wxVariant& value );
 591
 592     bool DoSetPropertyValueWxObjectPtr( wxPGProperty* p, wxObject* value );
 593     void DoSetPropertyValues( const wxVariantList& list,
 594                               wxPGProperty* default_category );
 595
 596     void DoSetPropertyValueUnspecified( wxPGProperty* p );
 597
 598     void SetSplitterLeft( bool subProps = false );
 599
 600     /** Set virtual width for this particular page. */
 601     void SetVirtualWidth( int width );
 602
 603     void SortChildren( wxPGProperty* p );
 604     void Sort();
 605
 606     void SetSelection( wxPGProperty* p ) { m_selected = p; }
 607
 608     /** Called after virtual height needs to be recalculated.
 609     */
 610     void VirtualHeightChanged()
 611     {
 612         m_vhCalcPending = 1;
 613     }
 614
 615     /** Base append. */
 616     wxPGProperty* DoAppend( wxPGProperty* property );
 617
 618     /** Returns property by its name. */
 619     wxPGProperty* BaseGetPropertyByName( const wxString& name ) const;
 620
 621     void DoClearSelection()
 622     {
 623         m_selected = NULL;
 624     }
 625
 626     /** Called in, for example, wxPropertyGrid::Clear. */
 627     void DoClear();
 628
 629     bool DoCollapse( wxPGProperty* p );
 630
 631     bool DoExpand( wxPGProperty* p );
 632
 633     void CalculateFontAndBitmapStuff( int vspacing );
 634
 635 protected:
 636
 637     int DoGetSplitterPosition( int splitterIndex = 0 ) const;
 638
 639     /** Returns column at x coordinate (in GetGrid()->GetPanel()).
 640         @param pSplitterHit
 641         Give pointer to int that receives index to splitter that is at x.
 642         @param pSplitterHitOffset
 643         Distance from said splitter.
 644     */
 645     int HitTestH( int x, int* pSplitterHit, int* pSplitterHitOffset ) const;
 646
 647     bool PrepareToAddItem( wxPGProperty* property,
 648                            wxPGProperty* scheduledParent );
 649
 650     /** If visible, then this is pointer to wxPropertyGrid.
 651         This shall *never* be NULL to indicate that this state is not visible.
 652     */
 653     wxPropertyGrid*             m_pPropGrid;
 654
 655     /** Pointer to currently used array. */
 656     wxPGProperty*               m_properties;
 657
 658     /** Array for categoric mode. */
 659     wxPGRootProperty            m_regularArray;
 660
 661     /** Array for root of non-categoric mode. */
 662     wxPGRootProperty*           m_abcArray;
 663
 664     /** Dictionary for name-based access. */
 665     wxPGHashMapS2P              m_dictName;
 666
 667     /** List of column widths (first column does not include margin). */
 668     wxArrayInt                  m_colWidths;
 669
 670     double                      m_fSplitterX;
 671
 672     /** Most recently added category. */
 673     wxPropertyCategory*         m_currentCategory;
 674
 675     /** Pointer to selected property. */
 676     wxPGProperty*               m_selected;
 677
 678     /** Virtual width. */
 679     int                         m_width;
 680
 681     /** Indicates total virtual height of visible properties. */
 682     unsigned int                m_virtualHeight;
 683
 684     /** 1 if m_lastCaption is also the bottommost caption. */
 685     unsigned char               m_lastCaptionBottomnest;
 686
 687     /** 1 items appended/inserted, so stuff needs to be done before drawing;
 688         If m_virtualHeight == 0, then calcylatey's must be done.
 689         Otherwise just sort.
 690     */
 691     unsigned char               m_itemsAdded;
 692
 693     /** 1 if any value is modified. */
 694     unsigned char               m_anyModified;
 695
 696     unsigned char               m_vhCalcPending;
 697 };
 698
 699 #endif // #ifndef SWIG
 700
 701 // -----------------------------------------------------------------------
 702
 703 #endif // wxUSE_PROPGRID
 704
 705 #endif // _WX_PROPGRID_PROPGRIDPAGESTATE_H_
 706