interface/wx/aui/framemanager.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        aui/aui.h
   3 // Purpose:     interface of wxAuiManager
   4 // Author:      wxWidgets team
   5 // RCS-ID:      $Id$
   6 // Licence:     wxWindows license
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9
  10 /**
  11     @todo TOWRITE
  12 */
  13 enum wxAuiManagerDock
  14 {
  15     wxAUI_DOCK_NONE = 0,
  16     wxAUI_DOCK_TOP = 1,
  17     wxAUI_DOCK_RIGHT = 2,
  18     wxAUI_DOCK_BOTTOM = 3,
  19     wxAUI_DOCK_LEFT = 4,
  20     wxAUI_DOCK_CENTER = 5,
  21     wxAUI_DOCK_CENTRE = wxAUI_DOCK_CENTER
  22 };
  23
  24
  25 /**
  26     @todo TOWRITE
  27 */
  28 enum wxAuiManagerOption
  29 {
  30     wxAUI_MGR_ALLOW_FLOATING           = 1 << 0,
  31     wxAUI_MGR_ALLOW_ACTIVE_PANE        = 1 << 1,
  32     wxAUI_MGR_TRANSPARENT_DRAG         = 1 << 2,
  33     wxAUI_MGR_TRANSPARENT_HINT         = 1 << 3,
  34     wxAUI_MGR_VENETIAN_BLINDS_HINT     = 1 << 4,
  35     wxAUI_MGR_RECTANGLE_HINT           = 1 << 5,
  36     wxAUI_MGR_HINT_FADE                = 1 << 6,
  37     wxAUI_MGR_NO_VENETIAN_BLINDS_FADE  = 1 << 7,
  38
  39     wxAUI_MGR_DEFAULT = wxAUI_MGR_ALLOW_FLOATING |
  40                         wxAUI_MGR_TRANSPARENT_HINT |
  41                         wxAUI_MGR_HINT_FADE |
  42                         wxAUI_MGR_NO_VENETIAN_BLINDS_FADE
  43 };
  44
  45 /**
  46     @class wxAuiManager
  47
  48     wxAuiManager is the central class of the wxAUI class framework.
  49     See also @ref overview_aui.
  50
  51     wxAuiManager manages the panes associated with it for a particular wxFrame,
  52     using a pane's wxAuiPaneInfo information to determine each pane's docking
  53     and floating behavior.
  54
  55     wxAuiManager uses wxWidgets' sizer mechanism to plan the layout of each frame.
  56     It uses a replaceable dock art class to do all drawing, so all drawing is
  57     localized in one area, and may be customized depending on an application's
  58     specific needs.
  59
  60     wxAuiManager works as follows: the programmer adds panes to the class,
  61     or makes changes to existing pane properties (dock position, floating
  62     state, show state, etc.). To apply these changes, wxAuiManager's
  63     Update() function is called. This batch processing can be used to avoid
  64     flicker, by modifying more than one pane at a time, and then "committing"
  65     all of the changes at once by calling Update().
  66
  67     Panes can be added quite easily:
  68
  69     @code
  70     wxTextCtrl* text1 = new wxTextCtrl(this, -1);
  71     wxTextCtrl* text2 = new wxTextCtrl(this, -1);
  72     m_mgr.AddPane(text1, wxLEFT, wxT("Pane Caption"));
  73     m_mgr.AddPane(text2, wxBOTTOM, wxT("Pane Caption"));
  74     m_mgr.Update();
  75     @endcode
  76
  77     Later on, the positions can be modified easily. The following will float
  78     an existing pane in a tool window:
  79
  80     @code
  81     m_mgr.GetPane(text1).Float();
  82     @endcode
  83
  84
  85     @section auimanager_layers Layers, Rows and Directions, Positions
  86
  87     Inside wxAUI, the docking layout is figured out by checking several pane
  88     parameters. Four of these are important for determining where a pane will end up:
  89
  90     @li Direction: Each docked pane has a direction, Top, Bottom, Left, Right, or Center.
  91         This is fairly self-explanatory. The pane will be placed in the location specified
  92         by this variable.
  93     @li Position: More than one pane can be placed inside of a dock. Imagine two panes
  94         being docked on the left side of a window. One pane can be placed over another.
  95         In proportionally managed docks, the pane position indicates its sequential position,
  96         starting with zero. So, in our scenario with two panes docked on the left side,
  97         the top pane in the dock would have position 0, and the second one would occupy
  98         position 1.
  99     @li Row: A row can allow for two docks to be placed next to each other. One of the
 100         most common places for this to happen is in the toolbar. Multiple toolbar rows
 101         are allowed, the first row being row 0, and the second row 1. Rows can also be
 102         used on vertically docked panes.
 103     @li Layer: A layer is akin to an onion. Layer 0 is the very center of the managed pane.
 104         Thus, if a pane is in layer 0, it will be closest to the center window (also
 105         sometimes known as the "content window"). Increasing layers "swallow up" all
 106         layers of a lower value. This can look very similar to multiple rows, but is
 107         different because all panes in a lower level yield to panes in higher levels.
 108         The best way to understand layers is by running the wxAUI sample.
 109
 110
 111     @library{wxbase}
 112     @category{aui}
 113
 114     @see wxAuiPaneInfo, wxAuiDockArt
 115 */
 116 class wxAuiManager : public wxEvtHandler
 117 {
 118 public:
 119     /**
 120         Constructor. @a managed_wnd specifies the wxFrame which should be managed.
 121         @a flags  specifies options which allow the frame management behavior
 122         to be modified.
 123     */
 124     wxAuiManager(wxWindow* managed_wnd = NULL,
 125                  unsigned int flags = wxAUI_MGR_DEFAULT);
 126
 127     /**
 128         Dtor.
 129     */
 130     virtual ~wxAuiManager();
 131
 132     //@{
 133     /**
 134         AddPane() tells the frame manager to start managing a child window.
 135         There are several versions of this function. The first version allows
 136         the full spectrum of pane parameter possibilities. The second version is
 137         used for simpler user interfaces which do not require as much configuration.
 138         The last version allows a drop position to be specified, which will determine
 139         where the pane will be added.
 140     */
 141     bool AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info);
 142     bool AddPane(wxWindow* window, int direction = wxLEFT,
 143                  const wxString& caption = wxEmptyString);
 144     bool AddPane(wxWindow* window,
 145                  const wxAuiPaneInfo& pane_info,
 146                  const wxPoint& drop_pos);
 147     //@}
 148
 149     /**
 150         Tells the wxAuiManager to stop managing the pane specified by window.
 151         The window, if in a floated frame, is reparented to the frame managed
 152         by wxAuiManager.
 153     */
 154     bool DetachPane(wxWindow* window);
 155
 156     /**
 157         Returns an array of all panes managed by the frame manager.
 158     */
 159     wxAuiPaneInfoArray& GetAllPanes();
 160
 161     /**
 162         Returns the current art provider being used.
 163         @see wxAuiDockArt.
 164     */
 165     wxAuiDockArt* GetArtProvider() const;
 166
 167     /**
 168         Returns the current dock constraint values.
 169         See SetDockSizeConstraint() for more information.
 170     */
 171     void GetDockSizeConstraint(double* widthpct, double* heightpct) const;
 172
 173     /**
 174         Returns the current manager's flags.
 175     */
 176     unsigned int GetFlags() const;
 177
 178     /**
 179         Returns the frame currently being managed by wxAuiManager.
 180     */
 181     wxWindow* GetManagedWindow() const;
 182
 183     /**
 184         Calling this method will return the wxAuiManager for a given window.
 185         The @a window parameter should specify any child window or sub-child
 186         window of the frame or window managed by wxAuiManager.
 187
 188         The @a window parameter need not be managed by the manager itself, nor does it
 189         even need to be a child or sub-child of a managed window. It must however
 190         be inside the window hierarchy underneath the managed window.
 191     */
 192     static wxAuiManager* GetManager(wxWindow* window);
 193
 194     //@{
 195     /**
 196         GetPane() is used to lookup a wxAuiPaneInfo object either by window pointer
 197         or by pane name, which acts as a unique id for a window pane.
 198
 199         The returned wxAuiPaneInfo object may then be modified to change a pane's
 200         look, state or position. After one or more modifications to wxAuiPaneInfo,
 201         wxAuiManager::Update() should be called to commit the changes to the user
 202         interface. If the lookup failed (meaning the pane could not be found in the
 203         manager), a call to the returned wxAuiPaneInfo's IsOk() method will return @false.
 204     */
 205     wxAuiPaneInfo GetPane(wxWindow* window);
 206     wxAuiPaneInfo GetPane(const wxString& name);
 207     //@}
 208
 209     /**
 210         HideHint() hides any docking hint that may be visible.
 211     */
 212     virtual void HideHint();
 213
 214     /**
 215         This method is used to insert either a previously unmanaged pane window
 216         into the frame manager, or to insert a currently managed pane somewhere
 217         else. InsertPane() will push all panes, rows, or docks aside and
 218         insert the window into the position specified by @a insert_location.
 219
 220         Because @a insert_location can specify either a pane, dock row, or dock
 221         layer, the @a insert_level parameter is used to disambiguate this.
 222         The parameter @a insert_level can take a value of wxAUI_INSERT_PANE,
 223         wxAUI_INSERT_ROW or wxAUI_INSERT_DOCK.
 224     */
 225     bool InsertPane(wxWindow* window,
 226                     const wxAuiPaneInfo& insert_location,
 227                     int insert_level = wxAUI_INSERT_PANE);
 228
 229     /**
 230         LoadPaneInfo() is similar to to LoadPerspective, with the exception that it
 231         only loads information about a single pane.  It is used in combination with
 232         SavePaneInfo().
 233     */
 234     void LoadPaneInfo(wxString pane_part, wxAuiPaneInfo& pane);
 235
 236     /**
 237         Loads a saved perspective. If update is @true, wxAuiManager::Update()
 238         is automatically invoked, thus realizing the saved perspective on screen.
 239     */
 240     bool LoadPerspective(const wxString& perspective,
 241                          bool update = true);
 242
 243     /**
 244         SavePaneInfo() is similar to SavePerspective, with the exception that it only
 245         saves information about a single pane.  It is used in combination with
 246         LoadPaneInfo().
 247     */
 248     wxString SavePaneInfo(wxAuiPaneInfo& pane);
 249
 250     /**
 251         Saves the entire user interface layout into an encoded wxString, which
 252         can then be stored by the application (probably using wxConfig).
 253
 254         When a perspective is restored using LoadPerspective(), the entire user
 255         interface will return to the state it was when the perspective was saved.
 256     */
 257     wxString SavePerspective();
 258
 259     /**
 260         Instructs wxAuiManager to use art provider specified by parameter
 261         @a art_provider for all drawing calls.
 262         This allows plugable look-and-feel features. The previous art provider object,
 263         if any, will be deleted by wxAuiManager.
 264
 265         @see wxAuiDockArt.
 266     */
 267     void SetArtProvider(wxAuiDockArt* art_provider);
 268
 269     /**
 270         When a user creates a new dock by dragging a window into a docked position,
 271         often times the large size of the window will create a dock that is unwieldly
 272         large. wxAuiManager by default limits the size of any new dock to 1/3 of the
 273         window size.  For horizontal docks, this would be 1/3 of the window height.
 274         For vertical docks, 1/3 of the width.
 275
 276         Calling this function will adjust this constraint value. The numbers must be
 277         between 0.0 and 1.0.  For instance, calling SetDockSizeContraint with
 278         0.5, 0.5 will cause new docks to be limited to half of the size of the
 279         entire managed window.
 280     */
 281     void SetDockSizeConstraint(double widthpct, double heightpct);
 282
 283     /**
 284         This method is used to specify wxAuiManager's settings flags. @a flags
 285         specifies options which allow the frame management behavior to be modified.
 286     */
 287     void SetFlags(int flags);
 288
 289     /**
 290         Called to specify the frame or window which is to be managed by wxAuiManager.
 291         Frame management is not restricted to just frames.  Child windows or custom
 292         controls are also allowed.
 293     */
 294     void SetManagedWindow(wxWindow* managed_wnd);
 295
 296     /**
 297         This function is used by controls to explicitly show a hint window at the
 298         specified rectangle. It is rarely called, and is mostly used by controls
 299         implementing custom pane drag/drop behaviour.
 300         The specified rectangle should be in screen coordinates.
 301     */
 302     virtual void ShowHint(const wxRect& rect);
 303
 304     /**
 305         Uninitializes the framework and should be called before a managed frame or
 306         window is destroyed. UnInit() is usually called in the managed wxFrame's
 307         destructor.  It is necessary to call this function before the managed frame
 308         or window is destroyed, otherwise the manager cannot remove its custom event
 309         handlers from a window.
 310     */
 311     void UnInit();
 312
 313     /**
 314         This method is called after any number of changes are
 315         made to any of the managed panes. Update() must be invoked after
 316         AddPane() or InsertPane() are called in order to "realize" or "commit"
 317         the changes. In addition, any number of changes may be made to
 318         wxAuiPaneInfo structures (retrieved with wxAuiManager::GetPane), but to
 319         realize the changes, Update() must be called. This construction allows
 320         pane flicker to be avoided by updating the whole layout at one time.
 321     */
 322     void Update();
 323
 324 protected:
 325
 326     /**
 327         ProcessDockResult() is a protected member of the wxAUI layout manager.
 328         It can be overridden by derived classes to provide custom docking calculations.
 329     */
 330     virtual bool ProcessDockResult(wxAuiPaneInfo& target,
 331                                    const wxAuiPaneInfo& new_pos);
 332 };
 333
 334
 335
 336 /**
 337     @class wxAuiPaneInfo
 338
 339     wxAuiPaneInfo is part of the wxAUI class framework.
 340     See also @ref overview_aui.
 341
 342     wxAuiPaneInfo specifies all the parameters for a pane.
 343     These parameters specify where the pane is on the screen, whether it is docked
 344     or floating, or hidden.
 345     In addition, these parameters specify the pane's docked position, floating
 346     position, preferred size, minimum size, caption text among many other parameters.
 347
 348     @library{wxbase}
 349     @category{aui}
 350
 351     @see wxAuiManager, wxAuiDockArt
 352 */
 353 class wxAuiPaneInfo
 354 {
 355 public:
 356     wxAuiPaneInfo();
 357
 358     /**
 359         Copy constructor.
 360     */
 361     wxAuiPaneInfo(const wxAuiPaneInfo& c);
 362
 363     //@{
 364     /**
 365         BestSize() sets the ideal size for the pane. The docking manager will attempt
 366         to use this size as much as possible when docking or floating the pane.
 367     */
 368     wxAuiPaneInfo BestSize(const wxSize& size);
 369     wxAuiPaneInfo BestSize(int x, int y);
 370     //@}
 371
 372     /**
 373         Bottom() sets the pane dock position to the bottom side of the frame. This is
 374         the same thing as calling Direction(wxAUI_DOCK_BOTTOM).
 375     */
 376     wxAuiPaneInfo& Bottom();
 377
 378     /**
 379         BottomDockable() indicates whether a pane can be docked at the bottom of the
 380         frame.
 381     */
 382     wxAuiPaneInfo& BottomDockable(bool b = true);
 383
 384     /**
 385         Caption() sets the caption of the pane.
 386     */
 387     wxAuiPaneInfo& Caption(const wxString& c);
 388
 389     /**
 390         CaptionVisible indicates that a pane caption should be visible. If @false, no
 391         pane caption is drawn.
 392     */
 393     wxAuiPaneInfo& CaptionVisible(bool visible = true);
 394
 395     //@{
 396     /**
 397         Center() sets the pane dock position to the left side of the frame.
 398         The centre pane is the space in the middle after all border panes (left, top,
 399         right, bottom) are subtracted from the layout.
 400         This is the same thing as calling Direction(wxAUI_DOCK_CENTRE).
 401     */
 402     wxAuiPaneInfo Centre();
 403     wxAuiPaneInfo Center();
 404     //@}
 405
 406     //@{
 407     /**
 408         CentrePane() specifies that the pane should adopt the default center pane
 409         settings. Centre panes usually do not have caption bars.
 410         This function provides an easy way of preparing a pane to be displayed in
 411         the center dock position.
 412     */
 413     wxAuiPaneInfo CentrePane();
 414     wxAuiPaneInfo CenterPane();
 415     //@}
 416
 417     /**
 418         CloseButton() indicates that a close button should be drawn for the pane.
 419     */
 420     wxAuiPaneInfo& CloseButton(bool visible = true);
 421
 422     /**
 423         DefaultPane() specifies that the pane should adopt the default pane settings.
 424     */
 425     wxAuiPaneInfo& DefaultPane();
 426
 427     /**
 428         DestroyOnClose() indicates whether a pane should be detroyed when it is closed.
 429         Normally a pane is simply hidden when the close button is clicked.
 430         Setting DestroyOnClose to @true will cause the window to be destroyed when
 431         the user clicks the pane's close button.
 432     */
 433     wxAuiPaneInfo& DestroyOnClose(bool b = true);
 434
 435     /**
 436         Direction() determines the direction of the docked pane. It is functionally the
 437         same as calling Left(), Right(), Top() or Bottom(), except that docking direction
 438         may be specified programmatically via the parameter.
 439     */
 440     wxAuiPaneInfo& Direction(int direction);
 441
 442     /**
 443         Dock() indicates that a pane should be docked.  It is the opposite of Float().
 444     */
 445     wxAuiPaneInfo& Dock();
 446
 447     /**
 448         DockFixed() causes the containing dock to have no resize sash.  This is useful
 449         for creating panes that span the entire width or height of a dock, but should
 450         not be resizable in the other direction.
 451     */
 452     wxAuiPaneInfo& DockFixed(bool b = true);
 453
 454     /**
 455         Dockable() specifies whether a frame can be docked or not. It is the same as
 456         specifying TopDockable(b).BottomDockable(b).LeftDockable(b).RightDockable(b).
 457     */
 458     wxAuiPaneInfo& Dockable(bool b = true);
 459
 460     /**
 461         Fixed() forces a pane to be fixed size so that it cannot be resized. After
 462         calling Fixed(), IsFixed() will return @true.
 463     */
 464     wxAuiPaneInfo& Fixed();
 465
 466     /**
 467         Float() indicates that a pane should be floated.  It is the opposite of Dock().
 468     */
 469     wxAuiPaneInfo& Float();
 470
 471     /**
 472         Floatable() sets whether the user will be able to undock a pane and turn it
 473         into a floating window.
 474     */
 475     wxAuiPaneInfo& Floatable(bool b = true);
 476
 477     //@{
 478     /**
 479         FloatingPosition() sets the position of the floating pane.
 480     */
 481     wxAuiPaneInfo FloatingPosition(const wxPoint& pos);
 482     wxAuiPaneInfo FloatingPosition(int x, int y);
 483     //@}
 484
 485     //@{
 486     /**
 487         FloatingSize() sets the size of the floating pane.
 488     */
 489     wxAuiPaneInfo FloatingSize(const wxSize& size);
 490     wxAuiPaneInfo FloatingSize(int x, int y);
 491     //@}
 492
 493     /**
 494         Gripper() indicates that a gripper should be drawn for the pane.
 495     */
 496     wxAuiPaneInfo& Gripper(bool visible = true);
 497
 498     /**
 499         GripperTop() indicates that a gripper should be drawn at the top of the pane.
 500     */
 501     wxAuiPaneInfo& GripperTop(bool attop = true);
 502
 503     /**
 504         HasBorder() returns @true if the pane displays a border.
 505     */
 506     bool HasBorder() const;
 507
 508     /**
 509         HasCaption() returns @true if the pane displays a caption.
 510     */
 511     bool HasCaption() const;
 512
 513     /**
 514         HasCloseButton() returns @true if the pane displays a button to close the pane.
 515     */
 516     bool HasCloseButton() const;
 517
 518     /**
 519         HasFlag() returns @true if the property specified by flag is active for
 520         the pane.
 521     */
 522     bool HasFlag(int flag) const;
 523
 524     /**
 525         HasGripper() returns @true if the pane displays a gripper.
 526     */
 527     bool HasGripper() const;
 528
 529     /**
 530         HasGripper() returns @true if the pane displays a gripper at the top.
 531     */
 532     bool HasGripperTop() const;
 533
 534     /**
 535         HasMaximizeButton() returns @true if the pane displays a button to maximize the
 536         pane.
 537     */
 538     bool HasMaximizeButton() const;
 539
 540     /**
 541         HasMinimizeButton() returns @true if the pane displays a button to minimize the
 542         pane.
 543     */
 544     bool HasMinimizeButton() const;
 545
 546     /**
 547         HasPinButton() returns @true if the pane displays a button to float the pane.
 548     */
 549     bool HasPinButton() const;
 550
 551     /**
 552         Hide() indicates that a pane should be hidden.
 553     */
 554     wxAuiPaneInfo& Hide();
 555
 556     /**
 557         IsBottomDockable() returns @true if the pane can be docked at the bottom of the
 558         managed frame.
 559     */
 560     bool IsBottomDockable() const;
 561
 562     /**
 563         IsDocked() returns @true if the pane is docked.
 564     */
 565     bool IsDocked() const;
 566
 567     /**
 568         IsFixed() returns @true if the pane cannot be resized.
 569     */
 570     bool IsFixed() const;
 571
 572     /**
 573         IsFloatable() returns @true if the pane can be undocked and displayed as a
 574         floating window.
 575     */
 576     bool IsFloatable() const;
 577
 578     /**
 579         IsFloating() returns @true if the pane is floating.
 580     */
 581     bool IsFloating() const;
 582
 583     /**
 584         IsLeftDockable() returns @true if the pane can be docked on the left of the
 585         managed frame.
 586     */
 587     bool IsLeftDockable() const;
 588
 589     /**
 590         IsMoveable() returns @true if the docked frame can be undocked or moved to
 591         another dock position.
 592     */
 593     bool IsMovable() const;
 594
 595     /**
 596         IsOk() returns @true if the wxAuiPaneInfo structure is valid. A pane structure
 597         is valid if it has an associated window.
 598     */
 599     bool IsOk() const;
 600
 601     /**
 602         IsResizable() returns @true if the pane can be resized.
 603     */
 604     bool IsResizable() const;
 605
 606     /**
 607         IsRightDockable() returns @true if the pane can be docked on the right of the
 608         managed frame.
 609     */
 610     bool IsRightDockable() const;
 611
 612     /**
 613         IsShown() returns @true if the pane is currently shown.
 614     */
 615     bool IsShown() const;
 616
 617     /**
 618         IsToolbar() returns @true if the pane contains a toolbar.
 619     */
 620     bool IsToolbar() const;
 621
 622     /**
 623         IsTopDockable() returns @true if the pane can be docked at the top of the
 624         managed frame.
 625     */
 626     bool IsTopDockable() const;
 627
 628     /**
 629         Layer() determines the layer of the docked pane. The dock layer is similar to
 630         an onion, the inner-most layer being layer 0. Each shell moving in the outward
 631         direction has a higher layer number. This allows for more complex docking layout
 632         formation.
 633     */
 634     wxAuiPaneInfo& Layer(int layer);
 635
 636     /**
 637         Left() sets the pane dock position to the left side of the frame. This is the
 638         same thing as calling Direction(wxAUI_DOCK_LEFT).
 639     */
 640     wxAuiPaneInfo& Left();
 641
 642     /**
 643         LeftDockable() indicates whether a pane can be docked on the left of the frame.
 644     */
 645     wxAuiPaneInfo& LeftDockable(bool b = true);
 646
 647     //@{
 648     /**
 649         MaxSize() sets the maximum size of the pane.
 650     */
 651     wxAuiPaneInfo MaxSize(const wxSize& size);
 652     wxAuiPaneInfo MaxSize(int x, int y);
 653     //@}
 654
 655     /**
 656         MaximizeButton() indicates that a maximize button should be drawn for the pane.
 657     */
 658     wxAuiPaneInfo& MaximizeButton(bool visible = true);
 659
 660     //@{
 661     /**
 662         MinSize() sets the minimum size of the pane. Please note that this is only
 663         partially supported as of this writing.
 664     */
 665     wxAuiPaneInfo MinSize(const wxSize& size);
 666     wxAuiPaneInfo MinSize(int x, int y);
 667     //@}
 668
 669     /**
 670         MinimizeButton() indicates that a minimize button should be drawn for the pane.
 671     */
 672     wxAuiPaneInfo& MinimizeButton(bool visible = true);
 673
 674     /**
 675         Movable indicates whether a frame can be moved.
 676     */
 677     wxAuiPaneInfo& Movable(bool b = true);
 678
 679     /**
 680         Name() sets the name of the pane so it can be referenced in lookup functions.
 681         If a name is not specified by the user, a random name is assigned to the pane
 682         when it is added to the manager.
 683     */
 684     wxAuiPaneInfo& Name(const wxString& n);
 685
 686     /**
 687         PaneBorder indicates that a border should be drawn for the pane.
 688     */
 689     wxAuiPaneInfo& PaneBorder(bool visible = true);
 690
 691     /**
 692         PinButton() indicates that a pin button should be drawn for the pane.
 693     */
 694     wxAuiPaneInfo& PinButton(bool visible = true);
 695
 696     /**
 697         Position() determines the position of the docked pane.
 698     */
 699     wxAuiPaneInfo& Position(int pos);
 700
 701     /**
 702         Resizable() allows a pane to be resized if the parameter is @true, and forces it
 703         to be a fixed size if the parameter is @false. This is simply an antonym for Fixed().
 704     */
 705     wxAuiPaneInfo& Resizable(bool resizable = true);
 706
 707     /**
 708         Right() sets the pane dock position to the right side of the frame.
 709     */
 710     wxAuiPaneInfo& Right();
 711
 712     /**
 713         RightDockable() indicates whether a pane can be docked on the right of the
 714         frame.
 715     */
 716     wxAuiPaneInfo& RightDockable(bool b = true);
 717
 718     /**
 719         Row() determines the row of the docked pane.
 720     */
 721     wxAuiPaneInfo& Row(int row);
 722
 723     /**
 724         Write the safe parts of a newly loaded PaneInfo structure "source" into "this"
 725         used on loading perspectives etc.
 726     */
 727     void SafeSet(wxAuiPaneInfo source);
 728
 729     /**
 730         SetFlag() turns the property given by flag on or off with the option_state
 731         parameter.
 732     */
 733     wxAuiPaneInfo& SetFlag(unsigned int flag, bool option_state);
 734
 735     /**
 736         Show() indicates that a pane should be shown.
 737     */
 738     wxAuiPaneInfo& Show(bool show = true);
 739
 740     /**
 741         ToolbarPane() specifies that the pane should adopt the default toolbar pane
 742         settings.
 743     */
 744     wxAuiPaneInfo& ToolbarPane();
 745
 746     /**
 747         Top() sets the pane dock position to the top of the frame.
 748     */
 749     wxAuiPaneInfo& Top();
 750
 751     /**
 752         TopDockable() indicates whether a pane can be docked at the top of the frame.
 753     */
 754     wxAuiPaneInfo& TopDockable(bool b = true);
 755
 756     /**
 757         Window() assigns the window pointer that the wxAuiPaneInfo should use.
 758         This normally does not need to be specified, as the window pointer is
 759         automatically assigned to the wxAuiPaneInfo structure as soon as it is added
 760         to the manager.
 761     */
 762     wxAuiPaneInfo& Window(wxWindow* w);
 763
 764     /**
 765         Makes a copy of the wxAuiPaneInfo object.
 766     */
 767     wxAuiPaneInfo& operator=(const wxAuiPaneInfo& c);
 768 };
 769