1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: interface of wxAuiManager
4 // Author: wxWidgets team
6 // Licence: wxWindows licence
7 /////////////////////////////////////////////////////////////////////////////
11 @todo wxAuiPaneInfo dock direction types used with wxAuiManager.
18 wxAUI_DOCK_BOTTOM
= 3,
20 wxAUI_DOCK_CENTER
= 5,
21 wxAUI_DOCK_CENTRE
= wxAUI_DOCK_CENTER
26 wxAuiManager behaviour and visual effects style flags.
28 enum wxAuiManagerOption
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,
51 wxAUI_MGR_DEFAULT
= wxAUI_MGR_ALLOW_FLOATING
|
52 wxAUI_MGR_TRANSPARENT_HINT
|
54 wxAUI_MGR_NO_VENETIAN_BLINDS_FADE
60 wxAuiManager is the central class of the wxAUI class framework.
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.
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.
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().
78 Panes can be added quite easily:
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");
88 Later on, the positions can be modified easily. The following will float
89 an existing pane in a tool window:
92 m_mgr.GetPane(text1).Float();
96 @section auimanager_layers Layers, Rows and Directions, Positions
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
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
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.
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
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.
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).
169 @see @ref overview_aui, wxAuiNotebook, wxAuiDockArt, wxAuiPaneInfo
171 class wxAuiManager
: public wxEvtHandler
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.
179 wxAuiManager(wxWindow
* managed_wnd
= NULL
,
180 unsigned int flags
= wxAUI_MGR_DEFAULT
);
185 virtual ~wxAuiManager();
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.
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
);
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
209 bool DetachPane(wxWindow
* window
);
212 Returns an array of all panes managed by the frame manager.
214 wxAuiPaneInfoArray
& GetAllPanes();
217 Returns the current art provider being used.
220 wxAuiDockArt
* GetArtProvider() const;
223 Returns the current dock constraint values.
224 See SetDockSizeConstraint() for more information.
226 void GetDockSizeConstraint(double* widthpct
, double* heightpct
) const;
229 Returns the current wxAuiManagerOption's flags.
231 unsigned int GetFlags() const;
234 Returns the frame currently being managed by wxAuiManager.
236 wxWindow
* GetManagedWindow() const;
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.
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.
247 static wxAuiManager
* GetManager(wxWindow
* window
);
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.
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.
260 wxAuiPaneInfo
& GetPane(wxWindow
* window
);
261 wxAuiPaneInfo
& GetPane(const wxString
& name
);
265 HideHint() hides any docking hint that may be visible.
267 virtual void HideHint();
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.
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.
280 bool InsertPane(wxWindow
* window
,
281 const wxAuiPaneInfo
& insert_location
,
282 int insert_level
= wxAUI_INSERT_PANE
);
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
289 void LoadPaneInfo(wxString pane_part
, wxAuiPaneInfo
& pane
);
292 Loads a saved perspective. If update is @true, wxAuiManager::Update()
293 is automatically invoked, thus realizing the saved perspective on screen.
295 bool LoadPerspective(const wxString
& perspective
,
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
303 wxString
SavePaneInfo(wxAuiPaneInfo
& pane
);
306 Saves the entire user interface layout into an encoded wxString, which
307 can then be stored by the application (probably using wxConfig).
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.
312 wxString
SavePerspective();
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.
322 void SetArtProvider(wxAuiDockArt
* art_provider
);
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.
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.
336 void SetDockSizeConstraint(double widthpct
, double heightpct
);
339 This method is used to specify wxAuiManagerOption's flags. @a flags
340 specifies options which allow the frame management behaviour to be modified.
342 void SetFlags(unsigned int flags
);
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.
349 void SetManagedWindow(wxWindow
* managed_wnd
);
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.
357 virtual void ShowHint(const wxRect
& rect
);
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.
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.
382 ProcessDockResult() is a protected member of the wxAUI layout manager.
383 It can be overridden by derived classes to provide custom docking calculations.
385 virtual bool ProcessDockResult(wxAuiPaneInfo
& target
,
386 const wxAuiPaneInfo
& new_pos
);
394 wxAuiPaneInfo is part of the wxAUI class framework.
395 See also @ref overview_aui.
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.
406 @see wxAuiManager, wxAuiDockArt
416 wxAuiPaneInfo(const wxAuiPaneInfo
& c
);
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.
423 wxAuiPaneInfo
& BestSize(const wxSize
& size
);
424 wxAuiPaneInfo
& BestSize(int x
, int y
);
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).
431 wxAuiPaneInfo
& Bottom();
434 BottomDockable() indicates whether a pane can be docked at the bottom of the
437 wxAuiPaneInfo
& BottomDockable(bool b
= true);
440 Caption() sets the caption of the pane.
442 wxAuiPaneInfo
& Caption(const wxString
& c
);
445 CaptionVisible indicates that a pane caption should be visible. If @false, no
446 pane caption is drawn.
448 wxAuiPaneInfo
& CaptionVisible(bool visible
= true);
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).
457 wxAuiPaneInfo
& Centre();
458 wxAuiPaneInfo
& Center();
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.
468 wxAuiPaneInfo
& CentrePane();
469 wxAuiPaneInfo
& CenterPane();
473 CloseButton() indicates that a close button should be drawn for the pane.
475 wxAuiPaneInfo
& CloseButton(bool visible
= true);
478 DefaultPane() specifies that the pane should adopt the default pane settings.
480 wxAuiPaneInfo
& DefaultPane();
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.
488 wxAuiPaneInfo
& DestroyOnClose(bool b
= true);
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.
495 wxAuiPaneInfo
& Direction(int direction
);
498 Dock() indicates that a pane should be docked. It is the opposite of Float().
500 wxAuiPaneInfo
& Dock();
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.
507 wxAuiPaneInfo
& DockFixed(bool b
= true);
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).
513 wxAuiPaneInfo
& Dockable(bool b
= true);
516 Fixed() forces a pane to be fixed size so that it cannot be resized. After
517 calling Fixed(), IsFixed() will return @true.
519 wxAuiPaneInfo
& Fixed();
522 Float() indicates that a pane should be floated. It is the opposite of Dock().
524 wxAuiPaneInfo
& Float();
527 Floatable() sets whether the user will be able to undock a pane and turn it
528 into a floating window.
530 wxAuiPaneInfo
& Floatable(bool b
= true);
534 FloatingPosition() sets the position of the floating pane.
536 wxAuiPaneInfo
& FloatingPosition(const wxPoint
& pos
);
537 wxAuiPaneInfo
& FloatingPosition(int x
, int y
);
542 FloatingSize() sets the size of the floating pane.
544 wxAuiPaneInfo
& FloatingSize(const wxSize
& size
);
545 wxAuiPaneInfo
& FloatingSize(int x
, int y
);
549 Gripper() indicates that a gripper should be drawn for the pane.
551 wxAuiPaneInfo
& Gripper(bool visible
= true);
554 GripperTop() indicates that a gripper should be drawn at the top of the pane.
556 wxAuiPaneInfo
& GripperTop(bool attop
= true);
559 HasBorder() returns @true if the pane displays a border.
561 bool HasBorder() const;
564 HasCaption() returns @true if the pane displays a caption.
566 bool HasCaption() const;
569 HasCloseButton() returns @true if the pane displays a button to close the pane.
571 bool HasCloseButton() const;
574 HasFlag() returns @true if the property specified by flag is active for
577 bool HasFlag(int flag
) const;
580 HasGripper() returns @true if the pane displays a gripper.
582 bool HasGripper() const;
585 HasGripper() returns @true if the pane displays a gripper at the top.
587 bool HasGripperTop() const;
590 HasMaximizeButton() returns @true if the pane displays a button to maximize the
593 bool HasMaximizeButton() const;
596 HasMinimizeButton() returns @true if the pane displays a button to minimize the
599 bool HasMinimizeButton() const;
602 HasPinButton() returns @true if the pane displays a button to float the pane.
604 bool HasPinButton() const;
607 Hide() indicates that a pane should be hidden.
609 wxAuiPaneInfo
& Hide();
612 Icon() sets the icon of the pane.
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.
620 wxAuiPaneInfo
& Icon(const wxBitmap
& b
);
623 IsBottomDockable() returns @true if the pane can be docked at the bottom of the
628 bool IsBottomDockable() const;
631 Returns @true if the pane can be docked at any side.
633 @see IsTopDockable(), IsBottomDockable(), IsLeftDockable(), IsRightDockable()
637 bool IsDockable() const;
640 IsDocked() returns @true if the pane is currently docked.
642 bool IsDocked() const;
645 IsFixed() returns @true if the pane cannot be resized.
647 bool IsFixed() const;
650 IsFloatable() returns @true if the pane can be undocked and displayed as a
653 bool IsFloatable() const;
656 IsFloating() returns @true if the pane is floating.
658 bool IsFloating() const;
661 IsLeftDockable() returns @true if the pane can be docked on the left of the
666 bool IsLeftDockable() const;
669 IsMoveable() returns @true if the docked frame can be undocked or moved to
670 another dock position.
672 bool IsMovable() const;
675 IsOk() returns @true if the wxAuiPaneInfo structure is valid. A pane structure
676 is valid if it has an associated window.
681 IsResizable() returns @true if the pane can be resized.
683 bool IsResizable() const;
686 IsRightDockable() returns @true if the pane can be docked on the right of the
691 bool IsRightDockable() const;
694 IsShown() returns @true if the pane is currently shown.
696 bool IsShown() const;
699 IsToolbar() returns @true if the pane contains a toolbar.
701 bool IsToolbar() const;
704 IsTopDockable() returns @true if the pane can be docked at the top of the
709 bool IsTopDockable() const;
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
717 wxAuiPaneInfo
& Layer(int layer
);
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).
723 wxAuiPaneInfo
& Left();
726 LeftDockable() indicates whether a pane can be docked on the left of the frame.
728 wxAuiPaneInfo
& LeftDockable(bool b
= true);
732 MaxSize() sets the maximum size of the pane.
734 wxAuiPaneInfo
& MaxSize(const wxSize
& size
);
735 wxAuiPaneInfo
& MaxSize(int x
, int y
);
739 MaximizeButton() indicates that a maximize button should be drawn for the pane.
741 wxAuiPaneInfo
& MaximizeButton(bool visible
= true);
745 MinSize() sets the minimum size of the pane. Please note that this is only
746 partially supported as of this writing.
748 wxAuiPaneInfo
& MinSize(const wxSize
& size
);
749 wxAuiPaneInfo
& MinSize(int x
, int y
);
753 MinimizeButton() indicates that a minimize button should be drawn for the pane.
755 wxAuiPaneInfo
& MinimizeButton(bool visible
= true);
758 Movable indicates whether a frame can be moved.
760 wxAuiPaneInfo
& Movable(bool b
= true);
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.
767 wxAuiPaneInfo
& Name(const wxString
& n
);
770 PaneBorder indicates that a border should be drawn for the pane.
772 wxAuiPaneInfo
& PaneBorder(bool visible
= true);
775 PinButton() indicates that a pin button should be drawn for the pane.
777 wxAuiPaneInfo
& PinButton(bool visible
= true);
780 Position() determines the position of the docked pane.
782 wxAuiPaneInfo
& Position(int pos
);
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().
788 wxAuiPaneInfo
& Resizable(bool resizable
= true);
791 Right() sets the pane dock position to the right side of the frame.
793 wxAuiPaneInfo
& Right();
796 RightDockable() indicates whether a pane can be docked on the right of the
799 wxAuiPaneInfo
& RightDockable(bool b
= true);
802 Row() determines the row of the docked pane.
804 wxAuiPaneInfo
& Row(int row
);
807 Write the safe parts of a newly loaded PaneInfo structure "source" into "this"
808 used on loading perspectives etc.
810 void SafeSet(wxAuiPaneInfo source
);
813 SetFlag() turns the property given by flag on or off with the option_state
816 wxAuiPaneInfo
& SetFlag(int flag
, bool option_state
);
819 Show() indicates that a pane should be shown.
821 wxAuiPaneInfo
& Show(bool show
= true);
824 ToolbarPane() specifies that the pane should adopt the default toolbar pane
827 wxAuiPaneInfo
& ToolbarPane();
830 Top() sets the pane dock position to the top of the frame.
832 wxAuiPaneInfo
& Top();
835 TopDockable() indicates whether a pane can be docked at the top of the frame.
837 wxAuiPaneInfo
& TopDockable(bool b
= true);
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
845 wxAuiPaneInfo
& Window(wxWindow
* w
);
848 Makes a copy of the wxAuiPaneInfo object.
850 wxAuiPaneInfo
& operator=(const wxAuiPaneInfo
& c
);
856 @class wxAuiManagerEvent
858 Event used to indicate various actions taken with wxAuiManager.
860 See wxAuiManager for available event types.
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).
877 @category{events,aui}
879 @see wxAuiManager, wxAuiPaneInfo
881 class wxAuiManagerEvent
: public wxEvent
887 wxAuiManagerEvent(wxEventType type
= wxEVT_NULL
);
890 @return @true if this event can be vetoed.
897 @return The ID of the button that was clicked.
907 @return @true if this event was vetoed.
914 @return The wxAuiManager this event is associated with.
916 wxAuiManager
* GetManager();
919 @return The pane this event is associated with.
921 wxAuiPaneInfo
* GetPane();
924 Sets the ID of the button clicked that triggered this event.
926 void SetButton(int button
);
929 Sets whether or not this event can be vetoed.
931 void SetCanVeto(bool can_veto
);
936 void SetDC(wxDC
* pdc
);
939 Sets the wxAuiManager this event is associated with.
941 void SetManager(wxAuiManager
* manager
);
944 Sets the pane this event is associated with.
946 void SetPane(wxAuiPaneInfo
* pane
);
949 Cancels the action indicated by this event if CanVeto() is @true.
951 void Veto(bool veto
= true);