wxAuiManager Class Reference

#include <framemanager.h>

List of all members.

Public Member Functions
	wxAuiManager (wxWindow *managed_wnd=NULL, unsigned int flags=wxAUI_MGR_DEFAULT)
virtual	~wxAuiManager ()
void	UnInit ()
void	SetFlags (unsigned int flags)
unsigned int	GetFlags () const
void	SetManagedWindow (wxWindow *managed_wnd)
wxWindow *	GetManagedWindow () const
void	SetArtProvider (wxAuiDockArt *art_provider)
wxAuiDockArt *	GetArtProvider () const
wxAuiPaneInfo &	GetPane (wxWindow *window)
wxAuiPaneInfo &	GetPane (const wxString &name)
wxAuiPaneInfoArray &	GetAllPanes ()
bool	AddPane (wxWindow *window, const wxAuiPaneInfo &pane_info)
bool	AddPane (wxWindow *window, const wxAuiPaneInfo &pane_info, const wxPoint &drop_pos)
bool	AddPane (wxWindow *window, int direction=wxLEFT, const wxString &caption=wxEmptyString)
bool	InsertPane (wxWindow *window, const wxAuiPaneInfo &insert_location, int insert_level=wxAUI_INSERT_PANE)
bool	DetachPane (wxWindow *window)
wxString	SavePaneInfo (wxAuiPaneInfo &pane)
void	LoadPaneInfo (wxString pane_part, wxAuiPaneInfo &pane)
wxString	SavePerspective ()
bool	LoadPerspective (const wxString &perspective, bool update=true)
void	Update ()
void	DrawHintRect (wxWindow *pane_window, const wxPoint &pt, const wxPoint &offset)
virtual void	ShowHint (const wxRect &rect)
virtual void	HideHint ()
	wxDEPRECATED (void SetFrame(wxFrame *frame))
	wxDEPRECATED (wxFrame *GetFrame() const )
void	OnRender (wxAuiManagerEvent &evt)
void	OnPaneButton (wxAuiManagerEvent &evt)
Protected Types
enum	{   actionNone = 0, actionResize, actionClickButton, actionClickCaption,   actionDragToolbarPane, actionDragFloatingPane }
Protected Member Functions
void	DoFrameLayout ()
void	LayoutAddPane (wxSizer *container, wxAuiDockInfo &dock, wxAuiPaneInfo &pane, wxAuiDockUIPartArray &uiparts, bool spacer_only)
void	LayoutAddDock (wxSizer *container, wxAuiDockInfo &dock, wxAuiDockUIPartArray &uiparts, bool spacer_only)
wxSizer *	LayoutAll (wxAuiPaneInfoArray &panes, wxAuiDockInfoArray &docks, wxAuiDockUIPartArray &uiparts, bool spacer_only=false)
virtual bool	ProcessDockResult (wxAuiPaneInfo &target, const wxAuiPaneInfo &new_pos)
bool	DoDrop (wxAuiDockInfoArray &docks, wxAuiPaneInfoArray &panes, wxAuiPaneInfo &drop, const wxPoint &pt, const wxPoint &action_offset=wxPoint(0, 0))
wxAuiPaneInfo &	LookupPane (wxWindow *window)
wxAuiPaneInfo &	LookupPane (const wxString &name)
wxAuiDockUIPart *	HitTest (int x, int y)
wxAuiDockUIPart *	GetPanePart (wxWindow *pane)
int	GetDockPixelOffset (wxAuiPaneInfo &test)
void	OnFloatingPaneMoveStart (wxWindow *window)
void	OnFloatingPaneMoving (wxWindow *window)
void	OnFloatingPaneMoved (wxWindow *window)
void	OnFloatingPaneActivated (wxWindow *window)
void	OnFloatingPaneClosed (wxWindow *window, wxCloseEvent &evt)
void	OnFloatingPaneResized (wxWindow *window, const wxSize &size)
void	Render (wxDC *dc)
void	Repaint (wxDC *dc=NULL)
void	ProcessMgrEvent (wxAuiManagerEvent &event)
void	UpdateButtonOnScreen (wxAuiDockUIPart *button_ui_part, const wxMouseEvent &event)
void	GetPanePositionsAndSizes (wxAuiDockInfo &dock, wxArrayInt &positions, wxArrayInt &sizes)
void	OnPaint (wxPaintEvent &evt)
void	OnEraseBackground (wxEraseEvent &evt)
void	OnSize (wxSizeEvent &evt)
void	OnSetCursor (wxSetCursorEvent &evt)
void	OnLeftDown (wxMouseEvent &evt)
void	OnLeftUp (wxMouseEvent &evt)
void	OnMotion (wxMouseEvent &evt)
void	OnLeaveWindow (wxMouseEvent &evt)
void	OnChildFocus (wxChildFocusEvent &evt)
void	OnHintFadeTimer (wxTimerEvent &evt)
Protected Attributes
wxWindow *	m_frame
wxAuiDockArt *	m_art
unsigned int	m_flags
wxAuiPaneInfoArray	m_panes
wxAuiDockInfoArray	m_docks
wxAuiDockUIPartArray	m_uiparts
int	m_action
wxPoint	m_action_start
wxPoint	m_action_offset
wxAuiDockUIPart *	m_action_part
wxWindow *	m_action_window
wxRect	m_action_hintrect
wxAuiDockUIPart *	m_hover_button
wxRect	m_last_hint
wxPoint	m_last_mouse_move
wxFrame *	m_hint_wnd
wxTimer	m_hint_fadetimer
wxByte	m_hint_fadeamt
wxByte	m_hint_fademax
Friends
class	wxAuiFloatingFrame

---

Detailed Description

Definition at line 393 of file framemanager.h.

---

Member Enumeration Documentation

anonymous enum [protected]

Enumerator: actionNone  actionResize  actionClickButton  actionClickCaption  actionDragToolbarPane  actionDragFloatingPane  Definition at line 538 of file framemanager.h. { actionNone = 0, actionResize, actionClickButton, actionClickCaption, actionDragToolbarPane, actionDragFloatingPane };

---

Constructor & Destructor Documentation

wxAuiManager::wxAuiManager (  wxWindow *  managed_wnd = NULL, unsigned int  flags = wxAUI_MGR_DEFAULT )

wxAuiManager::~wxAuiManager (   )  [virtual]

Definition at line 452 of file framemanager.cpp. { delete m_art; }

---

Member Function Documentation

bool wxAuiManager::AddPane (  wxWindow *  window, int  direction = wxLEFT, const wxString &  caption = wxEmptyString )

Definition at line 765 of file framemanager.cpp. { wxAuiPaneInfo pinfo; pinfo.Caption(caption); switch (direction) { case wxTOP: pinfo.Top(); break; case wxBOTTOM: pinfo.Bottom(); break; case wxLEFT: pinfo.Left(); break; case wxRIGHT: pinfo.Right(); break; case wxCENTER: pinfo.CenterPane(); break; } return AddPane(window, pinfo); }

bool wxAuiManager::AddPane (  wxWindow *  window, const wxAuiPaneInfo &  pane_info, const wxPoint &  drop_pos )

Definition at line 782 of file framemanager.cpp. { if (!AddPane(window, pane_info)) return false; wxAuiPaneInfo& pane = GetPane(window); DoDrop(m_docks, m_panes, pane, drop_pos, wxPoint(0,0)); return true; }

bool wxAuiManager::AddPane (  wxWindow *  window, const wxAuiPaneInfo &  pane_info )

Definition at line 690 of file framemanager.cpp. { // check if the pane has a valid window if (!window) return false; // check if the pane already exists if (GetPane(pane_info.window).IsOk()) return false; m_panes.Add(pane_info); wxAuiPaneInfo& pinfo = m_panes.Last(); // set the pane window pinfo.window = window; // if the pane's name identifier is blank, create a random string if (pinfo.name.empty()) { pinfo.name.Printf(wxT("%08lx%08x%08x%08lx"), ((unsigned long)pinfo.window) & 0xffffffff, (unsigned int)time(NULL), #ifdef __WXWINCE__ (unsigned int)GetTickCount(), #else (unsigned int)clock(), #endif (unsigned long)m_panes.GetCount()); } // set initial proportion (if not already set) if (pinfo.dock_proportion == 0) pinfo.dock_proportion = 100000; if (pinfo.HasCloseButton() && pinfo.buttons.size() == 0) { wxAuiPaneButton button; button.button_id = wxAuiPaneInfo::buttonClose; pinfo.buttons.Add(button); } if (pinfo.best_size == wxDefaultSize && pinfo.window) { pinfo.best_size = pinfo.window->GetClientSize(); if (pinfo.window->IsKindOf(CLASSINFO(wxToolBar))) { // GetClientSize() doesn't get the best size for // a toolbar under some newer versions of wxWidgets, // so use GetBestSize() pinfo.best_size = pinfo.window->GetBestSize(); // for some reason, wxToolBar::GetBestSize() is returning // a size that is a pixel shy of the correct amount. // I believe this to be the correct action, until // wxToolBar::GetBestSize() is fixed. Is this assumption // correct? pinfo.best_size.y++; } if (pinfo.min_size != wxDefaultSize) { if (pinfo.best_size.x < pinfo.min_size.x) pinfo.best_size.x = pinfo.min_size.x; if (pinfo.best_size.y < pinfo.min_size.y) pinfo.best_size.y = pinfo.min_size.y; } } return true; }

bool wxAuiManager::DetachPane (  wxWindow *  window  )

Definition at line 854 of file framemanager.cpp. { int i, count; for (i = 0, count = m_panes.GetCount(); i < count; ++i) { wxAuiPaneInfo& p = m_panes.Item(i); if (p.window == window) { if (p.frame) { // we have a floating frame which is being detached. We need to // reparent it to m_frame and destroy the floating frame // reduce flicker p.window->SetSize(1,1); p.frame->Show(false); // reparent to m_frame and destroy the pane p.window->Reparent(m_frame); p.frame->SetSizer(NULL); p.frame->Destroy(); p.frame = NULL; } // make sure there are no references to this pane in our uiparts, // just in case the caller doesn't call Update() immediately after // the DetachPane() call. This prevets obscure crashes which would // happen at window repaint if the caller forgets to call Update() int pi, part_count; for (pi = 0, part_count = (int)m_uiparts.GetCount(); pi < part_count; ++pi) { wxAuiDockUIPart& part = m_uiparts.Item(pi); if (part.pane == &p) { m_uiparts.RemoveAt(pi); part_count--; pi--; continue; } } m_panes.RemoveAt(i); return true; } } return false; }

bool wxAuiManager::DoDrop (  wxAuiDockInfoArray &  docks, wxAuiPaneInfoArray &  panes, wxAuiPaneInfo &  drop, const wxPoint &  pt, const wxPoint &  action_offset = wxPoint(0, 0) )  [protected]

Definition at line 2249 of file framemanager.cpp. { wxSize cli_size = m_frame->GetClientSize(); wxAuiPaneInfo drop = target; // The result should always be shown drop.Show(); // Check to see if the pane has been dragged outside of the window // (or near to the outside of the window), if so, dock it along the edge int layer_insert_offset = auiLayerInsertOffset; if (target.IsToolbar()) layer_insert_offset = 0; if (pt.x < layer_insert_offset && pt.x > layer_insert_offset-auiLayerInsertPixels) { int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT), GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)), GetMaxLayer(docks, wxAUI_DOCK_TOP)) + 1; drop.Dock().Left(). Layer(new_layer). Row(0). Position(pt.y - GetDockPixelOffset(drop) - offset.y); return ProcessDockResult(target, drop); } else if (pt.y < layer_insert_offset && pt.y > layer_insert_offset-auiLayerInsertPixels) { int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP), GetMaxLayer(docks, wxAUI_DOCK_LEFT)), GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1; drop.Dock().Top(). Layer(new_layer). Row(0). Position(pt.x - GetDockPixelOffset(drop) - offset.x); return ProcessDockResult(target, drop); } else if (pt.x >= cli_size.x - layer_insert_offset && pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels) { int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT), GetMaxLayer(docks, wxAUI_DOCK_TOP)), GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)) + 1; drop.Dock().Right(). Layer(new_layer). Row(0). Position(pt.y - GetDockPixelOffset(drop) - offset.y); return ProcessDockResult(target, drop); } else if (pt.y >= cli_size.y - layer_insert_offset && pt.y < cli_size.y - layer_insert_offset + auiLayerInsertPixels) { int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_BOTTOM), GetMaxLayer(docks, wxAUI_DOCK_LEFT)), GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1; drop.Dock().Bottom(). Layer(new_layer). Row(0). Position(pt.x - GetDockPixelOffset(drop) - offset.x); return ProcessDockResult(target, drop); } wxAuiDockUIPart* part = HitTest(pt.x, pt.y); if (drop.IsToolbar()) { if (!part || !part->dock) return false; // calculate the offset from where the dock begins // to the point where the user dropped the pane int dock_drop_offset = 0; if (part->dock->IsHorizontal()) dock_drop_offset = pt.x - part->dock->rect.x - offset.x; else dock_drop_offset = pt.y - part->dock->rect.y - offset.y; // toolbars may only be moved in and to fixed-pane docks, // otherwise we will try to float the pane. Also, the pane // should float if being dragged over center pane windows if (!part->dock->fixed || part->dock->dock_direction == wxAUI_DOCK_CENTER) { if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) && (drop.IsFloatable() || (part->dock->dock_direction != wxAUI_DOCK_CENTER && part->dock->dock_direction != wxAUI_DOCK_NONE))) { drop.Float(); } return ProcessDockResult(target, drop); } drop.Dock(). Direction(part->dock->dock_direction). Layer(part->dock->dock_layer). Row(part->dock->dock_row). Position(dock_drop_offset); if (( ((pt.y < part->dock->rect.y + 2) && part->dock->IsHorizontal()) || ((pt.x < part->dock->rect.x + 2) && part->dock->IsVertical()) ) && part->dock->panes.GetCount() > 1) { int row = drop.dock_row; DoInsertDockRow(panes, part->dock->dock_direction, part->dock->dock_layer, part->dock->dock_row); drop.dock_row = row; } if (( ((pt.y > part->dock->rect.y + part->dock->rect.height - 2 ) && part->dock->IsHorizontal()) || ((pt.x > part->dock->rect.x + part->dock->rect.width - 2 ) && part->dock->IsVertical()) ) && part->dock->panes.GetCount() > 1) { DoInsertDockRow(panes, part->dock->dock_direction, part->dock->dock_layer, part->dock->dock_row+1); drop.dock_row = part->dock->dock_row+1; } return ProcessDockResult(target, drop); } if (!part) return false; if (part->type == wxAuiDockUIPart::typePaneBorder || part->type == wxAuiDockUIPart::typeCaption || part->type == wxAuiDockUIPart::typeGripper || part->type == wxAuiDockUIPart::typePaneButton || part->type == wxAuiDockUIPart::typePane || part->type == wxAuiDockUIPart::typePaneSizer || part->type == wxAuiDockUIPart::typeDockSizer || part->type == wxAuiDockUIPart::typeBackground) { if (part->type == wxAuiDockUIPart::typeDockSizer) { if (part->dock->panes.GetCount() != 1) return false; part = GetPanePart(part->dock->panes.Item(0)->window); if (!part) return false; } // If a normal frame is being dragged over a toolbar, insert it // along the edge under the toolbar, but over all other panes. // (this could be done much better, but somehow factoring this // calculation with the one at the beginning of this function) if (part->dock && part->dock->toolbar) { int layer = 0; switch (part->dock->dock_direction) { case wxAUI_DOCK_LEFT: layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT), GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)), GetMaxLayer(docks, wxAUI_DOCK_TOP)); break; case wxAUI_DOCK_TOP: layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP), GetMaxLayer(docks, wxAUI_DOCK_LEFT)), GetMaxLayer(docks, wxAUI_DOCK_RIGHT)); break; case wxAUI_DOCK_RIGHT: layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT), GetMaxLayer(docks, wxAUI_DOCK_TOP)), GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)); break; case wxAUI_DOCK_BOTTOM: layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_BOTTOM), GetMaxLayer(docks, wxAUI_DOCK_LEFT)), GetMaxLayer(docks, wxAUI_DOCK_RIGHT)); break; } DoInsertDockRow(panes, part->dock->dock_direction, layer, 0); drop.Dock(). Direction(part->dock->dock_direction). Layer(layer).Row(0).Position(0); return ProcessDockResult(target, drop); } if (!part->pane) return false; part = GetPanePart(part->pane->window); if (!part) return false; bool insert_dock_row = false; int insert_row = part->pane->dock_row; int insert_dir = part->pane->dock_direction; int insert_layer = part->pane->dock_layer; switch (part->pane->dock_direction) { case wxAUI_DOCK_TOP: if (pt.y >= part->rect.y && pt.y < part->rect.y+auiInsertRowPixels) insert_dock_row = true; break; case wxAUI_DOCK_BOTTOM: if (pt.y > part->rect.y+part->rect.height-auiInsertRowPixels && pt.y <= part->rect.y + part->rect.height) insert_dock_row = true; break; case wxAUI_DOCK_LEFT: if (pt.x >= part->rect.x && pt.x < part->rect.x+auiInsertRowPixels) insert_dock_row = true; break; case wxAUI_DOCK_RIGHT: if (pt.x > part->rect.x+part->rect.width-auiInsertRowPixels && pt.x <= part->rect.x+part->rect.width) insert_dock_row = true; break; case wxAUI_DOCK_CENTER: { // "new row pixels" will be set to the default, but // must never exceed 20% of the window size int new_row_pixels_x = auiNewRowPixels; int new_row_pixels_y = auiNewRowPixels; if (new_row_pixels_x > (part->rect.width*20)/100) new_row_pixels_x = (part->rect.width*20)/100; if (new_row_pixels_y > (part->rect.height*20)/100) new_row_pixels_y = (part->rect.height*20)/100; // determine if the mouse pointer is in a location that // will cause a new row to be inserted. The hot spot positions // are along the borders of the center pane insert_layer = 0; insert_dock_row = true; if (pt.x >= part->rect.x && pt.x < part->rect.x+new_row_pixels_x) insert_dir = wxAUI_DOCK_LEFT; else if (pt.y >= part->rect.y && pt.y < part->rect.y+new_row_pixels_y) insert_dir = wxAUI_DOCK_TOP; else if (pt.x >= part->rect.x + part->rect.width-new_row_pixels_x && pt.x < part->rect.x + part->rect.width) insert_dir = wxAUI_DOCK_RIGHT; else if (pt.y >= part->rect.y+ part->rect.height-new_row_pixels_y && pt.y < part->rect.y + part->rect.height) insert_dir = wxAUI_DOCK_BOTTOM; else return false; insert_row = GetMaxRow(panes, insert_dir, insert_layer) + 1; } } if (insert_dock_row) { DoInsertDockRow(panes, insert_dir, insert_layer, insert_row); drop.Dock().Direction(insert_dir). Layer(insert_layer). Row(insert_row). Position(0); return ProcessDockResult(target, drop); } // determine the mouse offset and the pane size, both in the // direction of the dock itself, and perpendicular to the dock int offset, size; if (part->orientation == wxVERTICAL) { offset = pt.y - part->rect.y; size = part->rect.GetHeight(); } else { offset = pt.x - part->rect.x; size = part->rect.GetWidth(); } int drop_position = part->pane->dock_pos; // if we are in the top/left part of the pane, // insert the pane before the pane being hovered over if (offset <= size/2) { drop_position = part->pane->dock_pos; DoInsertPane(panes, part->pane->dock_direction, part->pane->dock_layer, part->pane->dock_row, part->pane->dock_pos); } // if we are in the bottom/right part of the pane, // insert the pane before the pane being hovered over if (offset > size/2) { drop_position = part->pane->dock_pos+1; DoInsertPane(panes, part->pane->dock_direction, part->pane->dock_layer, part->pane->dock_row, part->pane->dock_pos+1); } drop.Dock(). Direction(part->dock->dock_direction). Layer(part->dock->dock_layer). Row(part->dock->dock_row). Position(drop_position); return ProcessDockResult(target, drop); } return false; }

void wxAuiManager::DoFrameLayout (   )  [protected]

Definition at line 2087 of file framemanager.cpp. { m_frame->Layout(); int i, part_count; for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) { wxAuiDockUIPart& part = m_uiparts.Item(i); // get the rectangle of the UI part // originally, this code looked like this: // part.rect = wxRect(part.sizer_item->GetPosition(), // part.sizer_item->GetSize()); // this worked quite well, with one exception: the mdi // client window had a "deferred" size variable // that returned the wrong size. It looks like // a bug in wx, because the former size of the window // was being returned. So, we will retrieve the part's // rectangle via other means part.rect = part.sizer_item->GetRect(); int flag = part.sizer_item->GetFlag(); int border = part.sizer_item->GetBorder(); if (flag & wxTOP) { part.rect.y -= border; part.rect.height += border; } if (flag & wxLEFT) { part.rect.x -= border; part.rect.width += border; } if (flag & wxBOTTOM) part.rect.height += border; if (flag & wxRIGHT) part.rect.width += border; if (part.type == wxAuiDockUIPart::typeDock) part.dock->rect = part.rect; if (part.type == wxAuiDockUIPart::typePane) part.pane->rect = part.rect; } }

void wxAuiManager::DrawHintRect (  wxWindow *  pane_window, const wxPoint &  pt, const wxPoint &  offset )

Definition at line 2746 of file framemanager.cpp. { wxRect rect; // we need to paint a hint rectangle; to find out the exact hint rectangle, // we will create a new temporary layout and then measure the resulting // rectangle; we will create a copy of the docking structures (m_dock) // so that we don't modify the real thing on screen int i, pane_count, part_count; wxAuiDockInfoArray docks; wxAuiPaneInfoArray panes; wxAuiDockUIPartArray uiparts; wxAuiPaneInfo hint = GetPane(pane_window); hint.name = wxT("__HINT__"); hint.Show(); if (!hint.IsOk()) return; CopyDocksAndPanes(docks, panes, m_docks, m_panes); // remove any pane already there which bears the same window; // this happens when you are moving a pane around in a dock for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) { if (panes.Item(i).window == pane_window) { RemovePaneFromDocks(docks, panes.Item(i)); panes.RemoveAt(i); break; } } // find out where the new pane would be if (!DoDrop(docks, panes, hint, pt, offset)) { HideHint(); return; } panes.Add(hint); wxSizer* sizer = LayoutAll(panes, docks, uiparts, true); wxSize client_size = m_frame->GetClientSize(); sizer->SetDimension(0, 0, client_size.x, client_size.y); sizer->Layout(); for (i = 0, part_count = uiparts.GetCount(); i < part_count; ++i) { wxAuiDockUIPart& part = uiparts.Item(i); if (part.type == wxAuiDockUIPart::typePaneBorder && part.pane && part.pane->name == wxT("__HINT__")) { rect = wxRect(part.sizer_item->GetPosition(), part.sizer_item->GetSize()); break; } } delete sizer; if (rect.IsEmpty()) { HideHint(); return; } // actually show the hint rectangle on the screen m_frame->ClientToScreen(&rect.x, &rect.y); ShowHint(rect); }

wxAuiPaneInfoArray & wxAuiManager::GetAllPanes (   )

Definition at line 493 of file framemanager.cpp. { return m_panes; }

wxAuiDockArt * wxAuiManager::GetArtProvider (   )  const

Definition at line 658 of file framemanager.cpp. { return m_art; }

int wxAuiManager::GetDockPixelOffset (  wxAuiPaneInfo &  test  )  [protected]

Definition at line 2167 of file framemanager.cpp. { // the only way to accurately calculate the dock's // offset is to actually run a theoretical layout int i, part_count, dock_count; wxAuiDockInfoArray docks; wxAuiPaneInfoArray panes; wxAuiDockUIPartArray uiparts; CopyDocksAndPanes(docks, panes, m_docks, m_panes); panes.Add(test); wxSizer* sizer = LayoutAll(panes, docks, uiparts, true); wxSize client_size = m_frame->GetClientSize(); sizer->SetDimension(0, 0, client_size.x, client_size.y); sizer->Layout(); for (i = 0, part_count = uiparts.GetCount(); i < part_count; ++i) { wxAuiDockUIPart& part = uiparts.Item(i); part.rect = wxRect(part.sizer_item->GetPosition(), part.sizer_item->GetSize()); if (part.type == wxAuiDockUIPart::typeDock) part.dock->rect = part.rect; } delete sizer; for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) { wxAuiDockInfo& dock = docks.Item(i); if (test.dock_direction == dock.dock_direction && test.dock_layer==dock.dock_layer && test.dock_row==dock.dock_row) { if (dock.IsVertical()) return dock.rect.y; else return dock.rect.x; } } return 0; }

unsigned int wxAuiManager::GetFlags (   )  const

Definition at line 540 of file framemanager.cpp. { return m_flags; }

wxWindow * wxAuiManager::GetManagedWindow (   )  const

Definition at line 653 of file framemanager.cpp. { return m_frame; }

wxAuiPaneInfo & wxAuiManager::GetPane (  const wxString &  name  )

Definition at line 480 of file framemanager.cpp. { int i, pane_count; for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) { wxAuiPaneInfo& p = m_panes.Item(i); if (p.name == name) return p; } return wxAuiNullPaneInfo; }

wxAuiPaneInfo & wxAuiManager::GetPane (  wxWindow *  window  )

Definition at line 466 of file framemanager.cpp. { int i, pane_count; for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) { wxAuiPaneInfo& p = m_panes.Item(i); if (p.window == window) return p; } return wxAuiNullPaneInfo; }

wxAuiDockUIPart * wxAuiManager::GetPanePart (  wxWindow *  pane  )  [protected]

Definition at line 2139 of file framemanager.cpp. { int i, part_count; for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) { wxAuiDockUIPart& part = m_uiparts.Item(i); if (part.type == wxAuiDockUIPart::typePaneBorder && part.pane && part.pane->window == wnd) return &part; } for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) { wxAuiDockUIPart& part = m_uiparts.Item(i); if (part.type == wxAuiDockUIPart::typePane && part.pane && part.pane->window == wnd) return &part; } return NULL; }

void wxAuiManager::GetPanePositionsAndSizes (  wxAuiDockInfo &  dock, wxArrayInt &  positions, wxArrayInt &  sizes )  [protected]

Definition at line 1148 of file framemanager.cpp. { int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE); int pane_border_size = m_art->GetMetric(wxAUI_ART_PANE_BORDER_SIZE); int gripper_size = m_art->GetMetric(wxAUI_ART_GRIPPER_SIZE); positions.Empty(); sizes.Empty(); int offset, action_pane = -1; int pane_i, pane_count = dock.panes.GetCount(); // find the pane marked as our action pane for (pane_i = 0; pane_i < pane_count; ++pane_i) { wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i)); if (pane.state & wxAuiPaneInfo::actionPane) { wxASSERT_MSG(action_pane==-1, wxT("Too many fixed action panes")); action_pane = pane_i; } } // set up each panes default position, and // determine the size (width or height, depending // on the dock's orientation) of each pane for (pane_i = 0; pane_i < pane_count; ++pane_i) { wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i)); positions.Add(pane.dock_pos); int size = 0; if (pane.HasBorder()) size += (pane_border_size*2); if (dock.IsHorizontal()) { if (pane.HasGripper() && !pane.HasGripperTop()) size += gripper_size; size += pane.best_size.x; } else