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 protected:
 293 };
 294
 295 // -----------------------------------------------------------------------
 296
 297 /** Base class to derive new viterators.
 298 */
 299 class WXDLLIMPEXP_PROPGRID wxPGVIteratorBase
 300 {
 301     friend class wxPGVIterator;
 302 public:
 303     wxPGVIteratorBase() { m_refCount = 1; }
 304     virtual void Next() = 0;
 305     void IncRef()
 306     {
 307         m_refCount++;
 308     }
 309     void DecRef()
 310     {
 311         m_refCount--;
 312         if ( m_refCount <= 0 )
 313             delete this;
 314     }
 315 protected:
 316     virtual ~wxPGVIteratorBase() { }
 317
 318     wxPropertyGridIterator  m_it;
 319 private:
 320     int     m_refCount;
 321 };
 322
 323 /** @class wxPGVIterator
 324
 325     Abstract implementation of a simple iterator. Can only be used
 326     to iterate in forward order, and only through the entire container.
 327     Used to have functions dealing with all properties work with both
 328     wxPropertyGrid and wxPropertyGridManager.
 329 */
 330 class WXDLLIMPEXP_PROPGRID wxPGVIterator
 331 {
 332 public:
 333     wxPGVIterator() { m_pIt = NULL; }
 334     wxPGVIterator( wxPGVIteratorBase* obj ) { m_pIt = obj; }
 335     ~wxPGVIterator() { UnRef(); }
 336     void UnRef() { if (m_pIt) m_pIt->DecRef(); }
 337     wxPGVIterator( const wxPGVIterator& it )
 338     {
 339         m_pIt = it.m_pIt;
 340         m_pIt->IncRef();
 341     }
 342 #ifndef SWIG
 343     const wxPGVIterator& operator=( const wxPGVIterator& it )
 344     {
 345         UnRef();
 346         m_pIt = it.m_pIt;
 347         m_pIt->IncRef();
 348         return *this;
 349     }
 350 #endif
 351     void Next() { m_pIt->Next(); }
 352     bool AtEnd() const { return m_pIt->m_it.AtEnd(); }
 353     wxPGProperty* GetProperty() const { return m_pIt->m_it.GetProperty(); }
 354 protected:
 355     wxPGVIteratorBase*  m_pIt;
 356 };
 357
 358 // -----------------------------------------------------------------------
 359
 360 #ifndef SWIG
 361 // We won't need this class from wxPython
 362
 363 /** @class wxPropertyGridPageState
 364
 365     Contains low-level property page information (properties, column widths,
 366     etc) of a single wxPropertyGrid or single wxPropertyGridPage. Generally you
 367     should not use this class directly, but instead member functions in
 368     wxPropertyGridInterface, wxPropertyGrid, wxPropertyGridPage, and
 369     wxPropertyGridManager.
 370
 371     @remarks
 372     - In separate wxPropertyGrid component this class was known as
 373     wxPropertyGridState.
 374     - Currently this class is not implemented in wxPython.
 375
 376     @library{wxpropgrid}
 377     @category{propgrid}
 378 */
 379 class WXDLLIMPEXP_PROPGRID wxPropertyGridPageState
 380 {
 381     friend class wxPGProperty;
 382     friend class wxPropertyGrid;
 383     friend class wxPGCanvas;
 384     friend class wxPropertyGridInterface;
 385     friend class wxPropertyGridPage;
 386     friend class wxPropertyGridManager;
 387 public:
 388
 389     /** Default constructor. */
 390     wxPropertyGridPageState();
 391
 392     /** Destructor. */
 393     virtual ~wxPropertyGridPageState();
 394
 395     /** Makes sure all columns have minimum width.
 396     */
 397     void CheckColumnWidths( int widthChange = 0 );
 398
 399     /**
 400         Override this member function to add custom behavior on property
 401         deletion.
 402     */
 403     virtual void DoDelete( wxPGProperty* item );
 404
 405     wxSize DoFitColumns( bool allowGridResize = false );
 406
 407     wxPGProperty* DoGetItemAtY( int y ) const;
 408
 409     /**
 410         Override this member function to add custom behavior on property
 411         insertion.
 412     */
 413     virtual wxPGProperty* DoInsert( wxPGProperty* parent,
 414                                     int index,
 415                                     wxPGProperty* property );
 416
 417     /**
 418         This needs to be overridden in grid used the manager so that splitter
 419         changes can be propagated to other pages.
 420     */
 421     virtual void DoSetSplitterPosition( int pos,
 422                                         int splitterColumn = 0,
 423                                         bool allPages = false,
 424                                         bool fromAutoCenter = false );
 425
 426     bool EnableCategories( bool enable );
 427
 428     /** Make sure virtual height is up-to-date.
 429     */
 430     void EnsureVirtualHeight()
 431     {
 432         if ( m_vhCalcPending )
 433         {
 434             RecalculateVirtualHeight();
 435             m_vhCalcPending = 0;
 436         }
 437     }
 438
 439     /** Enables or disables given property and its subproperties. */
 440     bool DoEnableProperty( wxPGProperty* p, bool enable );
 441
 442     /** Returns (precalculated) height of contained visible properties.
 443     */
 444     unsigned int GetVirtualHeight() const
 445     {
 446         wxASSERT( !m_vhCalcPending );
 447         return m_virtualHeight;
 448     }
 449
 450     /** Returns (precalculated) height of contained visible properties.
 451     */
 452     unsigned int GetVirtualHeight()
 453     {
 454         EnsureVirtualHeight();
 455         return m_virtualHeight;
 456     }
 457
 458     /** Returns actual height of contained visible properties.
 459         @remarks
 460         Mostly used for internal diagnostic purposes.
 461     */
 462     inline unsigned int GetActualVirtualHeight() const;
 463
 464     unsigned int GetColumnCount() const
 465     {
 466         return m_colWidths.size();
 467     }
 468
 469     wxPGProperty* GetSelection() const
 470     {
 471         return m_selected;
 472     }
 473
 474     int GetColumnMinWidth( int column ) const;
 475
 476     int GetColumnWidth( unsigned int column ) const
 477     {
 478         return m_colWidths[column];
 479     }
 480
 481     wxPropertyGrid* GetGrid() const { return m_pPropGrid; }
 482
 483     /** Returns last item which could be iterated using given flags.
 484         @param flags
 485         @link iteratorflags List of iterator flags@endlink
 486     */
 487     wxPGProperty* GetLastItem( int flags = wxPG_ITERATE_DEFAULT );
 488
 489     const wxPGProperty* GetLastItem( int flags = wxPG_ITERATE_DEFAULT ) const
 490     {
 491         return ((wxPropertyGridPageState*)this)->GetLastItem(flags);
 492     }
 493
 494     wxPropertyCategory* GetPropertyCategory( const wxPGProperty* p ) const;
 495
 496     wxPGProperty* GetPropertyByLabel( const wxString& name,
 497                                       wxPGProperty* parent = NULL ) const;
 498
 499     wxVariant DoGetPropertyValues( const wxString& listname,
 500                                    wxPGProperty* baseparent,
 501                                    long flags ) const;
 502
 503     wxPGProperty* DoGetRoot() const { return m_properties; }
 504
 505     void DoSetPropertyName( wxPGProperty* p, const wxString& newName );
 506
 507     // Returns combined width of margin and all the columns
 508     int GetVirtualWidth() const
 509     {
 510         return m_width;
 511     }
 512
 513     /**
 514         Returns minimal width for given column so that all images and texts
 515         will fit entirely.
 516
 517         Used by SetSplitterLeft() and DoFitColumns().
 518     */
 519     int GetColumnFitWidth(wxClientDC& dc,
 520                           wxPGProperty* pwc,
 521                           unsigned int col,
 522                           bool subProps) const;
 523
 524     /** Returns information about arbitrary position in the grid.
 525
 526         wxPropertyGridHitTestResult definition:
 527         @code
 528             struct wxPropertyGridHitTestResult
 529             {
 530                 wxPGProperty* GetProperty() const;
 531
 532                 // column. -1 for margin
 533                 int             column;
 534
 535                 // Index of splitter hit, -1 for none.
 536                 int             splitter;
 537
 538                 // If splitter hit, then offset to that.
 539                 int             splitterHitOffset;
 540             };
 541         @endcode
 542     */
 543     wxPropertyGridHitTestResult HitTest( const wxPoint& pt ) const;
 544
 545     /** Returns true if page is visibly displayed.
 546     */
 547     inline bool IsDisplayed() const;
 548
 549     bool IsInNonCatMode() const { return (bool)(m_properties == m_abcArray); }
 550
 551     /** Only inits arrays, doesn't migrate things or such. */
 552     void InitNonCatMode ();
 553
 554     void DoLimitPropertyEditing( wxPGProperty* p, bool limit = true )
 555     {
 556         p->SetFlagRecursively(wxPG_PROP_NOEDITOR, limit);
 557     }
 558
 559     bool DoSelectProperty( wxPGProperty* p, unsigned int flags = 0 );
 560
 561     /** widthChange is non-client.
 562     */
 563     void OnClientWidthChange( int newWidth,
 564                               int widthChange,
 565                               bool fromOnResize = false );
 566
 567     /** Recalculates m_virtualHeight.
 568     */
 569     void RecalculateVirtualHeight()
 570     {
 571         m_virtualHeight = GetActualVirtualHeight();
 572     }
 573
 574     void SetColumnCount( int colCount );
 575
 576     void PropagateColSizeDec( int column, int decrease, int dir );
 577
 578     bool DoHideProperty( wxPGProperty* p, bool hide, int flags = wxPG_RECURSE );
 579
 580     bool DoSetPropertyValueString( wxPGProperty* p, const wxString& value );
 581
 582     bool DoSetPropertyValue( wxPGProperty* p, wxVariant& value );
 583
 584     bool DoSetPropertyValueWxObjectPtr( wxPGProperty* p, wxObject* value );
 585     void DoSetPropertyValues( const wxVariantList& list,
 586                               wxPGProperty* default_category );
 587
 588     void DoSetPropertyValueUnspecified( wxPGProperty* p );
 589
 590     void SetSplitterLeft( bool subProps = false );
 591
 592     /** Set virtual width for this particular page. */
 593     void SetVirtualWidth( int width );
 594
 595     void SortChildren( wxPGProperty* p );
 596     void Sort();
 597
 598     void SetSelection( wxPGProperty* p ) { m_selected = p; }
 599
 600     /** Called after virtual height needs to be recalculated.
 601     */
 602     void VirtualHeightChanged()
 603     {
 604         m_vhCalcPending = 1;
 605     }
 606
 607     /** Base append. */
 608     wxPGProperty* DoAppend( wxPGProperty* property );
 609
 610     /** Returns property by its name. */
 611     wxPGProperty* BaseGetPropertyByName( const wxString& name ) const;
 612
 613     void DoClearSelection()
 614     {
 615         m_selected = NULL;
 616     }
 617
 618     /** Called in, for example, wxPropertyGrid::Clear. */
 619     void DoClear();
 620
 621     bool DoCollapse( wxPGProperty* p );
 622
 623     bool DoExpand( wxPGProperty* p );
 624
 625     void CalculateFontAndBitmapStuff( int vspacing );
 626
 627 protected:
 628
 629     int DoGetSplitterPosition( int splitterIndex = 0 ) const;
 630
 631     /** Returns column at x coordinate (in GetGrid()->GetPanel()).
 632         @param pSplitterHit
 633         Give pointer to int that receives index to splitter that is at x.
 634         @param pSplitterHitOffset
 635         Distance from said splitter.
 636     */
 637     int HitTestH( int x, int* pSplitterHit, int* pSplitterHitOffset ) const;
 638
 639     int PrepareToAddItem ( wxPGProperty* property,
 640                            wxPGProperty* scheduledParent );
 641
 642     /** If visible, then this is pointer to wxPropertyGrid.
 643         This shall *never* be NULL to indicate that this state is not visible.
 644     */
 645     wxPropertyGrid*             m_pPropGrid;
 646
 647     /** Pointer to currently used array. */
 648     wxPGProperty*               m_properties;
 649
 650     /** Array for categoric mode. */
 651     wxPGRootProperty            m_regularArray;
 652
 653     /** Array for root of non-categoric mode. */
 654     wxPGRootProperty*           m_abcArray;
 655
 656     /** Dictionary for name-based access. */
 657     wxPGHashMapS2P              m_dictName;
 658
 659     /** List of column widths (first column does not include margin). */
 660     wxArrayInt                  m_colWidths;
 661
 662     double                      m_fSplitterX;
 663
 664     /** Most recently added category. */
 665     wxPropertyCategory*         m_currentCategory;
 666
 667     /** Pointer to selected property. */
 668     wxPGProperty*               m_selected;
 669
 670     /** Virtual width. */
 671     int                         m_width;
 672
 673     /** Indicates total virtual height of visible properties. */
 674     unsigned int                m_virtualHeight;
 675
 676     /** 1 if m_lastCaption is also the bottommost caption. */
 677     unsigned char               m_lastCaptionBottomnest;
 678
 679     /** 1 items appended/inserted, so stuff needs to be done before drawing;
 680         If m_virtualHeight == 0, then calcylatey's must be done.
 681         Otherwise just sort.
 682     */
 683     unsigned char               m_itemsAdded;
 684
 685     /** 1 if any value is modified. */
 686     unsigned char               m_anyModified;
 687
 688     unsigned char               m_vhCalcPending;
 689 };
 690
 691 #endif // #ifndef SWIG
 692
 693 // -----------------------------------------------------------------------
 694
 695 #endif // wxUSE_PROPGRID
 696
 697 #endif // _WX_PROPGRID_PROPGRIDPAGESTATE_H_
 698