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