include/wx/propgrid/manager.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/propgrid/manager.h
   3 // Purpose:     wxPropertyGridManager
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2005-01-14
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Jaakko Salli
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_PROPGRID_MANAGER_H_
  13 #define _WX_PROPGRID_MANAGER_H_
  14
  15 #include "wx/defs.h"
  16
  17 #if wxUSE_PROPGRID
  18
  19 #include "wx/propgrid/propgrid.h"
  20
  21 #include "wx/dcclient.h"
  22 #include "wx/scrolwin.h"
  23 #include "wx/toolbar.h"
  24 #include "wx/stattext.h"
  25 #include "wx/button.h"
  26 #include "wx/textctrl.h"
  27 #include "wx/dialog.h"
  28 #include "wx/headerctrl.h"
  29
  30 // -----------------------------------------------------------------------
  31
  32 #ifndef SWIG
  33 extern WXDLLIMPEXP_DATA_PROPGRID(const char) wxPropertyGridManagerNameStr[];
  34 #endif
  35
  36 /** @class wxPropertyGridPage
  37
  38     Holder of property grid page information. You can subclass this and
  39     give instance in wxPropertyGridManager::AddPage. It inherits from
  40     wxEvtHandler and can be used to process events specific to this
  41     page (id of events will still be same as manager's). If you don't
  42     want to use it to process all events of the page, you need to
  43     return false in the derived wxPropertyGridPage::IsHandlingAllEvents.
  44
  45     Please note that wxPropertyGridPage lacks many non-const property
  46     manipulation functions found in wxPropertyGridManager. Please use
  47     parent manager (m_manager member variable) when needed.
  48
  49     Please note that most member functions are inherited and as such not
  50     documented on this page. This means you will probably also want to read
  51     wxPropertyGridInterface class reference.
  52
  53     @section propgridpage_event_handling Event Handling
  54
  55     wxPropertyGridPage receives events emitted by its wxPropertyGridManager, but
  56     only those events that are specific to that page. If
  57     wxPropertyGridPage::IsHandlingAllEvents returns false, then unhandled
  58     events are sent to the manager's parent, as usual.
  59
  60     See @ref propgrid_event_handling "wxPropertyGrid Event Handling"
  61     for more information.
  62
  63     @library{wxpropgrid}
  64     @category{propgrid}
  65 */
  66 class WXDLLIMPEXP_PROPGRID wxPropertyGridPage : public wxEvtHandler,
  67                                                 public wxPropertyGridInterface,
  68                                                 public wxPropertyGridPageState
  69 {
  70     friend class wxPropertyGridManager;
  71     DECLARE_CLASS(wxPropertyGridPage)
  72 public:
  73
  74     wxPropertyGridPage();
  75     virtual ~wxPropertyGridPage();
  76
  77     /** Deletes all properties on page.
  78     */
  79     virtual void Clear();
  80
  81     /**
  82         Reduces column sizes to minimum possible that contents are still
  83         visibly (naturally some margin space will be applied as well).
  84
  85         @return
  86         Minimum size for the page to still display everything.
  87
  88         @remarks
  89         This function only works properly if size of containing grid was
  90         already fairly large.
  91
  92         Note that you can also get calculated column widths by calling
  93         GetColumnWidth() immediately after this function returns.
  94     */
  95     wxSize FitColumns();
  96
  97     /** Returns page index in manager;
  98     */
  99     inline int GetIndex() const;
 100
 101     /** Returns x-coordinate position of splitter on a page.
 102     */
 103     int GetSplitterPosition( int col = 0 ) const
 104         { return GetStatePtr()->DoGetSplitterPosition(col); }
 105
 106     /** Returns "root property". It does not have name, etc. and it is not
 107         visible. It is only useful for accessing its children.
 108     */
 109     wxPGProperty* GetRoot() const { return GetStatePtr()->DoGetRoot(); }
 110
 111     /** Return pointer to contained property grid state.
 112     */
 113     wxPropertyGridPageState* GetStatePtr()
 114     {
 115         return this;
 116     }
 117
 118     /** Return pointer to contained property grid state.
 119     */
 120     const wxPropertyGridPageState* GetStatePtr() const
 121     {
 122         return this;
 123     }
 124
 125     /**
 126         Returns id of the tool bar item that represents this page on
 127         wxPropertyGridManager's wxToolBar.
 128     */
 129     int GetToolId() const
 130     {
 131         return m_toolId;
 132     }
 133
 134     /** Do any member initialization in this method.
 135         @remarks
 136         - Called every time the page is added into a manager.
 137         - You can add properties to the page here.
 138     */
 139     virtual void Init() {}
 140
 141     /** Return false here to indicate unhandled events should be
 142         propagated to manager's parent, as normal.
 143     */
 144     virtual bool IsHandlingAllEvents() const { return true; }
 145
 146     /** Called every time page is about to be shown.
 147         Useful, for instance, creating properties just-in-time.
 148     */
 149     virtual void OnShow();
 150
 151     virtual void RefreshProperty( wxPGProperty* p );
 152
 153     /** Sets splitter position on page.
 154         @remarks
 155         Splitter position cannot exceed grid size, and therefore setting it
 156         during form creation may fail as initial grid size is often smaller
 157         than desired splitter position, especially when sizers are being used.
 158     */
 159     void SetSplitterPosition( int splitterPos, int col = 0 );
 160
 161 protected:
 162
 163     /** Propagate to other pages.
 164     */
 165     virtual void DoSetSplitterPosition( int pos,
 166                                         int splitterColumn = 0,
 167                                         int flags = wxPG_SPLITTER_REFRESH );
 168
 169     /** Page label (may be referred as name in some parts of documentation).
 170         Can be set in constructor, or passed in
 171         wxPropertyGridManager::AddPage(), but *not* in both.
 172     */
 173     wxString                m_label;
 174
 175     //virtual bool ProcessEvent( wxEvent& event );
 176
 177     wxPropertyGridManager*  m_manager;
 178
 179     // Toolbar tool id. Note that this is only valid when the tool bar
 180     // exists.
 181     int                     m_toolId;
 182
 183 private:
 184     bool                    m_isDefault; // is this base page object?
 185
 186     DECLARE_EVENT_TABLE()
 187 };
 188
 189 // -----------------------------------------------------------------------
 190
 191 #if wxUSE_HEADERCTRL
 192 class wxPGHeaderCtrl;
 193 #endif
 194
 195
 196 /** @class wxPropertyGridManager
 197
 198     wxPropertyGridManager is an efficient multi-page version of wxPropertyGrid,
 199     which can optionally have toolbar for mode and page selection, and help
 200     text box.
 201     Use window flags to select components to include.
 202
 203     @section propgridmanager_window_styles_ Window Styles
 204
 205     See @ref propgrid_window_styles.
 206
 207     @section propgridmanager_event_handling Event Handling
 208
 209     See @ref propgrid_event_handling "wxPropertyGrid Event Handling"
 210     for more information.
 211
 212     @library{wxpropgrid}
 213     @category{propgrid}
 214 */
 215 class WXDLLIMPEXP_PROPGRID
 216     wxPropertyGridManager : public wxPanel, public wxPropertyGridInterface
 217 {
 218     DECLARE_CLASS(wxPropertyGridManager)
 219     friend class wxPropertyGridPage;
 220 public:
 221
 222 #ifndef SWIG
 223     /**
 224         Two step constructor.
 225         Call Create when this constructor is called to build up the
 226         wxPropertyGridManager.
 227       */
 228     wxPropertyGridManager();
 229 #endif
 230
 231     /** The default constructor. The styles to be used are styles valid for
 232         the wxWindow.
 233         @see @link wndflags Additional Window Styles@endlink
 234     */
 235     wxPropertyGridManager( wxWindow *parent, wxWindowID id = wxID_ANY,
 236                            const wxPoint& pos = wxDefaultPosition,
 237                            const wxSize& size = wxDefaultSize,
 238                            long style = wxPGMAN_DEFAULT_STYLE,
 239                            const wxString& name = wxPropertyGridManagerNameStr );
 240
 241     /** Destructor */
 242     virtual ~wxPropertyGridManager();
 243
 244     /** Creates new property page. Note that the first page is not created
 245         automatically.
 246         @param label
 247         A label for the page. This may be shown as a toolbar tooltip etc.
 248         @param bmp
 249         Bitmap image for toolbar. If wxNullBitmap is used, then a built-in
 250         default image is used.
 251         @param pageObj
 252         wxPropertyGridPage instance. Manager will take ownership of this object.
 253         NULL indicates that a default page instance should be created.
 254
 255         @return
 256         Returns pointer to created page.
 257
 258         @remarks
 259         If toolbar is used, it is highly recommended that the pages are
 260         added when the toolbar is not turned off using window style flag
 261         switching.
 262     */
 263     wxPropertyGridPage* AddPage( const wxString& label = wxEmptyString,
 264                                  const wxBitmap& bmp = wxPG_NULL_BITMAP,
 265                                  wxPropertyGridPage* pageObj = NULL )
 266     {
 267         return InsertPage(-1, label, bmp, pageObj);
 268     }
 269
 270     /** Deletes all all properties and all pages.
 271     */
 272     virtual void Clear();
 273
 274     /** Deletes all properties on given page.
 275     */
 276     void ClearPage( int page );
 277
 278     /** Forces updating the value of property from the editor control.
 279         Returns true if DoPropertyChanged was actually called.
 280     */
 281     bool CommitChangesFromEditor( wxUint32 flags = 0 )
 282     {
 283         return m_pPropGrid->CommitChangesFromEditor(flags);
 284     }
 285
 286     /**
 287         Two step creation.
 288         Whenever the control is created without any parameters, use Create to
 289         actually create it. Don't access the control's public methods before
 290         this is called.
 291         @see @link wndflags Additional Window Styles@endlink
 292     */
 293     bool Create( wxWindow *parent, wxWindowID id = wxID_ANY,
 294                  const wxPoint& pos = wxDefaultPosition,
 295                  const wxSize& size = wxDefaultSize,
 296                  long style = wxPGMAN_DEFAULT_STYLE,
 297                  const wxString& name = wxPropertyGridManagerNameStr );
 298
 299     /**
 300         Enables or disables (shows/hides) categories according to parameter
 301         enable.
 302
 303         WARNING: Not tested properly, use at your own risk.
 304     */
 305     bool EnableCategories( bool enable )
 306     {
 307         long fl = m_windowStyle | wxPG_HIDE_CATEGORIES;
 308         if ( enable ) fl = m_windowStyle & ~(wxPG_HIDE_CATEGORIES);
 309         SetWindowStyleFlag(fl);
 310         return true;
 311     }
 312
 313     /** Selects page, scrolls and/or expands items to ensure that the
 314         given item is visible. Returns true if something was actually done.
 315     */
 316     bool EnsureVisible( wxPGPropArg id );
 317
 318     /** Returns number of columns on given page. By the default,
 319         returns number of columns on current page. */
 320     int GetColumnCount( int page = -1 ) const;
 321
 322     /** Returns height of the description text box. */
 323     int GetDescBoxHeight() const;
 324
 325     /** Returns pointer to the contained wxPropertyGrid. This does not change
 326         after wxPropertyGridManager has been created, so you can safely obtain
 327         pointer once and use it for the entire lifetime of the instance.
 328     */
 329     wxPropertyGrid* GetGrid()
 330     {
 331         wxASSERT(m_pPropGrid);
 332         return m_pPropGrid;
 333     };
 334
 335     const wxPropertyGrid* GetGrid() const
 336     {
 337         wxASSERT(m_pPropGrid);
 338         return (const wxPropertyGrid*)m_pPropGrid;
 339     };
 340
 341     /** Returns iterator class instance.
 342         @remarks
 343         Calling this method in wxPropertyGridManager causes run-time assertion
 344         failure. Please only iterate through individual pages or use
 345         CreateVIterator().
 346     */
 347     wxPropertyGridIterator GetIterator( int flags = wxPG_ITERATE_DEFAULT,
 348                                         wxPGProperty* firstProp = NULL )
 349     {
 350         wxFAIL_MSG( "Please only iterate through individual pages "
 351                     "or use CreateVIterator()" );
 352         return wxPropertyGridInterface::GetIterator( flags, firstProp );
 353     }
 354
 355     wxPropertyGridConstIterator
 356     GetIterator(int flags = wxPG_ITERATE_DEFAULT,
 357                 wxPGProperty* firstProp = NULL) const
 358     {
 359         wxFAIL_MSG( "Please only iterate through individual pages "
 360                     " or use CreateVIterator()" );
 361         return wxPropertyGridInterface::GetIterator( flags, firstProp );
 362     }
 363
 364     /** Returns iterator class instance.
 365         @remarks
 366         Calling this method in wxPropertyGridManager causes run-time assertion
 367         failure. Please only iterate through individual pages or use
 368         CreateVIterator().
 369     */
 370     wxPropertyGridIterator GetIterator( int flags, int startPos )
 371     {
 372         wxFAIL_MSG( "Please only iterate through individual pages "
 373                     "or use CreateVIterator()" );
 374
 375         return wxPropertyGridInterface::GetIterator( flags, startPos );
 376     }
 377
 378     wxPropertyGridConstIterator GetIterator( int flags, int startPos ) const
 379     {
 380         wxFAIL_MSG( "Please only iterate through individual pages "
 381                     "or use CreateVIterator()" );
 382         return wxPropertyGridInterface::GetIterator( flags, startPos );
 383     }
 384
 385     /** Similar to GetIterator, but instead returns wxPGVIterator instance,
 386         which can be useful for forward-iterating through arbitrary property
 387         containers.
 388     */
 389     virtual wxPGVIterator GetVIterator( int flags ) const;
 390
 391     /** Returns currently selected page.
 392     */
 393     wxPropertyGridPage* GetCurrentPage() const
 394     {
 395         return GetPage(m_selPage);
 396     }
 397
 398     /** Returns page object for given page index.
 399     */
 400     wxPropertyGridPage* GetPage( unsigned int ind ) const
 401     {
 402         return m_arrPages[ind];
 403     }
 404
 405     /** Returns page object for given page name.
 406     */
 407     wxPropertyGridPage* GetPage( const wxString& name ) const
 408     {
 409         return GetPage(GetPageByName(name));
 410     }
 411
 412     /**
 413         Returns index for a page name.
 414
 415         If no match is found, wxNOT_FOUND is returned.
 416      */
 417     int GetPageByName( const wxString& name ) const;
 418
 419     /** Returns index for a relevant propertygrid state.
 420
 421         If no match is found, wxNOT_FOUND is returned.
 422     */
 423     int GetPageByState( const wxPropertyGridPageState* pstate ) const;
 424
 425 protected:
 426     /** Returns wxPropertyGridPageState of given page, current page's for -1.
 427     */
 428     virtual wxPropertyGridPageState* GetPageState( int page ) const;
 429
 430 public:
 431     /** Returns number of managed pages. */
 432     size_t GetPageCount() const;
 433
 434     /** Returns name of given page. */
 435     const wxString& GetPageName( int index ) const;
 436
 437     /** Returns "root property" of the given page. It does not have name, etc.
 438         and it is not visible. It is only useful for accessing its children.
 439     */
 440     wxPGProperty* GetPageRoot( int index ) const;
 441
 442     /** Returns index to currently selected page. */
 443     int GetSelectedPage() const { return m_selPage; }
 444
 445     /** Alias for GetSelection(). */
 446     wxPGProperty* GetSelectedProperty() const
 447     {
 448         return GetSelection();
 449     }
 450
 451     /** Shortcut for GetGrid()->GetSelection(). */
 452     wxPGProperty* GetSelection() const
 453     {
 454         return m_pPropGrid->GetSelection();
 455     }
 456
 457     /** Returns a pointer to the toolbar currently associated with the
 458         wxPropertyGridManager (if any). */
 459     wxToolBar* GetToolBar() const { return m_pToolbar; }
 460
 461     /** Creates new property page. Note that the first page is not created
 462         automatically.
 463         @param index
 464         Add to this position. -1 will add as the last item.
 465         @param label
 466         A label for the page. This may be shown as a toolbar tooltip etc.
 467         @param bmp
 468         Bitmap image for toolbar. If wxNullBitmap is used, then a built-in
 469         default image is used.
 470         @param pageObj
 471         wxPropertyGridPage instance. Manager will take ownership of this object.
 472         If NULL, default page object is constructed.
 473
 474         @return
 475         Returns pointer to created page.
 476     */
 477     virtual wxPropertyGridPage* InsertPage( int index,
 478                                             const wxString& label,
 479                                             const wxBitmap& bmp = wxNullBitmap,
 480                                             wxPropertyGridPage* pageObj = NULL );
 481
 482     /**
 483         Returns true if any property on any page has been modified by the user.
 484     */
 485     bool IsAnyModified() const;
 486
 487     /**
 488         Returns true if updating is frozen (ie Freeze() called but not yet
 489         Thaw() ).
 490      */
 491     bool IsFrozen() const { return m_pPropGrid->m_frozen > 0; }
 492
 493     /**
 494         Returns true if any property on given page has been modified by the
 495         user.
 496      */
 497     bool IsPageModified( size_t index ) const;
 498
 499     /**
 500         Returns true if property is selected. Since selection is page
 501         based, this function checks every page in the manager.
 502     */
 503     virtual bool IsPropertySelected( wxPGPropArg id ) const;
 504
 505     virtual void Refresh( bool eraseBackground = true,
 506                           const wxRect* rect = (const wxRect*) NULL );
 507
 508     /** Removes a page.
 509         @return
 510         Returns false if it was not possible to remove page in question.
 511     */
 512     virtual bool RemovePage( int page );
 513
 514     /** Select and displays a given page.
 515
 516         @param index
 517             Index of page being seleced. Can be -1 to select nothing.
 518     */
 519     void SelectPage( int index );
 520
 521     /** Select and displays a given page (by label). */
 522     void SelectPage( const wxString& label )
 523     {
 524         int index = GetPageByName(label);
 525         wxCHECK_RET( index >= 0, wxT("No page with such name") );
 526         SelectPage( index );
 527     }
 528
 529     /** Select and displays a given page. */
 530     void SelectPage( wxPropertyGridPage* ptr )
 531     {
 532         SelectPage( GetPageByState(ptr) );
 533     }
 534
 535     /** Select a property. */
 536     bool SelectProperty( wxPGPropArg id, bool focus = false )
 537     {
 538         wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 539         return p->GetParentState()->DoSelectProperty(p, focus);
 540     }
 541
 542     /**
 543         Sets a column title. Default title for column 0 is "Property",
 544         and "Value" for column 1.
 545
 546         @remarks If header is not shown yet, then calling this
 547                  member function will make it visible.
 548     */
 549     void SetColumnTitle( int idx, const wxString& title );
 550
 551     /**
 552         Sets number of columns on given page (default is current page).
 553
 554         @remarks If you use header, then you should always use this
 555                  member function to set the column count, instead of
 556                  ones present in wxPropertyGrid or wxPropertyGridPage.
 557     */
 558     void SetColumnCount( int colCount, int page = -1 );
 559
 560     /** Sets label and text in description box.
 561     */
 562     void SetDescription( const wxString& label, const wxString& content );
 563
 564     /** Sets y coordinate of the description box splitter. */
 565     void SetDescBoxHeight( int ht, bool refresh = true );
 566
 567     /** Moves splitter as left as possible, while still allowing all
 568         labels to be shown in full.
 569         @param subProps
 570         If false, will still allow sub-properties (ie. properties which
 571         parent is not root or category) to be cropped.
 572         @param allPages
 573         If true, takes labels on all pages into account.
 574     */
 575     void SetSplitterLeft( bool subProps = false, bool allPages = true );
 576
 577     /**
 578         Sets splitter position on individual page.
 579
 580         @remarks If you use header, then you should always use this
 581                  member function to set the splitter position, instead of
 582                  ones present in wxPropertyGrid or wxPropertyGridPage.
 583     */
 584     void SetPageSplitterPosition( int page, int pos, int column = 0 );
 585
 586     /**
 587         Sets splitter position for all pages.
 588
 589         @remarks Splitter position cannot exceed grid size, and therefore
 590                  setting it during form creation may fail as initial grid
 591                  size is often smaller than desired splitter position,
 592                  especially when sizers are being used.
 593
 594                  If you use header, then you should always use this
 595                  member function to set the splitter position, instead of
 596                  ones present in wxPropertyGrid or wxPropertyGridPage.
 597     */
 598     void SetSplitterPosition( int pos, int column = 0 );
 599
 600 #if wxUSE_HEADERCTRL
 601     /**
 602         Show or hide the property grid header control. It is hidden
 603         by the default.
 604
 605         @remarks Grid may look better if you use wxPG_NO_INTERNAL_BORDER
 606                  window style when showing a header.
 607     */
 608     void ShowHeader(bool show = true);
 609 #endif
 610
 611 protected:
 612
 613     //
 614     // Subclassing helpers
 615     //
 616
 617     /**
 618         Creates property grid for the manager. Reimplement in derived class to
 619         use subclassed wxPropertyGrid. However, if you do this then you
 620         must also use the two-step construction (ie. default constructor and
 621         Create() instead of constructor with arguments) when creating the
 622         manager.
 623     */
 624     virtual wxPropertyGrid* CreatePropertyGrid() const;
 625
 626 public:
 627     virtual void RefreshProperty( wxPGProperty* p );
 628
 629     //
 630     // Overridden functions - no documentation required.
 631     //
 632
 633     void SetId( wxWindowID winid );
 634
 635     virtual void Freeze();
 636     virtual void Thaw();
 637     virtual void SetExtraStyle ( long exStyle );
 638     virtual bool SetFont ( const wxFont& font );
 639     virtual void SetWindowStyleFlag ( long style );
 640     virtual bool Reparent( wxWindowBase *newParent );
 641
 642 protected:
 643     virtual wxSize DoGetBestSize() const;
 644
 645     //
 646     // Event handlers
 647     //
 648     void OnMouseMove( wxMouseEvent &event );
 649     void OnMouseClick( wxMouseEvent &event );
 650     void OnMouseUp( wxMouseEvent &event );
 651     void OnMouseEntry( wxMouseEvent &event );
 652
 653     void OnPaint( wxPaintEvent &event );
 654
 655     void OnToolbarClick( wxCommandEvent &event );
 656     void OnResize( wxSizeEvent& event );
 657     void OnPropertyGridSelect( wxPropertyGridEvent& event );
 658     void OnPGColDrag( wxPropertyGridEvent& event );
 659
 660
 661     wxPropertyGrid* m_pPropGrid;
 662
 663     wxVector<wxPropertyGridPage*>   m_arrPages;
 664
 665 #if wxUSE_TOOLBAR
 666     wxToolBar*      m_pToolbar;
 667 #endif
 668 #if wxUSE_HEADERCTRL
 669     wxPGHeaderCtrl* m_pHeaderCtrl;
 670 #endif
 671     wxStaticText*   m_pTxtHelpCaption;
 672     wxStaticText*   m_pTxtHelpContent;
 673
 674     wxPropertyGridPage*     m_emptyPage;
 675
 676     wxArrayString   m_columnLabels;
 677
 678     long            m_iFlags;
 679
 680     // Selected page index.
 681     int             m_selPage;
 682
 683     int             m_width;
 684
 685     int             m_height;
 686
 687     int             m_extraHeight;
 688
 689     int             m_splitterY;
 690
 691     int             m_splitterHeight;
 692
 693     int             m_dragOffset;
 694
 695     wxCursor        m_cursorSizeNS;
 696
 697     int             m_nextDescBoxSize;
 698
 699     // Toolbar tool ids for categorized and alphabetic mode selectors.
 700     int             m_categorizedModeToolId;
 701     int             m_alphabeticModeToolId;
 702
 703     unsigned char   m_dragStatus;
 704
 705     unsigned char   m_onSplitter;
 706
 707     bool            m_showHeader;
 708
 709     virtual wxPGProperty* DoGetPropertyByName( const wxString& name ) const;
 710
 711     /** Select and displays a given page. */
 712     virtual bool DoSelectPage( int index );
 713
 714     // Sets some members to defaults.
 715     void Init1();
 716
 717     // Initializes some members.
 718     void Init2( int style );
 719
 720 /*#ifdef __WXMSW__
 721     virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle) const;
 722 #endif*/
 723
 724     virtual bool ProcessEvent( wxEvent& event );
 725
 726     /** Recalculates new positions for components, according to the
 727         given size.
 728     */
 729     void RecalculatePositions( int width, int height );
 730
 731     /** (Re)creates/destroys controls, according to the window style bits. */
 732     void RecreateControls();
 733
 734     void UpdateDescriptionBox( int new_splittery, int new_width, int new_height );
 735
 736     void RepaintDescBoxDecorations( wxDC& dc,
 737                                     int newSplitterY,
 738                                     int newWidth,
 739                                     int newHeight );
 740
 741     void SetDescribedProperty( wxPGProperty* p );
 742
 743     // Reimplement these to handle "descboxheight" state item
 744     virtual bool SetEditableStateItem( const wxString& name, wxVariant value );
 745     virtual wxVariant GetEditableStateItem( const wxString& name ) const;
 746
 747 private:
 748     DECLARE_EVENT_TABLE()
 749 };
 750
 751 // -----------------------------------------------------------------------
 752
 753 inline int wxPropertyGridPage::GetIndex() const
 754 {
 755     if ( !m_manager )
 756         return wxNOT_FOUND;
 757     return m_manager->GetPageByState(this);
 758 }
 759
 760 // -----------------------------------------------------------------------
 761
 762 #endif // wxUSE_PROPGRID
 763
 764 #endif // _WX_PROPGRID_MANAGER_H_