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 license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_PROPGRID_MANAGER_H_
  13 #define _WX_PROPGRID_MANAGER_H_
  14
  15 #if wxUSE_PROPGRID
  16
  17 #include "wx/propgrid/propgrid.h"
  18
  19 #include "wx/dcclient.h"
  20 #include "wx/scrolwin.h"
  21 #include "wx/toolbar.h"
  22 #include "wx/stattext.h"
  23 #include "wx/button.h"
  24 #include "wx/textctrl.h"
  25 #include "wx/dialog.h"
  26 #include "wx/headerctrl.h"
  27
  28 // -----------------------------------------------------------------------
  29
  30 #ifndef SWIG
  31 extern WXDLLIMPEXP_DATA_PROPGRID(const char) wxPropertyGridManagerNameStr[];
  32 #endif
  33
  34 /** @class wxPropertyGridPage
  35
  36     Holder of property grid page information. You can subclass this and
  37     give instance in wxPropertyGridManager::AddPage. It inherits from
  38     wxEvtHandler and can be used to process events specific to this
  39     page (id of events will still be same as manager's). If you don't
  40     want to use it to process all events of the page, you need to
  41     return false in the derived wxPropertyGridPage::IsHandlingAllEvents.
  42
  43     Please note that wxPropertyGridPage lacks many non-const property
  44     manipulation functions found in wxPropertyGridManager. Please use
  45     parent manager (m_manager member variable) when needed.
  46
  47     Please note that most member functions are inherited and as such not
  48     documented on this page. This means you will probably also want to read
  49     wxPropertyGridInterface class reference.
  50
  51     @section propgridpage_event_handling Event Handling
  52
  53     wxPropertyGridPage receives events emitted by its wxPropertyGridManager, but
  54     only those events that are specific to that page. If
  55     wxPropertyGridPage::IsHandlingAllEvents returns false, then unhandled
  56     events are sent to the manager's parent, as usual.
  57
  58     See @ref propgrid_event_handling "wxPropertyGrid Event Handling"
  59     for more information.
  60
  61     @library{wxpropgrid}
  62     @category{propgrid}
  63 */
  64 class WXDLLIMPEXP_PROPGRID wxPropertyGridPage : public wxEvtHandler,
  65                                                 public wxPropertyGridInterface,
  66                                                 public wxPropertyGridPageState
  67 {
  68     friend class wxPropertyGridManager;
  69     DECLARE_CLASS(wxPropertyGridPage)
  70 public:
  71
  72     wxPropertyGridPage();
  73     virtual ~wxPropertyGridPage();
  74
  75     /** Deletes all properties on page.
  76     */
  77     virtual void Clear();
  78
  79     /**
  80         Reduces column sizes to minimum possible that contents are still
  81         visibly (naturally some margin space will be applied as well).
  82
  83         @return
  84         Minimum size for the page to still display everything.
  85
  86         @remarks
  87         This function only works properly if size of containing grid was
  88         already fairly large.
  89
  90         Note that you can also get calculated column widths by calling
  91         GetColumnWidth() immediately after this function returns.
  92     */
  93     wxSize FitColumns();
  94
  95     /** Returns page index in manager;
  96     */
  97     inline int GetIndex() const;
  98
  99     /** Returns x-coordinate position of splitter on a page.
 100     */
 101     int GetSplitterPosition( int col = 0 ) const
 102         { return GetStatePtr()->DoGetSplitterPosition(col); }
 103
 104     /** Returns "root property". It does not have name, etc. and it is not
 105         visible. It is only useful for accessing its children.
 106     */
 107     wxPGProperty* GetRoot() const { return GetStatePtr()->DoGetRoot(); }
 108
 109     /** Return pointer to contained property grid state.
 110     */
 111     wxPropertyGridPageState* GetStatePtr()
 112     {
 113         return this;
 114     }
 115
 116     /** Return pointer to contained property grid state.
 117     */
 118     const wxPropertyGridPageState* GetStatePtr() const
 119     {
 120         return this;
 121     }
 122
 123     /**
 124         Returns id of the tool bar item that represents this page on
 125         wxPropertyGridManager's wxToolBar.
 126     */
 127     int GetToolId() const
 128     {
 129         return m_id;
 130     }
 131
 132     /** Do any member initialization in this method.
 133         @remarks
 134         - Called every time the page is added into a manager.
 135         - You can add properties to the page here.
 136     */
 137     virtual void Init() {}
 138
 139     /** Return false here to indicate unhandled events should be
 140         propagated to manager's parent, as normal.
 141     */
 142     virtual bool IsHandlingAllEvents() const { return true; }
 143
 144     /** Called every time page is about to be shown.
 145         Useful, for instance, creating properties just-in-time.
 146     */
 147     virtual void OnShow();
 148
 149     virtual void RefreshProperty( wxPGProperty* p );
 150
 151     /** Sets splitter position on page.
 152         @remarks
 153         Splitter position cannot exceed grid size, and therefore setting it
 154         during form creation may fail as initial grid size is often smaller
 155         than desired splitter position, especially when sizers are being used.
 156     */
 157     void SetSplitterPosition( int splitterPos, int col = 0 );
 158
 159 protected:
 160
 161     /** Propagate to other pages.
 162     */
 163     virtual void DoSetSplitterPosition( int pos,
 164                                         int splitterColumn = 0,
 165                                         int flags = wxPG_SPLITTER_REFRESH );
 166
 167     /** Page label (may be referred as name in some parts of documentation).
 168         Can be set in constructor, or passed in
 169         wxPropertyGridManager::AddPage(), but *not* in both.
 170     */
 171     wxString                m_label;
 172
 173 #ifndef SWIG
 174
 175     //virtual bool ProcessEvent( wxEvent& event );
 176
 177     wxPropertyGridManager*  m_manager;
 178
 179     int                     m_id;  // toolbar index
 180
 181 private:
 182     bool                    m_isDefault; // is this base page object?
 183
 184 private:
 185     DECLARE_EVENT_TABLE()
 186 #endif
 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 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 #ifndef SWIG
 643
 644 protected:
 645     virtual wxSize DoGetBestSize() const;
 646
 647     //
 648     // Event handlers
 649     //
 650     void OnMouseMove( wxMouseEvent &event );
 651     void OnMouseClick( wxMouseEvent &event );
 652     void OnMouseUp( wxMouseEvent &event );
 653     void OnMouseEntry( wxMouseEvent &event );
 654
 655     void OnPaint( wxPaintEvent &event );
 656
 657     void OnToolbarClick( wxCommandEvent &event );
 658     void OnResize( wxSizeEvent& event );
 659     void OnPropertyGridSelect( wxPropertyGridEvent& event );
 660     void OnPGColDrag( wxPropertyGridEvent& event );
 661
 662
 663     wxPropertyGrid* m_pPropGrid;
 664
 665     wxVector<wxPropertyGridPage*>   m_arrPages;
 666
 667 #if wxUSE_TOOLBAR
 668     wxToolBar*      m_pToolbar;
 669 #endif
 670 #if wxUSE_HEADERCTRL
 671     wxPGHeaderCtrl* m_pHeaderCtrl;
 672 #endif
 673     wxStaticText*   m_pTxtHelpCaption;
 674     wxStaticText*   m_pTxtHelpContent;
 675
 676     wxPropertyGridPage*     m_emptyPage;
 677
 678     wxArrayString   m_columnLabels;
 679
 680     long            m_iFlags;
 681
 682     // Selected page index.
 683     int             m_selPage;
 684
 685     int             m_width;
 686
 687     int             m_height;
 688
 689     int             m_extraHeight;
 690
 691     int             m_splitterY;
 692
 693     int             m_splitterHeight;
 694
 695     int             m_nextTbInd;
 696
 697     int             m_dragOffset;
 698
 699     wxCursor        m_cursorSizeNS;
 700
 701     int             m_nextDescBoxSize;
 702
 703     wxWindowID      m_baseId;
 704
 705     unsigned char   m_dragStatus;
 706
 707     unsigned char   m_onSplitter;
 708
 709     bool            m_showHeader;
 710
 711     virtual wxPGProperty* DoGetPropertyByName( const wxString& name ) const;
 712
 713     /** Select and displays a given page. */
 714     virtual bool DoSelectPage( int index );
 715
 716     // Sets some members to defaults.
 717     void Init1();
 718
 719     // Initializes some members.
 720     void Init2( int style );
 721
 722 /*#ifdef __WXMSW__
 723     virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle) const;
 724 #endif*/
 725
 726     virtual bool ProcessEvent( wxEvent& event );
 727
 728     /** Recalculates new positions for components, according to the
 729         given size.
 730     */
 731     void RecalculatePositions( int width, int height );
 732
 733     /** (Re)creates/destroys controls, according to the window style bits. */
 734     void RecreateControls();
 735
 736     void UpdateDescriptionBox( int new_splittery, int new_width, int new_height );
 737
 738     void RepaintDescBoxDecorations( wxDC& dc,
 739                                     int newSplitterY,
 740                                     int newWidth,
 741                                     int newHeight );
 742
 743     void SetDescribedProperty( wxPGProperty* p );
 744
 745     // Reimplement these to handle "descboxheight" state item
 746     virtual bool SetEditableStateItem( const wxString& name, wxVariant value );
 747     virtual wxVariant GetEditableStateItem( const wxString& name ) const;
 748
 749 private:
 750     DECLARE_EVENT_TABLE()
 751 #endif // #ifndef SWIG
 752 };
 753
 754 // -----------------------------------------------------------------------
 755
 756 inline int wxPropertyGridPage::GetIndex() const
 757 {
 758     if ( !m_manager )
 759         return wxNOT_FOUND;
 760     return m_manager->GetPageByState(this);
 761 }
 762
 763 // -----------------------------------------------------------------------
 764
 765 #endif // wxUSE_PROPGRID
 766
 767 #endif // _WX_PROPGRID_MANAGER_H_