interface/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     @headerfile aui.h wx/aui/aui.h
  48
  49     wxAuiManager is the central class of the wxAUI class framework.
  50     See also @ref overview_aui.
  51
  52     wxAuiManager manages the panes associated with it for a particular wxFrame,
  53     using a pane's wxAuiPaneInfo information to determine each pane's docking
  54     and floating behavior.
  55
  56     wxAuiManager uses wxWidgets' sizer mechanism to plan the layout of each frame.
  57     It uses a replaceable dock art class to do all drawing, so all drawing is
  58     localized in one area, and may be customized depending on an application's
  59     specific needs.
  60
  61     wxAuiManager works as follows: the programmer adds panes to the class,
  62     or makes changes to existing pane properties (dock position, floating
  63     state, show state, etc.). To apply these changes, wxAuiManager's
  64     Update() function is called. This batch processing can be used to avoid
  65     flicker, by modifying more than one pane at a time, and then "committing"
  66     all of the changes at once by calling Update().
  67
  68     Panes can be added quite easily:
  69
  70     @code
  71     wxTextCtrl* text1 = new wxTextCtrl(this, -1);
  72     wxTextCtrl* text2 = new wxTextCtrl(this, -1);
  73     m_mgr.AddPane(text1, wxLEFT, wxT("Pane Caption"));
  74     m_mgr.AddPane(text2, wxBOTTOM, wxT("Pane Caption"));
  75     m_mgr.Update();
  76     @endcode
  77
  78     Later on, the positions can be modified easily. The following will float
  79     an existing pane in a tool window:
  80
  81     @code
  82     m_mgr.GetPane(text1).Float();
  83     @endcode
  84
  85
  86     @section wxauimanager_layers Layers, Rows and Directions, Positions
  87
  88     Inside wxAUI, the docking layout is figured out by checking several pane
  89     parameters. Four of these are important for determining where a pane will end up:
  90
  91     @li Direction: Each docked pane has a direction, Top, Bottom, Left, Right, or Center.
  92         This is fairly self-explanatory. The pane will be placed in the location specified
  93         by this variable.
  94     @li Position: More than one pane can be placed inside of a dock. Imagine two panes
  95         being docked on the left side of a window. One pane can be placed over another.
  96         In proportionally managed docks, the pane position indicates its sequential position,
  97         starting with zero. So, in our scenario with two panes docked on the left side,
  98         the top pane in the dock would have position 0, and the second one would occupy
  99         position 1.
 100     @li Row: A row can allow for two docks to be placed next to each other. One of the
 101         most common places for this to happen is in the toolbar. Multiple toolbar rows
 102         are allowed, the first row being row 0, and the second row 1. Rows can also be
 103         used on vertically docked panes.
 104     @li Layer: A layer is akin to an onion. Layer 0 is the very center of the managed pane.
 105         Thus, if a pane is in layer 0, it will be closest to the center window (also
 106         sometimes known as the "content window"). Increasing layers "swallow up" all
 107         layers of a lower value. This can look very similar to multiple rows, but is
 108         different because all panes in a lower level yield to panes in higher levels.
 109         The best way to understand layers is by running the wxAUI sample.
 110
 111
 112     @library{wxbase}
 113     @category{aui}
 114
 115     @see wxAuiPaneInfo, wxAuiDockArt
 116 */
 117 class wxAuiManager : public wxEvtHandler
 118 {
 119 public:
 120     /**
 121         Constructor. @a managed_wnd specifies the wxFrame which should be managed.
 122         @a flags  specifies options which allow the frame management behavior
 123         to be modified.
 124     */
 125     wxAuiManager(wxWindow* managed_wnd = NULL,
 126                  unsigned int flags = wxAUI_MGR_DEFAULT);
 127
 128     /**
 129         Dtor.
 130     */
 131     virtual ~wxAuiManager();
 132
 133     //@{
 134     /**
 135         AddPane() tells the frame manager to start managing a child window.
 136         There are several versions of this function. The first version allows
 137         the full spectrum of pane parameter possibilities. The second version is
 138         used for simpler user interfaces which do not require as much configuration.
 139         The last version allows a drop position to be specified, which will determine
 140         where the pane will be added.
 141     */
 142     bool AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info);
 143     bool AddPane(wxWindow* window, int direction = wxLEFT,
 144                  const wxString& caption = wxEmptyString);
 145     bool AddPane(wxWindow* window,
 146                  const wxAuiPaneInfo& pane_info,
 147                  const wxPoint& drop_pos);
 148     //@}
 149
 150     /**
 151         Tells the wxAuiManager to stop managing the pane specified by window.
 152         The window, if in a floated frame, is reparented to the frame managed
 153         by wxAuiManager.
 154     */
 155     bool DetachPane(wxWindow* window);
 156
 157     /**
 158         Returns an array of all panes managed by the frame manager.
 159     */
 160     wxAuiPaneInfoArray& GetAllPanes();
 161
 162     /**
 163         Returns the current art provider being used.
 164         @see wxAuiDockArt.
 165     */
 166     wxAuiDockArt* GetArtProvider() const;
 167
 168     /**
 169         Returns the current dock constraint values.
 170         See SetDockSizeConstraint() for more information.
 171     */
 172     void GetDockSizeConstraint(double* widthpct, double* heightpct) const;
 173
 174     /**
 175         Returns the current manager's flags.
 176     */
 177     unsigned int GetFlags() const;
 178
 179     /**
 180         Returns the frame currently being managed by wxAuiManager.
 181     */
 182     wxWindow* GetManagedWindow() const;
 183
 184     /**
 185         Calling this method will return the wxAuiManager for a given window.
 186         The @a window parameter should specify any child window or sub-child
 187         window of the frame or window managed by wxAuiManager.
 188
 189         The @a window parameter need not be managed by the manager itself, nor does it
 190         even need to be a child or sub-child of a managed window. It must however
 191         be inside the window hierarchy underneath the managed window.
 192     */
 193     static wxAuiManager* GetManager(wxWindow* window);
 194
 195     //@{
 196     /**
 197         GetPane() is used to lookup a wxAuiPaneInfo object either by window pointer
 198         or by pane name, which acts as a unique id for a window pane.
 199
 200         The returned wxAuiPaneInfo object may then be modified to change a pane's
 201         look, state or position. After one or more modifications to wxAuiPaneInfo,
 202         wxAuiManager::Update() should be called to commit the changes to the user
 203         interface. If the lookup failed (meaning the pane could not be found in the
 204         manager), a call to the returned wxAuiPaneInfo's IsOk() method will return @false.
 205     */
 206     wxAuiPaneInfo GetPane(wxWindow* window);
 207     wxAuiPaneInfo GetPane(const wxString& name);
 208     //@}
 209
 210     /**
 211         HideHint() hides any docking hint that may be visible.
 212     */
 213     virtual void HideHint();
 214
 215     /**
 216         This method is used to insert either a previously unmanaged pane window
 217         into the frame manager, or to insert a currently managed pane somewhere
 218         else. InsertPane() will push all panes, rows, or docks aside and
 219         insert the window into the position specified by @a insert_location.
 220
 221         Because @a insert_location can specify either a pane, dock row, or dock
 222         layer, the @a insert_level parameter is used to disambiguate this.
 223         The parameter @a insert_level can take a value of wxAUI_INSERT_PANE,
 224         wxAUI_INSERT_ROW or wxAUI_INSERT_DOCK.
 225     */
 226     bool InsertPane(wxWindow* window,
 227                     const wxAuiPaneInfo& insert_location,
 228                     int insert_level = wxAUI_INSERT_PANE);
 229
 230     /**
 231         LoadPaneInfo() is similar to to LoadPerspective, with the exception that it
 232         only loads information about a single pane.  It is used in combination with
 233         SavePaneInfo().
 234     */
 235     void LoadPaneInfo(wxString pane_part, wxAuiPaneInfo& pane);
 236
 237     /**
 238         Loads a saved perspective. If update is @true, wxAuiManager::Update()
 239         is automatically invoked, thus realizing the saved perspective on screen.
 240     */
 241     bool LoadPerspective(const wxString& perspective,
 242                          bool update = true);
 243
 244     /**
 245         ProcessDockResult() is a protected member of the wxAUI layout manager.
 246         It can be overridden by derived classes to provide custom docking calculations.
 247     */
 248     bool ProcessDockResult(wxAuiPaneInfo& target,
 249                            const wxAuiPaneInfo& new_pos);
 250
 251     /**
 252         SavePaneInfo() is similar to SavePerspective, with the exception that it only
 253         saves information about a single pane.  It is used in combination with
 254         LoadPaneInfo().
 255     */
 256     wxString SavePaneInfo(wxAuiPaneInfo& pane);
 257
 258     /**
 259         Saves the entire user interface layout into an encoded wxString, which
 260         can then be stored by the application (probably using wxConfig).
 261
 262         When a perspective is restored using LoadPerspective(), the entire user
 263         interface will return to the state it was when the perspective was saved.
 264     */
 265     wxString SavePerspective();
 266
 267     /**
 268         Instructs wxAuiManager to use art provider specified by parameter
 269         @a art_provider for all drawing calls.
 270         This allows plugable look-and-feel features. The previous art provider object,
 271         if any, will be deleted by wxAuiManager.
 272
 273         @see wxAuiDockArt.
 274     */
 275     void SetArtProvider(wxAuiDockArt* art_provider);
 276
 277     /**
 278         When a user creates a new dock by dragging a window into a docked position,
 279         often times the large size of the window will create a dock that is unwieldly
 280         large. wxAuiManager by default limits the size of any new dock to 1/3 of the
 281         window size.  For horizontal docks, this would be 1/3 of the window height.
 282         For vertical docks, 1/3 of the width.
 283
 284         Calling this function will adjust this constraint value. The numbers must be
 285         between 0.0 and 1.0.  For instance, calling SetDockSizeContraint with
 286         0.5, 0.5 will cause new docks to be limited to half of the size of the
 287         entire managed window.
 288     */
 289     void SetDockSizeConstraint(double widthpct, double heightpct);
 290
 291     /**
 292         This method is used to specify wxAuiManager's settings flags. @a flags
 293         specifies options which allow the frame management behavior to be modified.
 294     */
 295     void SetFlags(unsigned int flags);
 296
 297     /**
 298         Called to specify the frame or window which is to be managed by wxAuiManager.
 299         Frame management is not restricted to just frames.  Child windows or custom
 300         controls are also allowed.
 301     */
 302     void SetManagedWindow(wxWindow* managed_wnd);
 303
 304     /**
 305         This function is used by controls to explicitly show a hint window at the
 306         specified rectangle. It is rarely called, and is mostly used by controls
 307         implementing custom pane drag/drop behaviour.
 308         The specified rectangle should be in screen coordinates.
 309     */
 310     virtual void ShowHint(const wxRect& rect);
 311
 312     /**
 313         Uninitializes the framework and should be called before a managed frame or
 314         window is destroyed. UnInit() is usually called in the managed wxFrame's
 315         destructor.  It is necessary to call this function before the managed frame
 316         or window is destroyed, otherwise the manager cannot remove its custom event
 317         handlers from a window.
 318     */
 319     void UnInit();
 320
 321     /**
 322         This method is called after any number of changes are
 323         made to any of the managed panes. Update() must be invoked after
 324         AddPane() or InsertPane() are called in order to "realize" or "commit"
 325         the changes. In addition, any number of changes may be made to
 326         wxAuiPaneInfo structures (retrieved with wxAuiManager::GetPane), but to
 327         realize the changes, Update() must be called. This construction allows
 328         pane flicker to be avoided by updating the whole layout at one time.
 329     */
 330     void Update();
 331 };
 332
 333
 334
 335 /**
 336     @class wxAuiPaneInfo
 337     @headerfile aui.h wx/aui/aui.h
 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 the property specified by flag is active for the
 520         pane.
 521     */
 522     bool HasFlag(unsigned 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 operator=(const wxAuiPaneInfo& c);
 768 };
 769