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