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