/**
@class wxAuiManager
@headerfile aui.h wx/aui/aui.h
-
+
wxAuiManager is the central class of the wxAUI class framework.
-
- See also @ref overview_wxauioverview "wxAUI overview".
-
+
+ See also @ref overview_wxauioverview.
+
wxAuiManager manages the panes associated with it
for a particular wxFrame, using a pane's wxAuiPaneInfo information to
determine each pane's docking and floating behavior. wxAuiManager
uses a replaceable dock art class to do all drawing, so all drawing is
localized in one area, and may be customized depending on an
application's specific needs.
-
+
wxAuiManager works as follows: the programmer adds panes to the class,
or makes changes to existing pane properties (dock position, floating
state, show state, etc.). To apply these changes, wxAuiManager's
Update() function is called. This batch processing can be used to avoid
flicker, by modifying more than one pane at a time, and then "committing"
all of the changes at once by calling Update().
-
+
Panes can be added quite easily:
-
+
@code
wxTextCtrl* text1 = new wxTextCtrl(this, -1);
wxTextCtrl* text2 = new wxTextCtrl(this, -1);
m_mgr.AddPane(text2, wxBOTTOM, wxT("Pane Caption"));
m_mgr.Update();
@endcode
-
+
Later on, the positions can be modified easily. The following will float
an existing pane in a tool window:
-
+
@code
m_mgr.GetPane(text1).Float();
@endcode
-
+
@library{wxbase}
@category{aui}
-
+
@seealso
wxAuiPaneInfo, wxAuiDockArt
*/
{
public:
/**
- Constructor. @e managed_wnd specifies the wxFrame which should be managed.
- @e flags specifies options which allow the frame management behavior
+ Constructor. @a managed_wnd specifies the wxFrame which should be managed.
+ @a flags specifies options which allow the frame management behavior
to be modified.
*/
- wxAuiManager(wxWindow* managed_wnd = @NULL,
+ wxAuiManager(wxWindow* managed_wnd = NULL,
unsigned int flags = wxAUI_MGR_DEFAULT);
/**
several versions of this function. The first version allows the full spectrum of pane parameter possibilities. The second version is used for simpler user interfaces which do not require as much configuration. The last version allows a drop position to be specified, which will determine where the pane will be added.
*/
bool AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info);
- bool AddPane(wxWindow* window, int direction = wxLEFT,
- const wxString& caption = wxEmptyString);
- bool AddPane(wxWindow* window,
- const wxAuiPaneInfo& pane_info,
- const wxPoint& drop_pos);
+ bool AddPane(wxWindow* window, int direction = wxLEFT,
+ const wxString& caption = wxEmptyString);
+ bool AddPane(wxWindow* window,
+ const wxAuiPaneInfo& pane_info,
+ const wxPoint& drop_pos);
//@}
/**
/**
Returns the current art provider being used.
-
See also: wxAuiDockArt.
*/
- wxAuiDockArt* GetArtProvider();
+ wxAuiDockArt* GetArtProvider() const;
/**
Returns the current dock constraint values. See SetDockSizeConstraint() for
/**
Returns the current manager's flags.
*/
- unsigned int GetFlags();
+ unsigned int GetFlags() const;
/**
Returns the frame currently being managed by wxAuiManager.
*/
- wxWindow* GetManagedWindow();
+ wxWindow* GetManagedWindow() const;
/**
- Calling this method will return the wxAuiManager for a given window. The @e
+ Calling this method will return the wxAuiManager for a given window. The @a
window parameter should
specify any child window or sub-child window of the frame or window managed by
wxAuiManager.
- The @e window parameter need not be managed by the manager itself, nor does it
+ The @a window parameter need not be managed by the manager itself, nor does it
even need to be a child
or sub-child of a managed window. It must however be inside the window
hierarchy underneath the managed
returned wxAuiPaneInfo's IsOk() method will return @false.
*/
wxAuiPaneInfo GetPane(wxWindow* window);
- wxAuiPaneInfo GetPane(const wxString& name);
+ wxAuiPaneInfo GetPane(const wxString& name);
//@}
/**
/**
This method is used to insert either a previously unmanaged pane window
- into the frame manager, or to insert a currently managed pane somewhere
+ into the frame manager, or to insert a currently managed pane somewhere
else. @e InsertPane will push all panes, rows, or docks aside and
- insert the window into the position specified by @e insert_location.
- Because @e insert_location can specify either a pane, dock row, or dock
- layer, the @e insert_level parameter is used to disambiguate this. The
- parameter @e insert_level can take a value of wxAUI_INSERT_PANE,
- wxAUI_INSERT_ROW
+ insert the window into the position specified by @e insert_location.
+ Because @a insert_location can specify either a pane, dock row, or dock
+ layer, the @a insert_level parameter is used to disambiguate this. The
+ parameter @a insert_level can take a value of wxAUI_INSERT_PANE,
+ wxAUI_INSERT_ROW
or wxAUI_INSERT_DOCK.
*/
bool InsertPane(wxWindow* window,
is automatically invoked, thus realizing the saved perspective on screen.
*/
bool LoadPerspective(const wxString& perspective,
- bool update = @true);
+ bool update = true);
/**
ProcessDockResult() is a protected member of the wxAUI layout manager. It can
/**
Instructs wxAuiManager to use art provider specified by parameter
- @e art_provider for all drawing calls. This allows plugable
+ @a art_provider for all drawing calls. This allows plugable
look-and-feel features. The previous art provider object, if any,
will be deleted by wxAuiManager.
-
See also: wxAuiDockArt.
*/
void SetArtProvider(wxAuiDockArt* art_provider);
void SetFlags(unsigned int flags);
/**
- Called to specify the frame or window which is to be managed by wxAuiManager.
+ Called to specify the frame or window which is to be managed by wxAuiManager.
Frame management is not restricted to just frames. Child windows or custom controls are also allowed.
*/
void SetManagedWindow(wxWindow* managed_wnd);
/**
@class wxAuiPaneInfo
@headerfile aui.h wx/aui/aui.h
-
+
wxAuiPaneInfo is part of the wxAUI class framework.
- See also @ref overview_wxauioverview "wxAUI overview".
-
+ See also @ref overview_wxauioverview.
+
wxAuiPaneInfo specifies all the parameters for a pane.
These parameters specify where the pane is on the
screen, whether it is docked or floating, or hidden.
In addition, these parameters specify the pane's
docked position, floating position, preferred size,
minimum size, caption text among many other parameters.
-
+
@library{wxbase}
@category{aui}
-
+
@seealso
wxAuiManager, wxAuiDockArt
*/
-class wxAuiPaneInfo
+class wxAuiPaneInfo
{
public:
//@{
Copy constructor.
*/
wxAuiPaneInfo();
- wxAuiPaneInfo(const wxAuiPaneInfo& c);
+ wxAuiPaneInfo(const wxAuiPaneInfo& c);
//@}
//@{
to use this size as much as possible when docking or floating the pane.
*/
wxAuiPaneInfo BestSize(const wxSize& size);
- wxAuiPaneInfo BestSize(int x, int y);
+ wxAuiPaneInfo BestSize(int x, int y);
//@}
/**
BottomDockable() indicates whether a pane can be docked at the bottom of the
frame.
*/
- wxAuiPaneInfo BottomDockable(bool b = @true);
+ wxAuiPaneInfo BottomDockable(bool b = true);
/**
Caption() sets the caption of the pane.
CaptionVisible indicates that a pane caption should be visible. If @false, no
pane caption is drawn.
*/
- wxAuiPaneInfo CaptionVisible(bool visible = @true);
+ wxAuiPaneInfo CaptionVisible(bool visible = true);
//@{
/**
Center() sets the pane dock position to the left side of the frame.
The centre pane is the space in the middle after all border panes (left, top,
right, bottom) are subtracted from the layout.
-
This is the same thing as calling Direction(wxAUI_DOCK_CENTRE).
*/
wxAuiPaneInfo Centre();
- wxAuiPaneInfo Center();
+ wxAuiPaneInfo Center();
//@}
//@{
settings. Centre panes usually do not have caption bars. This function provides an easy way of preparing a pane to be displayed in the center dock position.
*/
wxAuiPaneInfo CentrePane();
- wxAuiPaneInfo CenterPane();
+ wxAuiPaneInfo CenterPane();
//@}
/**
CloseButton() indicates that a close button should be drawn for the pane.
*/
- wxAuiPaneInfo CloseButton(bool visible = @true);
+ wxAuiPaneInfo CloseButton(bool visible = true);
/**
DefaultPane() specifies that the pane should adopt the default pane settings.
DestroyOnClose() indicates whether a pane should be detroyed when it is closed.
Normally a pane is simply hidden when the close button is clicked. Setting DestroyOnClose to @true will cause the window to be destroyed when the user clicks the pane's close button.
*/
- wxAuiPaneInfo DestroyOnClose(bool b = @true);
+ wxAuiPaneInfo DestroyOnClose(bool b = true);
/**
Direction() determines the direction of the docked pane. It is functionally the
DockFixed() causes the containing dock to have no resize sash. This is useful
for creating panes that span the entire width or height of a dock, but should not be resizable in the other direction.
*/
- wxAuiPaneInfo DockFixed(bool b = @true);
+ wxAuiPaneInfo DockFixed(bool b = true);
/**
Dockable() specifies whether a frame can be docked or not. It is the same as
specifying TopDockable(b).BottomDockable(b).LeftDockable(b).RightDockable(b).
*/
- wxAuiPaneInfo Dockable(bool b = @true);
+ wxAuiPaneInfo Dockable(bool b = true);
/**
Fixed() forces a pane to be fixed size so that it cannot be resized. After
Floatable() sets whether the user will be able to undock a pane and turn it
into a floating window.
*/
- wxAuiPaneInfo Floatable(bool b = @true);
+ wxAuiPaneInfo Floatable(bool b = true);
//@{
/**
FloatingPosition() sets the position of the floating pane.
*/
wxAuiPaneInfo FloatingPosition(const wxPoint& pos);
- wxAuiPaneInfo FloatingPosition(int x, int y);
+ wxAuiPaneInfo FloatingPosition(int x, int y);
//@}
//@{
FloatingSize() sets the size of the floating pane.
*/
wxAuiPaneInfo FloatingSize(const wxSize& size);
- wxAuiPaneInfo FloatingSize(int x, int y);
+ wxAuiPaneInfo FloatingSize(int x, int y);
//@}
/**
Gripper() indicates that a gripper should be drawn for the pane.
*/
- wxAuiPaneInfo Gripper(bool visible = @true);
+ wxAuiPaneInfo Gripper(bool visible = true);
/**
GripperTop() indicates that a gripper should be drawn at the top of the pane.
*/
- wxAuiPaneInfo GripperTop(bool attop = @true);
+ wxAuiPaneInfo GripperTop(bool attop = true);
/**
HasBorder() returns @true if the pane displays a border.
*/
- bool HasBorder();
+ bool HasBorder() const;
/**
HasCaption() returns @true if the pane displays a caption.
*/
- bool HasCaption();
+ bool HasCaption() const;
/**
HasCloseButton() returns @true if the pane displays a button to close the pane.
*/
- bool HasCloseButton();
+ bool HasCloseButton() const;
/**
HasFlag() returns @true if the the property specified by flag is active for the
pane.
*/
- bool HasFlag(unsigned int flag);
+ bool HasFlag(unsigned int flag) const;
/**
HasGripper() returns @true if the pane displays a gripper.
*/
- bool HasGripper();
+ bool HasGripper() const;
/**
HasGripper() returns @true if the pane displays a gripper at the top.
*/
- bool HasGripperTop();
+ bool HasGripperTop() const;
/**
HasMaximizeButton() returns @true if the pane displays a button to maximize the
pane.
*/
- bool HasMaximizeButton();
+ bool HasMaximizeButton() const;
/**
HasMinimizeButton() returns @true if the pane displays a button to minimize the
pane.
*/
- bool HasMinimizeButton();
+ bool HasMinimizeButton() const;
/**
HasPinButton() returns @true if the pane displays a button to float the pane.
*/
- bool HasPinButton();
+ bool HasPinButton() const;
/**
Hide() indicates that a pane should be hidden.
IsBottomDockable() returns @true if the pane can be docked at the bottom of the
managed frame.
*/
- bool IsBottomDockable();
+ bool IsBottomDockable() const;
/**
IsDocked() returns @true if the pane is docked.
*/
- bool IsDocked();
+ bool IsDocked() const;
/**
IsFixed() returns @true if the pane cannot be resized.
*/
- bool IsFixed();
+ bool IsFixed() const;
/**
IsFloatable() returns @true if the pane can be undocked and displayed as a
floating window.
*/
- bool IsFloatable();
+ bool IsFloatable() const;
/**
IsFloating() returns @true if the pane is floating.
*/
- bool IsFloating();
+ bool IsFloating() const;
/**
IsLeftDockable() returns @true if the pane can be docked on the left of the
managed frame.
*/
- bool IsLeftDockable();
+ bool IsLeftDockable() const;
/**
IsMoveable() returns @true if the docked frame can be undocked or moved to
another dock position.
*/
- bool IsMovable();
+ bool IsMovable() const;
/**
IsOk() returns @true if the wxAuiPaneInfo structure is valid. A pane structure
is valid if it has an associated window.
*/
-#define bool IsOk() /* implementation is private */
+ bool IsOk() const;
/**
IsResizable() returns @true if the pane can be resized.
*/
- bool IsResizable();
+ bool IsResizable() const;
/**
IsRightDockable() returns @true if the pane can be docked on the right of the
managed frame.
*/
- bool IsRightDockable();
+ bool IsRightDockable() const;
/**
IsShown() returns @true if the pane is currently shown.
*/
- bool IsShown();
+ bool IsShown() const;
/**
IsToolbar() returns @true if the pane contains a toolbar.
*/
- bool IsToolbar();
+ bool IsToolbar() const;
/**
IsTopDockable() returns @true if the pane can be docked at the top of the
managed frame.
*/
- bool IsTopDockable();
+ bool IsTopDockable() const;
/**
Layer() determines the layer of the docked pane. The dock layer is similar to
/**
LeftDockable() indicates whether a pane can be docked on the left of the frame.
*/
- wxAuiPaneInfo LeftDockable(bool b = @true);
+ wxAuiPaneInfo LeftDockable(bool b = true);
//@{
/**
MaxSize() sets the maximum size of the pane.
*/
wxAuiPaneInfo MaxSize(const wxSize& size);
- wxAuiPaneInfo MaxSize(int x, int y);
+ wxAuiPaneInfo MaxSize(int x, int y);
//@}
/**
MaximizeButton() indicates that a maximize button should be drawn for the pane.
*/
- wxAuiPaneInfo MaximizeButton(bool visible = @true);
+ wxAuiPaneInfo MaximizeButton(bool visible = true);
//@{
/**
partially supported as of this writing.
*/
wxAuiPaneInfo MinSize(const wxSize& size);
- wxAuiPaneInfo MinSize(int x, int y);
+ wxAuiPaneInfo MinSize(int x, int y);
//@}
/**
MinimizeButton() indicates that a minimize button should be drawn for the pane.
*/
- wxAuiPaneInfo MinimizeButton(bool visible = @true);
+ wxAuiPaneInfo MinimizeButton(bool visible = true);
/**
Movable indicates whether a frame can be moved.
*/
- wxAuiPaneInfo Movable(bool b = @true);
+ wxAuiPaneInfo Movable(bool b = true);
/**
Name() sets the name of the pane so it can be referenced in lookup functions.
/**
PaneBorder indicates that a border should be drawn for the pane.
*/
- wxAuiPaneInfo PaneBorder(bool visible = @true);
+ wxAuiPaneInfo PaneBorder(bool visible = true);
/**
PinButton() indicates that a pin button should be drawn for the pane.
*/
- wxAuiPaneInfo PinButton(bool visible = @true);
+ wxAuiPaneInfo PinButton(bool visible = true);
/**
Position() determines the position of the docked pane.
Resizable() allows a pane to be resized if the parameter is @true, and forces it
to be a fixed size if the parameter is @false. This is simply an antonym for Fixed().
*/
- wxAuiPaneInfo Resizable(bool resizable = @true);
+ wxAuiPaneInfo Resizable(bool resizable = true);
/**
Right() sets the pane dock position to the right side of the frame.
RightDockable() indicates whether a pane can be docked on the right of the
frame.
*/
- wxAuiPaneInfo RightDockable(bool b = @true);
+ wxAuiPaneInfo RightDockable(bool b = true);
/**
Row() determines the row of the docked pane.
*/
-#define wxAuiPaneInfo Row(int row) /* implementation is private */
+ wxAuiPaneInfo Row(int row);
/**
Write the safe parts of a newly loaded PaneInfo structure "source" into "this"
/**
Show() indicates that a pane should be shown.
*/
- wxAuiPaneInfo Show(bool show = @true);
+ wxAuiPaneInfo Show(bool show = true);
/**
ToolbarPane() specifies that the pane should adopt the default toolbar pane
/**
Top() sets the pane dock position to the top of the frame.
*/
-#define wxAuiPaneInfo Top() /* implementation is private */
+ wxAuiPaneInfo Top();
/**
TopDockable() indicates whether a pane can be docked at the top of the frame.
*/
- wxAuiPaneInfo TopDockable(bool b = @true);
+ wxAuiPaneInfo TopDockable(bool b = true);
/**
Window() assigns the window pointer that the wxAuiPaneInfo should use. This
projects / wxWidgets.git / blobdiff