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         SavePaneInfo() is similar to SavePerspective, with the exception that it only
 246         saves information about a single pane.  It is used in combination with
 247         LoadPaneInfo().
 248     */
 249     wxString SavePaneInfo(wxAuiPaneInfo& pane);
 250
 251     /**
 252         Saves the entire user interface layout into an encoded wxString, which
 253         can then be stored by the application (probably using wxConfig).
 254
 255         When a perspective is restored using LoadPerspective(), the entire user
 256         interface will return to the state it was when the perspective was saved.
 257     */
 258     wxString SavePerspective();
 259
 260     /**
 261         Instructs wxAuiManager to use art provider specified by parameter
 262         @a art_provider for all drawing calls.
 263         This allows plugable look-and-feel features. The previous art provider object,
 264         if any, will be deleted by wxAuiManager.
 265
 266         @see wxAuiDockArt.
 267     */
 268     void SetArtProvider(wxAuiDockArt* art_provider);
 269
 270     /**
 271         When a user creates a new dock by dragging a window into a docked position,
 272         often times the large size of the window will create a dock that is unwieldly
 273         large. wxAuiManager by default limits the size of any new dock to 1/3 of the
 274         window size.  For horizontal docks, this would be 1/3 of the window height.
 275         For vertical docks, 1/3 of the width.
 276
 277         Calling this function will adjust this constraint value. The numbers must be
 278         between 0.0 and 1.0.  For instance, calling SetDockSizeContraint with
 279         0.5, 0.5 will cause new docks to be limited to half of the size of the
 280         entire managed window.
 281     */
 282     void SetDockSizeConstraint(double widthpct, double heightpct);
 283
 284     /**
 285         This method is used to specify wxAuiManager's settings flags. @a flags
 286         specifies options which allow the frame management behavior to be modified.
 287     */
 288     void SetFlags(unsigned int flags);
 289
 290     /**
 291         Called to specify the frame or window which is to be managed by wxAuiManager.
 292         Frame management is not restricted to just frames.  Child windows or custom
 293         controls are also allowed.
 294     */
 295     void SetManagedWindow(wxWindow* managed_wnd);
 296
 297     /**
 298         This function is used by controls to explicitly show a hint window at the
 299         specified rectangle. It is rarely called, and is mostly used by controls
 300         implementing custom pane drag/drop behaviour.
 301         The specified rectangle should be in screen coordinates.
 302     */
 303     virtual void ShowHint(const wxRect& rect);
 304
 305     /**
 306         Uninitializes the framework and should be called before a managed frame or
 307         window is destroyed. UnInit() is usually called in the managed wxFrame's
 308         destructor.  It is necessary to call this function before the managed frame
 309         or window is destroyed, otherwise the manager cannot remove its custom event
 310         handlers from a window.
 311     */
 312     void UnInit();
 313
 314     /**
 315         This method is called after any number of changes are
 316         made to any of the managed panes. Update() must be invoked after
 317         AddPane() or InsertPane() are called in order to "realize" or "commit"
 318         the changes. In addition, any number of changes may be made to
 319         wxAuiPaneInfo structures (retrieved with wxAuiManager::GetPane), but to
 320         realize the changes, Update() must be called. This construction allows
 321         pane flicker to be avoided by updating the whole layout at one time.
 322     */
 323     void Update();
 324
 325 protected:
 326
 327     /**
 328         ProcessDockResult() is a protected member of the wxAUI layout manager.
 329         It can be overridden by derived classes to provide custom docking calculations.
 330     */
 331     virtual bool ProcessDockResult(wxAuiPaneInfo& target,
 332                                    const wxAuiPaneInfo& new_pos);
 333 };
 334
 335
 336
 337 /**
 338     @class wxAuiPaneInfo
 339     @headerfile aui.h wx/aui/aui.h
 340
 341     wxAuiPaneInfo is part of the wxAUI class framework.
 342     See also @ref overview_aui.
 343
 344     wxAuiPaneInfo specifies all the parameters for a pane.
 345     These parameters specify where the pane is on the screen, whether it is docked
 346     or floating, or hidden.
 347     In addition, these parameters specify the pane's docked position, floating
 348     position, preferred size, minimum size, caption text among many other parameters.
 349
 350     @library{wxbase}
 351     @category{aui}
 352
 353     @see wxAuiManager, wxAuiDockArt
 354 */
 355 class wxAuiPaneInfo
 356 {
 357 public:
 358     wxAuiPaneInfo();
 359
 360     /**
 361         Copy constructor.
 362     */
 363     wxAuiPaneInfo(const wxAuiPaneInfo& c);
 364
 365     //@{
 366     /**
 367         BestSize() sets the ideal size for the pane. The docking manager will attempt
 368         to use this size as much as possible when docking or floating the pane.
 369     */
 370     wxAuiPaneInfo BestSize(const wxSize& size);
 371     wxAuiPaneInfo BestSize(int x, int y);
 372     //@}
 373
 374     /**
 375         Bottom() sets the pane dock position to the bottom side of the frame. This is
 376         the same thing as calling Direction(wxAUI_DOCK_BOTTOM).
 377     */
 378     wxAuiPaneInfo& Bottom();
 379
 380     /**
 381         BottomDockable() indicates whether a pane can be docked at the bottom of the
 382         frame.
 383     */
 384     wxAuiPaneInfo& BottomDockable(bool b = true);
 385
 386     /**
 387         Caption() sets the caption of the pane.
 388     */
 389     wxAuiPaneInfo& Caption(const wxString& c);
 390
 391     /**
 392         CaptionVisible indicates that a pane caption should be visible. If @false, no
 393         pane caption is drawn.
 394     */
 395     wxAuiPaneInfo& CaptionVisible(bool visible = true);
 396
 397     //@{
 398     /**
 399         Center() sets the pane dock position to the left side of the frame.
 400         The centre pane is the space in the middle after all border panes (left, top,
 401         right, bottom) are subtracted from the layout.
 402         This is the same thing as calling Direction(wxAUI_DOCK_CENTRE).
 403     */
 404     wxAuiPaneInfo Centre();
 405     wxAuiPaneInfo Center();
 406     //@}
 407
 408     //@{
 409     /**
 410         CentrePane() specifies that the pane should adopt the default center pane
 411         settings. Centre panes usually do not have caption bars.
 412         This function provides an easy way of preparing a pane to be displayed in
 413         the center dock position.
 414     */
 415     wxAuiPaneInfo CentrePane();
 416     wxAuiPaneInfo CenterPane();
 417     //@}
 418
 419     /**
 420         CloseButton() indicates that a close button should be drawn for the pane.
 421     */
 422     wxAuiPaneInfo& CloseButton(bool visible = true);
 423
 424     /**
 425         DefaultPane() specifies that the pane should adopt the default pane settings.
 426     */
 427     wxAuiPaneInfo& DefaultPane();
 428
 429     /**
 430         DestroyOnClose() indicates whether a pane should be detroyed when it is closed.
 431         Normally a pane is simply hidden when the close button is clicked.
 432         Setting DestroyOnClose to @true will cause the window to be destroyed when
 433         the user clicks the pane's close button.
 434     */
 435     wxAuiPaneInfo& DestroyOnClose(bool b = true);
 436
 437     /**
 438         Direction() determines the direction of the docked pane. It is functionally the
 439         same as calling Left(), Right(), Top() or Bottom(), except that docking direction
 440         may be specified programmatically via the parameter.
 441     */
 442     wxAuiPaneInfo& Direction(int direction);
 443
 444     /**
 445         Dock() indicates that a pane should be docked.  It is the opposite of Float().
 446     */
 447     wxAuiPaneInfo& Dock();
 448
 449     /**
 450         DockFixed() causes the containing dock to have no resize sash.  This is useful
 451         for creating panes that span the entire width or height of a dock, but should
 452         not be resizable in the other direction.
 453     */
 454     wxAuiPaneInfo& DockFixed(bool b = true);
 455
 456     /**
 457         Dockable() specifies whether a frame can be docked or not. It is the same as
 458         specifying TopDockable(b).BottomDockable(b).LeftDockable(b).RightDockable(b).
 459     */
 460     wxAuiPaneInfo& Dockable(bool b = true);
 461
 462     /**
 463         Fixed() forces a pane to be fixed size so that it cannot be resized. After
 464         calling Fixed(), IsFixed() will return @true.
 465     */
 466     wxAuiPaneInfo& Fixed();
 467
 468     /**
 469         Float() indicates that a pane should be floated.  It is the opposite of Dock().
 470     */
 471     wxAuiPaneInfo& Float();
 472
 473     /**
 474         Floatable() sets whether the user will be able to undock a pane and turn it
 475         into a floating window.
 476     */
 477     wxAuiPaneInfo& Floatable(bool b = true);
 478
 479     //@{
 480     /**
 481         FloatingPosition() sets the position of the floating pane.
 482     */
 483     wxAuiPaneInfo FloatingPosition(const wxPoint& pos);
 484     wxAuiPaneInfo FloatingPosition(int x, int y);
 485     //@}
 486
 487     //@{
 488     /**
 489         FloatingSize() sets the size of the floating pane.
 490     */
 491     wxAuiPaneInfo FloatingSize(const wxSize& size);
 492     wxAuiPaneInfo FloatingSize(int x, int y);
 493     //@}
 494
 495     /**
 496         Gripper() indicates that a gripper should be drawn for the pane.
 497     */
 498     wxAuiPaneInfo& Gripper(bool visible = true);
 499
 500     /**
 501         GripperTop() indicates that a gripper should be drawn at the top of the pane.
 502     */
 503     wxAuiPaneInfo& GripperTop(bool attop = true);
 504
 505     /**
 506         HasBorder() returns @true if the pane displays a border.
 507     */
 508     bool HasBorder() const;
 509
 510     /**
 511         HasCaption() returns @true if the pane displays a caption.
 512     */
 513     bool HasCaption() const;
 514
 515     /**
 516         HasCloseButton() returns @true if the pane displays a button to close the pane.
 517     */
 518     bool HasCloseButton() const;
 519
 520     /**
 521         HasFlag() returns @true if the the property specified by flag is active for the
 522         pane.
 523     */
 524     bool HasFlag(unsigned int flag) const;
 525
 526     /**
 527         HasGripper() returns @true if the pane displays a gripper.
 528     */
 529     bool HasGripper() const;
 530
 531     /**
 532         HasGripper() returns @true if the pane displays a gripper at the top.
 533     */
 534     bool HasGripperTop() const;
 535
 536     /**
 537         HasMaximizeButton() returns @true if the pane displays a button to maximize the
 538         pane.
 539     */
 540     bool HasMaximizeButton() const;
 541
 542     /**
 543         HasMinimizeButton() returns @true if the pane displays a button to minimize the
 544         pane.
 545     */
 546     bool HasMinimizeButton() const;
 547
 548     /**
 549         HasPinButton() returns @true if the pane displays a button to float the pane.
 550     */
 551     bool HasPinButton() const;
 552
 553     /**
 554         Hide() indicates that a pane should be hidden.
 555     */
 556     wxAuiPaneInfo& Hide();
 557
 558     /**
 559         IsBottomDockable() returns @true if the pane can be docked at the bottom of the
 560         managed frame.
 561     */
 562     bool IsBottomDockable() const;
 563
 564     /**
 565         IsDocked() returns @true if the pane is docked.
 566     */
 567     bool IsDocked() const;
 568
 569     /**
 570         IsFixed() returns @true if the pane cannot be resized.
 571     */
 572     bool IsFixed() const;
 573
 574     /**
 575         IsFloatable() returns @true if the pane can be undocked and displayed as a
 576         floating window.
 577     */
 578     bool IsFloatable() const;
 579
 580     /**
 581         IsFloating() returns @true if the pane is floating.
 582     */
 583     bool IsFloating() const;
 584
 585     /**
 586         IsLeftDockable() returns @true if the pane can be docked on the left of the
 587         managed frame.
 588     */
 589     bool IsLeftDockable() const;
 590
 591     /**
 592         IsMoveable() returns @true if the docked frame can be undocked or moved to
 593         another dock position.
 594     */
 595     bool IsMovable() const;
 596
 597     /**
 598         IsOk() returns @true if the wxAuiPaneInfo structure is valid. A pane structure
 599         is valid if it has an associated window.
 600     */
 601     bool IsOk() const;
 602
 603     /**
 604         IsResizable() returns @true if the pane can be resized.
 605     */
 606     bool IsResizable() const;
 607
 608     /**
 609         IsRightDockable() returns @true if the pane can be docked on the right of the
 610         managed frame.
 611     */
 612     bool IsRightDockable() const;
 613
 614     /**
 615         IsShown() returns @true if the pane is currently shown.
 616     */
 617     bool IsShown() const;
 618
 619     /**
 620         IsToolbar() returns @true if the pane contains a toolbar.
 621     */
 622     bool IsToolbar() const;
 623
 624     /**
 625         IsTopDockable() returns @true if the pane can be docked at the top of the
 626         managed frame.
 627     */
 628     bool IsTopDockable() const;
 629
 630     /**
 631         Layer() determines the layer of the docked pane. The dock layer is similar to
 632         an onion, the inner-most layer being layer 0. Each shell moving in the outward
 633         direction has a higher layer number. This allows for more complex docking layout
 634         formation.
 635     */
 636     wxAuiPaneInfo& Layer(int layer);
 637
 638     /**
 639         Left() sets the pane dock position to the left side of the frame. This is the
 640         same thing as calling Direction(wxAUI_DOCK_LEFT).
 641     */
 642     wxAuiPaneInfo& Left();
 643
 644     /**
 645         LeftDockable() indicates whether a pane can be docked on the left of the frame.
 646     */
 647     wxAuiPaneInfo& LeftDockable(bool b = true);
 648
 649     //@{
 650     /**
 651         MaxSize() sets the maximum size of the pane.
 652     */
 653     wxAuiPaneInfo MaxSize(const wxSize& size);
 654     wxAuiPaneInfo MaxSize(int x, int y);
 655     //@}
 656
 657     /**
 658         MaximizeButton() indicates that a maximize button should be drawn for the pane.
 659     */
 660     wxAuiPaneInfo& MaximizeButton(bool visible = true);
 661
 662     //@{
 663     /**
 664         MinSize() sets the minimum size of the pane. Please note that this is only
 665         partially supported as of this writing.
 666     */
 667     wxAuiPaneInfo MinSize(const wxSize& size);
 668     wxAuiPaneInfo MinSize(int x, int y);
 669     //@}
 670
 671     /**
 672         MinimizeButton() indicates that a minimize button should be drawn for the pane.
 673     */
 674     wxAuiPaneInfo& MinimizeButton(bool visible = true);
 675
 676     /**
 677         Movable indicates whether a frame can be moved.
 678     */
 679     wxAuiPaneInfo& Movable(bool b = true);
 680
 681     /**
 682         Name() sets the name of the pane so it can be referenced in lookup functions.
 683         If a name is not specified by the user, a random name is assigned to the pane
 684         when it is added to the manager.
 685     */
 686     wxAuiPaneInfo& Name(const wxString& n);
 687
 688     /**
 689         PaneBorder indicates that a border should be drawn for the pane.
 690     */
 691     wxAuiPaneInfo& PaneBorder(bool visible = true);
 692
 693     /**
 694         PinButton() indicates that a pin button should be drawn for the pane.
 695     */
 696     wxAuiPaneInfo& PinButton(bool visible = true);
 697
 698     /**
 699         Position() determines the position of the docked pane.
 700     */
 701     wxAuiPaneInfo& Position(int pos);
 702
 703     /**
 704         Resizable() allows a pane to be resized if the parameter is @true, and forces it
 705         to be a fixed size if the parameter is @false. This is simply an antonym for Fixed().
 706     */
 707     wxAuiPaneInfo& Resizable(bool resizable = true);
 708
 709     /**
 710         Right() sets the pane dock position to the right side of the frame.
 711     */
 712     wxAuiPaneInfo& Right();
 713
 714     /**
 715         RightDockable() indicates whether a pane can be docked on the right of the
 716         frame.
 717     */
 718     wxAuiPaneInfo& RightDockable(bool b = true);
 719
 720     /**
 721         Row() determines the row of the docked pane.
 722     */
 723     wxAuiPaneInfo& Row(int row);
 724
 725     /**
 726         Write the safe parts of a newly loaded PaneInfo structure "source" into "this"
 727         used on loading perspectives etc.
 728     */
 729     void SafeSet(wxAuiPaneInfo source);
 730
 731     /**
 732         SetFlag() turns the property given by flag on or off with the option_state
 733         parameter.
 734     */
 735     wxAuiPaneInfo& SetFlag(unsigned int flag, bool option_state);
 736
 737     /**
 738         Show() indicates that a pane should be shown.
 739     */
 740     wxAuiPaneInfo& Show(bool show = true);
 741
 742     /**
 743         ToolbarPane() specifies that the pane should adopt the default toolbar pane
 744         settings.
 745     */
 746     wxAuiPaneInfo& ToolbarPane();
 747
 748     /**
 749         Top() sets the pane dock position to the top of the frame.
 750     */
 751     wxAuiPaneInfo& Top();
 752
 753     /**
 754         TopDockable() indicates whether a pane can be docked at the top of the frame.
 755     */
 756     wxAuiPaneInfo& TopDockable(bool b = true);
 757
 758     /**
 759         Window() assigns the window pointer that the wxAuiPaneInfo should use.
 760         This normally does not need to be specified, as the window pointer is
 761         automatically assigned to the wxAuiPaneInfo structure as soon as it is added
 762         to the manager.
 763     */
 764     wxAuiPaneInfo& Window(wxWindow* w);
 765
 766     /**
 767         Makes a copy of the wxAuiPaneInfo object.
 768     */
 769     wxAuiPaneInfo& operator=(const wxAuiPaneInfo& c);
 770 };
 771