wxauipaneinfo

wxauipaneinfo is part of the wxaui class framework. see also wxaui overview.

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.

derived from

no base class

include files

see also

wxauimanager, wxauidockart

data structures

enum wxauipaneinsertlevel
{
    wxaui_insert_pane = 0,
    wxaui_insert_row = 1,
    wxaui_insert_dock = 2
}

members

wxauipaneinfo::wxauipaneinfo

wxauipaneinfo()

default constructor.

wxauipaneinfo(const wxauipaneinfo& c)

copy constructor.

wxauipaneinfo::~wxauipaneinfo

~wxauipaneinfo()

wxauipaneinfo::bestsize

wxauipaneinfo& bestsize(const wxsize& size)

wxauipaneinfo& bestsize(int x, int y)

bestsize() sets the ideal size for the pane. the docking manager will attempt to use this size as much as possible when docking or floating the pane.

wxauipaneinfo::bottom

wxauipaneinfo& bottom()

bottom() sets the pane dock position to the bottom side of the frame. this is the same thing as calling direction(wxaui_dock_bottom).

wxauipaneinfo::bottomdockable

wxauipaneinfo& bottomdockable(bool b = true)

bottomdockable() indicates whether a pane can be docked at the bottom of the frame.

wxauipaneinfo::caption

wxauipaneinfo& caption(const wxstring& c)

caption() sets the caption of the pane.

wxauipaneinfo::captionvisible

wxauipaneinfo& captionvisible(bool visible = true)

captionvisible indicates that a pane caption should be visible. if false, no pane caption is drawn.

wxauipaneinfo::centre

wxauipaneinfo& centre()

wxauipaneinfo& center()

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::centrepane

wxauipaneinfo& centrepane()

wxauipaneinfo& centerpane()

centrepane() specifies that the pane should adopt the default center pane 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::closebutton

wxauipaneinfo& closebutton(bool visible = true)

closebutton() indicates that a close button should be drawn for the pane.

wxauipaneinfo::defaultpane

wxauipaneinfo& defaultpane()

defaultpane() specifies that the pane should adopt the default pane settings.

wxauipaneinfo::destroyonclose

wxauipaneinfo& destroyonclose(bool b = true)

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::direction

wxauipaneinfo& direction(int direction)

direction() determines the direction of the docked pane. it is functionally the same as calling left(), right(), top() or bottom(), except that docking direction may be specified programmatically via the parameter.

wxauipaneinfo::dock

wxauipaneinfo& dock()

wxauipaneinfo::dockable

wxauipaneinfo& dockable(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::fixed

wxauipaneinfo& fixed()

fixed() forces a pane to be fixed size so that it cannot be resized. after calling fixed(), isfixed() will return true.

wxauipaneinfo::float

wxauipaneinfo& float()

float() indicates that a pane should be floated.

wxauipaneinfo::floatable

wxauipaneinfo& floatable(bool b = true)

floatable() sets whether the user will be able to undock a pane and turn it into a floating window.

wxauipaneinfo::floatingposition

wxauipaneinfo& floatingposition(const wxpoint& pos)

wxauipaneinfo& floatingposition(int x, int y)

floatingposition() sets the position of the floating pane.

wxauipaneinfo::floatingsize

wxauipaneinfo& floatingsize(const wxsize& size)

wxauipaneinfo& floatingsize(int x, int y)

floatingsize() sets the size of the floating pane.

wxauipaneinfo::gripper

wxauipaneinfo& gripper(bool visible = true)

gripper() indicates that a gripper should be drawn for the pane.

wxauipaneinfo::grippertop

wxauipaneinfo& grippertop(bool attop = true)

grippertop() indicates that a gripper should be drawn at the top of the pane.

wxauipaneinfo::hasborder

bool hasborder() const

hasborder() returns true if the pane displays a border.

wxauipaneinfo::hascaption

bool hascaption() const

hascaption() returns true if the pane displays a caption.

wxauipaneinfo::hasclosebutton

bool hasclosebutton() const

hasclosebutton() returns true if the pane displays a button to close the pane.

wxauipaneinfo::hasflag

bool hasflag(unsigned int flag) const

hasflag() returns true if the the property specified by flag is active for the pane.

wxauipaneinfo::hasgripper

bool hasgripper() const

hasgripper() returns true if the pane displays a gripper.

wxauipaneinfo::hasgrippertop

bool hasgrippertop() const

hasgripper() returns true if the pane displays a gripper at the top.

wxauipaneinfo::hasmaximizebutton

bool hasmaximizebutton() const

hasmaximizebutton() returns true if the pane displays a button to maximize the pane.

wxauipaneinfo::hasminimizebutton

bool hasminimizebutton() const

hasminimizebutton() returns true if the pane displays a button to minimize the pane.

wxauipaneinfo::haspinbutton

bool haspinbutton() const

haspinbutton() returns true if the pane displays a button to float the pane.

wxauipaneinfo::hide

wxauipaneinfo& hide()

hide() indicates that a pane should be hidden.

wxauipaneinfo::isbottomdockable

bool isbottomdockable() const

isbottomdockable() returns true if the pane can be docked at the bottom of the managed frame.

wxauipaneinfo::isdocked

bool isdocked() const

isdocked() returns true if the pane is docked.

wxauipaneinfo::isfixed

bool isfixed() const

isfixed() returns true if the pane cannot be resized.

wxauipaneinfo::isfloatable

bool isfloatable() const

isfloatable() returns true if the pane can be undocked and displayed as a floating window.

wxauipaneinfo::isfloating

bool isfloating() const

isfloating() returns true if the pane is floating.

wxauipaneinfo::isleftdockable

bool isleftdockable() const

isleftdockable() returns true if the pane can be docked on the left of the managed frame.

wxauipaneinfo::ismovable

bool ismovable() const

ismoveable() returns true if the docked frame can be undocked or moved to another dock position.

wxauipaneinfo::isok

bool isok() const

isok() returns true if the wxauipaneinfo structure is valid. a pane structure is valid if it has an associated window.

wxauipaneinfo::isresizable

bool isresizable() const

isresizable() returns true if the pane can be resized.

wxauipaneinfo::isrightdockable

bool isrightdockable() const

isrightdockable() returns true if the pane can be docked on the right of the managed frame.

wxauipaneinfo::isshown

bool isshown() const

isshown() returns true if the pane is currently shown.

wxauipaneinfo::istoolbar

bool istoolbar() const

istoolbar() returns true if the pane contains a toolbar.

wxauipaneinfo::istopdockable

bool istopdockable() const

istopdockable() returns true if the pane can be docked at the top of the managed frame.

wxauipaneinfo::layer

wxauipaneinfo& layer(int layer)

layer() determines the layer of the docked pane. the dock layer is similar to an onion, the inner-most layer being layer 0. each shell moving in the outward direction has a higher layer number. this allows for more complex docking layout formation.

wxauipaneinfo::left

wxauipaneinfo& left()

left() sets the pane dock position to the left side of the frame. this is the same thing as calling direction(wxaui_dock_left).

wxauipaneinfo::leftdockable

wxauipaneinfo& leftdockable(bool b = true)

leftdockable() indicates whether a pane can be docked on the left of the frame.

wxauipaneinfo::maxsize

wxauipaneinfo& maxsize(const wxsize& size)

wxauipaneinfo& maxsize(int x, int y)

maxsize() sets the maximum size of the pane.

wxauipaneinfo::maximizebutton

wxauipaneinfo& maximizebutton(bool visible = true)

maximizebutton() indicates that a maximize button should be drawn for the pane.

wxauipaneinfo::minsize

wxauipaneinfo& minsize(const wxsize& size)

wxauipaneinfo& minsize(int x, int y)

minsize() sets the minimum size of the pane. please note that this is only partially supported as of this writing.

wxauipaneinfo::minimizebutton

wxauipaneinfo& minimizebutton(bool visible = true)

minimizebutton() indicates that a minimize button should be drawn for the pane.

wxauipaneinfo::movable

wxauipaneinfo& movable(bool b = true)

movable indicates whether a frame can be moved.

wxauipaneinfo::name

wxauipaneinfo& name(const wxstring& n)

name() sets the name of the pane so it can be referenced in lookup functions. if a name is not specified by the user, a random name is assigned to the pane when it is added to the manager.

wxauipaneinfo::paneborder

wxauipaneinfo& paneborder(bool visible = true)

paneborder indicates that a border should be drawn for the pane.

wxauipaneinfo::pinbutton

wxauipaneinfo& pinbutton(bool visible = true)

pinbutton() indicates that a pin button should be drawn for the pane.

wxauipaneinfo::position

wxauipaneinfo& position(int pos)

position() determines the position of the docked pane.

wxauipaneinfo::resizable

wxauipaneinfo& resizable(bool resizable = true)

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::right

wxauipaneinfo& right()

right() sets the pane dock position to the right side of the frame.

wxauipaneinfo::rightdockable

wxauipaneinfo& rightdockable(bool b = true)

rightdockable() indicates whether a pane can be docked on the right of the frame.

wxauipaneinfo::row

wxauipaneinfo& row(int row)

row() determines the row of the docked pane.

wxauipaneinfo::safeset

void safeset(wxauipaneinfo source)

write the safe parts of a newly loaded paneinfo structure "source" into "this" used on loading perspectives etc.

wxauipaneinfo::setflag

wxauipaneinfo& setflag(unsigned int flag, bool option_state)

setflag() turns the property given by flag on or off with the option_state parameter.

wxauipaneinfo::show

wxauipaneinfo& show(bool show = true)

show() indicates that a pane should be shown.

wxauipaneinfo::toolbarpane

wxauipaneinfo& toolbarpane()

toolbarpane() specifies that the pane should adopt the default toolbar pane settings.

wxauipaneinfo::top

wxauipaneinfo& top()

top() sets the pane dock position to the top of the frame.

wxauipaneinfo::topdockable

wxauipaneinfo& topdockable(bool b = true)

topdockable() indicates whether a pane can be docked at the top of the frame.

wxauipaneinfo::window

wxauipaneinfo& window(wxwindow* w)

window() assigns the window pointer that the wxauipaneinfo should use. this normally does not need to be specified, as the window pointer is automatically assigned to the wxauipaneinfo structure as soon as it is added to the manager.

wxauipaneinfo::operator=

wxauipaneinfo& operator operator=(const wxauipaneinfo& c)

makes a copy of the wxauipaneinfo object.