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